@novnc/novnc 1.0.0 → 1.2.0

package/core/websock.js

@@ -1,6 +1,6 @@
 /*
  * Websock: high-performance binary WebSockets
- * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2019 The noVNC Authors
  * Licensed under MPL 2.0 (see LICENSE.txt)
  *
  * Websock is similar to the standard WebSocket object but with extra
@@ -14,143 +14,121 @@
 
 import * as Log from './util/logging.js';
 
-export default function Websock() {
-    "use strict";
-
-    this._websocket = null;  // WebSocket object
-
-    this._rQi = 0;           // Receive queue index
-    this._rQlen = 0;         // Next write position in the receive queue
-    this._rQbufferSize = 1024 * 1024 * 4; // Receive queue buffer size (4 MiB)
-    this._rQmax = this._rQbufferSize / 8;
-    // called in init: this._rQ = new Uint8Array(this._rQbufferSize);
-    this._rQ = null; // Receive queue
-
-    this._sQbufferSize = 1024 * 10;  // 10 KiB
-    // called in init: this._sQ = new Uint8Array(this._sQbufferSize);
-    this._sQlen = 0;
-    this._sQ = null;  // Send queue
-
-    this._eventHandlers = {
-        'message': function () {},
-        'open': function () {},
-        'close': function () {},
-        'error': function () {}
-    };
-};
-
 // this has performance issues in some versions Chromium, and
 // doesn't gain a tremendous amount of performance increase in Firefox
 // at the moment.  It may be valuable to turn it on in the future.
-var ENABLE_COPYWITHIN = false;
-
-var MAX_RQ_GROW_SIZE = 40 * 1024 * 1024;  // 40 MiB
-
-var typedArrayToString = (function () {
-    // This is only for PhantomJS, which doesn't like apply-ing
-    // with Typed Arrays
-    try {
-        var arr = new Uint8Array([1, 2, 3]);
-        String.fromCharCode.apply(null, arr);
-        return function (a) { return String.fromCharCode.apply(null, a); };
-    } catch (ex) {
-        return function (a) {
-            return String.fromCharCode.apply(
-                null, Array.prototype.slice.call(a));
+// Also copyWithin() for TypedArrays is not supported in IE 11 or
+// Safari 13 (at the moment we want to support Safari 11).
+const ENABLE_COPYWITHIN = false;
+const MAX_RQ_GROW_SIZE = 40 * 1024 * 1024;  // 40 MiB
+
+export default class Websock {
+    constructor() {
+        this._websocket = null;  // WebSocket object
+
+        this._rQi = 0;           // Receive queue index
+        this._rQlen = 0;         // Next write position in the receive queue
+        this._rQbufferSize = 1024 * 1024 * 4; // Receive queue buffer size (4 MiB)
+        // called in init: this._rQ = new Uint8Array(this._rQbufferSize);
+        this._rQ = null; // Receive queue
+
+        this._sQbufferSize = 1024 * 10;  // 10 KiB
+        // called in init: this._sQ = new Uint8Array(this._sQbufferSize);
+        this._sQlen = 0;
+        this._sQ = null;  // Send queue
+
+        this._eventHandlers = {
+            message: () => {},
+            open: () => {},
+            close: () => {},
+            error: () => {}
         };
     }
-})();
 
-Websock.prototype = {
     // Getters and Setters
-    get_sQ: function () {
+    get sQ() {
         return this._sQ;
-    },
+    }
 
-    get_rQ: function () {
+    get rQ() {
         return this._rQ;
-    },
+    }
 
-    get_rQi: function () {
+    get rQi() {
         return this._rQi;
-    },
+    }
 
-    set_rQi: function (val) {
+    set rQi(val) {
         this._rQi = val;
-    },
+    }
 
     // Receive Queue
-    rQlen: function () {
+    get rQlen() {
         return this._rQlen - this._rQi;
-    },
+    }
 
-    rQpeek8: function () {
+    rQpeek8() {
         return this._rQ[this._rQi];
-    },
+    }
+
+    rQskipBytes(bytes) {
+        this._rQi += bytes;
+    }
 
-    rQshift8: function () {
-        return this._rQ[this._rQi++];
-    },
+    rQshift8() {
+        return this._rQshift(1);
+    }
 
-    rQskip8: function () {
-        this._rQi++;
-    },
+    rQshift16() {
+        return this._rQshift(2);
+    }
 
-    rQskipBytes: function (num) {
-        this._rQi += num;
-    },
+    rQshift32() {
+        return this._rQshift(4);
+    }
 
     // TODO(directxman12): test performance with these vs a DataView
-    rQshift16: function () {
-        return (this._rQ[this._rQi++] << 8) +
-               this._rQ[this._rQi++];
-    },
-
-    rQshift32: function () {
-        return (this._rQ[this._rQi++] << 24) +
-               (this._rQ[this._rQi++] << 16) +
-               (this._rQ[this._rQi++] << 8) +
-               this._rQ[this._rQi++];
-    },
-
-    rQshiftStr: function (len) {
-        if (typeof(len) === 'undefined') { len = this.rQlen(); }
-        var arr = new Uint8Array(this._rQ.buffer, this._rQi, len);
-        this._rQi += len;
-        return typedArrayToString(arr);
-    },
+    _rQshift(bytes) {
+        let res = 0;
+        for (let byte = bytes - 1; byte >= 0; byte--) {
+            res += this._rQ[this._rQi++] << (byte * 8);
+        }
+        return res;
+    }
+
+    rQshiftStr(len) {
+        if (typeof(len) === 'undefined') { len = this.rQlen; }
+        let str = "";
+        // Handle large arrays in steps to avoid long strings on the stack
+        for (let i = 0; i < len; i += 4096) {
+            let part = this.rQshiftBytes(Math.min(4096, len - i));
+            str += String.fromCharCode.apply(null, part);
+        }
+        return str;
+    }
 
-    rQshiftBytes: function (len) {
-        if (typeof(len) === 'undefined') { len = this.rQlen(); }
+    rQshiftBytes(len) {
+        if (typeof(len) === 'undefined') { len = this.rQlen; }
         this._rQi += len;
         return new Uint8Array(this._rQ.buffer, this._rQi - len, len);
-    },
+    }
 
-    rQshiftTo: function (target, len) {
-        if (len === undefined) { len = this.rQlen(); }
+    rQshiftTo(target, len) {
+        if (len === undefined) { len = this.rQlen; }
         // TODO: make this just use set with views when using a ArrayBuffer to store the rQ
         target.set(new Uint8Array(this._rQ.buffer, this._rQi, len));
         this._rQi += len;
-    },
-
-    rQwhole: function () {
-        return new Uint8Array(this._rQ.buffer, 0, this._rQlen);
-    },
+    }
 
-    rQslice: function (start, end) {
-        if (end) {
-            return new Uint8Array(this._rQ.buffer, this._rQi + start, end - start);
-        } else {
-            return new Uint8Array(this._rQ.buffer, this._rQi + start, this._rQlen - this._rQi - start);
-        }
-    },
+    rQslice(start, end = this.rQlen) {
+        return new Uint8Array(this._rQ.buffer, this._rQi + start, end - start);
+    }
 
     // Check to see if we must wait for 'num' bytes (default to FBU.bytes)
     // to be available in the receive queue. Return true if we need to
     // wait (and possibly print a debug message), otherwise false.
-    rQwait: function (msg, num, goback) {
-        var rQlen = this._rQlen - this._rQi; // Skip rQlen() function call
-        if (rQlen < num) {
+    rQwait(msg, num, goback) {
+        if (this.rQlen < num) {
             if (goback) {
                 if (this._rQi < goback) {
                     throw new Error("rQwait cannot backup " + goback + " bytes");
@@ -160,58 +138,55 @@ Websock.prototype = {
             return true; // true means need more data
         }
         return false;
-    },
+    }
 
     // Send Queue
 
-    flush: function () {
+    flush() {
         if (this._sQlen > 0 && this._websocket.readyState === WebSocket.OPEN) {
-            this._websocket.send(this._encode_message());
+            this._websocket.send(this._encodeMessage());
             this._sQlen = 0;
         }
-    },
+    }
 
-    send: function (arr) {
+    send(arr) {
         this._sQ.set(arr, this._sQlen);
         this._sQlen += arr.length;
         this.flush();
-    },
+    }
 
-    send_string: function (str) {
-        this.send(str.split('').map(function (chr) {
-            return chr.charCodeAt(0);
-        }));
-    },
+    sendString(str) {
+        this.send(str.split('').map(chr => chr.charCodeAt(0)));
+    }
 
     // Event Handlers
-    off: function (evt) {
-        this._eventHandlers[evt] = function () {};
-    },
+    off(evt) {
+        this._eventHandlers[evt] = () => {};
+    }
 
-    on: function (evt, handler) {
+    on(evt, handler) {
         this._eventHandlers[evt] = handler;
-    },
+    }
 
-    _allocate_buffers: function () {
+    _allocateBuffers() {
         this._rQ = new Uint8Array(this._rQbufferSize);
         this._sQ = new Uint8Array(this._sQbufferSize);
-    },
+    }
 
-    init: function () {
-        this._allocate_buffers();
+    init() {
+        this._allocateBuffers();
         this._rQi = 0;
         this._websocket = null;
-    },
+    }
 
-    open: function (uri, protocols) {
-        var ws_schema = uri.match(/^([a-z]+):\/\//)[1];
+    open(uri, protocols) {
         this.init();
 
         this._websocket = new WebSocket(uri, protocols);
         this._websocket.binaryType = 'arraybuffer';
 
-        this._websocket.onmessage = this._recv_message.bind(this);
-        this._websocket.onopen = (function () {
+        this._websocket.onmessage = this._recvMessage.bind(this);
+        this._websocket.onopen = () => {
             Log.Debug('>> WebSock.onopen');
             if (this._websocket.protocol) {
                 Log.Info("Server choose sub-protocol: " + this._websocket.protocol);
@@ -219,20 +194,20 @@ Websock.prototype = {
 
             this._eventHandlers.open();
             Log.Debug("<< WebSock.onopen");
-        }).bind(this);
-        this._websocket.onclose = (function (e) {
+        };
+        this._websocket.onclose = (e) => {
             Log.Debug(">> WebSock.onclose");
             this._eventHandlers.close(e);
             Log.Debug("<< WebSock.onclose");
-        }).bind(this);
-        this._websocket.onerror = (function (e) {
+        };
+        this._websocket.onerror = (e) => {
             Log.Debug(">> WebSock.onerror: " + e);
             this._eventHandlers.error(e);
             Log.Debug("<< WebSock.onerror: " + e);
-        }).bind(this);
-    },
+        };
+    }
 
-    close: function () {
+    close() {
         if (this._websocket) {
             if ((this._websocket.readyState === WebSocket.OPEN) ||
                     (this._websocket.readyState === WebSocket.CONNECTING)) {
@@ -240,77 +215,80 @@ Websock.prototype = {
                 this._websocket.close();
             }
 
-            this._websocket.onmessage = function (e) { return; };
+            this._websocket.onmessage = () => {};
         }
-    },
+    }
 
     // private methods
-    _encode_message: function () {
+    _encodeMessage() {
         // Put in a binary arraybuffer
         // according to the spec, you can send ArrayBufferViews with the send method
         return new Uint8Array(this._sQ.buffer, 0, this._sQlen);
-    },
+    }
+
+    // We want to move all the unread data to the start of the queue,
+    // e.g. compacting.
+    // The function also expands the receive que if needed, and for
+    // performance reasons we combine these two actions to avoid
+    // unneccessary copying.
+    _expandCompactRQ(minFit) {
+        // if we're using less than 1/8th of the buffer even with the incoming bytes, compact in place
+        // instead of resizing
+        const requiredBufferSize =  (this._rQlen - this._rQi + minFit) * 8;
+        const resizeNeeded = this._rQbufferSize < requiredBufferSize;
 
-    _expand_compact_rQ: function (min_fit) {
-        var resizeNeeded = min_fit || this._rQlen - this._rQi > this._rQbufferSize / 2;
         if (resizeNeeded) {
-            if (!min_fit) {
-                // just double the size if we need to do compaction
-                this._rQbufferSize *= 2;
-            } else {
-                // otherwise, make sure we satisy rQlen - rQi + min_fit < rQbufferSize / 8
-                this._rQbufferSize = (this._rQlen - this._rQi + min_fit) * 8;
-            }
+            // Make sure we always *at least* double the buffer size, and have at least space for 8x
+            // the current amount of data
+            this._rQbufferSize = Math.max(this._rQbufferSize * 2, requiredBufferSize);
         }
 
         // we don't want to grow unboundedly
         if (this._rQbufferSize > MAX_RQ_GROW_SIZE) {
             this._rQbufferSize = MAX_RQ_GROW_SIZE;
-            if (this._rQbufferSize - this._rQlen - this._rQi < min_fit) {
-                throw new Exception("Receive Queue buffer exceeded " + MAX_RQ_GROW_SIZE + " bytes, and the new message could not fit");
+            if (this._rQbufferSize - this.rQlen < minFit) {
+                throw new Error("Receive Queue buffer exceeded " + MAX_RQ_GROW_SIZE + " bytes, and the new message could not fit");
             }
         }
 
         if (resizeNeeded) {
-            var old_rQbuffer = this._rQ.buffer;
-            this._rQmax = this._rQbufferSize / 8;
+            const oldRQbuffer = this._rQ.buffer;
             this._rQ = new Uint8Array(this._rQbufferSize);
-            this._rQ.set(new Uint8Array(old_rQbuffer, this._rQi));
+            this._rQ.set(new Uint8Array(oldRQbuffer, this._rQi, this._rQlen - this._rQi));
         } else {
             if (ENABLE_COPYWITHIN) {
-                this._rQ.copyWithin(0, this._rQi);
+                this._rQ.copyWithin(0, this._rQi, this._rQlen);
             } else {
-                this._rQ.set(new Uint8Array(this._rQ.buffer, this._rQi));
+                this._rQ.set(new Uint8Array(this._rQ.buffer, this._rQi, this._rQlen - this._rQi));
             }
         }
 
         this._rQlen = this._rQlen - this._rQi;
         this._rQi = 0;
-    },
+    }
 
-    _decode_message: function (data) {
-        // push arraybuffer values onto the end
-        var u8 = new Uint8Array(data);
+    // push arraybuffer values onto the end of the receive que
+    _DecodeMessage(data) {
+        const u8 = new Uint8Array(data);
         if (u8.length > this._rQbufferSize - this._rQlen) {
-            this._expand_compact_rQ(u8.length);
+            this._expandCompactRQ(u8.length);
         }
         this._rQ.set(u8, this._rQlen);
         this._rQlen += u8.length;
-    },
+    }
 
-    _recv_message: function (e) {
-        this._decode_message(e.data);
-        if (this.rQlen() > 0) {
+    _recvMessage(e) {
+        this._DecodeMessage(e.data);
+        if (this.rQlen > 0) {
             this._eventHandlers.message();
-            // Compact the receive queue
             if (this._rQlen == this._rQi) {
+                // All data has now been processed, this means we
+                // can reset the receive queue.
                 this._rQlen = 0;
                 this._rQi = 0;
-            } else if (this._rQlen > this._rQmax) {
-                this._expand_compact_rQ();
             }
         } else {
             Log.Debug("Ignoring empty message");
         }
     }
-};
+}

package/docs/API.md

@@ -24,13 +24,7 @@ protocol stream.
 `focusOnClick`
   - Is a `boolean` indicating if keyboard focus should automatically be
     moved to the remote session when a `mousedown` or `touchstart`
-    event is received.
-
-`touchButton`
-  - Is a `long` controlling the button mask that should be simulated
-    when a touch event is recieved. Uses the same values as
-    [`MouseEvent.button`](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button).
-    Is set to `1` by default.
+    event is received. Enabled by default.
 
 `clipViewport`
   - Is a `boolean` indicating if the remote session should be clipped
@@ -53,6 +47,30 @@ protocol stream.
     should be sent whenever the container changes dimensions. Disabled
     by default.
 
+`showDotCursor`
+  - Is a `boolean` indicating whether a dot cursor should be shown
+    instead of a zero-sized or fully-transparent cursor if the server
+    sets such invisible cursor. Disabled by default.
+
+`background`
+  - Is a valid CSS [background](https://developer.mozilla.org/en-US/docs/Web/CSS/background)
+    style value indicating which background style should be applied
+    to the element containing the remote session screen. The default value is `rgb(40, 40, 40)`
+    (solid gray color).
+
+`qualityLevel`
+  - Is an `int` in range `[0-9]` controlling the desired JPEG quality.
+    Value `0` implies low quality and `9` implies high quality.
+    Default value is `6`.
+
+`compressionLevel`
+  - Is an `int` in range `[0-9]` controlling the desired compression
+    level. Value `0` means no compression. Level 1 uses a minimum of CPU
+    resources and achieves weak compression ratios, while level 9 offers
+    best compression but is slow in terms of CPU consumption on the server
+    side. Use high levels with very slow network connections.
+    Default value is `2`.
+
 `capabilities` *Read only*
   - Is an `Object` indicating which optional extensions are available
     on the server. Some methods may only be called if the corresponding
@@ -137,7 +155,7 @@ connection to a specified VNC server.
 
 ##### Syntax
 
-    var rfb = new RFB( target, url [, options] );
+    let rfb = new RFB( target, url [, options] );
 
 ###### Parameters
 
@@ -176,6 +194,10 @@ connection to a specified VNC server.
       - A `DOMString` specifying the ID to provide to any VNC repeater
         encountered.
 
+    `wsProtocols`
+      - An `Array` of `DOMString`s specifying the sub-protocols to use
+        in the WebSocket connection. Empty by default.
+
 #### connect
 
 The `connect` event is fired after all the handshaking with the server
@@ -360,5 +382,4 @@ to the remote server.
 ###### Parameters
 
 **`text`**
-  - A `DOMString` specifying the clipboard data to send. Currently only
-  characters from ISO 8859-1 are supported.
+  - A `DOMString` specifying the clipboard data to send.

package/lib/base64.js

@@ -0,0 +1,115 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var Log = _interopRequireWildcard(require("./util/logging.js"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// From: http://hg.mozilla.org/mozilla-central/raw-file/ec10630b1a54/js/src/devtools/jint/sunspider/string-base64.js
+var _default = {
+  /* Convert data (an array of integers) to a Base64 string. */
+  toBase64Table: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split(''),
+  base64Pad: '=',
+  encode: function encode(data) {
+    "use strict";
+
+    var result = '';
+    var length = data.length;
+    var lengthpad = length % 3; // Convert every three bytes to 4 ascii characters.
+
+    for (var i = 0; i < length - 2; i += 3) {
+      result += this.toBase64Table[data[i] >> 2];
+      result += this.toBase64Table[((data[i] & 0x03) << 4) + (data[i + 1] >> 4)];
+      result += this.toBase64Table[((data[i + 1] & 0x0f) << 2) + (data[i + 2] >> 6)];
+      result += this.toBase64Table[data[i + 2] & 0x3f];
+    } // Convert the remaining 1 or 2 bytes, pad out to 4 characters.
+
+
+    var j = length - lengthpad;
+
+    if (lengthpad === 2) {
+      result += this.toBase64Table[data[j] >> 2];
+      result += this.toBase64Table[((data[j] & 0x03) << 4) + (data[j + 1] >> 4)];
+      result += this.toBase64Table[(data[j + 1] & 0x0f) << 2];
+      result += this.toBase64Table[64];
+    } else if (lengthpad === 1) {
+      result += this.toBase64Table[data[j] >> 2];
+      result += this.toBase64Table[(data[j] & 0x03) << 4];
+      result += this.toBase64Table[64];
+      result += this.toBase64Table[64];
+    }
+
+    return result;
+  },
+
+  /* Convert Base64 data to a string */
+
+  /* eslint-disable comma-spacing */
+  toBinaryTable: [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, 0, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1],
+
+  /* eslint-enable comma-spacing */
+  decode: function decode(data) {
+    var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var dataLength = data.indexOf('=') - offset;
+
+    if (dataLength < 0) {
+      dataLength = data.length - offset;
+    }
+    /* Every four characters is 3 resulting numbers */
+
+
+    var resultLength = (dataLength >> 2) * 3 + Math.floor(dataLength % 4 / 1.5);
+    var result = new Array(resultLength); // Convert one by one.
+
+    var leftbits = 0; // number of bits decoded, but yet to be appended
+
+    var leftdata = 0; // bits decoded, but yet to be appended
+
+    for (var idx = 0, i = offset; i < data.length; i++) {
+      var c = this.toBinaryTable[data.charCodeAt(i) & 0x7f];
+      var padding = data.charAt(i) === this.base64Pad; // Skip illegal characters and whitespace
+
+      if (c === -1) {
+        Log.Error("Illegal character code " + data.charCodeAt(i) + " at position " + i);
+        continue;
+      } // Collect data into leftdata, update bitcount
+
+
+      leftdata = leftdata << 6 | c;
+      leftbits += 6; // If we have 8 or more bits, append 8 bits to the result
+
+      if (leftbits >= 8) {
+        leftbits -= 8; // Append if not padding.
+
+        if (!padding) {
+          result[idx++] = leftdata >> leftbits & 0xff;
+        }
+
+        leftdata &= (1 << leftbits) - 1;
+      }
+    } // If there are any bits left, the base64 string was corrupted
+
+
+    if (leftbits) {
+      var err = new Error('Corrupted base64 string');
+      err.name = 'Base64-Error';
+      throw err;
+    }
+
+    return result;
+  }
+};
+/* End of Base64 namespace */
+
+exports.default = _default;