mirror of
https://github.com/novnc/noVNC.git
synced 2026-05-26 23:19:41 +00:00
ec34af8f61
Some browsers (Firefox) reject unencrypted ws connections if the hosting page uses https by throwing an exception when you create the websocket object. NoVNC interprets this as binary being unsupported, and falls back to base64. If we instead connect to wss://localhost, the websocket object can be created regardless of whether the hosting page is on http or https.
423 lines
11 KiB
JavaScript
423 lines
11 KiB
JavaScript
/*
|
|
* Websock: high-performance binary WebSockets
|
|
* Copyright (C) 2012 Joel Martin
|
|
* Licensed under MPL 2.0 (see LICENSE.txt)
|
|
*
|
|
* Websock is similar to the standard WebSocket object but Websock
|
|
* enables communication with raw TCP sockets (i.e. the binary stream)
|
|
* via websockify. This is accomplished by base64 encoding the data
|
|
* stream between Websock and websockify.
|
|
*
|
|
* Websock has built-in receive queue buffering; the message event
|
|
* does not contain actual data but is simply a notification that
|
|
* there is new data available. Several rQ* methods are available to
|
|
* read binary data off of the receive queue.
|
|
*/
|
|
|
|
/*jslint browser: true, bitwise: false, plusplus: false */
|
|
/*global Util, Base64 */
|
|
|
|
|
|
// Load Flash WebSocket emulator if needed
|
|
|
|
// To force WebSocket emulator even when native WebSocket available
|
|
//window.WEB_SOCKET_FORCE_FLASH = true;
|
|
// To enable WebSocket emulator debug:
|
|
//window.WEB_SOCKET_DEBUG=1;
|
|
|
|
if (window.WebSocket && !window.WEB_SOCKET_FORCE_FLASH) {
|
|
Websock_native = true;
|
|
} else if (window.MozWebSocket && !window.WEB_SOCKET_FORCE_FLASH) {
|
|
Websock_native = true;
|
|
window.WebSocket = window.MozWebSocket;
|
|
} else {
|
|
/* no builtin WebSocket so load web_socket.js */
|
|
|
|
Websock_native = false;
|
|
(function () {
|
|
window.WEB_SOCKET_SWF_LOCATION = Util.get_include_uri() +
|
|
"web-socket-js/WebSocketMain.swf";
|
|
if (Util.Engine.trident) {
|
|
Util.Debug("Forcing uncached load of WebSocketMain.swf");
|
|
window.WEB_SOCKET_SWF_LOCATION += "?" + Math.random();
|
|
}
|
|
Util.load_scripts(["web-socket-js/swfobject.js",
|
|
"web-socket-js/web_socket.js"]);
|
|
}());
|
|
}
|
|
|
|
|
|
function Websock() {
|
|
"use strict";
|
|
|
|
var api = {}, // Public API
|
|
websocket = null, // WebSocket object
|
|
mode = 'base64', // Current WebSocket mode: 'binary', 'base64'
|
|
rQ = [], // Receive queue
|
|
rQi = 0, // Receive queue index
|
|
rQmax = 10000, // Max receive queue size before compacting
|
|
sQ = [], // Send queue
|
|
|
|
eventHandlers = {
|
|
'message' : function() {},
|
|
'open' : function() {},
|
|
'close' : function() {},
|
|
'error' : function() {}
|
|
},
|
|
|
|
test_mode = false;
|
|
|
|
|
|
//
|
|
// Queue public functions
|
|
//
|
|
|
|
function get_sQ() {
|
|
return sQ;
|
|
}
|
|
|
|
function get_rQ() {
|
|
return rQ;
|
|
}
|
|
function get_rQi() {
|
|
return rQi;
|
|
}
|
|
function set_rQi(val) {
|
|
rQi = val;
|
|
}
|
|
|
|
function rQlen() {
|
|
return rQ.length - rQi;
|
|
}
|
|
|
|
function rQpeek8() {
|
|
return (rQ[rQi] );
|
|
}
|
|
function rQshift8() {
|
|
return (rQ[rQi++] );
|
|
}
|
|
function rQunshift8(num) {
|
|
if (rQi === 0) {
|
|
rQ.unshift(num);
|
|
} else {
|
|
rQi -= 1;
|
|
rQ[rQi] = num;
|
|
}
|
|
|
|
}
|
|
function rQshift16() {
|
|
return (rQ[rQi++] << 8) +
|
|
(rQ[rQi++] );
|
|
}
|
|
function rQshift32() {
|
|
return (rQ[rQi++] << 24) +
|
|
(rQ[rQi++] << 16) +
|
|
(rQ[rQi++] << 8) +
|
|
(rQ[rQi++] );
|
|
}
|
|
function rQshiftStr(len) {
|
|
if (typeof(len) === 'undefined') { len = rQlen(); }
|
|
var arr = rQ.slice(rQi, rQi + len);
|
|
rQi += len;
|
|
return String.fromCharCode.apply(null, arr);
|
|
}
|
|
function rQshiftBytes(len) {
|
|
if (typeof(len) === 'undefined') { len = rQlen(); }
|
|
rQi += len;
|
|
return rQ.slice(rQi-len, rQi);
|
|
}
|
|
|
|
function rQslice(start, end) {
|
|
if (end) {
|
|
return rQ.slice(rQi + start, rQi + end);
|
|
} else {
|
|
return rQ.slice(rQi + 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.
|
|
function rQwait(msg, num, goback) {
|
|
var rQlen = rQ.length - rQi; // Skip rQlen() function call
|
|
if (rQlen < num) {
|
|
if (goback) {
|
|
if (rQi < goback) {
|
|
throw("rQwait cannot backup " + goback + " bytes");
|
|
}
|
|
rQi -= goback;
|
|
}
|
|
//Util.Debug(" waiting for " + (num-rQlen) +
|
|
// " " + msg + " byte(s)");
|
|
return true; // true means need more data
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Private utility routines
|
|
//
|
|
|
|
function encode_message() {
|
|
if (mode === 'binary') {
|
|
// Put in a binary arraybuffer
|
|
return (new Uint8Array(sQ)).buffer;
|
|
} else {
|
|
// base64 encode
|
|
return Base64.encode(sQ);
|
|
}
|
|
}
|
|
|
|
function decode_message(data) {
|
|
//Util.Debug(">> decode_message: " + data);
|
|
if (mode === 'binary') {
|
|
// push arraybuffer values onto the end
|
|
var u8 = new Uint8Array(data);
|
|
for (var i = 0; i < u8.length; i++) {
|
|
rQ.push(u8[i]);
|
|
}
|
|
} else {
|
|
// base64 decode and concat to the end
|
|
rQ = rQ.concat(Base64.decode(data, 0));
|
|
}
|
|
//Util.Debug(">> decode_message, rQ: " + rQ);
|
|
}
|
|
|
|
|
|
//
|
|
// Public Send functions
|
|
//
|
|
|
|
function flush() {
|
|
if (websocket.bufferedAmount !== 0) {
|
|
Util.Debug("bufferedAmount: " + websocket.bufferedAmount);
|
|
}
|
|
if (websocket.bufferedAmount < api.maxBufferedAmount) {
|
|
//Util.Debug("arr: " + arr);
|
|
//Util.Debug("sQ: " + sQ);
|
|
if (sQ.length > 0) {
|
|
websocket.send(encode_message(sQ));
|
|
sQ = [];
|
|
}
|
|
return true;
|
|
} else {
|
|
Util.Info("Delaying send, bufferedAmount: " +
|
|
websocket.bufferedAmount);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// overridable for testing
|
|
function send(arr) {
|
|
//Util.Debug(">> send_array: " + arr);
|
|
sQ = sQ.concat(arr);
|
|
return flush();
|
|
}
|
|
|
|
function send_string(str) {
|
|
//Util.Debug(">> send_string: " + str);
|
|
api.send(str.split('').map(
|
|
function (chr) { return chr.charCodeAt(0); } ) );
|
|
}
|
|
|
|
//
|
|
// Other public functions
|
|
|
|
function recv_message(e) {
|
|
//Util.Debug(">> recv_message: " + e.data.length);
|
|
|
|
try {
|
|
decode_message(e.data);
|
|
if (rQlen() > 0) {
|
|
eventHandlers.message();
|
|
// Compact the receive queue
|
|
if (rQ.length > rQmax) {
|
|
//Util.Debug("Compacting receive queue");
|
|
rQ = rQ.slice(rQi);
|
|
rQi = 0;
|
|
}
|
|
} else {
|
|
Util.Debug("Ignoring empty message");
|
|
}
|
|
} catch (exc) {
|
|
if (typeof exc.stack !== 'undefined') {
|
|
Util.Warn("recv_message, caught exception: " + exc.stack);
|
|
} else if (typeof exc.description !== 'undefined') {
|
|
Util.Warn("recv_message, caught exception: " + exc.description);
|
|
} else {
|
|
Util.Warn("recv_message, caught exception:" + exc);
|
|
}
|
|
if (typeof exc.name !== 'undefined') {
|
|
eventHandlers.error(exc.name + ": " + exc.message);
|
|
} else {
|
|
eventHandlers.error(exc);
|
|
}
|
|
}
|
|
//Util.Debug("<< recv_message");
|
|
}
|
|
|
|
|
|
// Set event handlers
|
|
function on(evt, handler) {
|
|
eventHandlers[evt] = handler;
|
|
}
|
|
|
|
function init(protocols) {
|
|
rQ = [];
|
|
rQi = 0;
|
|
sQ = [];
|
|
websocket = null;
|
|
|
|
var bt = false,
|
|
wsbt = false,
|
|
try_binary = false;
|
|
|
|
// Check for full typed array support
|
|
if (('Uint8Array' in window) &&
|
|
('set' in Uint8Array.prototype)) {
|
|
bt = true;
|
|
}
|
|
|
|
// Check for full binary type support in WebSockets
|
|
// TODO: this sucks, the property should exist on the prototype
|
|
// but it does not.
|
|
try {
|
|
if (bt && ('binaryType' in (new WebSocket("wss://localhost:17523")))) {
|
|
Util.Info("Detected binaryType support in WebSockets");
|
|
wsbt = true;
|
|
}
|
|
} catch (exc) {
|
|
// Just ignore failed test localhost connections
|
|
}
|
|
|
|
// Default protocols if not specified
|
|
if (typeof(protocols) === "undefined") {
|
|
if (wsbt) {
|
|
protocols = ['binary', 'base64'];
|
|
} else {
|
|
protocols = 'base64';
|
|
}
|
|
}
|
|
|
|
// If no binary support, make sure it was not requested
|
|
if (!wsbt) {
|
|
if (protocols === 'binary') {
|
|
throw("WebSocket binary sub-protocol requested but not supported");
|
|
}
|
|
if (typeof(protocols) === "object") {
|
|
var new_protocols = [];
|
|
for (var i = 0; i < protocols.length; i++) {
|
|
if (protocols[i] === 'binary') {
|
|
Util.Error("Skipping unsupported WebSocket binary sub-protocol");
|
|
} else {
|
|
new_protocols.push(protocols[i]);
|
|
}
|
|
}
|
|
if (new_protocols.length > 0) {
|
|
protocols = new_protocols;
|
|
} else {
|
|
throw("Only WebSocket binary sub-protocol was requested and not supported.");
|
|
}
|
|
}
|
|
}
|
|
|
|
return protocols;
|
|
}
|
|
|
|
function open(uri, protocols) {
|
|
protocols = init(protocols);
|
|
|
|
if (test_mode) {
|
|
websocket = {};
|
|
} else {
|
|
websocket = new WebSocket(uri, protocols);
|
|
if (protocols.indexOf('binary') >= 0) {
|
|
websocket.binaryType = 'arraybuffer';
|
|
}
|
|
}
|
|
|
|
websocket.onmessage = recv_message;
|
|
websocket.onopen = function() {
|
|
Util.Debug(">> WebSock.onopen");
|
|
if (websocket.protocol) {
|
|
mode = websocket.protocol;
|
|
Util.Info("Server chose sub-protocol: " + websocket.protocol);
|
|
} else {
|
|
mode = 'base64';
|
|
Util.Error("Server select no sub-protocol!: " + websocket.protocol);
|
|
}
|
|
eventHandlers.open();
|
|
Util.Debug("<< WebSock.onopen");
|
|
};
|
|
websocket.onclose = function(e) {
|
|
Util.Debug(">> WebSock.onclose");
|
|
eventHandlers.close(e);
|
|
Util.Debug("<< WebSock.onclose");
|
|
};
|
|
websocket.onerror = function(e) {
|
|
Util.Debug(">> WebSock.onerror: " + e);
|
|
eventHandlers.error(e);
|
|
Util.Debug("<< WebSock.onerror");
|
|
};
|
|
}
|
|
|
|
function close() {
|
|
if (websocket) {
|
|
if ((websocket.readyState === WebSocket.OPEN) ||
|
|
(websocket.readyState === WebSocket.CONNECTING)) {
|
|
Util.Info("Closing WebSocket connection");
|
|
websocket.close();
|
|
}
|
|
websocket.onmessage = function (e) { return; };
|
|
}
|
|
}
|
|
|
|
// Override internal functions for testing
|
|
// Takes a send function, returns reference to recv function
|
|
function testMode(override_send, data_mode) {
|
|
test_mode = true;
|
|
mode = data_mode;
|
|
api.send = override_send;
|
|
api.close = function () {};
|
|
return recv_message;
|
|
}
|
|
|
|
function constructor() {
|
|
// Configuration settings
|
|
api.maxBufferedAmount = 200;
|
|
|
|
// Direct access to send and receive queues
|
|
api.get_sQ = get_sQ;
|
|
api.get_rQ = get_rQ;
|
|
api.get_rQi = get_rQi;
|
|
api.set_rQi = set_rQi;
|
|
|
|
// Routines to read from the receive queue
|
|
api.rQlen = rQlen;
|
|
api.rQpeek8 = rQpeek8;
|
|
api.rQshift8 = rQshift8;
|
|
api.rQunshift8 = rQunshift8;
|
|
api.rQshift16 = rQshift16;
|
|
api.rQshift32 = rQshift32;
|
|
api.rQshiftStr = rQshiftStr;
|
|
api.rQshiftBytes = rQshiftBytes;
|
|
api.rQslice = rQslice;
|
|
api.rQwait = rQwait;
|
|
|
|
api.flush = flush;
|
|
api.send = send;
|
|
api.send_string = send_string;
|
|
|
|
api.on = on;
|
|
api.init = init;
|
|
api.open = open;
|
|
api.close = close;
|
|
api.testMode = testMode;
|
|
|
|
return api;
|
|
}
|
|
|
|
return constructor();
|
|
|
|
}
|