RubyGems - foreman_discovery - Versions diffs - 1.0.0.rc1 - Mend

foreman_discovery 1.0.0.rc1

Files changed (1366) hide show

data/test/foreman_app/vendor/assets/javascripts/noVNC/logo.js ADDED Viewed

@@ -0,0 +1 @@

+ noVNC_logo = {"width": 640, "height": 435, "data": "data:image/png;base64,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"};

data/test/foreman_app/vendor/assets/javascripts/noVNC/playback.js ADDED Viewed

@@ -0,0 +1,90 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2011 Joel Martin
+ * Licensed under LGPL-3 (see LICENSE.LGPL-3)
+ */
+"use strict";
+/*jslint browser: true, white: false */
+/*global Util, VNC_frame_data, finish */
+var rfb, mode, test_state, frame_idx, frame_length,
+    iteration, iterations, istart_time,
+    // Pre-declarations for jslint
+    send_array, next_iteration, queue_next_packet, do_packet;
+// Override send_array
+send_array = function (arr) {
+    // Stub out send_array
+};
+next_iteration = function () {
+    if (iteration === 0) {
+        frame_length = VNC_frame_data.length;
+        test_state = 'running';
+    } else {
+        rfb.disconnect();
+    }
+    if (test_state !== 'running') { return; }
+    iteration += 1;
+    if (iteration > iterations) {
+        finish();
+        return;
+    }
+    frame_idx = 0;
+    istart_time = (new Date()).getTime();
+    rfb.connect('test', 0, "bogus");
+    queue_next_packet();
+};
+queue_next_packet = function () {
+    var frame, foffset, toffset, delay;
+    if (test_state !== 'running') { return; }
+    frame = VNC_frame_data[frame_idx];
+    while ((frame_idx < frame_length) && (frame.charAt(0) === "}")) {
+        //Util.Debug("Send frame " + frame_idx);
+        frame_idx += 1;
+        frame = VNC_frame_data[frame_idx];
+    }
+    if (frame === 'EOF') {
+        Util.Debug("Finished, found EOF");
+        next_iteration();
+        return;
+    }
+    if (frame_idx >= frame_length) {
+        Util.Debug("Finished, no more frames");
+        next_iteration();
+        return;
+    }
+    if (mode === 'realtime') {
+        foffset = frame.slice(1, frame.indexOf('{', 1));
+        toffset = (new Date()).getTime() - istart_time;
+        delay = foffset - toffset;
+        if (delay < 1) {
+            delay = 1;
+        }
+        setTimeout(do_packet, delay);
+    } else {
+        setTimeout(do_packet, 1);
+    }
+};
+do_packet = function () {
+    //Util.Debug("Processing frame: " + frame_idx);
+    var frame = VNC_frame_data[frame_idx];
+    rfb.recv_message({'data' : frame.slice(frame.indexOf('{', 1) + 1)});
+    frame_idx += 1;
+    queue_next_packet();
+};

data/test/foreman_app/vendor/assets/javascripts/noVNC/rfb.js ADDED Viewed

