core/rfb.js

   1 /*
   2  * noVNC: HTML5 VNC client
   3  * Copyright (C) 2012 Joel Martin
   4  * Copyright (C) 2016 Samuel Mannehed for Cendio AB
   5  * Licensed under MPL 2.0 (see LICENSE.txt)
   6  *
   7  * See README.md for usage and integration instructions.
   8  *
   9  * TIGHT decoder portion:
  10  * (c) 2012 Michael Tinglof, Joe Balaz, Les Piech (Mercuri.ca)
  11  */
  12
  13 import * as Log from './util/logging.js';
  14 import _ from './util/localization.js';
  15 import { decodeUTF8 } from './util/strings.js';
  16 import { set_defaults, make_properties } from './util/properties.js';
  17 import Display from "./display.js";
  18 import { Keyboard, Mouse } from "./input/devices.js";
  19 import Websock from "./websock.js";
  20 import Base64 from "./base64.js";
  21 import DES from "./des.js";
  22 import KeyTable from "./input/keysym.js";
  23 import XtScancode from "./input/xtscancodes.js";
  24 import Inflator from "./inflator.js";
  25
  26 /*jslint white: false, browser: true */
  27 /*global window, Util, Display, Keyboard, Mouse, Websock, Websock_native, Base64, DES, KeyTable, Inflator, XtScancode */
  28
  29 export default function RFB(defaults) {
  30     "use strict";
  31     if (!defaults) {
  32         defaults = {};
  33     }
  34
  35     this._rfb_host = '';
  36     this._rfb_port = 5900;
  37     this._rfb_password = '';
  38     this._rfb_path = '';
  39
  40     this._rfb_connection_state = '';
  41     this._rfb_init_state = '';
  42     this._rfb_version = 0;
  43     this._rfb_max_version = 3.8;
  44     this._rfb_auth_scheme = '';
  45     this._rfb_disconnect_reason = "";
  46
  47     this._rfb_tightvnc = false;
  48     this._rfb_xvp_ver = 0;
  49
  50     // In preference order
  51     this._encodings = [
  52         ['COPYRECT',             0x01 ],
  53         ['TIGHT',                0x07 ],
  54         ['TIGHT_PNG',            -260 ],
  55         ['HEXTILE',              0x05 ],
  56         ['RRE',                  0x02 ],
  57         ['RAW',                  0x00 ],
  58
  59         // Psuedo-encoding settings
  60
  61         //['JPEG_quality_lo',     -32 ],
  62         ['JPEG_quality_med',      -26 ],
  63         //['JPEG_quality_hi',     -23 ],
  64         //['compress_lo',        -255 ],
  65         ['compress_hi',          -254 ],
  66         //['compress_max',       -247 ],
  67
  68         ['DesktopSize',          -223 ],
  69         ['last_rect',            -224 ],
  70         ['Cursor',               -239 ],
  71         ['QEMUExtendedKeyEvent', -258 ],
  72         ['ExtendedDesktopSize',  -308 ],
  73         ['xvp',                  -309 ],
  74         ['Fence',                -312 ],
  75         ['ContinuousUpdates',    -313 ]
  76     ];
  77
  78     this._encHandlers = {};
  79     this._encNames = {};
  80     this._encStats = {};
  81
  82     this._sock = null;              // Websock object
  83     this._display = null;           // Display object
  84     this._flushing = false;         // Display flushing state
  85     this._keyboard = null;          // Keyboard input handler object
  86     this._mouse = null;             // Mouse input handler object
  87     this._disconnTimer = null;      // disconnection timer
  88
  89     this._supportsFence = false;
  90
  91     this._supportsContinuousUpdates = false;
  92     this._enabledContinuousUpdates = false;
  93
  94     // Frame buffer update state
  95     this._FBU = {
  96         rects: 0,
  97         subrects: 0,            // RRE
  98         lines: 0,               // RAW
  99         tiles: 0,               // HEXTILE
 100         bytes: 0,
 101         x: 0,
 102         y: 0,
 103         width: 0,
 104         height: 0,
 105         encoding: 0,
 106         subencoding: -1,
 107         background: null,
 108         zlib: []                // TIGHT zlib streams
 109     };
 110
 111     this._fb_width = 0;
 112     this._fb_height = 0;
 113     this._fb_name = "";
 114
 115     this._destBuff = null;
 116     this._paletteBuff = new Uint8Array(1024);  // 256 * 4 (max palette size * max bytes-per-pixel)
 117
 118     this._rre_chunk_sz = 100;
 119
 120     this._timing = {
 121         last_fbu: 0,
 122         fbu_total: 0,
 123         fbu_total_cnt: 0,
 124         full_fbu_total: 0,
 125         full_fbu_cnt: 0,
 126
 127         fbu_rt_start: 0,
 128         fbu_rt_total: 0,
 129         fbu_rt_cnt: 0,
 130         pixels: 0
 131     };
 132
 133     this._supportsSetDesktopSize = false;
 134     this._screen_id = 0;
 135     this._screen_flags = 0;
 136
 137     // Mouse state
 138     this._mouse_buttonMask = 0;
 139     this._mouse_arr = [];
 140     this._viewportDragging = false;
 141     this._viewportDragPos = {};
 142     this._viewportHasMoved = false;
 143
 144     // QEMU Extended Key Event support - default to false
 145     this._qemuExtKeyEventSupported = false;
 146
 147     // set the default value on user-facing properties
 148     set_defaults(this, defaults, {
 149         'target': 'null',                       // VNC display rendering Canvas object
 150         'focusContainer': document,             // DOM element that captures keyboard input
 151         'encrypt': false,                       // Use TLS/SSL/wss encryption
 152         'local_cursor': false,                  // Request locally rendered cursor
 153         'shared': true,                         // Request shared mode
 154         'view_only': false,                     // Disable client mouse/keyboard
 155         'xvp_password_sep': '@',                // Separator for XVP password fields
 156         'disconnectTimeout': 3,                 // Time (s) to wait for disconnection
 157         'wsProtocols': ['binary'],              // Protocols to use in the WebSocket connection
 158         'repeaterID': '',                       // [UltraVNC] RepeaterID to connect to
 159         'viewportDrag': false,                  // Move the viewport on mouse drags
 160
 161         // Callback functions
 162         'onUpdateState': function () { },       // onUpdateState(rfb, state, oldstate): connection state change
 163         'onNotification': function () { },      // onNotification(rfb, msg, level, options): notification for UI
 164         'onDisconnected': function () { },      // onDisconnected(rfb, reason): disconnection finished
 165         'onPasswordRequired': function () { },  // onPasswordRequired(rfb, msg): VNC password is required
 166         'onClipboard': function () { },         // onClipboard(rfb, text): RFB clipboard contents received
 167         'onBell': function () { },              // onBell(rfb): RFB Bell message received
 168         'onFBUReceive': function () { },        // onFBUReceive(rfb, fbu): RFB FBU received but not yet processed
 169         'onFBUComplete': function () { },       // onFBUComplete(rfb, fbu): RFB FBU received and processed
 170         'onFBResize': function () { },          // onFBResize(rfb, width, height): frame buffer resized
 171         'onDesktopName': function () { },       // onDesktopName(rfb, name): desktop name received
 172         'onXvpInit': function () { }            // onXvpInit(version): XVP extensions active for this connection
 173     });
 174
 175     // main setup
 176     Log.Debug(">> RFB.constructor");
 177
 178     // populate encHandlers with bound versions
 179     Object.keys(RFB.encodingHandlers).forEach(function (encName) {
 180         this._encHandlers[encName] = RFB.encodingHandlers[encName].bind(this);
 181     }.bind(this));
 182
 183     // Create lookup tables based on encoding number
 184     for (var i = 0; i < this._encodings.length; i++) {
 185         this._encHandlers[this._encodings[i][1]] = this._encHandlers[this._encodings[i][0]];
 186         this._encNames[this._encodings[i][1]] = this._encodings[i][0];
 187         this._encStats[this._encodings[i][1]] = [0, 0];
 188     }
 189
 190     // NB: nothing that needs explicit teardown should be done
 191     // before this point, since this can throw an exception
 192     try {
 193         this._display = new Display({target: this._target,
 194                                      onFlush: this._onFlush.bind(this)});
 195     } catch (exc) {
 196         Log.Error("Display exception: " + exc);
 197         throw exc;
 198     }
 199
 200     this._keyboard = new Keyboard({target: this._focusContainer,
 201                                    onKeyEvent: this._handleKeyEvent.bind(this)});
 202
 203     this._mouse = new Mouse({target: this._target,
 204                              onMouseButton: this._handleMouseButton.bind(this),
 205                              onMouseMove: this._handleMouseMove.bind(this)});
 206
 207     this._sock = new Websock();
 208     this._sock.on('message', this._handle_message.bind(this));
 209     this._sock.on('open', function () {
 210         if ((this._rfb_connection_state === 'connecting') &&
 211             (this._rfb_init_state === '')) {
 212             this._rfb_init_state = 'ProtocolVersion';
 213             Log.Debug("Starting VNC handshake");
 214         } else {
 215             this._fail("Unexpected server connection");
 216         }
 217     }.bind(this));
 218     this._sock.on('close', function (e) {
 219         Log.Warn("WebSocket on-close event");
 220         var msg = "";
 221         if (e.code) {
 222             msg = " (code: " + e.code;
 223             if (e.reason) {
 224                 msg += ", reason: " + e.reason;
 225             }
 226             msg += ")";
 227         }
 228         switch (this._rfb_connection_state) {
 229             case 'disconnecting':
 230                 this._updateConnectionState('disconnected');
 231                 break;
 232             case 'connecting':
 233                 this._fail('Failed to connect to server', msg);
 234                 break;
 235             case 'connected':
 236                 // Handle disconnects that were initiated server-side
 237                 this._updateConnectionState('disconnecting');
 238                 this._updateConnectionState('disconnected');
 239                 break;
 240             case 'disconnected':
 241                 this._fail("Unexpected server disconnect",
 242                            "Already disconnected: " + msg);
 243                 break;
 244             default:
 245                 this._fail("Unexpected server disconnect",
 246                            "Not in any state yet: " + msg);
 247                 break;
 248         }
 249         this._sock.off('close');
 250     }.bind(this));
 251     this._sock.on('error', function (e) {
 252         Log.Warn("WebSocket on-error event");
 253     });
 254
 255     this._init_vars();
 256     this._cleanup();
 257
 258     var rmode = this._display.get_render_mode();
 259     Log.Info("Using native WebSockets, render mode: " + rmode);
 260
 261     Log.Debug("<< RFB.constructor");
 262 };
 263
 264 RFB.prototype = {
 265     // Public methods
 266     connect: function (host, port, password, path) {
 267         this._rfb_host = host;
 268         this._rfb_port = port;
 269         this._rfb_password = (password !== undefined) ? password : "";
 270         this._rfb_path = (path !== undefined) ? path : "";
 271
 272         if (!this._rfb_host || !this._rfb_port) {
 273             return this._fail(
 274                 _("Must set host and port"));
 275         }
 276
 277         this._rfb_init_state = '';
 278         this._updateConnectionState('connecting');
 279         return true;
 280     },
 281
 282     disconnect: function () {
 283         this._updateConnectionState('disconnecting');
 284         this._sock.off('error');
 285         this._sock.off('message');
 286         this._sock.off('open');
 287     },
 288
 289     sendPassword: function (passwd) {
 290         this._rfb_password = passwd;
 291         setTimeout(this._init_msg.bind(this), 0);
 292     },
 293
 294     sendCtrlAltDel: function () {
 295         if (this._rfb_connection_state !== 'connected' || this._view_only) { return false; }
 296         Log.Info("Sending Ctrl-Alt-Del");
 297
 298         this.sendKey(KeyTable.XK_Control_L, "ControlLeft", true);
 299         this.sendKey(KeyTable.XK_Alt_L, "AltLeft", true);
 300         this.sendKey(KeyTable.XK_Delete, "Delete", true);
 301         this.sendKey(KeyTable.XK_Delete, "Delete", false);
 302         this.sendKey(KeyTable.XK_Alt_L, "AltLeft", false);
 303         this.sendKey(KeyTable.XK_Control_L, "ControlLeft", false);
 304
 305         return true;
 306     },
 307
 308     xvpOp: function (ver, op) {
 309         if (this._rfb_xvp_ver < ver) { return false; }
 310         Log.Info("Sending XVP operation " + op + " (version " + ver + ")");
 311         this._sock.send_string("\xFA\x00" + String.fromCharCode(ver) + String.fromCharCode(op));
 312         return true;
 313     },
 314
 315     xvpShutdown: function () {
 316         return this.xvpOp(1, 2);
 317     },
 318
 319     xvpReboot: function () {
 320         return this.xvpOp(1, 3);
 321     },
 322
 323     xvpReset: function () {
 324         return this.xvpOp(1, 4);
 325     },
 326
 327     // Send a key press. If 'down' is not specified then send a down key
 328     // followed by an up key.
 329     sendKey: function (keysym, code, down) {
 330         if (this._rfb_connection_state !== 'connected' || this._view_only) { return false; }
 331
 332         if (down === undefined) {
 333             this.sendKey(keysym, code, true);
 334             this.sendKey(keysym, code, false);
 335             return true;
 336         }
 337
 338         var scancode = XtScancode[code];
 339
 340         if (this._qemuExtKeyEventSupported && scancode) {
 341             // 0 is NoSymbol
 342             keysym = keysym || 0;
 343
 344             Log.Info("Sending key (" + (down ? "down" : "up") + "): keysym " + keysym + ", scancode " + scancode);
 345
 346             RFB.messages.QEMUExtendedKeyEvent(this._sock, keysym, down, scancode);
 347         } else {
 348             if (!keysym) {
 349                 return false;
 350             }
 351             Log.Info("Sending keysym (" + (down ? "down" : "up") + "): " + keysym);
 352             RFB.messages.keyEvent(this._sock, keysym, down ? 1 : 0);
 353         }
 354
 355         return true;
 356     },
 357
 358     clipboardPasteFrom: function (text) {
 359         if (this._rfb_connection_state !== 'connected' || this._view_only) { return; }
 360         RFB.messages.clientCutText(this._sock, text);
 361     },
 362
 363     // Requests a change of remote desktop size. This message is an extension
 364     // and may only be sent if we have received an ExtendedDesktopSize message
 365     requestDesktopSize: function (width, height) {
 366         if (this._rfb_connection_state !== 'connected' ||
 367             this._view_only) {
 368             return false;
 369         }
 370
 371         if (this._supportsSetDesktopSize) {
 372             RFB.messages.setDesktopSize(this._sock, width, height,
 373                                         this._screen_id, this._screen_flags);
 374             this._sock.flush();
 375             return true;
 376         } else {
 377             return false;
 378         }
 379     },
 380
 381
 382     // Private methods
 383
 384     _connect: function () {
 385         Log.Debug(">> RFB.connect");
 386         this._init_vars();
 387
 388         var uri;
 389         if (typeof UsingSocketIO !== 'undefined') {
 390             uri = 'http';
 391         } else {
 392             uri = this._encrypt ? 'wss' : 'ws';
 393         }
 394
 395         uri += '://' + this._rfb_host + ':' + this._rfb_port + '/' + this._rfb_path;
 396         Log.Info("connecting to " + uri);
 397
 398         try {
 399             // WebSocket.onopen transitions to the RFB init states
 400             this._sock.open(uri, this._wsProtocols);
 401         } catch (e) {
 402             if (e.name === 'SyntaxError') {
 403                 this._fail("Invalid host or port value given", e);
 404             } else {
 405                 this._fail("Error while connecting", e);
 406             }
 407         }
 408
 409         Log.Debug("<< RFB.connect");
 410     },
 411
 412     _disconnect: function () {
 413         Log.Debug(">> RFB.disconnect");
 414         this._cleanup();
 415         this._sock.close();
 416         this._print_stats();
 417         Log.Debug("<< RFB.disconnect");
 418     },
 419
 420     _init_vars: function () {
 421         // reset state
 422         this._FBU.rects        = 0;
 423         this._FBU.subrects     = 0;  // RRE and HEXTILE
 424         this._FBU.lines        = 0;  // RAW
 425         this._FBU.tiles        = 0;  // HEXTILE
 426         this._FBU.zlibs        = []; // TIGHT zlib encoders
 427         this._mouse_buttonMask = 0;
 428         this._mouse_arr        = [];
 429         this._rfb_tightvnc     = false;
 430
 431         // Clear the per connection encoding stats
 432         var i;
 433         for (i = 0; i < this._encodings.length; i++) {
 434             this._encStats[this._encodings[i][1]][0] = 0;
 435         }
 436
 437         for (i = 0; i < 4; i++) {
 438             this._FBU.zlibs[i] = new Inflator();
 439         }
 440     },
 441
 442     _print_stats: function () {
 443         Log.Info("Encoding stats for this connection:");
 444         var i, s;
 445         for (i = 0; i < this._encodings.length; i++) {
 446             s = this._encStats[this._encodings[i][1]];
 447             if (s[0] + s[1] > 0) {
 448                 Log.Info("    " + this._encodings[i][0] + ": " + s[0] + " rects");
 449             }
 450         }
 451
 452         Log.Info("Encoding stats since page load:");
 453         for (i = 0; i < this._encodings.length; i++) {
 454             s = this._encStats[this._encodings[i][1]];
 455             Log.Info("    " + this._encodings[i][0] + ": " + s[1] + " rects");
 456         }
 457     },
 458
 459     _cleanup: function () {
 460         if (!this._view_only) { this._keyboard.ungrab(); }
 461         if (!this._view_only) { this._mouse.ungrab(); }
 462         this._display.defaultCursor();
 463         if (Log.get_logging() !== 'debug') {
 464             // Show noVNC logo on load and when disconnected, unless in
 465             // debug mode
 466             this._display.clear();
 467         }
 468     },
 469
 470     /*
 471      * Connection states:
 472      *   connecting
 473      *   connected
 474      *   disconnecting
 475      *   disconnected - permanent state
 476      */
 477     _updateConnectionState: function (state) {
 478         var oldstate = this._rfb_connection_state;
 479
 480         if (state === oldstate) {
 481             Log.Debug("Already in state '" + state + "', ignoring");
 482             return;
 483         }
 484
 485         // The 'disconnected' state is permanent for each RFB object
 486         if (oldstate === 'disconnected') {
 487             Log.Error("Tried changing state of a disconnected RFB object");
 488             return;
 489         }
 490
 491         // Ensure proper transitions before doing anything
 492         switch (state) {
 493             case 'connected':
 494                 if (oldstate !== 'connecting') {
 495                     Log.Error("Bad transition to connected state, " +
 496                                "previous connection state: " + oldstate);
 497                     return;
 498                 }
 499                 break;
 500
 501             case 'disconnected':
 502                 if (oldstate !== 'disconnecting') {
 503                     Log.Error("Bad transition to disconnected state, " +
 504                                "previous connection state: " + oldstate);
 505                     return;
 506                 }
 507                 break;
 508
 509             case 'connecting':
 510                 if (oldstate !== '') {
 511                     Log.Error("Bad transition to connecting state, " +
 512                                "previous connection state: " + oldstate);
 513                     return;
 514                 }
 515                 break;
 516
 517             case 'disconnecting':
 518                 if (oldstate !== 'connected' && oldstate !== 'connecting') {
 519                     Log.Error("Bad transition to disconnecting state, " +
 520                                "previous connection state: " + oldstate);
 521                     return;
 522                 }
 523                 break;
 524
 525             default:
 526                 Log.Error("Unknown connection state: " + state);
 527                 return;
 528         }
 529
 530         // State change actions
 531
 532         this._rfb_connection_state = state;
 533         this._onUpdateState(this, state, oldstate);
 534
 535         var smsg = "New state '" + state + "', was '" + oldstate + "'.";
 536         Log.Debug(smsg);
 537
 538         if (this._disconnTimer && state !== 'disconnecting') {
 539             Log.Debug("Clearing disconnect timer");
 540             clearTimeout(this._disconnTimer);
 541             this._disconnTimer = null;
 542
 543             // make sure we don't get a double event
 544             this._sock.off('close');
 545         }
 546
 547         switch (state) {
 548             case 'disconnected':
 549                 // Call onDisconnected callback after onUpdateState since
 550                 // we don't know if the UI only displays the latest message
 551                 if (this._rfb_disconnect_reason !== "") {
 552                     this._onDisconnected(this, this._rfb_disconnect_reason);
 553                 } else {
 554                     // No reason means clean disconnect
 555                     this._onDisconnected(this);
 556                 }
 557                 break;
 558
 559             case 'connecting':
 560                 this._connect();
 561                 break;
 562
 563             case 'disconnecting':
 564                 this._disconnect();
 565
 566                 this._disconnTimer = setTimeout(function () {
 567                     this._rfb_disconnect_reason = _("Disconnect timeout");
 568                     this._updateConnectionState('disconnected');
 569                 }.bind(this), this._disconnectTimeout * 1000);
 570                 break;
 571         }
 572     },
 573
 574     /* Print errors and disconnect
 575      *
 576      * The optional parameter 'details' is used for information that
 577      * should be logged but not sent to the user interface.
 578      */
 579     _fail: function (msg, details) {
 580         var fullmsg = msg;
 581         if (typeof details !== 'undefined') {
 582             fullmsg = msg + " (" + details + ")";
 583         }
 584         switch (this._rfb_connection_state) {
 585             case 'disconnecting':
 586                 Log.Error("Failed when disconnecting: " + fullmsg);
 587                 break;
 588             case 'connected':
 589                 Log.Error("Failed while connected: " + fullmsg);
 590                 break;
 591             case 'connecting':
 592                 Log.Error("Failed when connecting: " + fullmsg);
 593                 break;
 594             default:
 595                 Log.Error("RFB failure: " + fullmsg);
 596                 break;
 597         }
 598         this._rfb_disconnect_reason = msg; //This is sent to the UI
 599
 600         // Transition to disconnected without waiting for socket to close
 601         this._updateConnectionState('disconnecting');
 602         this._updateConnectionState('disconnected');
 603
 604         return false;
 605     },
 606
 607     /*
 608      * Send a notification to the UI. Valid levels are:
 609      *   'normal'|'warn'|'error'
 610      *
 611      *   NOTE: Options could be added in the future.
 612      *   NOTE: If this function is called multiple times, remember that the
 613      *         interface could be only showing the latest notification.
 614      */
 615     _notification: function(msg, level, options) {
 616         switch (level) {
 617             case 'normal':
 618             case 'warn':
 619             case 'error':
 620                 Log.Debug("Notification[" + level + "]:" + msg);
 621                 break;
 622             default:
 623                 Log.Error("Invalid notification level: " + level);
 624                 return;
 625         }
 626
 627         if (options) {
 628             this._onNotification(this, msg, level, options);
 629         } else {
 630             this._onNotification(this, msg, level);
 631         }
 632     },
 633
 634     _handle_message: function () {
 635         if (this._sock.rQlen() === 0) {
 636             Log.Warn("handle_message called on an empty receive queue");
 637             return;
 638         }
 639
 640         switch (this._rfb_connection_state) {
 641             case 'disconnected':
 642                 Log.Error("Got data while disconnected");
 643                 break;
 644             case 'connected':
 645                 while (true) {
 646                     if (this._flushing) {
 647                         break;
 648                     }
 649                     if (!this._normal_msg()) {
 650                         break;
 651                     }
 652                     if (this._sock.rQlen() === 0) {
 653                         break;
 654                     }
 655                 }
 656                 break;
 657             default:
 658                 this._init_msg();
 659                 break;
 660         }
 661     },
 662
 663     _handleKeyEvent: function (keysym, code, down) {
 664         this.sendKey(keysym, code, down);
 665     },
 666
 667     _handleMouseButton: function (x, y, down, bmask) {
 668         if (down) {
 669             this._mouse_buttonMask |= bmask;
 670         } else {
 671             this._mouse_buttonMask &= ~bmask;
 672         }
 673
 674         if (this._viewportDrag) {
 675             if (down && !this._viewportDragging) {
 676                 this._viewportDragging = true;
 677                 this._viewportDragPos = {'x': x, 'y': y};
 678
 679                 // Skip sending mouse events
 680                 return;
 681             } else {
 682                 this._viewportDragging = false;
 683
 684                 // If the viewport didn't actually move, then treat as a mouse click event
 685                 // Send the button down event here, as the button up event is sent at the end of this function
 686                 if (!this._viewportHasMoved && !this._view_only) {
 687                     RFB.messages.pointerEvent(this._sock, this._display.absX(x), this._display.absY(y), bmask);
 688                 }
 689                 this._viewportHasMoved = false;
 690             }
 691         }
 692
 693         if (this._view_only) { return; } // View only, skip mouse events
 694
 695         if (this._rfb_connection_state !== 'connected') { return; }
 696         RFB.messages.pointerEvent(this._sock, this._display.absX(x), this._display.absY(y), this._mouse_buttonMask);
 697     },
 698
 699     _handleMouseMove: function (x, y) {
 700         if (this._viewportDragging) {
 701             var deltaX = this._viewportDragPos.x - x;
 702             var deltaY = this._viewportDragPos.y - y;
 703
 704             // The goal is to trigger on a certain physical width, the
 705             // devicePixelRatio brings us a bit closer but is not optimal.
 706             var dragThreshold = 10 * (window.devicePixelRatio || 1);
 707
 708             if (this._viewportHasMoved || (Math.abs(deltaX) > dragThreshold ||
 709                                            Math.abs(deltaY) > dragThreshold)) {
 710                 this._viewportHasMoved = true;
 711
 712                 this._viewportDragPos = {'x': x, 'y': y};
 713                 this._display.viewportChangePos(deltaX, deltaY);
 714             }
 715
 716             // Skip sending mouse events
 717             return;
 718         }
 719
 720         if (this._view_only) { return; } // View only, skip mouse events
 721
 722         if (this._rfb_connection_state !== 'connected') { return; }
 723         RFB.messages.pointerEvent(this._sock, this._display.absX(x), this._display.absY(y), this._mouse_buttonMask);
 724     },
 725
 726     // Message Handlers
 727
 728     _negotiate_protocol_version: function () {
 729         if (this._sock.rQlen() < 12) {
 730             return this._fail("Error while negotiating with server",
 731                               "Incomplete protocol version");
 732         }
 733
 734         var sversion = this._sock.rQshiftStr(12).substr(4, 7);
 735         Log.Info("Server ProtocolVersion: " + sversion);
 736         var is_repeater = 0;
 737         switch (sversion) {
 738             case "000.000":  // UltraVNC repeater
 739                 is_repeater = 1;
 740                 break;
 741             case "003.003":
 742             case "003.006":  // UltraVNC
 743             case "003.889":  // Apple Remote Desktop
 744                 this._rfb_version = 3.3;
 745                 break;
 746             case "003.007":
 747                 this._rfb_version = 3.7;
 748                 break;
 749             case "003.008":
 750             case "004.000":  // Intel AMT KVM
 751             case "004.001":  // RealVNC 4.6
 752             case "005.000":  // RealVNC 5.3
 753                 this._rfb_version = 3.8;
 754                 break;
 755             default:
 756                 return this._fail("Unsupported server",
 757                                   "Invalid server version: " + sversion);
 758         }
 759
 760         if (is_repeater) {
 761             var repeaterID = this._repeaterID;
 762             while (repeaterID.length < 250) {
 763                 repeaterID += "\0";
 764             }
 765             this._sock.send_string(repeaterID);
 766             return true;
 767         }
 768
 769         if (this._rfb_version > this._rfb_max_version) {
 770             this._rfb_version = this._rfb_max_version;
 771         }
 772
 773         var cversion = "00" + parseInt(this._rfb_version, 10) +
 774                        ".00" + ((this._rfb_version * 10) % 10);
 775         this._sock.send_string("RFB " + cversion + "\n");
 776         Log.Debug('Sent ProtocolVersion: ' + cversion);
 777
 778         this._rfb_init_state = 'Security';
 779     },
 780
 781     _negotiate_security: function () {
 782         // Polyfill since IE and PhantomJS doesn't have
 783         // TypedArray.includes()
 784         function includes(item, array) {
 785             for (var i = 0; i < array.length; i++) {
 786                 if (array[i] === item) {
 787                     return true;
 788                 }
 789             }
 790             return false;
 791         }
 792
 793         if (this._rfb_version >= 3.7) {
 794             // Server sends supported list, client decides
 795             var num_types = this._sock.rQshift8();
 796             if (this._sock.rQwait("security type", num_types, 1)) { return false; }
 797
 798             if (num_types === 0) {
 799                 var strlen = this._sock.rQshift32();
 800                 var reason = this._sock.rQshiftStr(strlen);
 801                 return this._fail("Error while negotiating with server",
 802                                   "Security failure: " + reason);
 803             }
 804
 805             var types = this._sock.rQshiftBytes(num_types);
 806             Log.Debug("Server security types: " + types);
 807
 808             // Look for each auth in preferred order
 809             this._rfb_auth_scheme = 0;
 810             if (includes(1, types)) {
 811                 this._rfb_auth_scheme = 1; // None
 812             } else if (includes(22, types)) {
 813                 this._rfb_auth_scheme = 22; // XVP
 814             } else if (includes(16, types)) {
 815                 this._rfb_auth_scheme = 16; // Tight
 816             } else if (includes(2, types)) {
 817                 this._rfb_auth_scheme = 2; // VNC Auth
 818             } else {
 819                 return this._fail("Unsupported server",
 820                                   "Unsupported security types: " + types);
 821             }
 822
 823             this._sock.send([this._rfb_auth_scheme]);
 824         } else {
 825             // Server decides
 826             if (this._sock.rQwait("security scheme", 4)) { return false; }
 827             this._rfb_auth_scheme = this._sock.rQshift32();
 828         }
 829
 830         this._rfb_init_state = 'Authentication';
 831         Log.Debug('Authenticating using scheme: ' + this._rfb_auth_scheme);
 832
 833         return this._init_msg(); // jump to authentication
 834     },
 835
 836     // authentication
 837     _negotiate_xvp_auth: function () {
 838         var xvp_sep = this._xvp_password_sep;
 839         var xvp_auth = this._rfb_password.split(xvp_sep);
 840         if (xvp_auth.length < 3) {
 841             var msg = 'XVP credentials required (user' + xvp_sep +
 842                 'target' + xvp_sep + 'password) -- got only ' + this._rfb_password;
 843             this._onPasswordRequired(this, msg);
 844             return false;
 845         }
 846
 847         var xvp_auth_str = String.fromCharCode(xvp_auth[0].length) +
 848                            String.fromCharCode(xvp_auth[1].length) +
 849                            xvp_auth[0] +
 850                            xvp_auth[1];
 851         this._sock.send_string(xvp_auth_str);
 852         this._rfb_password = xvp_auth.slice(2).join(xvp_sep);
 853         this._rfb_auth_scheme = 2;
 854         return this._negotiate_authentication();
 855     },
 856
 857     _negotiate_std_vnc_auth: function () {
 858         if (this._rfb_password.length === 0) {
 859             this._onPasswordRequired(this);
 860             return false;
 861         }
 862
 863         if (this._sock.rQwait("auth challenge", 16)) { return false; }
 864
 865         // TODO(directxman12): make genDES not require an Array
 866         var challenge = Array.prototype.slice.call(this._sock.rQshiftBytes(16));
 867         var response = RFB.genDES(this._rfb_password, challenge);
 868         this._sock.send(response);
 869         this._rfb_init_state = "SecurityResult";
 870         return true;
 871     },
 872
 873     _negotiate_tight_tunnels: function (numTunnels) {
 874         var clientSupportedTunnelTypes = {
 875             0: { vendor: 'TGHT', signature: 'NOTUNNEL' }
 876         };
 877         var serverSupportedTunnelTypes = {};
 878         // receive tunnel capabilities
 879         for (var i = 0; i < numTunnels; i++) {
 880             var cap_code = this._sock.rQshift32();
 881             var cap_vendor = this._sock.rQshiftStr(4);
 882             var cap_signature = this._sock.rQshiftStr(8);
 883             serverSupportedTunnelTypes[cap_code] = { vendor: cap_vendor, signature: cap_signature };
 884         }
 885
 886         // choose the notunnel type
 887         if (serverSupportedTunnelTypes[0]) {
 888             if (serverSupportedTunnelTypes[0].vendor != clientSupportedTunnelTypes[0].vendor ||
 889                 serverSupportedTunnelTypes[0].signature != clientSupportedTunnelTypes[0].signature) {
 890                 return this._fail("Unsupported server",
 891                                   "Client's tunnel type had the incorrect " +
 892                                   "vendor or signature");
 893             }
 894             this._sock.send([0, 0, 0, 0]);  // use NOTUNNEL
 895             return false; // wait until we receive the sub auth count to continue
 896         } else {
 897             return this._fail("Unsupported server",
 898                               "Server wanted tunnels, but doesn't support " +
 899                               "the notunnel type");
 900         }
 901     },
 902
 903     _negotiate_tight_auth: function () {
 904         if (!this._rfb_tightvnc) {  // first pass, do the tunnel negotiation
 905             if (this._sock.rQwait("num tunnels", 4)) { return false; }
 906             var numTunnels = this._sock.rQshift32();
 907             if (numTunnels > 0 && this._sock.rQwait("tunnel capabilities", 16 * numTunnels, 4)) { return false; }
 908
 909             this._rfb_tightvnc = true;
 910
 911             if (numTunnels > 0) {
 912                 this._negotiate_tight_tunnels(numTunnels);
 913                 return false;  // wait until we receive the sub auth to continue
 914             }
 915         }
 916
 917         // second pass, do the sub-auth negotiation
 918         if (this._sock.rQwait("sub auth count", 4)) { return false; }
 919         var subAuthCount = this._sock.rQshift32();
 920         if (subAuthCount === 0) {  // empty sub-auth list received means 'no auth' subtype selected
 921             this._rfb_init_state = 'SecurityResult';
 922             return true;
 923         }
 924
 925         if (this._sock.rQwait("sub auth capabilities", 16 * subAuthCount, 4)) { return false; }
 926
 927         var clientSupportedTypes = {
 928             'STDVNOAUTH__': 1,
 929             'STDVVNCAUTH_': 2
 930         };
 931
 932         var serverSupportedTypes = [];
 933
 934         for (var i = 0; i < subAuthCount; i++) {
 935             var capNum = this._sock.rQshift32();
 936             var capabilities = this._sock.rQshiftStr(12);
 937             serverSupportedTypes.push(capabilities);
 938         }
 939
 940         for (var authType in clientSupportedTypes) {
 941             if (serverSupportedTypes.indexOf(authType) != -1) {
 942                 this._sock.send([0, 0, 0, clientSupportedTypes[authType]]);
 943
 944                 switch (authType) {
 945                     case 'STDVNOAUTH__':  // no auth
 946                         this._rfb_init_state = 'SecurityResult';
 947                         return true;
 948                     case 'STDVVNCAUTH_': // VNC auth
 949                         this._rfb_auth_scheme = 2;
 950                         return this._init_msg();
 951                     default:
 952                         return this._fail("Unsupported server",
 953                                           "Unsupported tiny auth scheme: " +
 954                                           authType);
 955                 }
 956             }
 957         }
 958
 959         return this._fail("Unsupported server",
 960                           "No supported sub-auth types!");
 961     },
 962
 963     _negotiate_authentication: function () {
 964         switch (this._rfb_auth_scheme) {
 965             case 0:  // connection failed
 966                 if (this._sock.rQwait("auth reason", 4)) { return false; }
 967                 var strlen = this._sock.rQshift32();
 968                 var reason = this._sock.rQshiftStr(strlen);
 969                 return this._fail("Authentication failure", reason);
 970
 971             case 1:  // no auth
 972                 if (this._rfb_version >= 3.8) {
 973                     this._rfb_init_state = 'SecurityResult';
 974                     return true;
 975                 }
 976                 this._rfb_init_state = 'ClientInitialisation';
 977                 return this._init_msg();
 978
 979             case 22:  // XVP auth
 980                 return this._negotiate_xvp_auth();
 981
 982             case 2:  // VNC authentication
 983                 return this._negotiate_std_vnc_auth();
 984
 985             case 16:  // TightVNC Security Type
 986                 return this._negotiate_tight_auth();
 987
 988             default:
 989                 return this._fail("Unsupported server",
 990                                   "Unsupported auth scheme: " +
 991                                   this._rfb_auth_scheme);
 992         }
 993     },
 994
 995     _handle_security_result: function () {
 996         if (this._sock.rQwait('VNC auth response ', 4)) { return false; }
 997         switch (this._sock.rQshift32()) {
 998             case 0:  // OK
 999                 this._rfb_init_state = 'ClientInitialisation';
1000                 Log.Debug('Authentication OK');
1001                 return this._init_msg();
1002             case 1:  // failed
1003                 if (this._rfb_version >= 3.8) {
1004                     var length = this._sock.rQshift32();
1005                     if (this._sock.rQwait("SecurityResult reason", length, 8)) { return false; }
1006                     var reason = this._sock.rQshiftStr(length);
1007                     return this._fail("Authentication failure", reason);
1008                 } else {
1009                     return this._fail("Authentication failure");
1010                 }
1011                 return false;
1012             case 2:
1013                 return this._fail("Too many authentication attempts");
1014             default:
1015                 return this._fail("Unsupported server",
1016                                   "Unknown SecurityResult");
1017         }
1018     },
1019
1020     _negotiate_server_init: function () {
1021         if (this._sock.rQwait("server initialization", 24)) { return false; }
1022
1023         /* Screen size */
1024         this._fb_width  = this._sock.rQshift16();
1025         this._fb_height = this._sock.rQshift16();
1026         this._destBuff = new Uint8Array(this._fb_width * this._fb_height * 4);
1027
1028         /* PIXEL_FORMAT */
1029         var bpp         = this._sock.rQshift8();
1030         var depth       = this._sock.rQshift8();
1031         var big_endian  = this._sock.rQshift8();
1032         var true_color  = this._sock.rQshift8();
1033
1034         var red_max     = this._sock.rQshift16();
1035         var green_max   = this._sock.rQshift16();
1036         var blue_max    = this._sock.rQshift16();
1037         var red_shift   = this._sock.rQshift8();
1038         var green_shift = this._sock.rQshift8();
1039         var blue_shift  = this._sock.rQshift8();
1040         this._sock.rQskipBytes(3);  // padding
1041
1042         // NB(directxman12): we don't want to call any callbacks or print messages until
1043         //                   *after* we're past the point where we could backtrack
1044
1045         /* Connection name/title */
1046         var name_length = this._sock.rQshift32();
1047         if (this._sock.rQwait('server init name', name_length, 24)) { return false; }
1048         this._fb_name = decodeUTF8(this._sock.rQshiftStr(name_length));
1049
1050         if (this._rfb_tightvnc) {
1051             if (this._sock.rQwait('TightVNC extended server init header', 8, 24 + name_length)) { return false; }
1052             // In TightVNC mode, ServerInit message is extended
1053             var numServerMessages = this._sock.rQshift16();
1054             var numClientMessages = this._sock.rQshift16();
1055             var numEncodings = this._sock.rQshift16();
1056             this._sock.rQskipBytes(2);  // padding
1057
1058             var totalMessagesLength = (numServerMessages + numClientMessages + numEncodings) * 16;
1059             if (this._sock.rQwait('TightVNC extended server init header', totalMessagesLength, 32 + name_length)) { return false; }
1060
1061             // we don't actually do anything with the capability information that TIGHT sends,
1062             // so we just skip the all of this.
1063
1064             // TIGHT server message capabilities
1065             this._sock.rQskipBytes(16 * numServerMessages);
1066
1067             // TIGHT client message capabilities
1068             this._sock.rQskipBytes(16 * numClientMessages);
1069
1070             // TIGHT encoding capabilities
1071             this._sock.rQskipBytes(16 * numEncodings);
1072         }
1073
1074         // NB(directxman12): these are down here so that we don't run them multiple times
1075         //                   if we backtrack
1076         Log.Info("Screen: " + this._fb_width + "x" + this._fb_height +
1077                   ", bpp: " + bpp + ", depth: " + depth +
1078                   ", big_endian: " + big_endian +
1079                   ", true_color: " + true_color +
1080                   ", red_max: " + red_max +
1081                   ", green_max: " + green_max +
1082                   ", blue_max: " + blue_max +
1083                   ", red_shift: " + red_shift +
1084                   ", green_shift: " + green_shift +
1085                   ", blue_shift: " + blue_shift);
1086
1087         if (big_endian !== 0) {
1088             Log.Warn("Server native endian is not little endian");
1089         }
1090
1091         if (red_shift !== 16) {
1092             Log.Warn("Server native red-shift is not 16");
1093         }
1094
1095         if (blue_shift !== 0) {
1096             Log.Warn("Server native blue-shift is not 0");
1097         }
1098
1099         // we're past the point where we could backtrack, so it's safe to call this
1100         this._onDesktopName(this, this._fb_name);
1101
1102         this._display.resize(this._fb_width, this._fb_height);
1103         this._onFBResize(this, this._fb_width, this._fb_height);
1104
1105         if (!this._view_only) { this._keyboard.grab(); }
1106         if (!this._view_only) { this._mouse.grab(); }
1107
1108         RFB.messages.pixelFormat(this._sock, 4, 3, true);
1109         RFB.messages.clientEncodings(this._sock, this._encodings, this._local_cursor);
1110         RFB.messages.fbUpdateRequest(this._sock, false, 0, 0, this._fb_width, this._fb_height);
1111
1112         this._timing.fbu_rt_start = (new Date()).getTime();
1113         this._timing.pixels = 0;
1114
1115         this._updateConnectionState('connected');
1116         return true;
1117     },
1118
1119     /* RFB protocol initialization states:
1120      *   ProtocolVersion
1121      *   Security
1122      *   Authentication
1123      *   SecurityResult
1124      *   ClientInitialization - not triggered by server message
1125      *   ServerInitialization
1126      */
1127     _init_msg: function () {
1128         switch (this._rfb_init_state) {
1129             case 'ProtocolVersion':
1130                 return this._negotiate_protocol_version();
1131
1132             case 'Security':
1133                 return this._negotiate_security();
1134
1135             case 'Authentication':
1136                 return this._negotiate_authentication();
1137
1138             case 'SecurityResult':
1139                 return this._handle_security_result();
1140
1141             case 'ClientInitialisation':
1142                 this._sock.send([this._shared ? 1 : 0]); // ClientInitialisation
1143                 this._rfb_init_state = 'ServerInitialisation';
1144                 return true;
1145
1146             case 'ServerInitialisation':
1147                 return this._negotiate_server_init();
1148
1149             default:
1150                 return this._fail("Internal error", "Unknown init state: " +
1151                                   this._rfb_init_state);
1152         }
1153     },
1154
1155     _handle_set_colour_map_msg: function () {
1156         Log.Debug("SetColorMapEntries");
1157
1158         return this._fail("Protocol error", "Unexpected SetColorMapEntries message");
1159     },
1160
1161     _handle_server_cut_text: function () {
1162         Log.Debug("ServerCutText");
1163
1164         if (this._sock.rQwait("ServerCutText header", 7, 1)) { return false; }
1165         this._sock.rQskipBytes(3);  // Padding
1166         var length = this._sock.rQshift32();
1167         if (this._sock.rQwait("ServerCutText", length, 8)) { return false; }
1168
1169         var text = this._sock.rQshiftStr(length);
1170
1171         if (this._view_only) { return true; }
1172
1173         this._onClipboard(this, text);
1174
1175         return true;
1176     },
1177
1178     _handle_server_fence_msg: function() {
1179         if (this._sock.rQwait("ServerFence header", 8, 1)) { return false; }
1180         this._sock.rQskipBytes(3); // Padding
1181         var flags = this._sock.rQshift32();
1182         var length = this._sock.rQshift8();
1183
1184         if (this._sock.rQwait("ServerFence payload", length, 9)) { return false; }
1185
1186         if (length > 64) {
1187             Log.Warn("Bad payload length (" + length + ") in fence response");
1188             length = 64;
1189         }
1190
1191         var payload = this._sock.rQshiftStr(length);
1192
1193         this._supportsFence = true;
1194
1195         /*
1196          * Fence flags
1197          *
1198          *  (1<<0)  - BlockBefore
1199          *  (1<<1)  - BlockAfter
1200          *  (1<<2)  - SyncNext
1201          *  (1<<31) - Request
1202          */
1203
1204         if (!(flags & (1<<31))) {
1205             return this._fail("Internal error",
1206                               "Unexpected fence response");
1207         }
1208
1209         // Filter out unsupported flags
1210         // FIXME: support syncNext
1211         flags &= (1<<0) | (1<<1);
1212
1213         // BlockBefore and BlockAfter are automatically handled by
1214         // the fact that we process each incoming message
1215         // synchronuosly.
1216         RFB.messages.clientFence(this._sock, flags, payload);
1217
1218         return true;
1219     },
1220
1221     _handle_xvp_msg: function () {
1222         if (this._sock.rQwait("XVP version and message", 3, 1)) { return false; }
1223         this._sock.rQskip8();  // Padding
1224         var xvp_ver = this._sock.rQshift8();
1225         var xvp_msg = this._sock.rQshift8();
1226
1227         switch (xvp_msg) {
1228             case 0:  // XVP_FAIL
1229                 Log.Error("Operation Failed");
1230                 this._notification("XVP Operation Failed", 'error');
1231                 break;
1232             case 1:  // XVP_INIT
1233                 this._rfb_xvp_ver = xvp_ver;
1234                 Log.Info("XVP extensions enabled (version " + this._rfb_xvp_ver + ")");
1235                 this._onXvpInit(this._rfb_xvp_ver);
1236                 break;
1237             default:
1238                 this._fail("Unexpected server message",
1239                            "Illegal server XVP message " + xvp_msg);
1240                 break;
1241         }
1242
1243         return true;
1244     },
1245
1246     _normal_msg: function () {
1247         var msg_type;
1248
1249         if (this._FBU.rects > 0) {
1250             msg_type = 0;
1251         } else {
1252             msg_type = this._sock.rQshift8();
1253         }
1254
1255         switch (msg_type) {
1256             case 0:  // FramebufferUpdate
1257                 var ret = this._framebufferUpdate();
1258                 if (ret && !this._enabledContinuousUpdates) {
1259                     RFB.messages.fbUpdateRequest(this._sock, true, 0, 0,
1260                                                  this._fb_width, this._fb_height);
1261                 }
1262                 return ret;
1263
1264             case 1:  // SetColorMapEntries
1265                 return this._handle_set_colour_map_msg();
1266
1267             case 2:  // Bell
1268                 Log.Debug("Bell");
1269                 this._onBell(this);
1270                 return true;
1271
1272             case 3:  // ServerCutText
1273                 return this._handle_server_cut_text();
1274
1275             case 150: // EndOfContinuousUpdates
1276                 var first = !(this._supportsContinuousUpdates);
1277                 this._supportsContinuousUpdates = true;
1278                 this._enabledContinuousUpdates = false;
1279                 if (first) {
1280                     this._enabledContinuousUpdates = true;
1281                     this._updateContinuousUpdates();
1282                     Log.Info("Enabling continuous updates.");
1283                 } else {
1284                     // FIXME: We need to send a framebufferupdaterequest here
1285                     // if we add support for turning off continuous updates
1286                 }
1287                 return true;
1288
1289             case 248: // ServerFence
1290                 return this._handle_server_fence_msg();
1291
1292             case 250:  // XVP
1293                 return this._handle_xvp_msg();
1294
1295             default:
1296                 this._fail("Unexpected server message", "Type:" + msg_type);
1297                 Log.Debug("sock.rQslice(0, 30): " + this._sock.rQslice(0, 30));
1298                 return true;
1299         }
1300     },
1301
1302     _onFlush: function() {
1303         this._flushing = false;
1304         // Resume processing
1305         if (this._sock.rQlen() > 0) {
1306             this._handle_message();
1307         }
1308     },
1309
1310     _framebufferUpdate: function () {
1311         var ret = true;
1312         var now;
1313
1314         if (this._FBU.rects === 0) {
1315             if (this._sock.rQwait("FBU header", 3, 1)) { return false; }
1316             this._sock.rQskip8();  // Padding
1317             this._FBU.rects = this._sock.rQshift16();
1318             this._FBU.bytes = 0;
1319             this._timing.cur_fbu = 0;
1320             if (this._timing.fbu_rt_start > 0) {
1321                 now = (new Date()).getTime();
1322                 Log.Info("First FBU latency: " + (now - this._timing.fbu_rt_start));
1323             }
1324
1325             // Make sure the previous frame is fully rendered first
1326             // to avoid building up an excessive queue
1327             if (this._display.pending()) {
1328                 this._flushing = true;
1329                 this._display.flush();
1330                 return false;
1331             }
1332         }
1333
1334         while (this._FBU.rects > 0) {
1335             if (this._rfb_connection_state !== 'connected') { return false; }
1336
1337             if (this._sock.rQwait("FBU", this._FBU.bytes)) { return false; }
1338             if (this._FBU.bytes === 0) {
1339                 if (this._sock.rQwait("rect header", 12)) { return false; }
1340                 /* New FramebufferUpdate */
1341
1342                 var hdr = this._sock.rQshiftBytes(12);
1343                 this._FBU.x        = (hdr[0] << 8) + hdr[1];
1344                 this._FBU.y        = (hdr[2] << 8) + hdr[3];
1345                 this._FBU.width    = (hdr[4] << 8) + hdr[5];
1346                 this._FBU.height   = (hdr[6] << 8) + hdr[7];
1347                 this._FBU.encoding = parseInt((hdr[8] << 24) + (hdr[9] << 16) +
1348                                               (hdr[10] << 8) + hdr[11], 10);
1349
1350                 this._onFBUReceive(this,
1351                     {'x': this._FBU.x, 'y': this._FBU.y,
1352                      'width': this._FBU.width, 'height': this._FBU.height,
1353                      'encoding': this._FBU.encoding,
1354                      'encodingName': this._encNames[this._FBU.encoding]});
1355
1356                 if (!this._encNames[this._FBU.encoding]) {
1357                     this._fail("Unexpected server message",
1358                                "Unsupported encoding " +
1359                                this._FBU.encoding);
1360                     return false;
1361                 }
1362             }
1363
1364             this._timing.last_fbu = (new Date()).getTime();
1365
1366             ret = this._encHandlers[this._FBU.encoding]();
1367
1368             now = (new Date()).getTime();
1369             this._timing.cur_fbu += (now - this._timing.last_fbu);
1370
1371             if (ret) {
1372                 this._encStats[this._FBU.encoding][0]++;
1373                 this._encStats[this._FBU.encoding][1]++;
1374                 this._timing.pixels += this._FBU.width * this._FBU.height;
1375             }
1376
1377             if (this._timing.pixels >= (this._fb_width * this._fb_height)) {
1378                 if ((this._FBU.width === this._fb_width && this._FBU.height === this._fb_height) ||
1379                     this._timing.fbu_rt_start > 0) {
1380                     this._timing.full_fbu_total += this._timing.cur_fbu;
1381                     this._timing.full_fbu_cnt++;
1382                     Log.Info("Timing of full FBU, curr: " +
1383                               this._timing.cur_fbu + ", total: " +
1384                               this._timing.full_fbu_total + ", cnt: " +
1385                               this._timing.full_fbu_cnt + ", avg: " +
1386                               (this._timing.full_fbu_total / this._timing.full_fbu_cnt));
1387                 }
1388
1389                 if (this._timing.fbu_rt_start > 0) {
1390                     var fbu_rt_diff = now - this._timing.fbu_rt_start;
1391                     this._timing.fbu_rt_total += fbu_rt_diff;
1392                     this._timing.fbu_rt_cnt++;
1393                     Log.Info("full FBU round-trip, cur: " +
1394                               fbu_rt_diff + ", total: " +
1395                               this._timing.fbu_rt_total + ", cnt: " +
1396                               this._timing.fbu_rt_cnt + ", avg: " +
1397                               (this._timing.fbu_rt_total / this._timing.fbu_rt_cnt));
1398                     this._timing.fbu_rt_start = 0;
1399                 }
1400             }
1401
1402             if (!ret) { return ret; }  // need more data
1403         }
1404
1405         this._display.flip();
1406
1407         this._onFBUComplete(this,
1408                 {'x': this._FBU.x, 'y': this._FBU.y,
1409                  'width': this._FBU.width, 'height': this._FBU.height,
1410                  'encoding': this._FBU.encoding,
1411                  'encodingName': this._encNames[this._FBU.encoding]});
1412
1413         return true;  // We finished this FBU
1414     },
1415
1416     _updateContinuousUpdates: function() {
1417         if (!this._enabledContinuousUpdates) { return; }
1418
1419         RFB.messages.enableContinuousUpdates(this._sock, true, 0, 0,
1420                                              this._fb_width, this._fb_height);
1421     }
1422 };
1423
1424 make_properties(RFB, [
1425     ['target', 'wo', 'dom'],                // VNC display rendering Canvas object
1426     ['focusContainer', 'wo', 'dom'],        // DOM element that captures keyboard input
1427     ['encrypt', 'rw', 'bool'],              // Use TLS/SSL/wss encryption
1428     ['local_cursor', 'rw', 'bool'],         // Request locally rendered cursor
1429     ['shared', 'rw', 'bool'],               // Request shared mode
1430     ['view_only', 'rw', 'bool'],            // Disable client mouse/keyboard
1431     ['xvp_password_sep', 'rw', 'str'],      // Separator for XVP password fields
1432     ['disconnectTimeout', 'rw', 'int'],     // Time (s) to wait for disconnection
1433     ['wsProtocols', 'rw', 'arr'],           // Protocols to use in the WebSocket connection
1434     ['repeaterID', 'rw', 'str'],            // [UltraVNC] RepeaterID to connect to
1435     ['viewportDrag', 'rw', 'bool'],         // Move the viewport on mouse drags
1436
1437     // Callback functions
1438     ['onUpdateState', 'rw', 'func'],        // onUpdateState(rfb, state, oldstate): connection state change
1439     ['onNotification', 'rw', 'func'],       // onNotification(rfb, msg, level, options): notification for the UI
1440     ['onDisconnected', 'rw', 'func'],       // onDisconnected(rfb, reason): disconnection finished
1441     ['onPasswordRequired', 'rw', 'func'],   // onPasswordRequired(rfb, msg): VNC password is required
1442     ['onClipboard', 'rw', 'func'],          // onClipboard(rfb, text): RFB clipboard contents received
1443     ['onBell', 'rw', 'func'],               // onBell(rfb): RFB Bell message received
1444     ['onFBUReceive', 'rw', 'func'],         // onFBUReceive(rfb, fbu): RFB FBU received but not yet processed
1445     ['onFBUComplete', 'rw', 'func'],        // onFBUComplete(rfb, fbu): RFB FBU received and processed
1446     ['onFBResize', 'rw', 'func'],           // onFBResize(rfb, width, height): frame buffer resized
1447     ['onDesktopName', 'rw', 'func'],        // onDesktopName(rfb, name): desktop name received
1448     ['onXvpInit', 'rw', 'func']             // onXvpInit(version): XVP extensions active for this connection
1449 ]);
1450
1451 RFB.prototype.set_local_cursor = function (cursor) {
1452     if (!cursor || (cursor in {'0': 1, 'no': 1, 'false': 1})) {
1453         this._local_cursor = false;
1454         this._display.disableLocalCursor(); //Only show server-side cursor
1455     } else {
1456         if (this._display.get_cursor_uri()) {
1457             this._local_cursor = true;
1458         } else {
1459             Log.Warn("Browser does not support local cursor");
1460             this._display.disableLocalCursor();
1461         }
1462     }
1463
1464     // Need to send an updated list of encodings if we are connected
1465     if (this._rfb_connection_state === "connected") {
1466         RFB.messages.clientEncodings(this._sock, this._encodings, cursor);
1467     }
1468 };
1469
1470 RFB.prototype.set_view_only = function (view_only) {
1471     this._view_only = view_only;
1472
1473     if (this._rfb_connection_state === "connecting" ||
1474         this._rfb_connection_state === "connected") {
1475         if (view_only) {
1476             this._keyboard.ungrab();
1477             this._mouse.ungrab();
1478         } else {
1479             this._keyboard.grab();
1480             this._mouse.grab();
1481         }
1482     }
1483 };
1484
1485 RFB.prototype.get_display = function () { return this._display; };
1486 RFB.prototype.get_keyboard = function () { return this._keyboard; };
1487 RFB.prototype.get_mouse = function () { return this._mouse; };
1488
1489 // Class Methods
1490 RFB.messages = {
1491     keyEvent: function (sock, keysym, down) {
1492         var buff = sock._sQ;
1493         var offset = sock._sQlen;
1494
1495         buff[offset] = 4;  // msg-type
1496         buff[offset + 1] = down;
1497
1498         buff[offset + 2] = 0;
1499         buff[offset + 3] = 0;
1500
1501         buff[offset + 4] = (keysym >> 24);
1502         buff[offset + 5] = (keysym >> 16);
1503         buff[offset + 6] = (keysym >> 8);
1504         buff[offset + 7] = keysym;
1505
1506         sock._sQlen += 8;
1507         sock.flush();
1508     },
1509
1510     QEMUExtendedKeyEvent: function (sock, keysym, down, keycode) {
1511         function getRFBkeycode(xt_scancode) {
1512             var upperByte = (keycode >> 8);
1513             var lowerByte = (keycode & 0x00ff);
1514             if (upperByte === 0xe0 && lowerByte < 0x7f) {
1515                 lowerByte = lowerByte | 0x80;
1516                 return lowerByte;
1517             }
1518             return xt_scancode;
1519         }
1520
1521         var buff = sock._sQ;
1522         var offset = sock._sQlen;
1523
1524         buff[offset] = 255; // msg-type
1525         buff[offset + 1] = 0; // sub msg-type
1526
1527         buff[offset + 2] = (down >> 8);
1528         buff[offset + 3] = down;
1529
1530         buff[offset + 4] = (keysym >> 24);
1531         buff[offset + 5] = (keysym >> 16);
1532         buff[offset + 6] = (keysym >> 8);
1533         buff[offset + 7] = keysym;
1534
1535         var RFBkeycode = getRFBkeycode(keycode);
1536
1537         buff[offset + 8] = (RFBkeycode >> 24);
1538         buff[offset + 9] = (RFBkeycode >> 16);
1539         buff[offset + 10] = (RFBkeycode >> 8);
1540         buff[offset + 11] = RFBkeycode;
1541
1542         sock._sQlen += 12;
1543         sock.flush();
1544     },
1545
1546     pointerEvent: function (sock, x, y, mask) {
1547         var buff = sock._sQ;
1548         var offset = sock._sQlen;
1549
1550         buff[offset] = 5; // msg-type
1551
1552         buff[offset + 1] = mask;
1553
1554         buff[offset + 2] = x >> 8;
1555         buff[offset + 3] = x;
1556
1557         buff[offset + 4] = y >> 8;
1558         buff[offset + 5] = y;
1559
1560         sock._sQlen += 6;
1561         sock.flush();
1562     },
1563
1564     // TODO(directxman12): make this unicode compatible?
1565     clientCutText: function (sock, text) {
1566         var buff = sock._sQ;
1567         var offset = sock._sQlen;
1568
1569         buff[offset] = 6; // msg-type
1570
1571         buff[offset + 1] = 0; // padding
1572         buff[offset + 2] = 0; // padding
1573         buff[offset + 3] = 0; // padding
1574
1575         var n = text.length;
1576
1577         buff[offset + 4] = n >> 24;
1578         buff[offset + 5] = n >> 16;
1579         buff[offset + 6] = n >> 8;
1580         buff[offset + 7] = n;
1581
1582         for (var i = 0; i < n; i++) {
1583             buff[offset + 8 + i] =  text.charCodeAt(i);
1584         }
1585
1586         sock._sQlen += 8 + n;
1587         sock.flush();
1588     },
1589
1590     setDesktopSize: function (sock, width, height, id, flags) {
1591         var buff = sock._sQ;
1592         var offset = sock._sQlen;
1593
1594         buff[offset] = 251;              // msg-type
1595         buff[offset + 1] = 0;            // padding
1596         buff[offset + 2] = width >> 8;   // width
1597         buff[offset + 3] = width;
1598         buff[offset + 4] = height >> 8;  // height
1599         buff[offset + 5] = height;
1600
1601         buff[offset + 6] = 1;            // number-of-screens
1602         buff[offset + 7] = 0;            // padding
1603
1604         // screen array
1605         buff[offset + 8] = id >> 24;     // id
1606         buff[offset + 9] = id >> 16;
1607         buff[offset + 10] = id >> 8;
1608         buff[offset + 11] = id;
1609         buff[offset + 12] = 0;           // x-position
1610         buff[offset + 13] = 0;
1611         buff[offset + 14] = 0;           // y-position
1612         buff[offset + 15] = 0;
1613         buff[offset + 16] = width >> 8;  // width
1614         buff[offset + 17] = width;
1615         buff[offset + 18] = height >> 8; // height
1616         buff[offset + 19] = height;
1617         buff[offset + 20] = flags >> 24; // flags
1618         buff[offset + 21] = flags >> 16;
1619         buff[offset + 22] = flags >> 8;
1620         buff[offset + 23] = flags;
1621
1622         sock._sQlen += 24;
1623         sock.flush();
1624     },
1625
1626     clientFence: function (sock, flags, payload) {
1627         var buff = sock._sQ;
1628         var offset = sock._sQlen;
1629
1630         buff[offset] = 248; // msg-type
1631
1632         buff[offset + 1] = 0; // padding
1633         buff[offset + 2] = 0; // padding
1634         buff[offset + 3] = 0; // padding
1635
1636         buff[offset + 4] = flags >> 24; // flags
1637         buff[offset + 5] = flags >> 16;
1638         buff[offset + 6] = flags >> 8;
1639         buff[offset + 7] = flags;
1640
1641         var n = payload.length;
1642
1643         buff[offset + 8] = n; // length
1644
1645         for (var i = 0; i < n; i++) {
1646             buff[offset + 9 + i] = payload.charCodeAt(i);
1647         }
1648
1649         sock._sQlen += 9 + n;
1650         sock.flush();
1651     },
1652
1653     enableContinuousUpdates: function (sock, enable, x, y, width, height) {
1654         var buff = sock._sQ;
1655         var offset = sock._sQlen;
1656
1657         buff[offset] = 150;             // msg-type
1658         buff[offset + 1] = enable;      // enable-flag
1659
1660         buff[offset + 2] = x >> 8;      // x
1661         buff[offset + 3] = x;
1662         buff[offset + 4] = y >> 8;      // y
1663         buff[offset + 5] = y;
1664         buff[offset + 6] = width >> 8;  // width
1665         buff[offset + 7] = width;
1666         buff[offset + 8] = height >> 8; // height
1667         buff[offset + 9] = height;
1668
1669         sock._sQlen += 10;
1670         sock.flush();
1671     },
1672
1673     pixelFormat: function (sock, bpp, depth, true_color) {
1674         var buff = sock._sQ;
1675         var offset = sock._sQlen;
1676
1677         buff[offset] = 0;  // msg-type
1678
1679         buff[offset + 1] = 0; // padding
1680         buff[offset + 2] = 0; // padding
1681         buff[offset + 3] = 0; // padding
1682
1683         buff[offset + 4] = bpp * 8;             // bits-per-pixel
1684         buff[offset + 5] = depth * 8;           // depth
1685         buff[offset + 6] = 0;                   // little-endian
1686         buff[offset + 7] = true_color ? 1 : 0;  // true-color
1687
1688         buff[offset + 8] = 0;    // red-max
1689         buff[offset + 9] = 255;  // red-max
1690
1691         buff[offset + 10] = 0;   // green-max
1692         buff[offset + 11] = 255; // green-max
1693
1694         buff[offset + 12] = 0;   // blue-max
1695         buff[offset + 13] = 255; // blue-max
1696
1697         buff[offset + 14] = 16;  // red-shift
1698         buff[offset + 15] = 8;   // green-shift
1699         buff[offset + 16] = 0;   // blue-shift
1700
1701         buff[offset + 17] = 0;   // padding
1702         buff[offset + 18] = 0;   // padding
1703         buff[offset + 19] = 0;   // padding
1704
1705         sock._sQlen += 20;
1706         sock.flush();
1707     },
1708
1709     clientEncodings: function (sock, encodings, local_cursor) {
1710         var buff = sock._sQ;
1711         var offset = sock._sQlen;
1712
1713         buff[offset] = 2; // msg-type
1714         buff[offset + 1] = 0; // padding
1715
1716         // offset + 2 and offset + 3 are encoding count
1717
1718         var i, j = offset + 4, cnt = 0;
1719         for (i = 0; i < encodings.length; i++) {
1720             if (encodings[i][0] === "Cursor" && !local_cursor) {
1721                 Log.Debug("Skipping Cursor pseudo-encoding");
1722             } else {
1723                 var enc = encodings[i][1];
1724                 buff[j] = enc >> 24;
1725                 buff[j + 1] = enc >> 16;
1726                 buff[j + 2] = enc >> 8;
1727                 buff[j + 3] = enc;
1728
1729                 j += 4;
1730                 cnt++;
1731             }
1732         }
1733
1734         buff[offset + 2] = cnt >> 8;
1735         buff[offset + 3] = cnt;
1736
1737         sock._sQlen += j - offset;
1738         sock.flush();
1739     },
1740
1741     fbUpdateRequest: function (sock, incremental, x, y, w, h) {
1742         var buff = sock._sQ;
1743         var offset = sock._sQlen;
1744
1745         if (typeof(x) === "undefined") { x = 0; }
1746         if (typeof(y) === "undefined") { y = 0; }
1747
1748         buff[offset] = 3;  // msg-type
1749         buff[offset + 1] = incremental ? 1 : 0;
1750
1751         buff[offset + 2] = (x >> 8) & 0xFF;
1752         buff[offset + 3] = x & 0xFF;
1753
1754         buff[offset + 4] = (y >> 8) & 0xFF;
1755         buff[offset + 5] = y & 0xFF;
1756
1757         buff[offset + 6] = (w >> 8) & 0xFF;
1758         buff[offset + 7] = w & 0xFF;
1759
1760         buff[offset + 8] = (h >> 8) & 0xFF;
1761         buff[offset + 9] = h & 0xFF;
1762
1763         sock._sQlen += 10;
1764         sock.flush();
1765     }
1766 };
1767
1768 RFB.genDES = function (password, challenge) {
1769     var passwd = [];
1770     for (var i = 0; i < password.length; i++) {
1771         passwd.push(password.charCodeAt(i));
1772     }
1773     return (new DES(passwd)).encrypt(challenge);
1774 };
1775
1776 RFB.encodingHandlers = {
1777     RAW: function () {
1778         if (this._FBU.lines === 0) {
1779             this._FBU.lines = this._FBU.height;
1780         }
1781
1782         this._FBU.bytes = this._FBU.width * 4;  // at least a line
1783         if (this._sock.rQwait("RAW", this._FBU.bytes)) { return false; }
1784         var cur_y = this._FBU.y + (this._FBU.height - this._FBU.lines);
1785         var curr_height = Math.min(this._FBU.lines,
1786                                    Math.floor(this._sock.rQlen() / (this._FBU.width * 4)));
1787         this._display.blitImage(this._FBU.x, cur_y, this._FBU.width,
1788                                 curr_height, this._sock.get_rQ(),
1789                                 this._sock.get_rQi());
1790         this._sock.rQskipBytes(this._FBU.width * curr_height * 4);
1791         this._FBU.lines -= curr_height;
1792
1793         if (this._FBU.lines > 0) {
1794             this._FBU.bytes = this._FBU.width * 4;  // At least another line
1795         } else {
1796             this._FBU.rects--;
1797             this._FBU.bytes = 0;
1798         }
1799
1800         return true;
1801     },
1802
1803     COPYRECT: function () {
1804         this._FBU.bytes = 4;
1805         if (this._sock.rQwait("COPYRECT", 4)) { return false; }
1806         this._display.copyImage(this._sock.rQshift16(), this._sock.rQshift16(),
1807                                 this._FBU.x, this._FBU.y, this._FBU.width,
1808                                 this._FBU.height);
1809
1810         this._FBU.rects--;
1811         this._FBU.bytes = 0;
1812         return true;
1813     },
1814
1815     RRE: function () {
1816         var color;
1817         if (this._FBU.subrects === 0) {
1818             this._FBU.bytes = 4 + 4;
1819             if (this._sock.rQwait("RRE", 4 + 4)) { return false; }
1820             this._FBU.subrects = this._sock.rQshift32();
1821             color = this._sock.rQshiftBytes(4);  // Background
1822             this._display.fillRect(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, color);
1823         }
1824
1825         while (this._FBU.subrects > 0 && this._sock.rQlen() >= (4 + 8)) {
1826             color = this._sock.rQshiftBytes(4);
1827             var x = this._sock.rQshift16();
1828             var y = this._sock.rQshift16();
1829             var width = this._sock.rQshift16();
1830             var height = this._sock.rQshift16();
1831             this._display.fillRect(this._FBU.x + x, this._FBU.y + y, width, height, color);
1832             this._FBU.subrects--;
1833         }
1834
1835         if (this._FBU.subrects > 0) {
1836             var chunk = Math.min(this._rre_chunk_sz, this._FBU.subrects);
1837             this._FBU.bytes = (4 + 8) * chunk;
1838         } else {
1839             this._FBU.rects--;
1840             this._FBU.bytes = 0;
1841         }
1842
1843         return true;
1844     },
1845
1846     HEXTILE: function () {
1847         var rQ = this._sock.get_rQ();
1848         var rQi = this._sock.get_rQi();
1849
1850         if (this._FBU.tiles === 0) {
1851             this._FBU.tiles_x = Math.ceil(this._FBU.width / 16);
1852             this._FBU.tiles_y = Math.ceil(this._FBU.height / 16);
1853             this._FBU.total_tiles = this._FBU.tiles_x * this._FBU.tiles_y;
1854             this._FBU.tiles = this._FBU.total_tiles;
1855         }
1856
1857         while (this._FBU.tiles > 0) {
1858             this._FBU.bytes = 1;
1859             if (this._sock.rQwait("HEXTILE subencoding", this._FBU.bytes)) { return false; }
1860             var subencoding = rQ[rQi];  // Peek
1861             if (subencoding > 30) {  // Raw
1862                 this._fail("Unexpected server message",
1863                            "Illegal hextile subencoding: " + subencoding);
1864                 return false;
1865             }
1866
1867             var subrects = 0;
1868             var curr_tile = this._FBU.total_tiles - this._FBU.tiles;
1869             var tile_x = curr_tile % this._FBU.tiles_x;
1870             var tile_y = Math.floor(curr_tile / this._FBU.tiles_x);
1871             var x = this._FBU.x + tile_x * 16;
1872             var y = this._FBU.y + tile_y * 16;
1873             var w = Math.min(16, (this._FBU.x + this._FBU.width) - x);
1874             var h = Math.min(16, (this._FBU.y + this._FBU.height) - y);
1875
1876             // Figure out how much we are expecting
1877             if (subencoding & 0x01) {  // Raw
1878                 this._FBU.bytes += w * h * 4;
1879             } else {
1880                 if (subencoding & 0x02) {  // Background
1881                     this._FBU.bytes += 4;
1882                 }
1883                 if (subencoding & 0x04) {  // Foreground
1884                     this._FBU.bytes += 4;
1885                 }
1886                 if (subencoding & 0x08) {  // AnySubrects
1887                     this._FBU.bytes++;  // Since we aren't shifting it off
1888                     if (this._sock.rQwait("hextile subrects header", this._FBU.bytes)) { return false; }
1889                     subrects = rQ[rQi + this._FBU.bytes - 1];  // Peek
1890                     if (subencoding & 0x10) {  // SubrectsColoured
1891                         this._FBU.bytes += subrects * (4 + 2);
1892                     } else {
1893                         this._FBU.bytes += subrects * 2;
1894                     }
1895                 }
1896             }
1897
1898             if (this._sock.rQwait("hextile", this._FBU.bytes)) { return false; }
1899
1900             // We know the encoding and have a whole tile
1901             this._FBU.subencoding = rQ[rQi];
1902             rQi++;
1903             if (this._FBU.subencoding === 0) {
1904                 if (this._FBU.lastsubencoding & 0x01) {
1905                     // Weird: ignore blanks are RAW
1906                     Log.Debug("     Ignoring blank after RAW");
1907                 } else {
1908                     this._display.fillRect(x, y, w, h, this._FBU.background);
1909                 }
1910             } else if (this._FBU.subencoding & 0x01) {  // Raw
1911                 this._display.blitImage(x, y, w, h, rQ, rQi);
1912                 rQi += this._FBU.bytes - 1;
1913             } else {
1914                 if (this._FBU.subencoding & 0x02) {  // Background
1915                     this._FBU.background = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
1916                     rQi += 4;
1917                 }
1918                 if (this._FBU.subencoding & 0x04) {  // Foreground
1919                     this._FBU.foreground = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
1920                     rQi += 4;
1921                 }
1922
1923                 this._display.startTile(x, y, w, h, this._FBU.background);
1924                 if (this._FBU.subencoding & 0x08) {  // AnySubrects
1925                     subrects = rQ[rQi];
1926                     rQi++;
1927
1928                     for (var s = 0; s < subrects; s++) {
1929                         var color;
1930                         if (this._FBU.subencoding & 0x10) {  // SubrectsColoured
1931                             color = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
1932                             rQi += 4;
1933                         } else {
1934                             color = this._FBU.foreground;
1935                         }
1936                         var xy = rQ[rQi];
1937                         rQi++;
1938                         var sx = (xy >> 4);
1939                         var sy = (xy & 0x0f);
1940
1941                         var wh = rQ[rQi];
1942                         rQi++;
1943                         var sw = (wh >> 4) + 1;
1944                         var sh = (wh & 0x0f) + 1;
1945
1946                         this._display.subTile(sx, sy, sw, sh, color);
1947                     }
1948                 }
1949                 this._display.finishTile();
1950             }
1951             this._sock.set_rQi(rQi);
1952             this._FBU.lastsubencoding = this._FBU.subencoding;
1953             this._FBU.bytes = 0;
1954             this._FBU.tiles--;
1955         }
1956
1957         if (this._FBU.tiles === 0) {
1958             this._FBU.rects--;
1959         }
1960
1961         return true;
1962     },
1963
1964     getTightCLength: function (arr) {
1965         var header = 1, data = 0;
1966         data += arr[0] & 0x7f;
1967         if (arr[0] & 0x80) {
1968             header++;
1969             data += (arr[1] & 0x7f) << 7;
1970             if (arr[1] & 0x80) {
1971                 header++;
1972                 data += arr[2] << 14;
1973             }
1974         }
1975         return [header, data];
1976     },
1977
1978     display_tight: function (isTightPNG) {
1979         this._FBU.bytes = 1;  // compression-control byte
1980         if (this._sock.rQwait("TIGHT compression-control", this._FBU.bytes)) { return false; }
1981
1982         var checksum = function (data) {
1983             var sum = 0;
1984             for (var i = 0; i < data.length; i++) {
1985                 sum += data[i];
1986                 if (sum > 65536) sum -= 65536;
1987             }
1988             return sum;
1989         };
1990
1991         var resetStreams = 0;
1992         var streamId = -1;
1993         var decompress = function (data, expected) {
1994             for (var i = 0; i < 4; i++) {
1995                 if ((resetStreams >> i) & 1) {
1996                     this._FBU.zlibs[i].reset();
1997                     Log.Info("Reset zlib stream " + i);
1998                 }
1999             }
2000
2001             //var uncompressed = this._FBU.zlibs[streamId].uncompress(data, 0);
2002             var uncompressed = this._FBU.zlibs[streamId].inflate(data, true, expected);
2003             /*if (uncompressed.status !== 0) {
2004                 Log.Error("Invalid data in zlib stream");
2005             }*/
2006
2007             //return uncompressed.data;
2008             return uncompressed;
2009         }.bind(this);
2010
2011         var indexedToRGBX2Color = function (data, palette, width, height) {
2012             // Convert indexed (palette based) image data to RGB
2013             // TODO: reduce number of calculations inside loop
2014             var dest = this._destBuff;
2015             var w = Math.floor((width + 7) / 8);
2016             var w1 = Math.floor(width / 8);
2017
2018             /*for (var y = 0; y < height; y++) {
2019                 var b, x, dp, sp;
2020                 var yoffset = y * width;
2021                 var ybitoffset = y * w;
2022                 var xoffset, targetbyte;
2023                 for (x = 0; x < w1; x++) {
2024                     xoffset = yoffset + x * 8;
2025                     targetbyte = data[ybitoffset + x];
2026                     for (b = 7; b >= 0; b--) {
2027                         dp = (xoffset + 7 - b) * 3;
2028                         sp = (targetbyte >> b & 1) * 3;
2029                         dest[dp] = palette[sp];
2030                         dest[dp + 1] = palette[sp + 1];
2031                         dest[dp + 2] = palette[sp + 2];
2032                     }
2033                 }
2034
2035                 xoffset = yoffset + x * 8;
2036                 targetbyte = data[ybitoffset + x];
2037                 for (b = 7; b >= 8 - width % 8; b--) {
2038                     dp = (xoffset + 7 - b) * 3;
2039                     sp = (targetbyte >> b & 1) * 3;
2040                     dest[dp] = palette[sp];
2041                     dest[dp + 1] = palette[sp + 1];
2042                     dest[dp + 2] = palette[sp + 2];
2043                 }
2044             }*/
2045
2046             for (var y = 0; y < height; y++) {
2047                 var b, x, dp, sp;
2048                 for (x = 0; x < w1; x++) {
2049                     for (b = 7; b >= 0; b--) {
2050                         dp = (y * width + x * 8 + 7 - b) * 4;
2051                         sp = (data[y * w + x] >> b & 1) * 3;
2052                         dest[dp] = palette[sp];
2053                         dest[dp + 1] = palette[sp + 1];
2054                         dest[dp + 2] = palette[sp + 2];
2055                         dest[dp + 3] = 255;
2056                     }
2057                 }
2058
2059                 for (b = 7; b >= 8 - width % 8; b--) {
2060                     dp = (y * width + x * 8 + 7 - b) * 4;
2061                     sp = (data[y * w + x] >> b & 1) * 3;
2062                     dest[dp] = palette[sp];
2063                     dest[dp + 1] = palette[sp + 1];
2064                     dest[dp + 2] = palette[sp + 2];
2065                     dest[dp + 3] = 255;
2066                 }
2067             }
2068
2069             return dest;
2070         }.bind(this);
2071
2072         var indexedToRGBX = function (data, palette, width, height) {
2073             // Convert indexed (palette based) image data to RGB
2074             var dest = this._destBuff;
2075             var total = width * height * 4;
2076             for (var i = 0, j = 0; i < total; i += 4, j++) {
2077                 var sp = data[j] * 3;
2078                 dest[i] = palette[sp];
2079                 dest[i + 1] = palette[sp + 1];
2080                 dest[i + 2] = palette[sp + 2];
2081                 dest[i + 3] = 255;
2082             }
2083
2084             return dest;
2085         }.bind(this);
2086
2087         var rQi = this._sock.get_rQi();
2088         var rQ = this._sock.rQwhole();
2089         var cmode, data;
2090         var cl_header, cl_data;
2091
2092         var handlePalette = function () {
2093             var numColors = rQ[rQi + 2] + 1;
2094             var paletteSize = numColors * 3;
2095             this._FBU.bytes += paletteSize;
2096             if (this._sock.rQwait("TIGHT palette " + cmode, this._FBU.bytes)) { return false; }
2097
2098             var bpp = (numColors <= 2) ? 1 : 8;
2099             var rowSize = Math.floor((this._FBU.width * bpp + 7) / 8);
2100             var raw = false;
2101             if (rowSize * this._FBU.height < 12) {
2102                 raw = true;
2103                 cl_header = 0;
2104                 cl_data = rowSize * this._FBU.height;
2105                 //clength = [0, rowSize * this._FBU.height];
2106             } else {
2107                 // begin inline getTightCLength (returning two-item arrays is bad for performance with GC)
2108                 var cl_offset = rQi + 3 + paletteSize;
2109                 cl_header = 1;
2110                 cl_data = 0;
2111                 cl_data += rQ[cl_offset] & 0x7f;
2112                 if (rQ[cl_offset] & 0x80) {
2113                     cl_header++;
2114                     cl_data += (rQ[cl_offset + 1] & 0x7f) << 7;
2115                     if (rQ[cl_offset + 1] & 0x80) {
2116                         cl_header++;
2117                         cl_data += rQ[cl_offset + 2] << 14;
2118                     }
2119                 }
2120                 // end inline getTightCLength
2121             }
2122
2123             this._FBU.bytes += cl_header + cl_data;
2124             if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
2125
2126             // Shift ctl, filter id, num colors, palette entries, and clength off
2127             this._sock.rQskipBytes(3);
2128             //var palette = this._sock.rQshiftBytes(paletteSize);
2129             this._sock.rQshiftTo(this._paletteBuff, paletteSize);
2130             this._sock.rQskipBytes(cl_header);
2131
2132             if (raw) {
2133                 data = this._sock.rQshiftBytes(cl_data);
2134             } else {
2135                 data = decompress(this._sock.rQshiftBytes(cl_data), rowSize * this._FBU.height);
2136             }
2137
2138             // Convert indexed (palette based) image data to RGB
2139             var rgbx;
2140             if (numColors == 2) {
2141                 rgbx = indexedToRGBX2Color(data, this._paletteBuff, this._FBU.width, this._FBU.height);
2142                 this._display.blitRgbxImage(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, rgbx, 0, false);
2143             } else {
2144                 rgbx = indexedToRGBX(data, this._paletteBuff, this._FBU.width, this._FBU.height);
2145                 this._display.blitRgbxImage(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, rgbx, 0, false);
2146             }
2147
2148
2149             return true;
2150         }.bind(this);
2151
2152         var handleCopy = function () {
2153             var raw = false;
2154             var uncompressedSize = this._FBU.width * this._FBU.height * 3;
2155             if (uncompressedSize < 12) {
2156                 raw = true;
2157                 cl_header = 0;
2158                 cl_data = uncompressedSize;
2159             } else {
2160                 // begin inline getTightCLength (returning two-item arrays is for peformance with GC)
2161                 var cl_offset = rQi + 1;
2162                 cl_header = 1;
2163                 cl_data = 0;
2164                 cl_data += rQ[cl_offset] & 0x7f;
2165                 if (rQ[cl_offset] & 0x80) {
2166                     cl_header++;
2167                     cl_data += (rQ[cl_offset + 1] & 0x7f) << 7;
2168                     if (rQ[cl_offset + 1] & 0x80) {
2169                         cl_header++;
2170                         cl_data += rQ[cl_offset + 2] << 14;
2171                     }
2172                 }
2173                 // end inline getTightCLength
2174             }
2175             this._FBU.bytes = 1 + cl_header + cl_data;
2176             if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
2177
2178             // Shift ctl, clength off
2179             this._sock.rQshiftBytes(1 + cl_header);
2180
2181             if (raw) {
2182                 data = this._sock.rQshiftBytes(cl_data);
2183             } else {
2184                 data = decompress(this._sock.rQshiftBytes(cl_data), uncompressedSize);
2185             }
2186
2187             this._display.blitRgbImage(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, data, 0, false);
2188
2189             return true;
2190         }.bind(this);
2191
2192         var ctl = this._sock.rQpeek8();
2193
2194         // Keep tight reset bits
2195         resetStreams = ctl & 0xF;
2196
2197         // Figure out filter
2198         ctl = ctl >> 4;
2199         streamId = ctl & 0x3;
2200
2201         if (ctl === 0x08)       cmode = "fill";
2202         else if (ctl === 0x09)  cmode = "jpeg";
2203         else if (ctl === 0x0A)  cmode = "png";
2204         else if (ctl & 0x04)    cmode = "filter";
2205         else if (ctl < 0x04)    cmode = "copy";
2206         else return this._fail("Unexpected server message",
2207                                "Illegal tight compression received, " +
2208                                "ctl: " + ctl);
2209
2210         if (isTightPNG && (cmode === "filter" || cmode === "copy")) {
2211             return this._fail("Unexpected server message",
2212                               "filter/copy received in tightPNG mode");
2213         }
2214
2215         switch (cmode) {
2216             // fill use depth because TPIXELs drop the padding byte
2217             case "fill":  // TPIXEL
2218                 this._FBU.bytes += 3;
2219                 break;
2220             case "jpeg":  // max clength
2221                 this._FBU.bytes += 3;
2222                 break;
2223             case "png":  // max clength
2224                 this._FBU.bytes += 3;
2225                 break;
2226             case "filter":  // filter id + num colors if palette
2227                 this._FBU.bytes += 2;
2228                 break;
2229             case "copy":
2230                 break;
2231         }
2232
2233         if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
2234
2235         // Determine FBU.bytes
2236         switch (cmode) {
2237             case "fill":
2238                 // skip ctl byte
2239                 this._display.fillRect(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, [rQ[rQi + 3], rQ[rQi + 2], rQ[rQi + 1]], false);
2240                 this._sock.rQskipBytes(4);
2241                 break;
2242             case "png":
2243             case "jpeg":
2244                 // begin inline getTightCLength (returning two-item arrays is for peformance with GC)
2245                 var cl_offset = rQi + 1;
2246                 cl_header = 1;
2247                 cl_data = 0;
2248                 cl_data += rQ[cl_offset] & 0x7f;
2249                 if (rQ[cl_offset] & 0x80) {
2250                     cl_header++;
2251                     cl_data += (rQ[cl_offset + 1] & 0x7f) << 7;
2252                     if (rQ[cl_offset + 1] & 0x80) {
2253                         cl_header++;
2254                         cl_data += rQ[cl_offset + 2] << 14;
2255                     }
2256                 }
2257                 // end inline getTightCLength
2258                 this._FBU.bytes = 1 + cl_header + cl_data;  // ctl + clength size + jpeg-data
2259                 if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
2260
2261                 // We have everything, render it
2262                 this._sock.rQskipBytes(1 + cl_header);  // shift off clt + compact length
2263                 data = this._sock.rQshiftBytes(cl_data);
2264                 this._display.imageRect(this._FBU.x, this._FBU.y, "image/" + cmode, data);
2265                 break;
2266             case "filter":
2267                 var filterId = rQ[rQi + 1];
2268                 if (filterId === 1) {
2269                     if (!handlePalette()) { return false; }
2270                 } else {
2271                     // Filter 0, Copy could be valid here, but servers don't send it as an explicit filter
2272                     // Filter 2, Gradient is valid but not use if jpeg is enabled
2273                     this._fail("Unexpected server message",
2274                                "Unsupported tight subencoding received, " +
2275                                "filter: " + filterId);
2276                 }
2277                 break;
2278             case "copy":
2279                 if (!handleCopy()) { return false; }
2280                 break;
2281         }
2282
2283
2284         this._FBU.bytes = 0;
2285         this._FBU.rects--;
2286
2287         return true;
2288     },
2289
2290     TIGHT: function () { return this._encHandlers.display_tight(false); },
2291     TIGHT_PNG: function () { return this._encHandlers.display_tight(true); },
2292
2293     last_rect: function () {
2294         this._FBU.rects = 0;
2295         return true;
2296     },
2297
2298     handle_FB_resize: function () {
2299         this._fb_width = this._FBU.width;
2300         this._fb_height = this._FBU.height;
2301         this._destBuff = new Uint8Array(this._fb_width * this._fb_height * 4);
2302         this._display.resize(this._fb_width, this._fb_height);
2303         this._onFBResize(this, this._fb_width, this._fb_height);
2304         this._timing.fbu_rt_start = (new Date()).getTime();
2305         this._updateContinuousUpdates();
2306
2307         this._FBU.bytes = 0;
2308         this._FBU.rects -= 1;
2309         return true;
2310     },
2311
2312     ExtendedDesktopSize: function () {
2313         this._FBU.bytes = 1;
2314         if (this._sock.rQwait("ExtendedDesktopSize", this._FBU.bytes)) { return false; }
2315
2316         this._supportsSetDesktopSize = true;
2317         var number_of_screens = this._sock.rQpeek8();
2318
2319         this._FBU.bytes = 4 + (number_of_screens * 16);
2320         if (this._sock.rQwait("ExtendedDesktopSize", this._FBU.bytes)) { return false; }
2321
2322         this._sock.rQskipBytes(1);  // number-of-screens
2323         this._sock.rQskipBytes(3);  // padding
2324
2325         for (var i = 0; i < number_of_screens; i += 1) {
2326             // Save the id and flags of the first screen
2327             if (i === 0) {
2328                 this._screen_id = this._sock.rQshiftBytes(4);    // id
2329                 this._sock.rQskipBytes(2);                       // x-position
2330                 this._sock.rQskipBytes(2);                       // y-position
2331                 this._sock.rQskipBytes(2);                       // width
2332                 this._sock.rQskipBytes(2);                       // height
2333                 this._screen_flags = this._sock.rQshiftBytes(4); // flags
2334             } else {
2335                 this._sock.rQskipBytes(16);
2336             }
2337         }
2338
2339         /*
2340          * The x-position indicates the reason for the change:
2341          *
2342          *  0 - server resized on its own
2343          *  1 - this client requested the resize
2344          *  2 - another client requested the resize
2345          */
2346
2347         // We need to handle errors when we requested the resize.
2348         if (this._FBU.x === 1 && this._FBU.y !== 0) {
2349             var msg = "";
2350             // The y-position indicates the status code from the server
2351             switch (this._FBU.y) {
2352             case 1:
2353                 msg = "Resize is administratively prohibited";
2354                 break;
2355             case 2:
2356                 msg = "Out of resources";
2357                 break;
2358             case 3:
2359                 msg = "Invalid screen layout";
2360                 break;
2361             default:
2362                 msg = "Unknown reason";
2363                 break;
2364             }
2365             this._notification("Server did not accept the resize request: "
2366                                + msg, 'normal');
2367             return true;
2368         }
2369
2370         this._encHandlers.handle_FB_resize();
2371         return true;
2372     },
2373
2374     DesktopSize: function () {
2375         this._encHandlers.handle_FB_resize();
2376         return true;
2377     },
2378
2379     Cursor: function () {
2380         Log.Debug(">> set_cursor");
2381         var x = this._FBU.x;  // hotspot-x
2382         var y = this._FBU.y;  // hotspot-y
2383         var w = this._FBU.width;
2384         var h = this._FBU.height;
2385
2386         var pixelslength = w * h * 4;
2387         var masklength = Math.floor((w + 7) / 8) * h;
2388
2389         this._FBU.bytes = pixelslength + masklength;
2390         if (this._sock.rQwait("cursor encoding", this._FBU.bytes)) { return false; }
2391
2392         this._display.changeCursor(this._sock.rQshiftBytes(pixelslength),
2393                                    this._sock.rQshiftBytes(masklength),
2394                                    x, y, w, h);
2395
2396         this._FBU.bytes = 0;
2397         this._FBU.rects--;
2398
2399         Log.Debug("<< set_cursor");
2400         return true;
2401     },
2402
2403     QEMUExtendedKeyEvent: function () {
2404         this._FBU.rects--;
2405
2406         // Old Safari doesn't support creating keyboard events
2407         try {
2408             var keyboardEvent = document.createEvent("keyboardEvent");
2409             if (keyboardEvent.code !== undefined) {
2410                 this._qemuExtKeyEventSupported = true;
2411             }
2412         } catch (err) {
2413         }
2414     },
2415
2416     JPEG_quality_lo: function () {
2417         Log.Error("Server sent jpeg_quality pseudo-encoding");
2418     },
2419
2420     compress_lo: function () {
2421         Log.Error("Server sent compress level pseudo-encoding");
2422     }
2423 };