@@ -0,0 +1,1846 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2011 Joel Martin
+ * Licensed under LGPL-3 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ *
+ * TIGHT decoder portion:
+ * (c) 2012 Michael Tinglof, Joe Balaz, Les Piech (Mercuri.ca)
+ */
+/*jslint white: false, browser: true, bitwise: false, plusplus: false */
+/*global window, Util, Display, Keyboard, Mouse, Websock, Websock_native, Base64, DES */
+function RFB(defaults) {
+"use strict";
+var that           = {},  // Public API methods
+    conf           = {},  // Configuration attributes
+    // Pre-declare private functions used before definitions (jslint)
+    init_vars, updateState, fail, handle_message,
+    init_msg, normal_msg, framebufferUpdate, print_stats,
+    pixelFormat, clientEncodings, fbUpdateRequest, fbUpdateRequests,
+    keyEvent, pointerEvent, clientCutText,
+    getTightCLength, extract_data_uri, scan_tight_imgQ,
+    keyPress, mouseButton, mouseMove,
+    checkEvents,  // Overridable for testing
+    //
+    // Private RFB namespace variables
+    //
+    rfb_host       = '',
+    rfb_port       = 5900,
+    rfb_password   = '',
+    rfb_path       = '',
+    rfb_state      = 'disconnected',
+    rfb_version    = 0,
+    rfb_max_version= 3.8,
+    rfb_auth_scheme= '',
+    // In preference order
+    encodings      = [
+        ['COPYRECT',         0x01 ],
+        ['TIGHT',            0x07 ],
+        ['TIGHT_PNG',        -260 ],
+        ['HEXTILE',          0x05 ],
+        ['RRE',              0x02 ],
+        ['RAW',              0x00 ],
+        ['DesktopSize',      -223 ],
+        ['Cursor',           -239 ],
+        // Psuedo-encoding settings
+        //['JPEG_quality_lo',   -32 ],
+        ['JPEG_quality_med',    -26 ],
+        //['JPEG_quality_hi',   -23 ],
+        //['compress_lo',      -255 ],
+        ['compress_hi',        -247 ],
+        ['last_rect',          -224 ]
+        ],
+    encHandlers    = {},
+    encNames       = {},
+    encStats       = {},     // [rectCnt, rectCntTot]
+    ws             = null,   // Websock object
+    display        = null,   // Display object
+    keyboard       = null,   // Keyboard input handler object
+    mouse          = null,   // Mouse input handler object
+    sendTimer      = null,   // Send Queue check timer
+    connTimer      = null,   // connection timer
+    disconnTimer   = null,   // disconnection timer
+    msgTimer       = null,   // queued handle_message timer
+    // Frame buffer update state
+    FBU            = {
+        rects          : 0,
+        subrects       : 0,  // RRE
+        lines          : 0,  // RAW
+        tiles          : 0,  // HEXTILE
+        bytes          : 0,
+        x              : 0,
+        y              : 0,
+        width          : 0,
+        height         : 0,
+        encoding       : 0,
+        subencoding    : -1,
+        background     : null,
+        imgQ           : [],  // TIGHT_PNG image queue
+        zlibs          : []   // TIGHT zlib streams
+    },
+    fb_Bpp         = 4,
+    fb_depth       = 3,
+    fb_width       = 0,
+    fb_height      = 0,
+    fb_name        = "",
+    scan_imgQ_rate = 40, // 25 times per second or so
+    last_req_time  = 0,
+    rre_chunk_sz   = 100,
+    timing         = {
+        last_fbu       : 0,
+        fbu_total      : 0,
+        fbu_total_cnt  : 0,
+        full_fbu_total : 0,
+        full_fbu_cnt   : 0,
+        fbu_rt_start   : 0,
+        fbu_rt_total   : 0,
+        fbu_rt_cnt     : 0,
+        pixels         : 0
+    },
+    test_mode        = false,
+    def_con_timeout  = Websock_native ? 10 : 25,
+    /* Mouse state */
+    mouse_buttonMask = 0,
+    mouse_arr        = [],
+    viewportDragging = false,
+    viewportDragPos  = {};
+// Configuration attributes
+Util.conf_defaults(conf, that, defaults, [
+    ['target',             'wo', 'dom', null, 'VNC display rendering Canvas object'],
+    ['focusContainer',     'wo', 'dom', document, 'DOM element that captures keyboard input'],
+    ['encrypt',            'rw', 'bool', false, 'Use TLS/SSL/wss encryption'],
+    ['true_color',         'rw', 'bool', true,  'Request true color pixel data'],
+    ['local_cursor',       'rw', 'bool', false, 'Request locally rendered cursor'],
+    ['shared',             'rw', 'bool', true,  'Request shared mode'],
+    ['view_only',          'rw', 'bool', false, 'Disable client mouse/keyboard'],
+    ['connectTimeout',     'rw', 'int', def_con_timeout, 'Time (s) to wait for connection'],
+    ['disconnectTimeout',  'rw', 'int', 10,    'Time (s) to wait for disconnection'],
+    ['viewportDrag',       'rw', 'bool', false, 'Move the viewport on mouse drags'],
+    ['check_rate',         'rw', 'int', 217,  'Timing (ms) of send/receive check'],
+    ['fbu_req_rate',       'rw', 'int', 1413, 'Timing (ms) of frameBufferUpdate requests'],
+    // Callback functions
+    ['onUpdateState',      'rw', 'func', function() { },
+        'onUpdateState(rfb, state, oldstate, statusMsg): RFB state update/change '],
+    ['onPasswordRequired', 'rw', 'func', function() { },
+        'onPasswordRequired(rfb): VNC password is required '],
+    ['onClipboard',        'rw', 'func', function() { },
+        'onClipboard(rfb, text): RFB clipboard contents received'],
+    ['onBell',             'rw', 'func', function() { },
+        'onBell(rfb): RFB Bell message received '],
+    ['onFBUReceive',       'rw', 'func', function() { },
+        'onFBUReceive(rfb, fbu): RFB FBU received but not yet processed '],
+    ['onFBUComplete',      'rw', 'func', function() { },
+        'onFBUComplete(rfb, fbu): RFB FBU received and processed '],
+    // These callback names are deprecated
+    ['updateState',        'rw', 'func', function() { },
+        'obsolete, use onUpdateState'],
+    ['clipboardReceive',   'rw', 'func', function() { },
+        'obsolete, use onClipboard']
+    ]);
+// Override/add some specific configuration getters/setters
+that.set_local_cursor = function(cursor) {
+    if ((!cursor) || (cursor in {'0':1, 'no':1, 'false':1})) {
+        conf.local_cursor = false;
+    } else {
+        if (display.get_cursor_uri()) {
+            conf.local_cursor = true;
+        } else {
+            Util.Warn("Browser does not support local cursor");
+        }
+    }
+};
+// These are fake configuration getters
+that.get_display = function() { return display; };
+that.get_keyboard = function() { return keyboard; };
+that.get_mouse = function() { return mouse; };
+//
+// Setup routines
+//
+// Create the public API interface and initialize values that stay
+// constant across connect/disconnect
+function constructor() {
+    var i, rmode;
+    Util.Debug(">> RFB.constructor");
+    // Create lookup tables based encoding number
+    for (i=0; i < encodings.length; i+=1) {
+        encHandlers[encodings[i][1]] = encHandlers[encodings[i][0]];
+        encNames[encodings[i][1]] = encodings[i][0];
+        encStats[encodings[i][1]] = [0, 0];
+    }
+    // Initialize display, mouse, keyboard, and websock
+    try {
+        display   = new Display({'target': conf.target});
+    } catch (exc) {
+        Util.Error("Display exception: " + exc);
+        updateState('fatal', "No working Display");
+    }
+    keyboard = new Keyboard({'target': conf.focusContainer,
+                                'onKeyPress': keyPress});
+    mouse    = new Mouse({'target': conf.target,
+                            'onMouseButton': mouseButton,
+                            'onMouseMove': mouseMove});
+    rmode = display.get_render_mode();
+    ws = new Websock();
+    ws.on('message', handle_message);
+    ws.on('open', function() {
+        if (rfb_state === "connect") {
+            updateState('ProtocolVersion', "Starting VNC handshake");
+        } else {
+            fail("Got unexpected WebSockets connection");
+        }
+    });
+    ws.on('close', function(e) {
+        if (e.code) {
+            Util.Info("Close code: " + e.code + ", reason: " + e.reason + ", wasClean: " + e.wasClean);
+        }
+        if (rfb_state === 'disconnect') {
+            updateState('disconnected', 'VNC disconnected');
+        } else if (rfb_state === 'ProtocolVersion') {
+            fail('Failed to connect to server');
+        } else if (rfb_state in {'failed':1, 'disconnected':1}) {
+            Util.Error("Received onclose while disconnected");
+        } else  {
+            fail('Server disconnected');
+        }
+    });
+    ws.on('error', function(e) {
+        fail("WebSock error: " + e);
+    });
+    init_vars();
+    /* Check web-socket-js if no builtin WebSocket support */
+    if (Websock_native) {
+        Util.Info("Using native WebSockets");
+        updateState('loaded', 'noVNC ready: native WebSockets, ' + rmode);
+    } else {
+        Util.Warn("Using web-socket-js bridge. Flash version: " +
+                  Util.Flash.version);
+        if ((! Util.Flash) ||
+            (Util.Flash.version < 9)) {
+            updateState('fatal', "WebSockets or <a href='http://get.adobe.com/flashplayer'>Adobe Flash<\/a> is required");
+        } else if (document.location.href.substr(0, 7) === "file://") {
+            updateState('fatal',
+                    "'file://' URL is incompatible with Adobe Flash");
+        } else {
+            updateState('loaded', 'noVNC ready: WebSockets emulation, ' + rmode);
+        }
+    }
+    Util.Debug("<< RFB.constructor");
+    return that;  // Return the public API interface
+}
+function connect() {
+    Util.Debug(">> RFB.connect");
+    var uri;
+    if (typeof UsingSocketIO !== "undefined") {
+        uri = "http://" + rfb_host + ":" + rfb_port + "/" + rfb_path;
+    } else {
+        if (conf.encrypt) {
+            uri = "wss://";
+        } else {
+            uri = "ws://";
+        }
+        uri += rfb_host + ":" + rfb_port + "/" + rfb_path;
+    }
+    Util.Info("connecting to " + uri);
+    ws.open(uri);
+    Util.Debug("<< RFB.connect");
+}
+// Initialize variables that are reset before each connection
+init_vars = function() {
+    var i;
+    /* Reset state */
+    ws.init();
+    FBU.rects        = 0;
+    FBU.subrects     = 0;  // RRE and HEXTILE
+    FBU.lines        = 0;  // RAW
+    FBU.tiles        = 0;  // HEXTILE
+    FBU.imgQ         = []; // TIGHT_PNG image queue
+    FBU.zlibs        = []; // TIGHT zlib encoders
+    mouse_buttonMask = 0;
+    mouse_arr        = [];
+    // Clear the per connection encoding stats
+    for (i=0; i < encodings.length; i+=1) {
+        encStats[encodings[i][1]][0] = 0;
+    }
+    for (i=0; i < 4; i++) {
+        //FBU.zlibs[i] = new InflateStream();
+        FBU.zlibs[i] = new TINF();
+        FBU.zlibs[i].init();
+    }
+};
+// Print statistics
+print_stats = function() {
+    var i, s;
+    Util.Info("Encoding stats for this connection:");
+    for (i=0; i < encodings.length; i+=1) {
+        s = encStats[encodings[i][1]];
+        if ((s[0] + s[1]) > 0) {
+            Util.Info("    " + encodings[i][0] + ": " +
+                      s[0] + " rects");
+        }
+    }
+    Util.Info("Encoding stats since page load:");
+    for (i=0; i < encodings.length; i+=1) {
+        s = encStats[encodings[i][1]];
+        if ((s[0] + s[1]) > 0) {
+            Util.Info("    " + encodings[i][0] + ": " +
+                      s[1] + " rects");
+        }
+    }
+};
+//
+// Utility routines
+//
+/*
+ * Page states:
+ *   loaded       - page load, equivalent to disconnected
+ *   disconnected - idle state
+ *   connect      - starting to connect (to ProtocolVersion)
+ *   normal       - connected
+ *   disconnect   - starting to disconnect
+ *   failed       - abnormal disconnect
+ *   fatal        - failed to load page, or fatal error
+ *
+ * RFB protocol initialization states:
+ *   ProtocolVersion
+ *   Security
+ *   Authentication
+ *   password     - waiting for password, not part of RFB
+ *   SecurityResult
+ *   ClientInitialization - not triggered by server message
+ *   ServerInitialization (to normal)
+ */
+updateState = function(state, statusMsg) {
+    var func, cmsg, oldstate = rfb_state;
+    if (state === oldstate) {
+        /* Already here, ignore */
+        Util.Debug("Already in state '" + state + "', ignoring.");
+        return;
+    }
+    /*
+     * These are disconnected states. A previous connect may
+     * asynchronously cause a connection so make sure we are closed.
+     */
+    if (state in {'disconnected':1, 'loaded':1, 'connect':1,
+                  'disconnect':1, 'failed':1, 'fatal':1}) {
+        if (sendTimer) {
+            clearInterval(sendTimer);
+            sendTimer = null;
+        }
+        if (msgTimer) {
+            clearInterval(msgTimer);
+            msgTimer = null;
+        }
+        if (display && display.get_context()) {
+            keyboard.ungrab();
+            mouse.ungrab();
+            display.defaultCursor();
+            if ((Util.get_logging() !== 'debug') ||
+                (state === 'loaded')) {
+                // Show noVNC logo on load and when disconnected if
+                // debug is off
+                display.clear();
+            }
+        }
+        ws.close();
+    }
+    if (oldstate === 'fatal') {
+        Util.Error("Fatal error, cannot continue");
+    }
+    if ((state === 'failed') || (state === 'fatal')) {
+        func = Util.Error;
+    } else {
+        func = Util.Warn;
+    }
+    if ((oldstate === 'failed') && (state === 'disconnected')) {
+        // Do disconnect action, but stay in failed state.
+        rfb_state = 'failed';
+    } else {
+        rfb_state = state;
+    }
+    cmsg = typeof(statusMsg) !== 'undefined' ? (" Msg: " + statusMsg) : "";
+    func("New state '" + rfb_state + "', was '" + oldstate + "'." + cmsg);
+    if (connTimer && (rfb_state !== 'connect')) {
+        Util.Debug("Clearing connect timer");
+        clearInterval(connTimer);
+        connTimer = null;
+    }
+    if (disconnTimer && (rfb_state !== 'disconnect')) {
+        Util.Debug("Clearing disconnect timer");
+        clearInterval(disconnTimer);
+        disconnTimer = null;
+    }
+    switch (state) {
+    case 'normal':
+        if ((oldstate === 'disconnected') || (oldstate === 'failed')) {
+            Util.Error("Invalid transition from 'disconnected' or 'failed' to 'normal'");
+        }
+        break;
+    case 'connect':
+        connTimer = setTimeout(function () {
+                fail("Connect timeout");
+            }, conf.connectTimeout * 1000);
+        init_vars();
+        connect();
+        // WebSocket.onopen transitions to 'ProtocolVersion'
+        break;
+    case 'disconnect':
+        if (! test_mode) {
+            disconnTimer = setTimeout(function () {
+                    fail("Disconnect timeout");
+                }, conf.disconnectTimeout * 1000);
+        }
+        print_stats();
+        // WebSocket.onclose transitions to 'disconnected'
+        break;
+    case 'failed':
+        if (oldstate === 'disconnected') {
+            Util.Error("Invalid transition from 'disconnected' to 'failed'");
+        }
+        if (oldstate === 'normal') {
+            Util.Error("Error while connected.");
+        }
+        if (oldstate === 'init') {
+            Util.Error("Error while initializing.");
+        }
+        // Make sure we transition to disconnected
+        setTimeout(function() { updateState('disconnected'); }, 50);
+        break;
+    default:
+        // No state change action to take
+    }
+    if ((oldstate === 'failed') && (state === 'disconnected')) {
+        // Leave the failed message
+        conf.updateState(that, state, oldstate); // Obsolete
+        conf.onUpdateState(that, state, oldstate);
+    } else {
+        conf.updateState(that, state, oldstate, statusMsg); // Obsolete
+        conf.onUpdateState(that, state, oldstate, statusMsg);
+    }
+};
+fail = function(msg) {
+    updateState('failed', msg);
+    return false;
+};
+handle_message = function() {
+    //Util.Debug(">> handle_message ws.rQlen(): " + ws.rQlen());
+    //Util.Debug("ws.rQslice(0,20): " + ws.rQslice(0,20) + " (" + ws.rQlen() + ")");
+    if (ws.rQlen() === 0) {
+        Util.Warn("handle_message called on empty receive queue");
+        return;
+    }
+    switch (rfb_state) {
+    case 'disconnected':
+    case 'failed':
+        Util.Error("Got data while disconnected");
+        break;
+    case 'normal':
+        if (normal_msg() && ws.rQlen() > 0) {
+            // true means we can continue processing
+            // Give other events a chance to run
+            if (msgTimer === null) {
+                Util.Debug("More data to process, creating timer");
+                msgTimer = setTimeout(function () {
+                            msgTimer = null;
+                            handle_message();
+                        }, 10);
+            } else {
+                Util.Debug("More data to process, existing timer");
+            }
+        }
+        break;
+    default:
+        init_msg();
+        break;
+    }
+};
+function genDES(password, challenge) {
+    var i, passwd = [];
+    for (i=0; i < password.length; i += 1) {
+        passwd.push(password.charCodeAt(i));
+    }
+    return (new DES(passwd)).encrypt(challenge);
+}
+function flushClient() {
+    if (mouse_arr.length > 0) {
+        //send(mouse_arr.concat(fbUpdateRequests()));
+        ws.send(mouse_arr);
+        setTimeout(function() {
+                ws.send(fbUpdateRequests());
+            }, 50);
+        mouse_arr = [];
+        return true;
+    } else {
+        return false;
+    }
+}
+// overridable for testing
+checkEvents = function() {
+    var now;
+    if (rfb_state === 'normal' && !viewportDragging) {
+        if (! flushClient()) {
+            now = new Date().getTime();
+            if (now > last_req_time + conf.fbu_req_rate) {
+                last_req_time = now;
+                ws.send(fbUpdateRequests());
+            }
+        }
+    }
+    setTimeout(checkEvents, conf.check_rate);
+};
+keyPress = function(keysym, down) {
+    var arr;
+    if (conf.view_only) { return; } // View only, skip keyboard events
+    arr = keyEvent(keysym, down);
+    arr = arr.concat(fbUpdateRequests());
+    ws.send(arr);
+};
+mouseButton = function(x, y, down, bmask) {
+    if (down) {
+        mouse_buttonMask |= bmask;
+    } else {
+        mouse_buttonMask ^= bmask;
+    }
+    if (conf.viewportDrag) {
+        if (down && !viewportDragging) {
+            viewportDragging = true;
+            viewportDragPos = {'x': x, 'y': y};
+            // Skip sending mouse events
+            return;
+        } else {
+            viewportDragging = false;
+            ws.send(fbUpdateRequests()); // Force immediate redraw
+        }
+    }
+    if (conf.view_only) { return; } // View only, skip mouse events
+    mouse_arr = mouse_arr.concat(
+            pointerEvent(display.absX(x), display.absY(y)) );
+    flushClient();
+};
+mouseMove = function(x, y) {
+    //Util.Debug('>> mouseMove ' + x + "," + y);
+    var deltaX, deltaY;
+    if (viewportDragging) {
+        //deltaX = x - viewportDragPos.x; // drag viewport
+        deltaX = viewportDragPos.x - x; // drag frame buffer
+        //deltaY = y - viewportDragPos.y; // drag viewport
+        deltaY = viewportDragPos.y - y; // drag frame buffer
+        viewportDragPos = {'x': x, 'y': y};
+        display.viewportChange(deltaX, deltaY);
+        // Skip sending mouse events
+        return;
+    }
+    if (conf.view_only) { return; } // View only, skip mouse events
+    mouse_arr = mouse_arr.concat(
+            pointerEvent(display.absX(x), display.absY(y)) );
+};
+//
+// Server message handlers
+//
+// RFB/VNC initialisation message handler
+init_msg = function() {
+    //Util.Debug(">> init_msg [rfb_state '" + rfb_state + "']");
+    var strlen, reason, length, sversion, cversion,
+        i, types, num_types, challenge, response, bpp, depth,
+        big_endian, red_max, green_max, blue_max, red_shift,
+        green_shift, blue_shift, true_color, name_length;
+    //Util.Debug("ws.rQ (" + ws.rQlen() + ") " + ws.rQslice(0));
+    switch (rfb_state) {
+    case 'ProtocolVersion' :
+        if (ws.rQlen() < 12) {
+            return fail("Incomplete protocol version");
+        }
+        sversion = ws.rQshiftStr(12).substr(4,7);
+        Util.Info("Server ProtocolVersion: " + sversion);
+        switch (sversion) {
+            case "003.003": rfb_version = 3.3; break;
+            case "003.006": rfb_version = 3.3; break;  // UltraVNC
+            case "003.007": rfb_version = 3.7; break;
+            case "003.008": rfb_version = 3.8; break;
+            case "004.000": rfb_version = 3.8; break;  // Intel AMT KVM
+            default:
+                return fail("Invalid server version " + sversion);
+        }
+        if (rfb_version > rfb_max_version) {
+            rfb_version = rfb_max_version;
+        }
+        if (! test_mode) {
+            sendTimer = setInterval(function() {
+                    // Send updates either at a rate of one update
+                    // every 50ms, or whatever slower rate the network
+                    // can handle.
+                    ws.flush();
+                }, 50);
+        }
+        cversion = "00" + parseInt(rfb_version,10) +
+                   ".00" + ((rfb_version * 10) % 10);
+        ws.send_string("RFB " + cversion + "\n");
+        updateState('Security', "Sent ProtocolVersion: " + cversion);
+        break;
+    case 'Security' :
+        if (rfb_version >= 3.7) {
+            // Server sends supported list, client decides
+            num_types = ws.rQshift8();
+            if (ws.rQwait("security type", num_types, 1)) { return false; }
+            if (num_types === 0) {
+                strlen = ws.rQshift32();
+                reason = ws.rQshiftStr(strlen);
+                return fail("Security failure: " + reason);
+            }
+            rfb_auth_scheme = 0;
+            types = ws.rQshiftBytes(num_types);
+            Util.Debug("Server security types: " + types);
+            for (i=0; i < types.length; i+=1) {
+                if ((types[i] > rfb_auth_scheme) && (types[i] < 3)) {
+                    rfb_auth_scheme = types[i];
+                }
+            }
+            if (rfb_auth_scheme === 0) {
+                return fail("Unsupported security types: " + types);
+            }
+            ws.send([rfb_auth_scheme]);
+        } else {
+            // Server decides
+            if (ws.rQwait("security scheme", 4)) { return false; }
+            rfb_auth_scheme = ws.rQshift32();
+        }
+        updateState('Authentication',
+                "Authenticating using scheme: " + rfb_auth_scheme);
+        init_msg();  // Recursive fallthrough (workaround JSLint complaint)
+        break;
+    // Triggered by fallthough, not by server message
+    case 'Authentication' :
+        //Util.Debug("Security auth scheme: " + rfb_auth_scheme);
+        switch (rfb_auth_scheme) {
+            case 0:  // connection failed
+                if (ws.rQwait("auth reason", 4)) { return false; }
+                strlen = ws.rQshift32();
+                reason = ws.rQshiftStr(strlen);
+                return fail("Auth failure: " + reason);
+            case 1:  // no authentication
+                if (rfb_version >= 3.8) {
+                    updateState('SecurityResult');
+                    return;
+                }
+                // Fall through to ClientInitialisation
+                break;
+            case 2:  // VNC authentication
+                if (rfb_password.length === 0) {
+                    // Notify via both callbacks since it is kind of
+                    // a RFB state change and a UI interface issue.
+                    updateState('password', "Password Required");
+                    conf.onPasswordRequired(that);
+                    return;
+                }
+                if (ws.rQwait("auth challenge", 16)) { return false; }
+                challenge = ws.rQshiftBytes(16);
+                //Util.Debug("Password: " + rfb_password);
+                //Util.Debug("Challenge: " + challenge +
+                //           " (" + challenge.length + ")");
+                response = genDES(rfb_password, challenge);
+                //Util.Debug("Response: " + response +
+                //           " (" + response.length + ")");
+                //Util.Debug("Sending DES encrypted auth response");
+                ws.send(response);
+                updateState('SecurityResult');
+                return;
+            default:
+                fail("Unsupported auth scheme: " + rfb_auth_scheme);
+                return;
+        }
+        updateState('ClientInitialisation', "No auth required");
+        init_msg();  // Recursive fallthrough (workaround JSLint complaint)
+        break;
+    case 'SecurityResult' :
+        if (ws.rQwait("VNC auth response ", 4)) { return false; }
+        switch (ws.rQshift32()) {
+            case 0:  // OK
+                // Fall through to ClientInitialisation
+                break;
+            case 1:  // failed
+                if (rfb_version >= 3.8) {
+                    length = ws.rQshift32();
+                    if (ws.rQwait("SecurityResult reason", length, 8)) {
+                        return false;
+                    }
+                    reason = ws.rQshiftStr(length);
+                    fail(reason);
+                } else {
+                    fail("Authentication failed");
+                }
+                return;
+            case 2:  // too-many
+                return fail("Too many auth attempts");
+        }
+        updateState('ClientInitialisation', "Authentication OK");
+        init_msg();  // Recursive fallthrough (workaround JSLint complaint)
+        break;
+    // Triggered by fallthough, not by server message
+    case 'ClientInitialisation' :
+        ws.send([conf.shared ? 1 : 0]); // ClientInitialisation
+        updateState('ServerInitialisation', "Authentication OK");
+        break;
+    case 'ServerInitialisation' :
+        if (ws.rQwait("server initialization", 24)) { return false; }
+        /* Screen size */
+        fb_width  = ws.rQshift16();
+        fb_height = ws.rQshift16();
+        /* PIXEL_FORMAT */
+        bpp            = ws.rQshift8();
+        depth          = ws.rQshift8();
+        big_endian     = ws.rQshift8();
+        true_color     = ws.rQshift8();
+        red_max        = ws.rQshift16();
+        green_max      = ws.rQshift16();
+        blue_max       = ws.rQshift16();
+        red_shift      = ws.rQshift8();
+        green_shift    = ws.rQshift8();
+        blue_shift     = ws.rQshift8();
+        ws.rQshiftStr(3); // padding
+        Util.Info("Screen: " + fb_width + "x" + fb_height +
+                  ", bpp: " + bpp + ", depth: " + depth +
+                  ", big_endian: " + big_endian +
+                  ", true_color: " + true_color +
+                  ", red_max: " + red_max +
+                  ", green_max: " + green_max +
+                  ", blue_max: " + blue_max +
+                  ", red_shift: " + red_shift +
+                  ", green_shift: " + green_shift +
+                  ", blue_shift: " + blue_shift);
+        if (big_endian !== 0) {
+            Util.Warn("Server native endian is not little endian");
+        }
+        if (red_shift !== 16) {
+            Util.Warn("Server native red-shift is not 16");
+        }
+        if (blue_shift !== 0) {
+            Util.Warn("Server native blue-shift is not 0");
+        }
+        /* Connection name/title */
+        name_length   = ws.rQshift32();
+        fb_name = ws.rQshiftStr(name_length);
+        if (conf.true_color && fb_name === "Intel(r) AMT KVM")
+        {
+            Util.Warn("Intel AMT KVM only support 8/16 bit depths. Disabling true color");
+            conf.true_color = false;
+        }
+        display.set_true_color(conf.true_color);
+        display.resize(fb_width, fb_height);
+        keyboard.grab();
+        mouse.grab();
+        if (conf.true_color) {
+            fb_Bpp           = 4;
+            fb_depth         = 3;
+        } else {
+            fb_Bpp           = 1;
+            fb_depth         = 1;
+        }
+        response = pixelFormat();
+        response = response.concat(clientEncodings());
+        response = response.concat(fbUpdateRequests());
+        timing.fbu_rt_start = (new Date()).getTime();
+        ws.send(response);
+        /* Start pushing/polling */
+        setTimeout(checkEvents, conf.check_rate);
+        setTimeout(scan_tight_imgQ, scan_imgQ_rate);
+        if (conf.encrypt) {
+            updateState('normal', "Connected (encrypted) to: " + fb_name);
+        } else {
+            updateState('normal', "Connected (unencrypted) to: " + fb_name);
+        }
+        break;
+    }
+    //Util.Debug("<< init_msg");
+};
+/* Normal RFB/VNC server message handler */
+normal_msg = function() {
+    //Util.Debug(">> normal_msg");
+    var ret = true, msg_type, length, text,
+        c, first_colour, num_colours, red, green, blue;
+    if (FBU.rects > 0) {
+        msg_type = 0;
+    } else {
+        msg_type = ws.rQshift8();
+    }
+    switch (msg_type) {
+    case 0:  // FramebufferUpdate
+        ret = framebufferUpdate(); // false means need more data
+        break;
+    case 1:  // SetColourMapEntries
+        Util.Debug("SetColourMapEntries");
+        ws.rQshift8();  // Padding
+        first_colour = ws.rQshift16(); // First colour
+        num_colours = ws.rQshift16();
+        if (ws.rQwait("SetColourMapEntries", num_colours*6, 6)) { return false; }
+        for (c=0; c < num_colours; c+=1) {
+            red = ws.rQshift16();
+            //Util.Debug("red before: " + red);
+            red = parseInt(red / 256, 10);
+            //Util.Debug("red after: " + red);
+            green = parseInt(ws.rQshift16() / 256, 10);
+            blue = parseInt(ws.rQshift16() / 256, 10);
+            display.set_colourMap([blue, green, red], first_colour + c);
+        }
+        Util.Debug("colourMap: " + display.get_colourMap());
+        Util.Info("Registered " + num_colours + " colourMap entries");
+        //Util.Debug("colourMap: " + display.get_colourMap());
+        break;
+    case 2:  // Bell
+        Util.Debug("Bell");
+        conf.onBell(that);
+        break;
+    case 3:  // ServerCutText
+        Util.Debug("ServerCutText");
+        if (ws.rQwait("ServerCutText header", 7, 1)) { return false; }
+        ws.rQshiftBytes(3);  // Padding
+        length = ws.rQshift32();
+        if (ws.rQwait("ServerCutText", length, 8)) { return false; }
+        text = ws.rQshiftStr(length);
+        conf.clipboardReceive(that, text); // Obsolete
+        conf.onClipboard(that, text);
+        break;
+    default:
+        fail("Disconnected: illegal server message type " + msg_type);
+        Util.Debug("ws.rQslice(0,30):" + ws.rQslice(0,30));
+        break;
+    }
+    //Util.Debug("<< normal_msg");
+    return ret;
+};
+framebufferUpdate = function() {
+    var now, hdr, fbu_rt_diff, ret = true;
+    if (FBU.rects === 0) {
+        //Util.Debug("New FBU: ws.rQslice(0,20): " + ws.rQslice(0,20));
+        if (ws.rQwait("FBU header", 3)) {
+            ws.rQunshift8(0);  // FBU msg_type
+            return false;
+        }
+        ws.rQshift8();  // padding
+        FBU.rects = ws.rQshift16();
+        //Util.Debug("FramebufferUpdate, rects:" + FBU.rects);
+        FBU.bytes = 0;
+        timing.cur_fbu = 0;
+        if (timing.fbu_rt_start > 0) {
+            now = (new Date()).getTime();
+            Util.Info("First FBU latency: " + (now - timing.fbu_rt_start));
+        }
+    }
+    while (FBU.rects > 0) {
+        if (rfb_state !== "normal") {
+            return false;
+        }
+        if (ws.rQwait("FBU", FBU.bytes)) { return false; }
+        if (FBU.bytes === 0) {
+            if (ws.rQwait("rect header", 12)) { return false; }
+            /* New FramebufferUpdate */
+            hdr = ws.rQshiftBytes(12);
+            FBU.x      = (hdr[0] << 8) + hdr[1];
+            FBU.y      = (hdr[2] << 8) + hdr[3];
+            FBU.width  = (hdr[4] << 8) + hdr[5];
+            FBU.height = (hdr[6] << 8) + hdr[7];
+            FBU.encoding = parseInt((hdr[8] << 24) + (hdr[9] << 16) +
+                                    (hdr[10] << 8) +  hdr[11], 10);
+            conf.onFBUReceive(that,
+                    {'x': FBU.x, 'y': FBU.y,
+                     'width': FBU.width, 'height': FBU.height,
+                     'encoding': FBU.encoding,
+                     'encodingName': encNames[FBU.encoding]});
+            if (encNames[FBU.encoding]) {
+                // Debug:
+                /*
+                var msg =  "FramebufferUpdate rects:" + FBU.rects;
+                msg += " x: " + FBU.x + " y: " + FBU.y;
+                msg += " width: " + FBU.width + " height: " + FBU.height;
+                msg += " encoding:" + FBU.encoding;
+                msg += "(" + encNames[FBU.encoding] + ")";
+                msg += ", ws.rQlen(): " + ws.rQlen();
+                Util.Debug(msg);
+                */
+            } else {
+                fail("Disconnected: unsupported encoding " +
+                    FBU.encoding);
+                return false;
+            }
+        }
+        timing.last_fbu = (new Date()).getTime();
+        ret = encHandlers[FBU.encoding]();
+        now = (new Date()).getTime();
+        timing.cur_fbu += (now - timing.last_fbu);
+        if (ret) {
+            encStats[FBU.encoding][0] += 1;
+            encStats[FBU.encoding][1] += 1;
+            timing.pixels += FBU.width * FBU.height;
+        }
+        if (FBU.rects === 0 || (timing.pixels >= (fb_width * fb_height))) {
+            if (((FBU.width === fb_width) &&
+                        (FBU.height === fb_height)) ||
+                    (timing.fbu_rt_start > 0)) {
+                timing.full_fbu_total += timing.cur_fbu;
+                timing.full_fbu_cnt += 1;
+                Util.Info("Timing of full FBU, cur: " +
+                          timing.cur_fbu + ", total: " +
+                          timing.full_fbu_total + ", cnt: " +
+                          timing.full_fbu_cnt + ", avg: " +
+                          (timing.full_fbu_total /
+                              timing.full_fbu_cnt));
+            }
+            if (timing.fbu_rt_start > 0) {
+                fbu_rt_diff = now - timing.fbu_rt_start;
+                timing.fbu_rt_total += fbu_rt_diff;
+                timing.fbu_rt_cnt += 1;
+                Util.Info("full FBU round-trip, cur: " +
+                          fbu_rt_diff + ", total: " +
+                          timing.fbu_rt_total + ", cnt: " +
+                          timing.fbu_rt_cnt + ", avg: " +
+                          (timing.fbu_rt_total /
+                              timing.fbu_rt_cnt));
+                timing.fbu_rt_start = 0;
+            }
+        }
+        if (! ret) {
+            return ret; // false ret means need more data
+        }
+    }
+    conf.onFBUComplete(that,
+            {'x': FBU.x, 'y': FBU.y,
+                'width': FBU.width, 'height': FBU.height,
+                'encoding': FBU.encoding,
+                'encodingName': encNames[FBU.encoding]});
+    return true; // We finished this FBU
+};
+//
+// FramebufferUpdate encodings
+//
+encHandlers.RAW = function display_raw() {
+    //Util.Debug(">> display_raw (" + ws.rQlen() + " bytes)");
+    var cur_y, cur_height;
+    if (FBU.lines === 0) {
+        FBU.lines = FBU.height;
+    }
+    FBU.bytes = FBU.width * fb_Bpp; // At least a line
+    if (ws.rQwait("RAW", FBU.bytes)) { return false; }
+    cur_y = FBU.y + (FBU.height - FBU.lines);
+    cur_height = Math.min(FBU.lines,
+                          Math.floor(ws.rQlen()/(FBU.width * fb_Bpp)));
+    display.blitImage(FBU.x, cur_y, FBU.width, cur_height,
+            ws.get_rQ(), ws.get_rQi());
+    ws.rQshiftBytes(FBU.width * cur_height * fb_Bpp);
+    FBU.lines -= cur_height;
+    if (FBU.lines > 0) {
+        FBU.bytes = FBU.width * fb_Bpp; // At least another line
+    } else {
+        FBU.rects -= 1;
+        FBU.bytes = 0;
+    }
+    //Util.Debug("<< display_raw (" + ws.rQlen() + " bytes)");
+    return true;
+};
+encHandlers.COPYRECT = function display_copy_rect() {
+    //Util.Debug(">> display_copy_rect");
+    var old_x, old_y;
+    if (ws.rQwait("COPYRECT", 4)) { return false; }
+    old_x = ws.rQshift16();
+    old_y = ws.rQshift16();
+    display.copyImage(old_x, old_y, FBU.x, FBU.y, FBU.width, FBU.height);
+    FBU.rects -= 1;
+    FBU.bytes = 0;
+    return true;
+};
+encHandlers.RRE = function display_rre() {
+    //Util.Debug(">> display_rre (" + ws.rQlen() + " bytes)");
+    var color, x, y, width, height, chunk;
+    if (FBU.subrects === 0) {
+        if (ws.rQwait("RRE", 4+fb_Bpp)) { return false; }
+        FBU.subrects = ws.rQshift32();
+        color = ws.rQshiftBytes(fb_Bpp); // Background
+        display.fillRect(FBU.x, FBU.y, FBU.width, FBU.height, color);
+    }
+    while ((FBU.subrects > 0) && (ws.rQlen() >= (fb_Bpp + 8))) {
+        color = ws.rQshiftBytes(fb_Bpp);
+        x = ws.rQshift16();
+        y = ws.rQshift16();
+        width = ws.rQshift16();
+        height = ws.rQshift16();
+        display.fillRect(FBU.x + x, FBU.y + y, width, height, color);
+        FBU.subrects -= 1;
+    }
+    //Util.Debug("   display_rre: rects: " + FBU.rects +
+    //           ", FBU.subrects: " + FBU.subrects);
+    if (FBU.subrects > 0) {
+        chunk = Math.min(rre_chunk_sz, FBU.subrects);
+        FBU.bytes = (fb_Bpp + 8) * chunk;
+    } else {
+        FBU.rects -= 1;
+        FBU.bytes = 0;
+    }
+    //Util.Debug("<< display_rre, FBU.bytes: " + FBU.bytes);
+    return true;
+};
+encHandlers.HEXTILE = function display_hextile() {
+    //Util.Debug(">> display_hextile");
+    var subencoding, subrects, color, cur_tile,
+        tile_x, x, w, tile_y, y, h, xy, s, sx, sy, wh, sw, sh,
+        rQ = ws.get_rQ(), rQi = ws.get_rQi();
+    if (FBU.tiles === 0) {
+        FBU.tiles_x = Math.ceil(FBU.width/16);
+        FBU.tiles_y = Math.ceil(FBU.height/16);
+        FBU.total_tiles = FBU.tiles_x * FBU.tiles_y;
+        FBU.tiles = FBU.total_tiles;
+    }
+    /* FBU.bytes comes in as 1, ws.rQlen() at least 1 */
+    while (FBU.tiles > 0) {
+        FBU.bytes = 1;
+        if (ws.rQwait("HEXTILE subencoding", FBU.bytes)) { return false; }
+        subencoding = rQ[rQi];  // Peek
+        if (subencoding > 30) { // Raw
+            fail("Disconnected: illegal hextile subencoding " + subencoding);
+            //Util.Debug("ws.rQslice(0,30):" + ws.rQslice(0,30));
+            return false;
+        }
+        subrects = 0;
+        cur_tile = FBU.total_tiles - FBU.tiles;
+        tile_x = cur_tile % FBU.tiles_x;
+        tile_y = Math.floor(cur_tile / FBU.tiles_x);
+        x = FBU.x + tile_x * 16;
+        y = FBU.y + tile_y * 16;
+        w = Math.min(16, (FBU.x + FBU.width) - x);
+        h = Math.min(16, (FBU.y + FBU.height) - y);
+        /* Figure out how much we are expecting */
+        if (subencoding & 0x01) { // Raw
+            //Util.Debug("   Raw subencoding");
+            FBU.bytes += w * h * fb_Bpp;
+        } else {
+            if (subencoding & 0x02) { // Background
+                FBU.bytes += fb_Bpp;
+            }
+            if (subencoding & 0x04) { // Foreground
+                FBU.bytes += fb_Bpp;
+            }
+            if (subencoding & 0x08) { // AnySubrects
+                FBU.bytes += 1;   // Since we aren't shifting it off
+                if (ws.rQwait("hextile subrects header", FBU.bytes)) { return false; }
+                subrects = rQ[rQi + FBU.bytes-1]; // Peek
+                if (subencoding & 0x10) { // SubrectsColoured
+                    FBU.bytes += subrects * (fb_Bpp + 2);
+                } else {
+                    FBU.bytes += subrects * 2;
+                }
+            }
+        }
+        /*
+        Util.Debug("   tile:" + cur_tile + "/" + (FBU.total_tiles - 1) +
+              " (" + tile_x + "," + tile_y + ")" +
+              " [" + x + "," + y + "]@" + w + "x" + h +
+              ", subenc:" + subencoding +
+              "(last: " + FBU.lastsubencoding + "), subrects:" +
+              subrects +
+              ", ws.rQlen():" + ws.rQlen() + ", FBU.bytes:" + FBU.bytes +
+              " last:" + ws.rQslice(FBU.bytes-10, FBU.bytes) +
+              " next:" + ws.rQslice(FBU.bytes-1, FBU.bytes+10));
+        */
+        if (ws.rQwait("hextile", FBU.bytes)) { return false; }
+        /* We know the encoding and have a whole tile */
+        FBU.subencoding = rQ[rQi];
+        rQi += 1;
+        if (FBU.subencoding === 0) {
+            if (FBU.lastsubencoding & 0x01) {
+                /* Weird: ignore blanks after RAW */
+                Util.Debug("     Ignoring blank after RAW");
+            } else {
+                display.fillRect(x, y, w, h, FBU.background);
+            }
+        } else if (FBU.subencoding & 0x01) { // Raw
+            display.blitImage(x, y, w, h, rQ, rQi);
+            rQi += FBU.bytes - 1;
+        } else {
+            if (FBU.subencoding & 0x02) { // Background
+                FBU.background = rQ.slice(rQi, rQi + fb_Bpp);
+                rQi += fb_Bpp;
+            }
+            if (FBU.subencoding & 0x04) { // Foreground
+                FBU.foreground = rQ.slice(rQi, rQi + fb_Bpp);
+                rQi += fb_Bpp;
+            }
+            display.startTile(x, y, w, h, FBU.background);
+            if (FBU.subencoding & 0x08) { // AnySubrects
+                subrects = rQ[rQi];
+                rQi += 1;
+                for (s = 0; s < subrects; s += 1) {
+                    if (FBU.subencoding & 0x10) { // SubrectsColoured
+                        color = rQ.slice(rQi, rQi + fb_Bpp);
+                        rQi += fb_Bpp;
+                    } else {
+                        color = FBU.foreground;
+                    }
+                    xy = rQ[rQi];
+                    rQi += 1;
+                    sx = (xy >> 4);
+                    sy = (xy & 0x0f);
+                    wh = rQ[rQi];
+                    rQi += 1;
+                    sw = (wh >> 4)   + 1;
+                    sh = (wh & 0x0f) + 1;
+                    display.subTile(sx, sy, sw, sh, color);
+                }
+            }
+            display.finishTile();
+        }
+        ws.set_rQi(rQi);
+        FBU.lastsubencoding = FBU.subencoding;
+        FBU.bytes = 0;
+        FBU.tiles -= 1;
+    }
+    if (FBU.tiles === 0) {
+        FBU.rects -= 1;
+    }
+    //Util.Debug("<< display_hextile");
+    return true;
+};
+// Get 'compact length' header and data size
+getTightCLength = function (arr) {
+    var header = 1, data = 0;
+    data += arr[0] & 0x7f;
+    if (arr[0] & 0x80) {
+        header += 1;
+        data += (arr[1] & 0x7f) << 7;
+        if (arr[1] & 0x80) {
+            header += 1;
+            data += arr[2] << 14;
+        }
+    }
+    return [header, data];
+};
+function display_tight(isTightPNG) {
+    //Util.Debug(">> display_tight");
+    if (fb_depth === 1) {
+        fail("Tight protocol handler only implements true color mode");
+    }
+    var ctl, cmode, clength, color, img, data;
+    var filterId = -1, resetStreams = 0, streamId = -1;
+    var rQ = ws.get_rQ(), rQi = ws.get_rQi();
+    FBU.bytes = 1; // compression-control byte
+    if (ws.rQwait("TIGHT compression-control", FBU.bytes)) { return false; }
+    var checksum = function(data) {
+        var sum=0, i;
+        for (i=0; i<data.length;i++) {
+            sum += data[i];
+            if (sum > 65536) sum -= 65536;
+        }
+        return sum;
+    }
+    var decompress = function(data) {
+        for (var i=0; i<4; i++) {
+            if ((resetStreams >> i) & 1) {
+                FBU.zlibs[i].reset();
+                Util.Info("Reset zlib stream " + i);
+            }
+        }
+        var uncompressed = FBU.zlibs[streamId].uncompress(data, 0);
+        if (uncompressed.status !== 0) {
+            Util.Error("Invalid data in zlib stream");
+        }
+        //Util.Warn("Decompressed " + data.length + " to " +
+        //    uncompressed.data.length + " checksums " +
+        //    checksum(data) + ":" + checksum(uncompressed.data));
+        return uncompressed.data;
+    }
+    var handlePalette = function() {
+        var numColors = rQ[rQi + 2] + 1;
+        var paletteSize = numColors * fb_depth;
+        FBU.bytes += paletteSize;
+        if (ws.rQwait("TIGHT palette " + cmode, FBU.bytes)) { return false; }
+        var bpp = (numColors <= 2) ? 1 : 8;
+        var rowSize = Math.floor((FBU.width * bpp + 7) / 8);
+        var raw = false;
+        if (rowSize * FBU.height < 12) {
+            raw = true;
+            clength = [0, rowSize * FBU.height];
+        } else {
+            clength = getTightCLength(ws.rQslice(3 + paletteSize,
+                                                 3 + paletteSize + 3));
+        }
+        FBU.bytes += clength[0] + clength[1];
+        if (ws.rQwait("TIGHT " + cmode, FBU.bytes)) { return false; }
+        // Shift ctl, filter id, num colors, palette entries, and clength off
+        ws.rQshiftBytes(3);
+        var palette = ws.rQshiftBytes(paletteSize);
+        ws.rQshiftBytes(clength[0]);
+        if (raw) {
+            data = ws.rQshiftBytes(clength[1]);
+        } else {
+            data = decompress(ws.rQshiftBytes(clength[1]));
+        }
+        // Convert indexed (palette based) image data to RGB
+        // TODO: reduce number of calculations inside loop
+        var dest = [];
+        var x, y, b, w, w1, dp, sp;
+        if (numColors === 2) {
+            w = Math.floor((FBU.width + 7) / 8);
+            w1 = Math.floor(FBU.width / 8);
+            for (y = 0; y < FBU.height; y++) {
+                for (x = 0; x < w1; x++) {
+                    for (b = 7; b >= 0; b--) {
+                        dp = (y*FBU.width + x*8 + 7-b) * 3;
+                        sp = (data[y*w + x] >> b & 1) * 3;
+                        dest[dp  ] = palette[sp  ];
+                        dest[dp+1] = palette[sp+1];
+                        dest[dp+2] = palette[sp+2];
+                    }
+                }
+                for (b = 7; b >= 8 - FBU.width % 8; b--) {
+                    dp = (y*FBU.width + x*8 + 7-b) * 3;
+                    sp = (data[y*w + x] >> b & 1) * 3;
+                    dest[dp  ] = palette[sp  ];
+                    dest[dp+1] = palette[sp+1];
+                    dest[dp+2] = palette[sp+2];
+                }
+            }
+        } else {
+            for (y = 0; y < FBU.height; y++) {
+                for (x = 0; x < FBU.width; x++) {
+                    dp = (y*FBU.width + x) * 3;
+                    sp = data[y*FBU.width + x] * 3;
+                    dest[dp  ] = palette[sp  ];
+                    dest[dp+1] = palette[sp+1];
+                    dest[dp+2] = palette[sp+2];
+                }
+            }
+        }
+        FBU.imgQ.push({
+                'type': 'rgb',
+                'img':  {'complete': true, 'data': dest},
+                'x': FBU.x,
+                'y': FBU.y,
+                'width': FBU.width,
+                'height': FBU.height});
+        return true;
+    }
+    var handleCopy = function() {
+        var raw = false;
+        var uncompressedSize = FBU.width * FBU.height * fb_depth;
+        if (uncompressedSize < 12) {
+            raw = true;
+            clength = [0, uncompressedSize];
+        } else {
+            clength = getTightCLength(ws.rQslice(1, 4));
+        }
+        FBU.bytes = 1 + clength[0] + clength[1];
+        if (ws.rQwait("TIGHT " + cmode, FBU.bytes)) { return false; }
+        // Shift ctl, clength off
+        ws.rQshiftBytes(1 + clength[0]);
+        if (raw) {
+            data = ws.rQshiftBytes(clength[1]);
+        } else {
+            data = decompress(ws.rQshiftBytes(clength[1]));
+        }
+        FBU.imgQ.push({
+                'type': 'rgb',
+                'img':  {'complete': true, 'data': data},
+                'x': FBU.x,
+                'y': FBU.y,
+                'width': FBU.width,
+                'height': FBU.height});
+        return true;
+    }
+    ctl = ws.rQpeek8();
+    // Keep tight reset bits
+    resetStreams = ctl & 0xF;
+    // Figure out filter
+    ctl = ctl >> 4;
+    streamId = ctl & 0x3;
+    if (ctl === 0x08)      cmode = "fill";
+    else if (ctl === 0x09) cmode = "jpeg";
+    else if (ctl === 0x0A) cmode = "png";
+    else if (ctl & 0x04)   cmode = "filter";
+    else if (ctl < 0x04)   cmode = "copy";
+    else throw("Illegal tight compression received, ctl: " + ctl);
+    if (isTightPNG && (cmode === "filter" || cmode === "copy")) {
+        throw("filter/copy received in tightPNG mode");
+    }
+    switch (cmode) {
+        // fill uses fb_depth because TPIXELs drop the padding byte
+        case "fill":   FBU.bytes += fb_depth; break; // TPIXEL
+        case "jpeg":   FBU.bytes += 3;        break; // max clength
+        case "png":    FBU.bytes += 3;        break; // max clength
+        case "filter": FBU.bytes += 2;        break; // filter id + num colors if palette
+        case "copy":                          break;
+    }
+    if (ws.rQwait("TIGHT " + cmode, FBU.bytes)) { return false; }
+    //Util.Debug("   ws.rQslice(0,20): " + ws.rQslice(0,20) + " (" + ws.rQlen() + ")");
+    //Util.Debug("   cmode: " + cmode);
+    // Determine FBU.bytes
+    switch (cmode) {
+    case "fill":
+        ws.rQshift8(); // shift off ctl
+        color = ws.rQshiftBytes(fb_depth);
+        FBU.imgQ.push({
+                'type': 'fill',
+                'img': {'complete': true},
+                'x': FBU.x,
+                'y': FBU.y,
+                'width': FBU.width,
+                'height': FBU.height,
+                'color': [color[2], color[1], color[0]] });
+        break;
+    case "png":
+    case "jpeg":
+        clength = getTightCLength(ws.rQslice(1, 4));
+        FBU.bytes = 1 + clength[0] + clength[1]; // ctl + clength size + jpeg-data
+        if (ws.rQwait("TIGHT " + cmode, FBU.bytes)) { return false; }
+        // We have everything, render it
+        //Util.Debug("   jpeg, ws.rQlen(): " + ws.rQlen() + ", clength[0]: " +
+        //           clength[0] + ", clength[1]: " + clength[1]);
+        ws.rQshiftBytes(1 + clength[0]); // shift off ctl + compact length
+        img = new Image();
+        //img.onload = scan_tight_imgQ;
+        FBU.imgQ.push({
+                'type': 'img',
+                'img': img,
+                'x': FBU.x,
+                'y': FBU.y});
+        img.src = "data:image/" + cmode +
+            extract_data_uri(ws.rQshiftBytes(clength[1]));
+        img = null;
+        break;
+    case "filter":
+        filterId = rQ[rQi + 1];
+        if (filterId === 1) {
+            if (!handlePalette()) { return false; }
+        } else {
+            // Filter 0, Copy could be valid here, but servers don't send it as an explicit filter
+            // Filter 2, Gradient is valid but not used if jpeg is enabled
+            throw("Unsupported tight subencoding received, filter: " + filterId);
+        }
+        break;
+    case "copy":
+        if (!handleCopy()) { return false; }
+        break;
+    }
+    FBU.bytes = 0;
+    FBU.rects -= 1;
+    //Util.Debug("   ending ws.rQslice(0,20): " + ws.rQslice(0,20) + " (" + ws.rQlen() + ")");
+    //Util.Debug("<< display_tight_png");
+    return true;
+}
+extract_data_uri = function(arr) {
+    //var i, stra = [];
+    //for (i=0; i< arr.length; i += 1) {
+    //    stra.push(String.fromCharCode(arr[i]));
+    //}
+    //return "," + escape(stra.join(''));
+    return ";base64," + Base64.encode(arr);
+};
+scan_tight_imgQ = function() {
+    var data, imgQ, ctx;
+    ctx = display.get_context();
+    if (rfb_state === 'normal') {
+        imgQ = FBU.imgQ;
+        while ((imgQ.length > 0) && (imgQ[0].img.complete)) {
+            data = imgQ.shift();
+            if (data.type === 'fill') {
+                display.fillRect(data.x, data.y, data.width, data.height, data.color);
+            } else if (data.type === 'rgb') {
+                display.blitRgbImage(data.x, data.y, data.width, data.height, data.img.data, 0);
+            } else {
+                ctx.drawImage(data.img, data.x, data.y);
+            }
+        }
+        setTimeout(scan_tight_imgQ, scan_imgQ_rate);
+    }
+};
+encHandlers.TIGHT = function () { return display_tight(false); };
+encHandlers.TIGHT_PNG = function () { return display_tight(true); };
+encHandlers.last_rect = function last_rect() {
+    Util.Debug(">> set_desktopsize");
+    FBU.rects = 0;
+    Util.Debug("<< set_desktopsize");
+    return true;
+};
+encHandlers.DesktopSize = function set_desktopsize() {
+    Util.Debug(">> set_desktopsize");
+    fb_width = FBU.width;
+    fb_height = FBU.height;
+    display.resize(fb_width, fb_height);
+    timing.fbu_rt_start = (new Date()).getTime();
+    // Send a new non-incremental request
+    ws.send(fbUpdateRequests());
+    FBU.bytes = 0;
+    FBU.rects -= 1;
+    Util.Debug("<< set_desktopsize");
+    return true;
+};
+encHandlers.Cursor = function set_cursor() {
+    var x, y, w, h, pixelslength, masklength;
+    //Util.Debug(">> set_cursor");
+    x = FBU.x;  // hotspot-x
+    y = FBU.y;  // hotspot-y
+    w = FBU.width;
+    h = FBU.height;
+    pixelslength = w * h * fb_Bpp;
+    masklength = Math.floor((w + 7) / 8) * h;
+    FBU.bytes = pixelslength + masklength;
+    if (ws.rQwait("cursor encoding", FBU.bytes)) { return false; }
+    //Util.Debug("   set_cursor, x: " + x + ", y: " + y + ", w: " + w + ", h: " + h);
+    display.changeCursor(ws.rQshiftBytes(pixelslength),
+                            ws.rQshiftBytes(masklength),
+                            x, y, w, h);
+    FBU.bytes = 0;
+    FBU.rects -= 1;
+    //Util.Debug("<< set_cursor");
+    return true;
+};
+encHandlers.JPEG_quality_lo = function set_jpeg_quality() {
+    Util.Error("Server sent jpeg_quality pseudo-encoding");
+};
+encHandlers.compress_lo = function set_compress_level() {
+    Util.Error("Server sent compress level pseudo-encoding");
+};
+/*
+ * Client message routines
+ */
+pixelFormat = function() {
+    //Util.Debug(">> pixelFormat");
+    var arr;
+    arr = [0];     // msg-type
+    arr.push8(0);  // padding
+    arr.push8(0);  // padding
+    arr.push8(0);  // padding
+    arr.push8(fb_Bpp * 8); // bits-per-pixel
+    arr.push8(fb_depth * 8); // depth
+    arr.push8(0);  // little-endian
+    arr.push8(conf.true_color ? 1 : 0);  // true-color
+    arr.push16(255);  // red-max
+    arr.push16(255);  // green-max
+    arr.push16(255);  // blue-max
+    arr.push8(16);    // red-shift
+    arr.push8(8);     // green-shift
+    arr.push8(0);     // blue-shift
+    arr.push8(0);     // padding
+    arr.push8(0);     // padding
+    arr.push8(0);     // padding
+    //Util.Debug("<< pixelFormat");
+    return arr;
+};
+clientEncodings = function() {
+    //Util.Debug(">> clientEncodings");
+    var arr, i, encList = [];
+    for (i=0; i<encodings.length; i += 1) {
+        if ((encodings[i][0] === "Cursor") &&
+            (! conf.local_cursor)) {
+            Util.Debug("Skipping Cursor pseudo-encoding");
+        } else {
+            //Util.Debug("Adding encoding: " + encodings[i][0]);
+            encList.push(encodings[i][1]);
+        }
+    }
+    arr = [2];     // msg-type
+    arr.push8(0);  // padding
+    arr.push16(encList.length); // encoding count
+    for (i=0; i < encList.length; i += 1) {
+        arr.push32(encList[i]);
+    }
+    //Util.Debug("<< clientEncodings: " + arr);
+    return arr;
+};
+fbUpdateRequest = function(incremental, x, y, xw, yw) {
+    //Util.Debug(">> fbUpdateRequest");
+    if (typeof(x) === "undefined") { x = 0; }
+    if (typeof(y) === "undefined") { y = 0; }
+    if (typeof(xw) === "undefined") { xw = fb_width; }
+    if (typeof(yw) === "undefined") { yw = fb_height; }
+    var arr;
+    arr = [3];  // msg-type
+    arr.push8(incremental);
+    arr.push16(x);
+    arr.push16(y);
+    arr.push16(xw);
+    arr.push16(yw);
+    //Util.Debug("<< fbUpdateRequest");
+    return arr;
+};
+// Based on clean/dirty areas, generate requests to send
+fbUpdateRequests = function() {
+    var cleanDirty = display.getCleanDirtyReset(),
+        arr = [], i, cb, db;
+    cb = cleanDirty.cleanBox;
+    if (cb.w > 0 && cb.h > 0) {
+        // Request incremental for clean box
+        arr = arr.concat(fbUpdateRequest(1, cb.x, cb.y, cb.w, cb.h));
+    }
+    for (i = 0; i < cleanDirty.dirtyBoxes.length; i++) {
+        db = cleanDirty.dirtyBoxes[i];
+        // Force all (non-incremental for dirty box
+        arr = arr.concat(fbUpdateRequest(0, db.x, db.y, db.w, db.h));
+    }
+    return arr;
+};
+keyEvent = function(keysym, down) {
+    //Util.Debug(">> keyEvent, keysym: " + keysym + ", down: " + down);
+    var arr;
+    arr = [4];  // msg-type
+    arr.push8(down);
+    arr.push16(0);
+    arr.push32(keysym);
+    //Util.Debug("<< keyEvent");
+    return arr;
+};
+pointerEvent = function(x, y) {
+    //Util.Debug(">> pointerEvent, x,y: " + x + "," + y +
+    //           " , mask: " + mouse_buttonMask);
+    var arr;
+    arr = [5];  // msg-type
+    arr.push8(mouse_buttonMask);
+    arr.push16(x);
+    arr.push16(y);
+    //Util.Debug("<< pointerEvent");
+    return arr;
+};
+clientCutText = function(text) {
+    //Util.Debug(">> clientCutText");
+    var arr, i, n;
+    arr = [6];     // msg-type
+    arr.push8(0);  // padding
+    arr.push8(0);  // padding
+    arr.push8(0);  // padding
+    arr.push32(text.length);
+    n = text.length;
+    for (i=0; i < n; i+=1) {
+        arr.push(text.charCodeAt(i));
+    }
+    //Util.Debug("<< clientCutText:" + arr);
+    return arr;
+};
+//
+// Public API interface functions
+//
+that.connect = function(host, port, password, path) {
+    //Util.Debug(">> connect");
+    rfb_host       = host;
+    rfb_port       = port;
+    rfb_password   = (password !== undefined)   ? password : "";
+    rfb_path       = (path !== undefined) ? path : "";
+    if ((!rfb_host) || (!rfb_port)) {
+        return fail("Must set host and port");
+    }
+    updateState('connect');
+    //Util.Debug("<< connect");
+};
+that.disconnect = function() {
+    //Util.Debug(">> disconnect");
+    updateState('disconnect', 'Disconnecting');
+    //Util.Debug("<< disconnect");
+};
+that.sendPassword = function(passwd) {
+    rfb_password = passwd;
+    rfb_state = "Authentication";
+    setTimeout(init_msg, 1);
+};
+that.sendCtrlAltDel = function() {
+    if (rfb_state !== "normal" || conf.view_only) { return false; }
+    Util.Info("Sending Ctrl-Alt-Del");
+    var arr = [];
+    arr = arr.concat(keyEvent(0xFFE3, 1)); // Control
+    arr = arr.concat(keyEvent(0xFFE9, 1)); // Alt
+    arr = arr.concat(keyEvent(0xFFFF, 1)); // Delete
+    arr = arr.concat(keyEvent(0xFFFF, 0)); // Delete
+    arr = arr.concat(keyEvent(0xFFE9, 0)); // Alt
+    arr = arr.concat(keyEvent(0xFFE3, 0)); // Control
+    arr = arr.concat(fbUpdateRequests());
+    ws.send(arr);
+};
+// Send a key press. If 'down' is not specified then send a down key
+// followed by an up key.
+that.sendKey = function(code, down) {
+    if (rfb_state !== "normal" || conf.view_only) { return false; }
+    var arr = [];
+    if (typeof down !== 'undefined') {
+        Util.Info("Sending key code (" + (down ? "down" : "up") + "): " + code);
+        arr = arr.concat(keyEvent(code, down ? 1 : 0));
+    } else {
+        Util.Info("Sending key code (down + up): " + code);
+        arr = arr.concat(keyEvent(code, 1));
+        arr = arr.concat(keyEvent(code, 0));
+    }
+    arr = arr.concat(fbUpdateRequests());
+    ws.send(arr);
+};
+that.clipboardPasteFrom = function(text) {
+    if (rfb_state !== "normal") { return; }
+    //Util.Debug(">> clipboardPasteFrom: " + text.substr(0,40) + "...");
+    ws.send(clientCutText(text));
+    //Util.Debug("<< clipboardPasteFrom");
+};
+// Override internal functions for testing
+that.testMode = function(override_send) {
+    test_mode = true;
+    that.recv_message = ws.testMode(override_send);
+    checkEvents = function () { /* Stub Out */ };
+    that.connect = function(host, port, password) {
+            rfb_host = host;
+            rfb_port = port;
+            rfb_password = password;
+            updateState('ProtocolVersion', "Starting VNC handshake");
+        };
+};
+return constructor();  // Return the public API interface
+}  // End of RFB()