/*
* noVNC: HTML5 VNC client
- * Copyright (C) 2012 Joel Martin
- * Copyright (C) 2018 Samuel Mannehed for Cendio AB
+ * Copyright (C) 2020 The noVNC Authors
* Licensed under MPL 2.0 (see LICENSE.txt)
*
* See README.md for usage and integration instructions.
*
- * TIGHT decoder portion:
- * (c) 2012 Michael Tinglof, Joe Balaz, Les Piech (Mercuri.ca)
*/
+import { toUnsigned32bit, toSigned32bit } from './util/int.js';
import * as Log from './util/logging.js';
-import { decodeUTF8 } from './util/strings.js';
+import { encodeUTF8, decodeUTF8 } from './util/strings.js';
import { dragThreshold } from './util/browser.js';
import EventTargetMixin from './util/eventtarget.js';
import Display from "./display.js";
+import Inflator from "./inflator.js";
+import Deflator from "./deflator.js";
import Keyboard from "./input/keyboard.js";
import Mouse from "./input/mouse.js";
import Cursor from "./util/cursor.js";
import DES from "./des.js";
import KeyTable from "./input/keysym.js";
import XtScancode from "./input/xtscancodes.js";
-import Inflator from "./inflator.js";
-import { encodings, encodingName } from "./encodings.js";
+import { encodings } from "./encodings.js";
import "./util/polyfill.js";
+import RawDecoder from "./decoders/raw.js";
+import CopyRectDecoder from "./decoders/copyrect.js";
+import RREDecoder from "./decoders/rre.js";
+import HextileDecoder from "./decoders/hextile.js";
+import TightDecoder from "./decoders/tight.js";
+import TightPNGDecoder from "./decoders/tightpng.js";
+
// How many seconds to wait for a disconnect to finish
const DISCONNECT_TIMEOUT = 3;
+const DEFAULT_BACKGROUND = 'rgb(40, 40, 40)';
+
+// Minimum wait (ms) between two mouse moves
+const MOUSE_MOVE_DELAY = 17;
+
+// Extended clipboard pseudo-encoding formats
+const extendedClipboardFormatText = 1;
+/*eslint-disable no-unused-vars */
+const extendedClipboardFormatRtf = 1 << 1;
+const extendedClipboardFormatHtml = 1 << 2;
+const extendedClipboardFormatDib = 1 << 3;
+const extendedClipboardFormatFiles = 1 << 4;
+/*eslint-enable */
+
+// Extended clipboard pseudo-encoding actions
+const extendedClipboardActionCaps = 1 << 24;
+const extendedClipboardActionRequest = 1 << 25;
+const extendedClipboardActionPeek = 1 << 26;
+const extendedClipboardActionNotify = 1 << 27;
+const extendedClipboardActionProvide = 1 << 28;
+
export default class RFB extends EventTargetMixin {
constructor(target, url, options) {
if (!target) {
- throw Error("Must specify target");
+ throw new Error("Must specify target");
}
if (!url) {
- throw Error("Must specify URL");
+ throw new Error("Must specify URL");
}
super();
// Connection details
options = options || {};
- this._rfb_credentials = options.credentials || {};
+ this._rfbCredentials = options.credentials || {};
this._shared = 'shared' in options ? !!options.shared : true;
this._repeaterID = options.repeaterID || '';
+ this._wsProtocols = options.wsProtocols || [];
// Internal state
- this._rfb_connection_state = '';
- this._rfb_init_state = '';
- this._rfb_auth_scheme = '';
- this._rfb_clean_disconnect = true;
+ this._rfbConnectionState = '';
+ this._rfbInitState = '';
+ this._rfbAuthScheme = -1;
+ this._rfbCleanDisconnect = true;
// Server capabilities
- this._rfb_version = 0;
- this._rfb_max_version = 3.8;
- this._rfb_tightvnc = false;
- this._rfb_xvp_ver = 0;
+ this._rfbVersion = 0;
+ this._rfbMaxVersion = 3.8;
+ this._rfbTightVNC = false;
+ this._rfbVeNCryptState = 0;
+ this._rfbXvpVer = 0;
- this._fb_width = 0;
- this._fb_height = 0;
+ this._fbWidth = 0;
+ this._fbHeight = 0;
- this._fb_name = "";
+ this._fbName = "";
this._capabilities = { power: false };
this._enabledContinuousUpdates = false;
this._supportsSetDesktopSize = false;
- this._screen_id = 0;
- this._screen_flags = 0;
+ this._screenID = 0;
+ this._screenFlags = 0;
this._qemuExtKeyEventSupported = false;
+ this._clipboardText = null;
+ this._clipboardServerCapabilitiesActions = {};
+ this._clipboardServerCapabilitiesFormats = {};
+
// Internal objects
this._sock = null; // Websock object
this._display = null; // Display object
// Timers
this._disconnTimer = null; // disconnection timer
this._resizeTimeout = null; // resize rate limiting
+ this._mouseMoveTimer = null;
- // Decoder states and stats
- this._encHandlers = {};
- this._encStats = {};
+ // Decoder states
+ this._decoders = {};
this._FBU = {
rects: 0,
- subrects: 0, // RRE and HEXTILE
- lines: 0, // RAW
- tiles: 0, // HEXTILE
- bytes: 0,
x: 0,
y: 0,
width: 0,
height: 0,
- encoding: 0,
- subencoding: -1,
- background: null,
- zlibs: [] // TIGHT zlib streams
- };
-
- for (let i = 0; i < 4; i++) {
- this._FBU.zlibs[i] = new Inflator();
- }
-
- this._destBuff = null;
- this._paletteBuff = new Uint8Array(1024); // 256 * 4 (max palette size * max bytes-per-pixel)
-
- this._rre_chunk_sz = 100;
-
- this._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
+ encoding: null,
};
// Mouse state
- this._mouse_buttonMask = 0;
- this._mouse_arr = [];
+ this._mousePos = {};
+ this._mouseButtonMask = 0;
+ this._mouseLastMoveTime = 0;
this._viewportDragging = false;
this._viewportDragPos = {};
this._viewportHasMoved = false;
this._screen.style.width = '100%';
this._screen.style.height = '100%';
this._screen.style.overflow = 'auto';
- this._screen.style.backgroundColor = 'rgb(40, 40, 40)';
+ this._screen.style.background = DEFAULT_BACKGROUND;
this._canvas = document.createElement('canvas');
this._canvas.style.margin = 'auto';
// Some browsers add an outline on focus
this._canvas.tabIndex = -1;
this._screen.appendChild(this._canvas);
+ // Cursor
this._cursor = new Cursor();
- // populate encHandlers with bound versions
- this._encHandlers[encodings.encodingRaw] = RFB.encodingHandlers.RAW.bind(this);
- this._encHandlers[encodings.encodingCopyRect] = RFB.encodingHandlers.COPYRECT.bind(this);
- this._encHandlers[encodings.encodingRRE] = RFB.encodingHandlers.RRE.bind(this);
- this._encHandlers[encodings.encodingHextile] = RFB.encodingHandlers.HEXTILE.bind(this);
- this._encHandlers[encodings.encodingTight] = RFB.encodingHandlers.TIGHT.bind(this, false);
- this._encHandlers[encodings.encodingTightPNG] = RFB.encodingHandlers.TIGHT.bind(this, true);
-
- this._encHandlers[encodings.pseudoEncodingDesktopSize] = RFB.encodingHandlers.DesktopSize.bind(this);
- this._encHandlers[encodings.pseudoEncodingLastRect] = RFB.encodingHandlers.last_rect.bind(this);
- this._encHandlers[encodings.pseudoEncodingCursor] = RFB.encodingHandlers.Cursor.bind(this);
- this._encHandlers[encodings.pseudoEncodingQEMUExtendedKeyEvent] = RFB.encodingHandlers.QEMUExtendedKeyEvent.bind(this);
- this._encHandlers[encodings.pseudoEncodingExtendedDesktopSize] = RFB.encodingHandlers.ExtendedDesktopSize.bind(this);
+ // XXX: TightVNC 2.8.11 sends no cursor at all until Windows changes
+ // it. Result: no cursor at all until a window border or an edit field
+ // is hit blindly. But there are also VNC servers that draw the cursor
+ // in the framebuffer and don't send the empty local cursor. There is
+ // no way to satisfy both sides.
+ //
+ // The spec is unclear on this "initial cursor" issue. Many other
+ // viewers (TigerVNC, RealVNC, Remmina) display an arrow as the
+ // initial cursor instead.
+ this._cursorImage = RFB.cursors.none;
+
+ // populate decoder array with objects
+ this._decoders[encodings.encodingRaw] = new RawDecoder();
+ this._decoders[encodings.encodingCopyRect] = new CopyRectDecoder();
+ this._decoders[encodings.encodingRRE] = new RREDecoder();
+ this._decoders[encodings.encodingHextile] = new HextileDecoder();
+ this._decoders[encodings.encodingTight] = new TightDecoder();
+ this._decoders[encodings.encodingTightPNG] = new TightPNGDecoder();
// NB: nothing that needs explicit teardown should be done
// before this point, since this can throw an exception
throw exc;
}
this._display.onflush = this._onFlush.bind(this);
- this._display.clear();
this._keyboard = new Keyboard(this._canvas);
this._keyboard.onkeyevent = this._handleKeyEvent.bind(this);
this._mouse.onmousemove = this._handleMouseMove.bind(this);
this._sock = new Websock();
- this._sock.on('message', this._handle_message.bind(this));
+ this._sock.on('message', () => {
+ this._handleMessage();
+ });
this._sock.on('open', () => {
- if ((this._rfb_connection_state === 'connecting') &&
- (this._rfb_init_state === '')) {
- this._rfb_init_state = 'ProtocolVersion';
+ if ((this._rfbConnectionState === 'connecting') &&
+ (this._rfbInitState === '')) {
+ this._rfbInitState = 'ProtocolVersion';
Log.Debug("Starting VNC handshake");
} else {
this._fail("Unexpected server connection while " +
- this._rfb_connection_state);
+ this._rfbConnectionState);
}
});
this._sock.on('close', (e) => {
}
msg += ")";
}
- switch (this._rfb_connection_state) {
+ switch (this._rfbConnectionState) {
case 'connecting':
this._fail("Connection closed " + msg);
break;
this._clipViewport = false;
this._scaleViewport = false;
this._resizeSession = false;
+
+ this._showDotCursor = false;
+ if (options.showDotCursor !== undefined) {
+ Log.Warn("Specifying showDotCursor as a RFB constructor argument is deprecated");
+ this._showDotCursor = options.showDotCursor;
+ }
+
+ this._qualityLevel = 6;
+ this._compressionLevel = 2;
}
// ===== PROPERTIES =====
set viewOnly(viewOnly) {
this._viewOnly = viewOnly;
- if (this._rfb_connection_state === "connecting" ||
- this._rfb_connection_state === "connected") {
+ if (this._rfbConnectionState === "connecting" ||
+ this._rfbConnectionState === "connected") {
if (viewOnly) {
this._keyboard.ungrab();
this._mouse.ungrab();
}
}
+ get showDotCursor() { return this._showDotCursor; }
+ set showDotCursor(show) {
+ this._showDotCursor = show;
+ this._refreshCursor();
+ }
+
+ get background() { return this._screen.style.background; }
+ set background(cssValue) { this._screen.style.background = cssValue; }
+
+ get qualityLevel() {
+ return this._qualityLevel;
+ }
+ set qualityLevel(qualityLevel) {
+ if (!Number.isInteger(qualityLevel) || qualityLevel < 0 || qualityLevel > 9) {
+ Log.Error("qualityLevel must be an integer between 0 and 9");
+ return;
+ }
+
+ if (this._qualityLevel === qualityLevel) {
+ return;
+ }
+
+ this._qualityLevel = qualityLevel;
+
+ if (this._rfbConnectionState === 'connected') {
+ this._sendEncodings();
+ }
+ }
+
+ get compressionLevel() {
+ return this._compressionLevel;
+ }
+ set compressionLevel(compressionLevel) {
+ if (!Number.isInteger(compressionLevel) || compressionLevel < 0 || compressionLevel > 9) {
+ Log.Error("compressionLevel must be an integer between 0 and 9");
+ return;
+ }
+
+ if (this._compressionLevel === compressionLevel) {
+ return;
+ }
+
+ this._compressionLevel = compressionLevel;
+
+ if (this._rfbConnectionState === 'connected') {
+ this._sendEncodings();
+ }
+ }
+
// ===== PUBLIC METHODS =====
disconnect() {
}
sendCredentials(creds) {
- this._rfb_credentials = creds;
- setTimeout(this._init_msg.bind(this), 0);
+ this._rfbCredentials = creds;
+ setTimeout(this._initMsg.bind(this), 0);
}
sendCtrlAltDel() {
- if (this._rfb_connection_state !== 'connected' || this._viewOnly) { return; }
+ if (this._rfbConnectionState !== 'connected' || this._viewOnly) { return; }
Log.Info("Sending Ctrl-Alt-Del");
this.sendKey(KeyTable.XK_Control_L, "ControlLeft", true);
// Send a key press. If 'down' is not specified then send a down key
// followed by an up key.
sendKey(keysym, code, down) {
- if (this._rfb_connection_state !== 'connected' || this._viewOnly) { return; }
+ if (this._rfbConnectionState !== 'connected' || this._viewOnly) { return; }
if (down === undefined) {
this.sendKey(keysym, code, true);
}
clipboardPasteFrom(text) {
- if (this._rfb_connection_state !== 'connected' || this._viewOnly) { return; }
- RFB.messages.clientCutText(this._sock, text);
+ if (this._rfbConnectionState !== 'connected' || this._viewOnly) { return; }
+
+ if (this._clipboardServerCapabilitiesFormats[extendedClipboardFormatText] &&
+ this._clipboardServerCapabilitiesActions[extendedClipboardActionNotify]) {
+
+ this._clipboardText = text;
+ RFB.messages.extendedClipboardNotify(this._sock, [extendedClipboardFormatText]);
+ } else {
+ let data = new Uint8Array(text.length);
+ for (let i = 0; i < text.length; i++) {
+ // FIXME: text can have values outside of Latin1/Uint8
+ data[i] = text.charCodeAt(i);
+ }
+
+ RFB.messages.clientCutText(this._sock, data);
+ }
}
// ===== PRIVATE METHODS =====
try {
// WebSocket.onopen transitions to the RFB init states
- this._sock.open(this._url, ['binary']);
+ this._sock.open(this._url, this._wsProtocols);
} catch (e) {
if (e.name === 'SyntaxError') {
this._fail("Invalid host or port (" + e + ")");
this._target.appendChild(this._screen);
this._cursor.attach(this._canvas);
+ this._refreshCursor();
// Monitor size changes of the screen
// FIXME: Use ResizeObserver, or hidden overflow
this._keyboard.ungrab();
this._mouse.ungrab();
this._sock.close();
- this._print_stats();
try {
this._target.removeChild(this._screen);
} catch (e) {
}
}
clearTimeout(this._resizeTimeout);
+ clearTimeout(this._mouseMoveTimer);
Log.Debug("<< RFB.disconnect");
}
- _print_stats() {
- const stats = this._encStats;
-
- Log.Info("Encoding stats for this connection:");
- Object.keys(stats).forEach((key) => {
- const s = stats[key];
- if (s[0] + s[1] > 0) {
- Log.Info(" " + encodingName(key) + ": " + s[0] + " rects");
- }
- });
-
- Log.Info("Encoding stats since page load:");
- Object.keys(stats).forEach(key => Log.Info(" " + encodingName(key) + ": " + stats[key][1] + " rects"));
- }
-
_focusCanvas(event) {
// Respect earlier handlers' request to not do side-effects
if (event.defaultPrevented) {
this.focus();
}
+ _setDesktopName(name) {
+ this._fbName = name;
+ this.dispatchEvent(new CustomEvent(
+ "desktopname",
+ { detail: { name: this._fbName } }));
+ }
+
_windowResize(event) {
// If the window resized then our screen element might have
// as well. Update the viewport dimensions.
// Update state of clipping in Display object, and make sure the
// configured viewport matches the current screen size
_updateClip() {
- const cur_clip = this._display.clipViewport;
- let new_clip = this._clipViewport;
+ const curClip = this._display.clipViewport;
+ let newClip = this._clipViewport;
if (this._scaleViewport) {
// Disable viewport clipping if we are scaling
- new_clip = false;
+ newClip = false;
}
- if (cur_clip !== new_clip) {
- this._display.clipViewport = new_clip;
+ if (curClip !== newClip) {
+ this._display.clipViewport = newClip;
}
- if (new_clip) {
+ if (newClip) {
// When clipping is enabled, the screen is limited to
// the size of the container.
const size = this._screenSize();
const size = this._screenSize();
RFB.messages.setDesktopSize(this._sock,
Math.floor(size.w), Math.floor(size.h),
- this._screen_id, this._screen_flags);
+ this._screenID, this._screenFlags);
Log.Debug('Requested new desktop size: ' +
size.w + 'x' + size.h);
* disconnected - permanent state
*/
_updateConnectionState(state) {
- const oldstate = this._rfb_connection_state;
+ const oldstate = this._rfbConnectionState;
if (state === oldstate) {
Log.Debug("Already in state '" + state + "', ignoring");
// State change actions
- this._rfb_connection_state = state;
+ this._rfbConnectionState = state;
Log.Debug("New state '" + state + "', was '" + oldstate + "'.");
case 'disconnected':
this.dispatchEvent(new CustomEvent(
"disconnect", { detail:
- { clean: this._rfb_clean_disconnect } }));
+ { clean: this._rfbCleanDisconnect } }));
break;
}
}
* should be logged but not sent to the user interface.
*/
_fail(details) {
- switch (this._rfb_connection_state) {
+ switch (this._rfbConnectionState) {
case 'disconnecting':
Log.Error("Failed when disconnecting: " + details);
break;
Log.Error("RFB failure: " + details);
break;
}
- this._rfb_clean_disconnect = false; //This is sent to the UI
+ this._rfbCleanDisconnect = false; //This is sent to the UI
// Transition to disconnected without waiting for socket to close
this._updateConnectionState('disconnecting');
{ detail: { capabilities: this._capabilities } }));
}
- _handle_message() {
- if (this._sock.rQlen() === 0) {
- Log.Warn("handle_message called on an empty receive queue");
+ _handleMessage() {
+ if (this._sock.rQlen === 0) {
+ Log.Warn("handleMessage called on an empty receive queue");
return;
}
- switch (this._rfb_connection_state) {
+ switch (this._rfbConnectionState) {
case 'disconnected':
Log.Error("Got data while disconnected");
break;
if (this._flushing) {
break;
}
- if (!this._normal_msg()) {
+ if (!this._normalMsg()) {
break;
}
- if (this._sock.rQlen() === 0) {
+ if (this._sock.rQlen === 0) {
break;
}
}
break;
default:
- this._init_msg();
+ this._initMsg();
break;
}
}
}
_handleMouseButton(x, y, down, bmask) {
- if (down) {
- this._mouse_buttonMask |= bmask;
- } else {
- this._mouse_buttonMask &= ~bmask;
- }
-
if (this.dragViewport) {
if (down && !this._viewportDragging) {
this._viewportDragging = true;
// Otherwise we treat this as a mouse click event.
// Send the button down event here, as the button up
// event is sent at the end of this function.
- RFB.messages.pointerEvent(this._sock,
- this._display.absX(x),
- this._display.absY(y),
- bmask);
+ this._sendMouse(x, y, bmask);
}
}
- if (this._viewOnly) { return; } // View only, skip mouse events
+ // Flush waiting move event first
+ if (this._mouseMoveTimer !== null) {
+ clearTimeout(this._mouseMoveTimer);
+ this._mouseMoveTimer = null;
+ this._sendMouse(x, y, this._mouseButtonMask);
+ }
+
+ if (down) {
+ this._mouseButtonMask |= bmask;
+ } else {
+ this._mouseButtonMask &= ~bmask;
+ }
- if (this._rfb_connection_state !== 'connected') { return; }
- RFB.messages.pointerEvent(this._sock, this._display.absX(x), this._display.absY(y), this._mouse_buttonMask);
+ this._sendMouse(x, y, this._mouseButtonMask);
}
_handleMouseMove(x, y) {
return;
}
+ this._mousePos = { 'x': x, 'y': y };
+
+ // Limit many mouse move events to one every MOUSE_MOVE_DELAY ms
+ if (this._mouseMoveTimer == null) {
+
+ const timeSinceLastMove = Date.now() - this._mouseLastMoveTime;
+ if (timeSinceLastMove > MOUSE_MOVE_DELAY) {
+ this._sendMouse(x, y, this._mouseButtonMask);
+ this._mouseLastMoveTime = Date.now();
+ } else {
+ // Too soon since the latest move, wait the remaining time
+ this._mouseMoveTimer = setTimeout(() => {
+ this._handleDelayedMouseMove();
+ }, MOUSE_MOVE_DELAY - timeSinceLastMove);
+ }
+ }
+ }
+
+ _handleDelayedMouseMove() {
+ this._mouseMoveTimer = null;
+ this._sendMouse(this._mousePos.x, this._mousePos.y,
+ this._mouseButtonMask);
+ this._mouseLastMoveTime = Date.now();
+ }
+
+ _sendMouse(x, y, mask) {
+ if (this._rfbConnectionState !== 'connected') { return; }
if (this._viewOnly) { return; } // View only, skip mouse events
- if (this._rfb_connection_state !== 'connected') { return; }
- RFB.messages.pointerEvent(this._sock, this._display.absX(x), this._display.absY(y), this._mouse_buttonMask);
+ RFB.messages.pointerEvent(this._sock, this._display.absX(x),
+ this._display.absY(y), mask);
}
// Message Handlers
- _negotiate_protocol_version() {
- if (this._sock.rQlen() < 12) {
- return this._fail("Received incomplete protocol version.");
+ _negotiateProtocolVersion() {
+ if (this._sock.rQwait("version", 12)) {
+ return false;
}
const sversion = this._sock.rQshiftStr(12).substr(4, 7);
Log.Info("Server ProtocolVersion: " + sversion);
- let is_repeater = 0;
+ let isRepeater = 0;
switch (sversion) {
case "000.000": // UltraVNC repeater
- is_repeater = 1;
+ isRepeater = 1;
break;
case "003.003":
case "003.006": // UltraVNC
case "003.889": // Apple Remote Desktop
- this._rfb_version = 3.3;
+ this._rfbVersion = 3.3;
break;
case "003.007":
- this._rfb_version = 3.7;
+ this._rfbVersion = 3.7;
break;
case "003.008":
case "004.000": // Intel AMT KVM
case "004.001": // RealVNC 4.6
case "005.000": // RealVNC 5.3
- this._rfb_version = 3.8;
+ this._rfbVersion = 3.8;
break;
default:
return this._fail("Invalid server version " + sversion);
}
- if (is_repeater) {
+ if (isRepeater) {
let repeaterID = "ID:" + this._repeaterID;
while (repeaterID.length < 250) {
repeaterID += "\0";
return true;
}
- if (this._rfb_version > this._rfb_max_version) {
- this._rfb_version = this._rfb_max_version;
+ if (this._rfbVersion > this._rfbMaxVersion) {
+ this._rfbVersion = this._rfbMaxVersion;
}
- const cversion = "00" + parseInt(this._rfb_version, 10) +
- ".00" + ((this._rfb_version * 10) % 10);
+ const cversion = "00" + parseInt(this._rfbVersion, 10) +
+ ".00" + ((this._rfbVersion * 10) % 10);
this._sock.send_string("RFB " + cversion + "\n");
Log.Debug('Sent ProtocolVersion: ' + cversion);
- this._rfb_init_state = 'Security';
+ this._rfbInitState = 'Security';
}
- _negotiate_security() {
+ _negotiateSecurity() {
// Polyfill since IE and PhantomJS doesn't have
// TypedArray.includes()
function includes(item, array) {
return false;
}
- if (this._rfb_version >= 3.7) {
+ if (this._rfbVersion >= 3.7) {
// Server sends supported list, client decides
- const num_types = this._sock.rQshift8();
- if (this._sock.rQwait("security type", num_types, 1)) { return false; }
-
- if (num_types === 0) {
- return this._handle_security_failure("no security types");
+ const numTypes = this._sock.rQshift8();
+ if (this._sock.rQwait("security type", numTypes, 1)) { return false; }
+
+ if (numTypes === 0) {
+ this._rfbInitState = "SecurityReason";
+ this._securityContext = "no security types";
+ this._securityStatus = 1;
+ return this._initMsg();
}
- const types = this._sock.rQshiftBytes(num_types);
+ const types = this._sock.rQshiftBytes(numTypes);
Log.Debug("Server security types: " + types);
// Look for each auth in preferred order
- this._rfb_auth_scheme = 0;
if (includes(1, types)) {
- this._rfb_auth_scheme = 1; // None
+ this._rfbAuthScheme = 1; // None
} else if (includes(22, types)) {
- this._rfb_auth_scheme = 22; // XVP
+ this._rfbAuthScheme = 22; // XVP
} else if (includes(16, types)) {
- this._rfb_auth_scheme = 16; // Tight
+ this._rfbAuthScheme = 16; // Tight
} else if (includes(2, types)) {
- this._rfb_auth_scheme = 2; // VNC Auth
+ this._rfbAuthScheme = 2; // VNC Auth
+ } else if (includes(19, types)) {
+ this._rfbAuthScheme = 19; // VeNCrypt Auth
} else {
return this._fail("Unsupported security types (types: " + types + ")");
}
- this._sock.send([this._rfb_auth_scheme]);
+ this._sock.send([this._rfbAuthScheme]);
} else {
// Server decides
if (this._sock.rQwait("security scheme", 4)) { return false; }
- this._rfb_auth_scheme = this._sock.rQshift32();
+ this._rfbAuthScheme = this._sock.rQshift32();
+
+ if (this._rfbAuthScheme == 0) {
+ this._rfbInitState = "SecurityReason";
+ this._securityContext = "authentication scheme";
+ this._securityStatus = 1;
+ return this._initMsg();
+ }
}
- this._rfb_init_state = 'Authentication';
- Log.Debug('Authenticating using scheme: ' + this._rfb_auth_scheme);
+ this._rfbInitState = 'Authentication';
+ Log.Debug('Authenticating using scheme: ' + this._rfbAuthScheme);
- return this._init_msg(); // jump to authentication
+ return this._initMsg(); // jump to authentication
}
- /*
- * Get the security failure reason if sent from the server and
- * send the 'securityfailure' event.
- *
- * - The optional parameter context can be used to add some extra
- * context to the log output.
- *
- * - The optional parameter security_result_status can be used to
- * add a custom status code to the event.
- */
- _handle_security_failure(context, security_result_status) {
-
- if (typeof context === 'undefined') {
- context = "";
- } else {
- context = " on " + context;
- }
-
- if (typeof security_result_status === 'undefined') {
- security_result_status = 1; // fail
- }
-
+ _handleSecurityReason() {
if (this._sock.rQwait("reason length", 4)) {
return false;
}
let reason = "";
if (strlen > 0) {
- if (this._sock.rQwait("reason", strlen, 8)) { return false; }
+ if (this._sock.rQwait("reason", strlen, 4)) { return false; }
reason = this._sock.rQshiftStr(strlen);
}
if (reason !== "") {
this.dispatchEvent(new CustomEvent(
"securityfailure",
- { detail: { status: security_result_status, reason: reason } }));
+ { detail: { status: this._securityStatus,
+ reason: reason } }));
- return this._fail("Security negotiation failed" + context +
+ return this._fail("Security negotiation failed on " +
+ this._securityContext +
" (reason: " + reason + ")");
} else {
this.dispatchEvent(new CustomEvent(
"securityfailure",
- { detail: { status: security_result_status } }));
+ { detail: { status: this._securityStatus } }));
- return this._fail("Security negotiation failed" + context);
+ return this._fail("Security negotiation failed on " +
+ this._securityContext);
}
}
// authentication
- _negotiate_xvp_auth() {
- if (!this._rfb_credentials.username ||
- !this._rfb_credentials.password ||
- !this._rfb_credentials.target) {
+ _negotiateXvpAuth() {
+ if (this._rfbCredentials.username === undefined ||
+ this._rfbCredentials.password === undefined ||
+ this._rfbCredentials.target === undefined) {
this.dispatchEvent(new CustomEvent(
"credentialsrequired",
{ detail: { types: ["username", "password", "target"] } }));
return false;
}
- const xvp_auth_str = String.fromCharCode(this._rfb_credentials.username.length) +
- String.fromCharCode(this._rfb_credentials.target.length) +
- this._rfb_credentials.username +
- this._rfb_credentials.target;
- this._sock.send_string(xvp_auth_str);
- this._rfb_auth_scheme = 2;
- return this._negotiate_authentication();
+ const xvpAuthStr = String.fromCharCode(this._rfbCredentials.username.length) +
+ String.fromCharCode(this._rfbCredentials.target.length) +
+ this._rfbCredentials.username +
+ this._rfbCredentials.target;
+ this._sock.send_string(xvpAuthStr);
+ this._rfbAuthScheme = 2;
+ return this._negotiateAuthentication();
+ }
+
+ // VeNCrypt authentication, currently only supports version 0.2 and only Plain subtype
+ _negotiateVeNCryptAuth() {
+
+ // waiting for VeNCrypt version
+ if (this._rfbVeNCryptState == 0) {
+ if (this._sock.rQwait("vencrypt version", 2)) { return false; }
+
+ const major = this._sock.rQshift8();
+ const minor = this._sock.rQshift8();
+
+ if (!(major == 0 && minor == 2)) {
+ return this._fail("Unsupported VeNCrypt version " + major + "." + minor);
+ }
+
+ this._sock.send([0, 2]);
+ this._rfbVeNCryptState = 1;
+ }
+
+ // waiting for ACK
+ if (this._rfbVeNCryptState == 1) {
+ if (this._sock.rQwait("vencrypt ack", 1)) { return false; }
+
+ const res = this._sock.rQshift8();
+
+ if (res != 0) {
+ return this._fail("VeNCrypt failure " + res);
+ }
+
+ this._rfbVeNCryptState = 2;
+ }
+ // must fall through here (i.e. no "else if"), beacause we may have already received
+ // the subtypes length and won't be called again
+
+ if (this._rfbVeNCryptState == 2) { // waiting for subtypes length
+ if (this._sock.rQwait("vencrypt subtypes length", 1)) { return false; }
+
+ const subtypesLength = this._sock.rQshift8();
+ if (subtypesLength < 1) {
+ return this._fail("VeNCrypt subtypes empty");
+ }
+
+ this._rfbVeNCryptSubtypesLength = subtypesLength;
+ this._rfbVeNCryptState = 3;
+ }
+
+ // waiting for subtypes list
+ if (this._rfbVeNCryptState == 3) {
+ if (this._sock.rQwait("vencrypt subtypes", 4 * this._rfbVeNCryptSubtypesLength)) { return false; }
+
+ const subtypes = [];
+ for (let i = 0; i < this._rfbVeNCryptSubtypesLength; i++) {
+ subtypes.push(this._sock.rQshift32());
+ }
+
+ // 256 = Plain subtype
+ if (subtypes.indexOf(256) != -1) {
+ // 0x100 = 256
+ this._sock.send([0, 0, 1, 0]);
+ this._rfbVeNCryptState = 4;
+ } else {
+ return this._fail("VeNCrypt Plain subtype not offered by server");
+ }
+ }
+
+ // negotiated Plain subtype, server waits for password
+ if (this._rfbVeNCryptState == 4) {
+ if (!this._rfbCredentials.username ||
+ !this._rfbCredentials.password) {
+ this.dispatchEvent(new CustomEvent(
+ "credentialsrequired",
+ { detail: { types: ["username", "password"] } }));
+ return false;
+ }
+
+ const user = encodeUTF8(this._rfbCredentials.username);
+ const pass = encodeUTF8(this._rfbCredentials.password);
+
+ // XXX we assume lengths are <= 255 (should not be an issue in the real world)
+ this._sock.send([0, 0, 0, user.length]);
+ this._sock.send([0, 0, 0, pass.length]);
+ this._sock.send_string(user);
+ this._sock.send_string(pass);
+
+ this._rfbInitState = "SecurityResult";
+ return true;
+ }
}
- _negotiate_std_vnc_auth() {
+ _negotiateStdVNCAuth() {
if (this._sock.rQwait("auth challenge", 16)) { return false; }
- if (!this._rfb_credentials.password) {
+ if (this._rfbCredentials.password === undefined) {
this.dispatchEvent(new CustomEvent(
"credentialsrequired",
{ detail: { types: ["password"] } }));
// TODO(directxman12): make genDES not require an Array
const challenge = Array.prototype.slice.call(this._sock.rQshiftBytes(16));
- const response = RFB.genDES(this._rfb_credentials.password, challenge);
+ const response = RFB.genDES(this._rfbCredentials.password, challenge);
this._sock.send(response);
- this._rfb_init_state = "SecurityResult";
+ this._rfbInitState = "SecurityResult";
+ return true;
+ }
+
+ _negotiateTightUnixAuth() {
+ if (this._rfbCredentials.username === undefined ||
+ this._rfbCredentials.password === undefined) {
+ this.dispatchEvent(new CustomEvent(
+ "credentialsrequired",
+ { detail: { types: ["username", "password"] } }));
+ return false;
+ }
+
+ this._sock.send([0, 0, 0, this._rfbCredentials.username.length]);
+ this._sock.send([0, 0, 0, this._rfbCredentials.password.length]);
+ this._sock.send_string(this._rfbCredentials.username);
+ this._sock.send_string(this._rfbCredentials.password);
+ this._rfbInitState = "SecurityResult";
return true;
}
- _negotiate_tight_tunnels(numTunnels) {
+ _negotiateTightTunnels(numTunnels) {
const clientSupportedTunnelTypes = {
0: { vendor: 'TGHT', signature: 'NOTUNNEL' }
};
const serverSupportedTunnelTypes = {};
// receive tunnel capabilities
for (let i = 0; i < numTunnels; i++) {
- const cap_code = this._sock.rQshift32();
- const cap_vendor = this._sock.rQshiftStr(4);
- const cap_signature = this._sock.rQshiftStr(8);
- serverSupportedTunnelTypes[cap_code] = { vendor: cap_vendor, signature: cap_signature };
+ const capCode = this._sock.rQshift32();
+ const capVendor = this._sock.rQshiftStr(4);
+ const capSignature = this._sock.rQshiftStr(8);
+ serverSupportedTunnelTypes[capCode] = { vendor: capVendor, signature: capSignature };
}
Log.Debug("Server Tight tunnel types: " + serverSupportedTunnelTypes);
}
}
- _negotiate_tight_auth() {
- if (!this._rfb_tightvnc) { // first pass, do the tunnel negotiation
+ _negotiateTightAuth() {
+ if (!this._rfbTightVNC) { // first pass, do the tunnel negotiation
if (this._sock.rQwait("num tunnels", 4)) { return false; }
const numTunnels = this._sock.rQshift32();
if (numTunnels > 0 && this._sock.rQwait("tunnel capabilities", 16 * numTunnels, 4)) { return false; }
- this._rfb_tightvnc = true;
+ this._rfbTightVNC = true;
if (numTunnels > 0) {
- this._negotiate_tight_tunnels(numTunnels);
+ this._negotiateTightTunnels(numTunnels);
return false; // wait until we receive the sub auth to continue
}
}
if (this._sock.rQwait("sub auth count", 4)) { return false; }
const subAuthCount = this._sock.rQshift32();
if (subAuthCount === 0) { // empty sub-auth list received means 'no auth' subtype selected
- this._rfb_init_state = 'SecurityResult';
+ this._rfbInitState = 'SecurityResult';
return true;
}
const clientSupportedTypes = {
'STDVNOAUTH__': 1,
- 'STDVVNCAUTH_': 2
+ 'STDVVNCAUTH_': 2,
+ 'TGHTULGNAUTH': 129
};
const serverSupportedTypes = [];
switch (authType) {
case 'STDVNOAUTH__': // no auth
- this._rfb_init_state = 'SecurityResult';
+ this._rfbInitState = 'SecurityResult';
return true;
case 'STDVVNCAUTH_': // VNC auth
- this._rfb_auth_scheme = 2;
- return this._init_msg();
+ this._rfbAuthScheme = 2;
+ return this._initMsg();
+ case 'TGHTULGNAUTH': // UNIX auth
+ this._rfbAuthScheme = 129;
+ return this._initMsg();
default:
return this._fail("Unsupported tiny auth scheme " +
"(scheme: " + authType + ")");
return this._fail("No supported sub-auth types!");
}
- _negotiate_authentication() {
- switch (this._rfb_auth_scheme) {
- case 0: // connection failed
- return this._handle_security_failure("authentication scheme");
-
+ _negotiateAuthentication() {
+ switch (this._rfbAuthScheme) {
case 1: // no auth
- if (this._rfb_version >= 3.8) {
- this._rfb_init_state = 'SecurityResult';
+ if (this._rfbVersion >= 3.8) {
+ this._rfbInitState = 'SecurityResult';
return true;
}
- this._rfb_init_state = 'ClientInitialisation';
- return this._init_msg();
+ this._rfbInitState = 'ClientInitialisation';
+ return this._initMsg();
case 22: // XVP auth
- return this._negotiate_xvp_auth();
+ return this._negotiateXvpAuth();
case 2: // VNC authentication
- return this._negotiate_std_vnc_auth();
+ return this._negotiateStdVNCAuth();
case 16: // TightVNC Security Type
- return this._negotiate_tight_auth();
+ return this._negotiateTightAuth();
+
+ case 19: // VeNCrypt Security Type
+ return this._negotiateVeNCryptAuth();
+
+ case 129: // TightVNC UNIX Security Type
+ return this._negotiateTightUnixAuth();
default:
return this._fail("Unsupported auth scheme (scheme: " +
- this._rfb_auth_scheme + ")");
+ this._rfbAuthScheme + ")");
}
}
- _handle_security_result() {
+ _handleSecurityResult() {
if (this._sock.rQwait('VNC auth response ', 4)) { return false; }
const status = this._sock.rQshift32();
if (status === 0) { // OK
- this._rfb_init_state = 'ClientInitialisation';
+ this._rfbInitState = 'ClientInitialisation';
Log.Debug('Authentication OK');
- return this._init_msg();
+ return this._initMsg();
} else {
- if (this._rfb_version >= 3.8) {
- return this._handle_security_failure("security result", status);
+ if (this._rfbVersion >= 3.8) {
+ this._rfbInitState = "SecurityReason";
+ this._securityContext = "security result";
+ this._securityStatus = status;
+ return this._initMsg();
} else {
this.dispatchEvent(new CustomEvent(
"securityfailure",
}
}
- _negotiate_server_init() {
+ _negotiateServerInit() {
if (this._sock.rQwait("server initialization", 24)) { return false; }
/* Screen size */
/* PIXEL_FORMAT */
const bpp = this._sock.rQshift8();
const depth = this._sock.rQshift8();
- const big_endian = this._sock.rQshift8();
- const true_color = this._sock.rQshift8();
-
- const red_max = this._sock.rQshift16();
- const green_max = this._sock.rQshift16();
- const blue_max = this._sock.rQshift16();
- const red_shift = this._sock.rQshift8();
- const green_shift = this._sock.rQshift8();
- const blue_shift = this._sock.rQshift8();
+ const bigEndian = this._sock.rQshift8();
+ const trueColor = this._sock.rQshift8();
+
+ const redMax = this._sock.rQshift16();
+ const greenMax = this._sock.rQshift16();
+ const blueMax = this._sock.rQshift16();
+ const redShift = this._sock.rQshift8();
+ const greenShift = this._sock.rQshift8();
+ const blueShift = this._sock.rQshift8();
this._sock.rQskipBytes(3); // padding
// NB(directxman12): we don't want to call any callbacks or print messages until
// *after* we're past the point where we could backtrack
/* Connection name/title */
- const name_length = this._sock.rQshift32();
- if (this._sock.rQwait('server init name', name_length, 24)) { return false; }
- this._fb_name = decodeUTF8(this._sock.rQshiftStr(name_length));
+ const nameLength = this._sock.rQshift32();
+ if (this._sock.rQwait('server init name', nameLength, 24)) { return false; }
+ let name = this._sock.rQshiftStr(nameLength);
+ name = decodeUTF8(name, true);
- if (this._rfb_tightvnc) {
- if (this._sock.rQwait('TightVNC extended server init header', 8, 24 + name_length)) { return false; }
+ if (this._rfbTightVNC) {
+ if (this._sock.rQwait('TightVNC extended server init header', 8, 24 + nameLength)) { return false; }
// In TightVNC mode, ServerInit message is extended
const numServerMessages = this._sock.rQshift16();
const numClientMessages = this._sock.rQshift16();
this._sock.rQskipBytes(2); // padding
const totalMessagesLength = (numServerMessages + numClientMessages + numEncodings) * 16;
- if (this._sock.rQwait('TightVNC extended server init header', totalMessagesLength, 32 + name_length)) { return false; }
+ if (this._sock.rQwait('TightVNC extended server init header', totalMessagesLength, 32 + nameLength)) { return false; }
// we don't actually do anything with the capability information that TIGHT sends,
// so we just skip the all of this.
// if we backtrack
Log.Info("Screen: " + width + "x" + 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) {
- Log.Warn("Server native endian is not little endian");
- }
-
- if (red_shift !== 16) {
- Log.Warn("Server native red-shift is not 16");
- }
-
- if (blue_shift !== 0) {
- Log.Warn("Server native blue-shift is not 0");
- }
+ ", bigEndian: " + bigEndian +
+ ", trueColor: " + trueColor +
+ ", redMax: " + redMax +
+ ", greenMax: " + greenMax +
+ ", blueMax: " + blueMax +
+ ", redShift: " + redShift +
+ ", greenShift: " + greenShift +
+ ", blueShift: " + blueShift);
// we're past the point where we could backtrack, so it's safe to call this
- this.dispatchEvent(new CustomEvent(
- "desktopname",
- { detail: { name: this._fb_name } }));
-
+ this._setDesktopName(name);
this._resize(width, height);
if (!this._viewOnly) { this._keyboard.grab(); }
if (!this._viewOnly) { this._mouse.grab(); }
- this._fb_depth = 24;
+ this._fbDepth = 24;
- if (this._fb_name === "Intel(r) AMT KVM") {
+ if (this._fbName === "Intel(r) AMT KVM") {
Log.Warn("Intel AMT KVM only supports 8/16 bit depths. Using low color mode.");
- this._fb_depth = 8;
+ this._fbDepth = 8;
}
- RFB.messages.pixelFormat(this._sock, this._fb_depth, true);
+ RFB.messages.pixelFormat(this._sock, this._fbDepth, true);
this._sendEncodings();
- RFB.messages.fbUpdateRequest(this._sock, false, 0, 0, this._fb_width, this._fb_height);
-
- this._timing.fbu_rt_start = (new Date()).getTime();
- this._timing.pixels = 0;
+ RFB.messages.fbUpdateRequest(this._sock, false, 0, 0, this._fbWidth, this._fbHeight);
this._updateConnectionState('connected');
return true;
// In preference order
encs.push(encodings.encodingCopyRect);
// Only supported with full depth support
- if (this._fb_depth == 24) {
+ if (this._fbDepth == 24) {
encs.push(encodings.encodingTight);
encs.push(encodings.encodingTightPNG);
encs.push(encodings.encodingHextile);
encs.push(encodings.encodingRaw);
// Psuedo-encoding settings
- encs.push(encodings.pseudoEncodingQualityLevel0 + 6);
- encs.push(encodings.pseudoEncodingCompressLevel0 + 2);
+ encs.push(encodings.pseudoEncodingQualityLevel0 + this._qualityLevel);
+ encs.push(encodings.pseudoEncodingCompressLevel0 + this._compressionLevel);
encs.push(encodings.pseudoEncodingDesktopSize);
encs.push(encodings.pseudoEncodingLastRect);
encs.push(encodings.pseudoEncodingXvp);
encs.push(encodings.pseudoEncodingFence);
encs.push(encodings.pseudoEncodingContinuousUpdates);
+ encs.push(encodings.pseudoEncodingDesktopName);
+ encs.push(encodings.pseudoEncodingExtendedClipboard);
- if (this._fb_depth == 24) {
+ if (this._fbDepth == 24) {
+ encs.push(encodings.pseudoEncodingVMwareCursor);
encs.push(encodings.pseudoEncodingCursor);
}
* ClientInitialization - not triggered by server message
* ServerInitialization
*/
- _init_msg() {
- switch (this._rfb_init_state) {
+ _initMsg() {
+ switch (this._rfbInitState) {
case 'ProtocolVersion':
- return this._negotiate_protocol_version();
+ return this._negotiateProtocolVersion();
case 'Security':
- return this._negotiate_security();
+ return this._negotiateSecurity();
case 'Authentication':
- return this._negotiate_authentication();
+ return this._negotiateAuthentication();
case 'SecurityResult':
- return this._handle_security_result();
+ return this._handleSecurityResult();
+
+ case 'SecurityReason':
+ return this._handleSecurityReason();
case 'ClientInitialisation':
this._sock.send([this._shared ? 1 : 0]); // ClientInitialisation
- this._rfb_init_state = 'ServerInitialisation';
+ this._rfbInitState = 'ServerInitialisation';
return true;
case 'ServerInitialisation':
- return this._negotiate_server_init();
+ return this._negotiateServerInit();
default:
return this._fail("Unknown init state (state: " +
- this._rfb_init_state + ")");
+ this._rfbInitState + ")");
}
}
- _handle_set_colour_map_msg() {
+ _handleSetColourMapMsg() {
Log.Debug("SetColorMapEntries");
return this._fail("Unexpected SetColorMapEntries message");
}
- _handle_server_cut_text() {
+ _handleServerCutText() {
Log.Debug("ServerCutText");
if (this._sock.rQwait("ServerCutText header", 7, 1)) { return false; }
+
this._sock.rQskipBytes(3); // Padding
- const length = this._sock.rQshift32();
- if (this._sock.rQwait("ServerCutText", length, 8)) { return false; }
- const text = this._sock.rQshiftStr(length);
+ let length = this._sock.rQshift32();
+ length = toSigned32bit(length);
- if (this._viewOnly) { return true; }
+ if (this._sock.rQwait("ServerCutText content", Math.abs(length), 8)) { return false; }
- this.dispatchEvent(new CustomEvent(
- "clipboard",
- { detail: { text: text } }));
+ if (length >= 0) {
+ //Standard msg
+ const text = this._sock.rQshiftStr(length);
+ if (this._viewOnly) {
+ return true;
+ }
+
+ this.dispatchEvent(new CustomEvent(
+ "clipboard",
+ { detail: { text: text } }));
+
+ } else {
+ //Extended msg.
+ length = Math.abs(length);
+ const flags = this._sock.rQshift32();
+ let formats = flags & 0x0000FFFF;
+ let actions = flags & 0xFF000000;
+
+ let isCaps = (!!(actions & extendedClipboardActionCaps));
+ if (isCaps) {
+ this._clipboardServerCapabilitiesFormats = {};
+ this._clipboardServerCapabilitiesActions = {};
+
+ // Update our server capabilities for Formats
+ for (let i = 0; i <= 15; i++) {
+ let index = 1 << i;
+
+ // Check if format flag is set.
+ if ((formats & index)) {
+ this._clipboardServerCapabilitiesFormats[index] = true;
+ // We don't send unsolicited clipboard, so we
+ // ignore the size
+ this._sock.rQshift32();
+ }
+ }
+
+ // Update our server capabilities for Actions
+ for (let i = 24; i <= 31; i++) {
+ let index = 1 << i;
+ this._clipboardServerCapabilitiesActions[index] = !!(actions & index);
+ }
+
+ /* Caps handling done, send caps with the clients
+ capabilities set as a response */
+ let clientActions = [
+ extendedClipboardActionCaps,
+ extendedClipboardActionRequest,
+ extendedClipboardActionPeek,
+ extendedClipboardActionNotify,
+ extendedClipboardActionProvide
+ ];
+ RFB.messages.extendedClipboardCaps(this._sock, clientActions, {extendedClipboardFormatText: 0});
+
+ } else if (actions === extendedClipboardActionRequest) {
+ if (this._viewOnly) {
+ return true;
+ }
+
+ // Check if server has told us it can handle Provide and there is clipboard data to send.
+ if (this._clipboardText != null &&
+ this._clipboardServerCapabilitiesActions[extendedClipboardActionProvide]) {
+
+ if (formats & extendedClipboardFormatText) {
+ RFB.messages.extendedClipboardProvide(this._sock, [extendedClipboardFormatText], [this._clipboardText]);
+ }
+ }
+
+ } else if (actions === extendedClipboardActionPeek) {
+ if (this._viewOnly) {
+ return true;
+ }
+
+ if (this._clipboardServerCapabilitiesActions[extendedClipboardActionNotify]) {
+
+ if (this._clipboardText != null) {
+ RFB.messages.extendedClipboardNotify(this._sock, [extendedClipboardFormatText]);
+ } else {
+ RFB.messages.extendedClipboardNotify(this._sock, []);
+ }
+ }
+
+ } else if (actions === extendedClipboardActionNotify) {
+ if (this._viewOnly) {
+ return true;
+ }
+
+ if (this._clipboardServerCapabilitiesActions[extendedClipboardActionRequest]) {
+
+ if (formats & extendedClipboardFormatText) {
+ RFB.messages.extendedClipboardRequest(this._sock, [extendedClipboardFormatText]);
+ }
+ }
+
+ } else if (actions === extendedClipboardActionProvide) {
+ if (this._viewOnly) {
+ return true;
+ }
+
+ if (!(formats & extendedClipboardFormatText)) {
+ return true;
+ }
+ // Ignore what we had in our clipboard client side.
+ this._clipboardText = null;
+
+ // FIXME: Should probably verify that this data was actually requested
+ let zlibStream = this._sock.rQshiftBytes(length - 4);
+ let streamInflator = new Inflator();
+ let textData = null;
+ streamInflator.setInput(zlibStream);
+ for (let i = 0; i <= 15; i++) {
+ let format = 1 << i;
+
+ if (formats & format) {
+
+ let size = 0x00;
+ let sizeArray = streamInflator.inflate(4);
+
+ size |= (sizeArray[0] << 24);
+ size |= (sizeArray[1] << 16);
+ size |= (sizeArray[2] << 8);
+ size |= (sizeArray[3]);
+ let chunk = streamInflator.inflate(size);
+
+ if (format === extendedClipboardFormatText) {
+ textData = chunk;
+ }
+ }
+ }
+ streamInflator.setInput(null);
+
+ if (textData !== null) {
+ let tmpText = "";
+ for (let i = 0; i < textData.length; i++) {
+ tmpText += String.fromCharCode(textData[i]);
+ }
+ textData = tmpText;
+
+ textData = decodeUTF8(textData);
+ if ((textData.length > 0) && "\0" === textData.charAt(textData.length - 1)) {
+ textData = textData.slice(0, -1);
+ }
+
+ textData = textData.replace("\r\n", "\n");
+
+ this.dispatchEvent(new CustomEvent(
+ "clipboard",
+ { detail: { text: textData } }));
+ }
+ } else {
+ return this._fail("Unexpected action in extended clipboard message: " + actions);
+ }
+ }
return true;
}
- _handle_server_fence_msg() {
+ _handleServerFenceMsg() {
if (this._sock.rQwait("ServerFence header", 8, 1)) { return false; }
this._sock.rQskipBytes(3); // Padding
let flags = this._sock.rQshift32();
return true;
}
- _handle_xvp_msg() {
+ _handleXvpMsg() {
if (this._sock.rQwait("XVP version and message", 3, 1)) { return false; }
- this._sock.rQskip8(); // Padding
- const xvp_ver = this._sock.rQshift8();
- const xvp_msg = this._sock.rQshift8();
+ this._sock.rQskipBytes(1); // Padding
+ const xvpVer = this._sock.rQshift8();
+ const xvpMsg = this._sock.rQshift8();
- switch (xvp_msg) {
+ switch (xvpMsg) {
case 0: // XVP_FAIL
Log.Error("XVP Operation Failed");
break;
case 1: // XVP_INIT
- this._rfb_xvp_ver = xvp_ver;
- Log.Info("XVP extensions enabled (version " + this._rfb_xvp_ver + ")");
+ this._rfbXvpVer = xvpVer;
+ Log.Info("XVP extensions enabled (version " + this._rfbXvpVer + ")");
this._setCapability("power", true);
break;
default:
- this._fail("Illegal server XVP message (msg: " + xvp_msg + ")");
+ this._fail("Illegal server XVP message (msg: " + xvpMsg + ")");
break;
}
return true;
}
- _normal_msg() {
- let msg_type;
+ _normalMsg() {
+ let msgType;
if (this._FBU.rects > 0) {
- msg_type = 0;
+ msgType = 0;
} else {
- msg_type = this._sock.rQshift8();
+ msgType = this._sock.rQshift8();
}
let first, ret;
- switch (msg_type) {
+ switch (msgType) {
case 0: // FramebufferUpdate
ret = this._framebufferUpdate();
if (ret && !this._enabledContinuousUpdates) {
RFB.messages.fbUpdateRequest(this._sock, true, 0, 0,
- this._fb_width, this._fb_height);
+ this._fbWidth, this._fbHeight);
}
return ret;
case 1: // SetColorMapEntries
- return this._handle_set_colour_map_msg();
+ return this._handleSetColourMapMsg();
case 2: // Bell
Log.Debug("Bell");
return true;
case 3: // ServerCutText
- return this._handle_server_cut_text();
+ return this._handleServerCutText();
case 150: // EndOfContinuousUpdates
first = !this._supportsContinuousUpdates;
return true;
case 248: // ServerFence
- return this._handle_server_fence_msg();
+ return this._handleServerFenceMsg();
case 250: // XVP
- return this._handle_xvp_msg();
+ return this._handleXvpMsg();
default:
- this._fail("Unexpected server message (type " + msg_type + ")");
+ this._fail("Unexpected server message (type " + msgType + ")");
Log.Debug("sock.rQslice(0, 30): " + this._sock.rQslice(0, 30));
return true;
}
_onFlush() {
this._flushing = false;
// Resume processing
- if (this._sock.rQlen() > 0) {
- this._handle_message();
+ if (this._sock.rQlen > 0) {
+ this._handleMessage();
}
}
_framebufferUpdate() {
if (this._FBU.rects === 0) {
if (this._sock.rQwait("FBU header", 3, 1)) { return false; }
- this._sock.rQskip8(); // Padding
+ this._sock.rQskipBytes(1); // Padding
this._FBU.rects = this._sock.rQshift16();
- this._FBU.bytes = 0;
- this._timing.cur_fbu = 0;
- if (this._timing.fbu_rt_start > 0) {
- const now = (new Date()).getTime();
- Log.Info("First FBU latency: " + (now - this._timing.fbu_rt_start));
- }
// Make sure the previous frame is fully rendered first
// to avoid building up an excessive queue
}
while (this._FBU.rects > 0) {
- if (this._rfb_connection_state !== 'connected') { return false; }
-
- if (this._sock.rQwait("FBU", this._FBU.bytes)) { return false; }
- if (this._FBU.bytes === 0) {
+ if (this._FBU.encoding === null) {
if (this._sock.rQwait("rect header", 12)) { return false; }
/* New FramebufferUpdate */
this._FBU.height = (hdr[6] << 8) + hdr[7];
this._FBU.encoding = parseInt((hdr[8] << 24) + (hdr[9] << 16) +
(hdr[10] << 8) + hdr[11], 10);
-
- if (!this._encHandlers[this._FBU.encoding]) {
- this._fail("Unsupported encoding (encoding: " +
- this._FBU.encoding + ")");
- return false;
- }
- }
-
- this._timing.last_fbu = (new Date()).getTime();
-
- const ret = this._encHandlers[this._FBU.encoding]();
-
- const now = (new Date()).getTime();
- this._timing.cur_fbu += (now - this._timing.last_fbu);
-
- if (ret) {
- if (!(this._FBU.encoding in this._encStats)) {
- this._encStats[this._FBU.encoding] = [0, 0];
- }
- this._encStats[this._FBU.encoding][0]++;
- this._encStats[this._FBU.encoding][1]++;
- this._timing.pixels += this._FBU.width * this._FBU.height;
}
- if (this._timing.pixels >= (this._fb_width * this._fb_height)) {
- if ((this._FBU.width === this._fb_width && this._FBU.height === this._fb_height) ||
- this._timing.fbu_rt_start > 0) {
- this._timing.full_fbu_total += this._timing.cur_fbu;
- this._timing.full_fbu_cnt++;
- Log.Info("Timing of full FBU, curr: " +
- this._timing.cur_fbu + ", total: " +
- this._timing.full_fbu_total + ", cnt: " +
- this._timing.full_fbu_cnt + ", avg: " +
- (this._timing.full_fbu_total / this._timing.full_fbu_cnt));
- }
-
- if (this._timing.fbu_rt_start > 0) {
- const fbu_rt_diff = now - this._timing.fbu_rt_start;
- this._timing.fbu_rt_total += fbu_rt_diff;
- this._timing.fbu_rt_cnt++;
- Log.Info("full FBU round-trip, cur: " +
- fbu_rt_diff + ", total: " +
- this._timing.fbu_rt_total + ", cnt: " +
- this._timing.fbu_rt_cnt + ", avg: " +
- (this._timing.fbu_rt_total / this._timing.fbu_rt_cnt));
- this._timing.fbu_rt_start = 0;
- }
+ if (!this._handleRect()) {
+ return false;
}
- if (!ret) { return ret; } // need more data
+ this._FBU.rects--;
+ this._FBU.encoding = null;
}
this._display.flip();
return true; // We finished this FBU
}
- _updateContinuousUpdates() {
- if (!this._enabledContinuousUpdates) { return; }
+ _handleRect() {
+ switch (this._FBU.encoding) {
+ case encodings.pseudoEncodingLastRect:
+ this._FBU.rects = 1; // Will be decreased when we return
+ return true;
- RFB.messages.enableContinuousUpdates(this._sock, true, 0, 0,
- this._fb_width, this._fb_height);
- }
+ case encodings.pseudoEncodingVMwareCursor:
+ return this._handleVMwareCursor();
- _resize(width, height) {
- this._fb_width = width;
- this._fb_height = height;
+ case encodings.pseudoEncodingCursor:
+ return this._handleCursor();
- this._destBuff = new Uint8Array(this._fb_width * this._fb_height * 4);
+ case encodings.pseudoEncodingQEMUExtendedKeyEvent:
+ // Old Safari doesn't support creating keyboard events
+ try {
+ const keyboardEvent = document.createEvent("keyboardEvent");
+ if (keyboardEvent.code !== undefined) {
+ this._qemuExtKeyEventSupported = true;
+ }
+ } catch (err) {
+ // Do nothing
+ }
+ return true;
- this._display.resize(this._fb_width, this._fb_height);
+ case encodings.pseudoEncodingDesktopName:
+ return this._handleDesktopName();
- // Adjust the visible viewport based on the new dimensions
- this._updateClip();
- this._updateScale();
+ case encodings.pseudoEncodingDesktopSize:
+ this._resize(this._FBU.width, this._FBU.height);
+ return true;
- this._timing.fbu_rt_start = (new Date()).getTime();
- this._updateContinuousUpdates();
- }
+ case encodings.pseudoEncodingExtendedDesktopSize:
+ return this._handleExtendedDesktopSize();
- _xvpOp(ver, op) {
- if (this._rfb_xvp_ver < ver) { return; }
- Log.Info("Sending XVP operation " + op + " (version " + ver + ")");
- RFB.messages.xvpOp(this._sock, ver, op);
+ default:
+ return this._handleDataRect();
+ }
}
- static genDES(password, challenge) {
- const passwd = [];
- for (let i = 0; i < password.length; i++) {
- passwd.push(password.charCodeAt(i));
+ _handleVMwareCursor() {
+ const hotx = this._FBU.x; // hotspot-x
+ const hoty = this._FBU.y; // hotspot-y
+ const w = this._FBU.width;
+ const h = this._FBU.height;
+ if (this._sock.rQwait("VMware cursor encoding", 1)) {
+ return false;
}
- return (new DES(passwd)).encrypt(challenge);
- }
-}
-// Class Methods
-RFB.messages = {
- keyEvent(sock, keysym, down) {
- const buff = sock._sQ;
- const offset = sock._sQlen;
+ const cursorType = this._sock.rQshift8();
- buff[offset] = 4; // msg-type
+ this._sock.rQshift8(); //Padding
+
+ let rgba;
+ const bytesPerPixel = 4;
+
+ //Classic cursor
+ if (cursorType == 0) {
+ //Used to filter away unimportant bits.
+ //OR is used for correct conversion in js.
+ const PIXEL_MASK = 0xffffff00 | 0;
+ rgba = new Array(w * h * bytesPerPixel);
+
+ if (this._sock.rQwait("VMware cursor classic encoding",
+ (w * h * bytesPerPixel) * 2, 2)) {
+ return false;
+ }
+
+ let andMask = new Array(w * h);
+ for (let pixel = 0; pixel < (w * h); pixel++) {
+ andMask[pixel] = this._sock.rQshift32();
+ }
+
+ let xorMask = new Array(w * h);
+ for (let pixel = 0; pixel < (w * h); pixel++) {
+ xorMask[pixel] = this._sock.rQshift32();
+ }
+
+ for (let pixel = 0; pixel < (w * h); pixel++) {
+ if (andMask[pixel] == 0) {
+ //Fully opaque pixel
+ let bgr = xorMask[pixel];
+ let r = bgr >> 8 & 0xff;
+ let g = bgr >> 16 & 0xff;
+ let b = bgr >> 24 & 0xff;
+
+ rgba[(pixel * bytesPerPixel) ] = r; //r
+ rgba[(pixel * bytesPerPixel) + 1 ] = g; //g
+ rgba[(pixel * bytesPerPixel) + 2 ] = b; //b
+ rgba[(pixel * bytesPerPixel) + 3 ] = 0xff; //a
+
+ } else if ((andMask[pixel] & PIXEL_MASK) ==
+ PIXEL_MASK) {
+ //Only screen value matters, no mouse colouring
+ if (xorMask[pixel] == 0) {
+ //Transparent pixel
+ rgba[(pixel * bytesPerPixel) ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 1 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 2 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 3 ] = 0x00;
+
+ } else if ((xorMask[pixel] & PIXEL_MASK) ==
+ PIXEL_MASK) {
+ //Inverted pixel, not supported in browsers.
+ //Fully opaque instead.
+ rgba[(pixel * bytesPerPixel) ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 1 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 2 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 3 ] = 0xff;
+
+ } else {
+ //Unhandled xorMask
+ rgba[(pixel * bytesPerPixel) ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 1 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 2 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 3 ] = 0xff;
+ }
+
+ } else {
+ //Unhandled andMask
+ rgba[(pixel * bytesPerPixel) ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 1 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 2 ] = 0x00;
+ rgba[(pixel * bytesPerPixel) + 3 ] = 0xff;
+ }
+ }
+
+ //Alpha cursor.
+ } else if (cursorType == 1) {
+ if (this._sock.rQwait("VMware cursor alpha encoding",
+ (w * h * 4), 2)) {
+ return false;
+ }
+
+ rgba = new Array(w * h * bytesPerPixel);
+
+ for (let pixel = 0; pixel < (w * h); pixel++) {
+ let data = this._sock.rQshift32();
+
+ rgba[(pixel * 4) ] = data >> 24 & 0xff; //r
+ rgba[(pixel * 4) + 1 ] = data >> 16 & 0xff; //g
+ rgba[(pixel * 4) + 2 ] = data >> 8 & 0xff; //b
+ rgba[(pixel * 4) + 3 ] = data & 0xff; //a
+ }
+
+ } else {
+ Log.Warn("The given cursor type is not supported: "
+ + cursorType + " given.");
+ return false;
+ }
+
+ this._updateCursor(rgba, hotx, hoty, w, h);
+
+ return true;
+ }
+
+ _handleCursor() {
+ const hotx = this._FBU.x; // hotspot-x
+ const hoty = this._FBU.y; // hotspot-y
+ const w = this._FBU.width;
+ const h = this._FBU.height;
+
+ const pixelslength = w * h * 4;
+ const masklength = Math.ceil(w / 8) * h;
+
+ let bytes = pixelslength + masklength;
+ if (this._sock.rQwait("cursor encoding", bytes)) {
+ return false;
+ }
+
+ // Decode from BGRX pixels + bit mask to RGBA
+ const pixels = this._sock.rQshiftBytes(pixelslength);
+ const mask = this._sock.rQshiftBytes(masklength);
+ let rgba = new Uint8Array(w * h * 4);
+
+ let pixIdx = 0;
+ for (let y = 0; y < h; y++) {
+ for (let x = 0; x < w; x++) {
+ let maskIdx = y * Math.ceil(w / 8) + Math.floor(x / 8);
+ let alpha = (mask[maskIdx] << (x % 8)) & 0x80 ? 255 : 0;
+ rgba[pixIdx ] = pixels[pixIdx + 2];
+ rgba[pixIdx + 1] = pixels[pixIdx + 1];
+ rgba[pixIdx + 2] = pixels[pixIdx];
+ rgba[pixIdx + 3] = alpha;
+ pixIdx += 4;
+ }
+ }
+
+ this._updateCursor(rgba, hotx, hoty, w, h);
+
+ return true;
+ }
+
+ _handleDesktopName() {
+ if (this._sock.rQwait("DesktopName", 4)) {
+ return false;
+ }
+
+ let length = this._sock.rQshift32();
+
+ if (this._sock.rQwait("DesktopName", length, 4)) {
+ return false;
+ }
+
+ let name = this._sock.rQshiftStr(length);
+ name = decodeUTF8(name, true);
+
+ this._setDesktopName(name);
+
+ return true;
+ }
+
+ _handleExtendedDesktopSize() {
+ if (this._sock.rQwait("ExtendedDesktopSize", 4)) {
+ return false;
+ }
+
+ const numberOfScreens = this._sock.rQpeek8();
+
+ let bytes = 4 + (numberOfScreens * 16);
+ if (this._sock.rQwait("ExtendedDesktopSize", bytes)) {
+ return false;
+ }
+
+ const firstUpdate = !this._supportsSetDesktopSize;
+ this._supportsSetDesktopSize = true;
+
+ // Normally we only apply the current resize mode after a
+ // window resize event. However there is no such trigger on the
+ // initial connect. And we don't know if the server supports
+ // resizing until we've gotten here.
+ if (firstUpdate) {
+ this._requestRemoteResize();
+ }
+
+ this._sock.rQskipBytes(1); // number-of-screens
+ this._sock.rQskipBytes(3); // padding
+
+ for (let i = 0; i < numberOfScreens; i += 1) {
+ // Save the id and flags of the first screen
+ if (i === 0) {
+ this._screenID = this._sock.rQshiftBytes(4); // id
+ this._sock.rQskipBytes(2); // x-position
+ this._sock.rQskipBytes(2); // y-position
+ this._sock.rQskipBytes(2); // width
+ this._sock.rQskipBytes(2); // height
+ this._screenFlags = this._sock.rQshiftBytes(4); // flags
+ } else {
+ this._sock.rQskipBytes(16);
+ }
+ }
+
+ /*
+ * The x-position indicates the reason for the change:
+ *
+ * 0 - server resized on its own
+ * 1 - this client requested the resize
+ * 2 - another client requested the resize
+ */
+
+ // We need to handle errors when we requested the resize.
+ if (this._FBU.x === 1 && this._FBU.y !== 0) {
+ let msg = "";
+ // The y-position indicates the status code from the server
+ switch (this._FBU.y) {
+ case 1:
+ msg = "Resize is administratively prohibited";
+ break;
+ case 2:
+ msg = "Out of resources";
+ break;
+ case 3:
+ msg = "Invalid screen layout";
+ break;
+ default:
+ msg = "Unknown reason";
+ break;
+ }
+ Log.Warn("Server did not accept the resize request: "
+ + msg);
+ } else {
+ this._resize(this._FBU.width, this._FBU.height);
+ }
+
+ return true;
+ }
+
+ _handleDataRect() {
+ let decoder = this._decoders[this._FBU.encoding];
+ if (!decoder) {
+ this._fail("Unsupported encoding (encoding: " +
+ this._FBU.encoding + ")");
+ return false;
+ }
+
+ try {
+ return decoder.decodeRect(this._FBU.x, this._FBU.y,
+ this._FBU.width, this._FBU.height,
+ this._sock, this._display,
+ this._fbDepth);
+ } catch (err) {
+ this._fail("Error decoding rect: " + err);
+ return false;
+ }
+ }
+
+ _updateContinuousUpdates() {
+ if (!this._enabledContinuousUpdates) { return; }
+
+ RFB.messages.enableContinuousUpdates(this._sock, true, 0, 0,
+ this._fbWidth, this._fbHeight);
+ }
+
+ _resize(width, height) {
+ this._fbWidth = width;
+ this._fbHeight = height;
+
+ this._display.resize(this._fbWidth, this._fbHeight);
+
+ // Adjust the visible viewport based on the new dimensions
+ this._updateClip();
+ this._updateScale();
+
+ this._updateContinuousUpdates();
+ }
+
+ _xvpOp(ver, op) {
+ if (this._rfbXvpVer < ver) { return; }
+ Log.Info("Sending XVP operation " + op + " (version " + ver + ")");
+ RFB.messages.xvpOp(this._sock, ver, op);
+ }
+
+ _updateCursor(rgba, hotx, hoty, w, h) {
+ this._cursorImage = {
+ rgbaPixels: rgba,
+ hotx: hotx, hoty: hoty, w: w, h: h,
+ };
+ this._refreshCursor();
+ }
+
+ _shouldShowDotCursor() {
+ // Called when this._cursorImage is updated
+ if (!this._showDotCursor) {
+ // User does not want to see the dot, so...
+ return false;
+ }
+
+ // The dot should not be shown if the cursor is already visible,
+ // i.e. contains at least one not-fully-transparent pixel.
+ // So iterate through all alpha bytes in rgba and stop at the
+ // first non-zero.
+ for (let i = 3; i < this._cursorImage.rgbaPixels.length; i += 4) {
+ if (this._cursorImage.rgbaPixels[i]) {
+ return false;
+ }
+ }
+
+ // At this point, we know that the cursor is fully transparent, and
+ // the user wants to see the dot instead of this.
+ return true;
+ }
+
+ _refreshCursor() {
+ if (this._rfbConnectionState !== "connecting" &&
+ this._rfbConnectionState !== "connected") {
+ return;
+ }
+ const image = this._shouldShowDotCursor() ? RFB.cursors.dot : this._cursorImage;
+ this._cursor.change(image.rgbaPixels,
+ image.hotx, image.hoty,
+ image.w, image.h
+ );
+ }
+
+ static genDES(password, challenge) {
+ const passwordChars = password.split('').map(c => c.charCodeAt(0));
+ return (new DES(passwordChars)).encrypt(challenge);
+ }
+}
+
+// Class Methods
+RFB.messages = {
+ keyEvent(sock, keysym, down) {
+ const buff = sock._sQ;
+ const offset = sock._sQlen;
+
+ buff[offset] = 4; // msg-type
buff[offset + 1] = down;
buff[offset + 2] = 0;
},
QEMUExtendedKeyEvent(sock, keysym, down, keycode) {
- function getRFBkeycode(xt_scancode) {
+ function getRFBkeycode(xtScanCode) {
const upperByte = (keycode >> 8);
const lowerByte = (keycode & 0x00ff);
if (upperByte === 0xe0 && lowerByte < 0x7f) {
return lowerByte | 0x80;
}
- return xt_scancode;
+ return xtScanCode;
}
const buff = sock._sQ;
sock.flush();
},
- // TODO(directxman12): make this unicode compatible?
- clientCutText(sock, text) {
+ // Used to build Notify and Request data.
+ _buildExtendedClipboardFlags(actions, formats) {
+ let data = new Uint8Array(4);
+ let formatFlag = 0x00000000;
+ let actionFlag = 0x00000000;
+
+ for (let i = 0; i < actions.length; i++) {
+ actionFlag |= actions[i];
+ }
+
+ for (let i = 0; i < formats.length; i++) {
+ formatFlag |= formats[i];
+ }
+
+ data[0] = actionFlag >> 24; // Actions
+ data[1] = 0x00; // Reserved
+ data[2] = 0x00; // Reserved
+ data[3] = formatFlag; // Formats
+
+ return data;
+ },
+
+ extendedClipboardProvide(sock, formats, inData) {
+ // Deflate incomming data and their sizes
+ let deflator = new Deflator();
+ let dataToDeflate = [];
+
+ for (let i = 0; i < formats.length; i++) {
+ // We only support the format Text at this time
+ if (formats[i] != extendedClipboardFormatText) {
+ throw new Error("Unsupported extended clipboard format for Provide message.");
+ }
+
+ // Change lone \r or \n into \r\n as defined in rfbproto
+ inData[i] = inData[i].replace(/\r\n|\r|\n/gm, "\r\n");
+
+ // Check if it already has \0
+ let text = encodeUTF8(inData[i] + "\0");
+
+ dataToDeflate.push( (text.length >> 24) & 0xFF,
+ (text.length >> 16) & 0xFF,
+ (text.length >> 8) & 0xFF,
+ (text.length & 0xFF));
+
+ for (let j = 0; j < text.length; j++) {
+ dataToDeflate.push(text.charCodeAt(j));
+ }
+ }
+
+ let deflatedData = deflator.deflate(new Uint8Array(dataToDeflate));
+
+ // Build data to send
+ let data = new Uint8Array(4 + deflatedData.length);
+ data.set(RFB.messages._buildExtendedClipboardFlags([extendedClipboardActionProvide],
+ formats));
+ data.set(deflatedData, 4);
+
+ RFB.messages.clientCutText(sock, data, true);
+ },
+
+ extendedClipboardNotify(sock, formats) {
+ let flags = RFB.messages._buildExtendedClipboardFlags([extendedClipboardActionNotify],
+ formats);
+ RFB.messages.clientCutText(sock, flags, true);
+ },
+
+ extendedClipboardRequest(sock, formats) {
+ let flags = RFB.messages._buildExtendedClipboardFlags([extendedClipboardActionRequest],
+ formats);
+ RFB.messages.clientCutText(sock, flags, true);
+ },
+
+ extendedClipboardCaps(sock, actions, formats) {
+ let formatKeys = Object.keys(formats);
+ let data = new Uint8Array(4 + (4 * formatKeys.length));
+
+ formatKeys.map(x => parseInt(x));
+ formatKeys.sort((a, b) => a - b);
+
+ data.set(RFB.messages._buildExtendedClipboardFlags(actions, []));
+
+ let loopOffset = 4;
+ for (let i = 0; i < formatKeys.length; i++) {
+ data[loopOffset] = formats[formatKeys[i]] >> 24;
+ data[loopOffset + 1] = formats[formatKeys[i]] >> 16;
+ data[loopOffset + 2] = formats[formatKeys[i]] >> 8;
+ data[loopOffset + 3] = formats[formatKeys[i]] >> 0;
+
+ loopOffset += 4;
+ data[3] |= (1 << formatKeys[i]); // Update our format flags
+ }
+
+ RFB.messages.clientCutText(sock, data, true);
+ },
+
+ clientCutText(sock, data, extended = false) {
const buff = sock._sQ;
const offset = sock._sQlen;
buff[offset + 2] = 0; // padding
buff[offset + 3] = 0; // padding
- let length = text.length;
+ let length;
+ if (extended) {
+ length = toUnsigned32bit(-data.length);
+ } else {
+ length = data.length;
+ }
buff[offset + 4] = length >> 24;
buff[offset + 5] = length >> 16;
sock._sQlen += 8;
- // We have to keep track of from where in the text we begin creating the
+ // We have to keep track of from where in the data we begin creating the
// buffer for the flush in the next iteration.
- let textOffset = 0;
+ let dataOffset = 0;
- let remaining = length;
+ let remaining = data.length;
while (remaining > 0) {
let flushSize = Math.min(remaining, (sock._sQbufferSize - sock._sQlen));
- if (flushSize <= 0) {
- this._fail("Clipboard contents could not be sent");
- break;
- }
-
for (let i = 0; i < flushSize; i++) {
- buff[sock._sQlen + i] = text.charCodeAt(textOffset + i);
+ buff[sock._sQlen + i] = data[dataOffset + i];
}
sock._sQlen += flushSize;
sock.flush();
remaining -= flushSize;
- textOffset += flushSize;
+ dataOffset += flushSize;
}
+
},
setDesktopSize(sock, width, height, id, flags) {
sock.flush();
},
- pixelFormat(sock, depth, true_color) {
+ pixelFormat(sock, depth, trueColor) {
const buff = sock._sQ;
const offset = sock._sQlen;
buff[offset + 4] = bpp; // bits-per-pixel
buff[offset + 5] = depth; // depth
buff[offset + 6] = 0; // little-endian
- buff[offset + 7] = true_color ? 1 : 0; // true-color
+ buff[offset + 7] = trueColor ? 1 : 0; // true-color
buff[offset + 8] = 0; // red-max
buff[offset + 9] = (1 << bits) - 1; // red-max
}
};
-
-RFB.encodingHandlers = {
- RAW() {
- if (this._FBU.lines === 0) {
- this._FBU.lines = this._FBU.height;
- }
-
- const pixelSize = this._fb_depth == 8 ? 1 : 4;
- this._FBU.bytes = this._FBU.width * pixelSize; // at least a line
- if (this._sock.rQwait("RAW", this._FBU.bytes)) { return false; }
- const cur_y = this._FBU.y + (this._FBU.height - this._FBU.lines);
- const curr_height = Math.min(this._FBU.lines,
- Math.floor(this._sock.rQlen() / (this._FBU.width * pixelSize)));
- let data = this._sock.get_rQ();
- let index = this._sock.get_rQi();
- if (this._fb_depth == 8) {
- const pixels = this._FBU.width * curr_height;
- const newdata = new Uint8Array(pixels * 4);
- for (let i = 0; i < pixels; i++) {
- newdata[i * 4 + 0] = ((data[index + i] >> 0) & 0x3) * 255 / 3;
- newdata[i * 4 + 1] = ((data[index + i] >> 2) & 0x3) * 255 / 3;
- newdata[i * 4 + 2] = ((data[index + i] >> 4) & 0x3) * 255 / 3;
- newdata[i * 4 + 4] = 0;
- }
- data = newdata;
- index = 0;
- }
- this._display.blitImage(this._FBU.x, cur_y, this._FBU.width,
- curr_height, data, index);
- this._sock.rQskipBytes(this._FBU.width * curr_height * pixelSize);
- this._FBU.lines -= curr_height;
-
- if (this._FBU.lines > 0) {
- this._FBU.bytes = this._FBU.width * pixelSize; // At least another line
- } else {
- this._FBU.rects--;
- this._FBU.bytes = 0;
- }
-
- return true;
- },
-
- COPYRECT() {
- this._FBU.bytes = 4;
- if (this._sock.rQwait("COPYRECT", 4)) { return false; }
- this._display.copyImage(this._sock.rQshift16(), this._sock.rQshift16(),
- this._FBU.x, this._FBU.y, this._FBU.width,
- this._FBU.height);
-
- this._FBU.rects--;
- this._FBU.bytes = 0;
- return true;
- },
-
- RRE() {
- let color;
- if (this._FBU.subrects === 0) {
- this._FBU.bytes = 4 + 4;
- if (this._sock.rQwait("RRE", 4 + 4)) { return false; }
- this._FBU.subrects = this._sock.rQshift32();
- color = this._sock.rQshiftBytes(4); // Background
- this._display.fillRect(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, color);
- }
-
- while (this._FBU.subrects > 0 && this._sock.rQlen() >= (4 + 8)) {
- color = this._sock.rQshiftBytes(4);
- const x = this._sock.rQshift16();
- const y = this._sock.rQshift16();
- const width = this._sock.rQshift16();
- const height = this._sock.rQshift16();
- this._display.fillRect(this._FBU.x + x, this._FBU.y + y, width, height, color);
- this._FBU.subrects--;
- }
-
- if (this._FBU.subrects > 0) {
- const chunk = Math.min(this._rre_chunk_sz, this._FBU.subrects);
- this._FBU.bytes = (4 + 8) * chunk;
- } else {
- this._FBU.rects--;
- this._FBU.bytes = 0;
- }
-
- return true;
- },
-
- HEXTILE() {
- const rQ = this._sock.get_rQ();
- let rQi = this._sock.get_rQi();
-
- if (this._FBU.tiles === 0) {
- this._FBU.tiles_x = Math.ceil(this._FBU.width / 16);
- this._FBU.tiles_y = Math.ceil(this._FBU.height / 16);
- this._FBU.total_tiles = this._FBU.tiles_x * this._FBU.tiles_y;
- this._FBU.tiles = this._FBU.total_tiles;
- }
-
- while (this._FBU.tiles > 0) {
- this._FBU.bytes = 1;
- if (this._sock.rQwait("HEXTILE subencoding", this._FBU.bytes)) { return false; }
- const subencoding = rQ[rQi]; // Peek
- if (subencoding > 30) { // Raw
- this._fail("Illegal hextile subencoding (subencoding: " +
- subencoding + ")");
- return false;
- }
-
- let subrects = 0;
- const curr_tile = this._FBU.total_tiles - this._FBU.tiles;
- const tile_x = curr_tile % this._FBU.tiles_x;
- const tile_y = Math.floor(curr_tile / this._FBU.tiles_x);
- const x = this._FBU.x + tile_x * 16;
- const y = this._FBU.y + tile_y * 16;
- const w = Math.min(16, (this._FBU.x + this._FBU.width) - x);
- const h = Math.min(16, (this._FBU.y + this._FBU.height) - y);
-
- // Figure out how much we are expecting
- if (subencoding & 0x01) { // Raw
- this._FBU.bytes += w * h * 4;
- } else {
- if (subencoding & 0x02) { // Background
- this._FBU.bytes += 4;
- }
- if (subencoding & 0x04) { // Foreground
- this._FBU.bytes += 4;
- }
- if (subencoding & 0x08) { // AnySubrects
- this._FBU.bytes++; // Since we aren't shifting it off
- if (this._sock.rQwait("hextile subrects header", this._FBU.bytes)) { return false; }
- subrects = rQ[rQi + this._FBU.bytes - 1]; // Peek
- if (subencoding & 0x10) { // SubrectsColoured
- this._FBU.bytes += subrects * (4 + 2);
- } else {
- this._FBU.bytes += subrects * 2;
- }
- }
- }
-
- if (this._sock.rQwait("hextile", this._FBU.bytes)) { return false; }
-
- // We know the encoding and have a whole tile
- this._FBU.subencoding = rQ[rQi];
- rQi++;
- if (this._FBU.subencoding === 0) {
- if (this._FBU.lastsubencoding & 0x01) {
- // Weird: ignore blanks are RAW
- Log.Debug(" Ignoring blank after RAW");
- } else {
- this._display.fillRect(x, y, w, h, this._FBU.background);
- }
- } else if (this._FBU.subencoding & 0x01) { // Raw
- this._display.blitImage(x, y, w, h, rQ, rQi);
- rQi += this._FBU.bytes - 1;
- } else {
- if (this._FBU.subencoding & 0x02) { // Background
- this._FBU.background = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
- rQi += 4;
- }
- if (this._FBU.subencoding & 0x04) { // Foreground
- this._FBU.foreground = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
- rQi += 4;
- }
-
- this._display.startTile(x, y, w, h, this._FBU.background);
- if (this._FBU.subencoding & 0x08) { // AnySubrects
- subrects = rQ[rQi];
- rQi++;
-
- for (let s = 0; s < subrects; s++) {
- let color;
- if (this._FBU.subencoding & 0x10) { // SubrectsColoured
- color = [rQ[rQi], rQ[rQi + 1], rQ[rQi + 2], rQ[rQi + 3]];
- rQi += 4;
- } else {
- color = this._FBU.foreground;
- }
- const xy = rQ[rQi];
- rQi++;
- const sx = (xy >> 4);
- const sy = (xy & 0x0f);
-
- const wh = rQ[rQi];
- rQi++;
- const sw = (wh >> 4) + 1;
- const sh = (wh & 0x0f) + 1;
-
- this._display.subTile(sx, sy, sw, sh, color);
- }
- }
- this._display.finishTile();
- }
- this._sock.set_rQi(rQi);
- this._FBU.lastsubencoding = this._FBU.subencoding;
- this._FBU.bytes = 0;
- this._FBU.tiles--;
- }
-
- if (this._FBU.tiles === 0) {
- this._FBU.rects--;
- }
-
- return true;
- },
-
- TIGHT(isTightPNG) {
- this._FBU.bytes = 1; // compression-control byte
- if (this._sock.rQwait("TIGHT compression-control", this._FBU.bytes)) { return false; }
-
- let resetStreams = 0;
- let streamId = -1;
- const decompress = (data, expected) => {
- for (let i = 0; i < 4; i++) {
- if ((resetStreams >> i) & 1) {
- this._FBU.zlibs[i].reset();
- Log.Info("Reset zlib stream " + i);
- }
- }
-
- //const uncompressed = this._FBU.zlibs[streamId].uncompress(data, 0);
- const uncompressed = this._FBU.zlibs[streamId].inflate(data, true, expected);
- /*if (uncompressed.status !== 0) {
- Log.Error("Invalid data in zlib stream");
- }*/
-
- //return uncompressed.data;
- return uncompressed;
- };
-
- const indexedToRGBX2Color = (data, palette, width, height) => {
- // Convert indexed (palette based) image data to RGB
- // TODO: reduce number of calculations inside loop
- const dest = this._destBuff;
- const w = Math.floor((width + 7) / 8);
- const w1 = Math.floor(width / 8);
-
- /*for (let y = 0; y < height; y++) {
- let b, x, dp, sp;
- const yoffset = y * width;
- const ybitoffset = y * w;
- let xoffset, targetbyte;
- for (x = 0; x < w1; x++) {
- xoffset = yoffset + x * 8;
- targetbyte = data[ybitoffset + x];
- for (b = 7; b >= 0; b--) {
- dp = (xoffset + 7 - b) * 3;
- sp = (targetbyte >> b & 1) * 3;
- dest[dp] = palette[sp];
- dest[dp + 1] = palette[sp + 1];
- dest[dp + 2] = palette[sp + 2];
- }
- }
-
- xoffset = yoffset + x * 8;
- targetbyte = data[ybitoffset + x];
- for (b = 7; b >= 8 - width % 8; b--) {
- dp = (xoffset + 7 - b) * 3;
- sp = (targetbyte >> b & 1) * 3;
- dest[dp] = palette[sp];
- dest[dp + 1] = palette[sp + 1];
- dest[dp + 2] = palette[sp + 2];
- }
- }*/
-
- for (let y = 0; y < height; y++) {
- let dp, sp, x;
- for (x = 0; x < w1; x++) {
- for (let b = 7; b >= 0; b--) {
- dp = (y * width + x * 8 + 7 - b) * 4;
- sp = (data[y * w + x] >> b & 1) * 3;
- dest[dp] = palette[sp];
- dest[dp + 1] = palette[sp + 1];
- dest[dp + 2] = palette[sp + 2];
- dest[dp + 3] = 255;
- }
- }
-
- for (let b = 7; b >= 8 - width % 8; b--) {
- dp = (y * width + x * 8 + 7 - b) * 4;
- sp = (data[y * w + x] >> b & 1) * 3;
- dest[dp] = palette[sp];
- dest[dp + 1] = palette[sp + 1];
- dest[dp + 2] = palette[sp + 2];
- dest[dp + 3] = 255;
- }
- }
-
- return dest;
- };
-
- const indexedToRGBX = (data, palette, width, height) => {
- // Convert indexed (palette based) image data to RGB
- const dest = this._destBuff;
- const total = width * height * 4;
- for (let i = 0, j = 0; i < total; i += 4, j++) {
- const sp = data[j] * 3;
- dest[i] = palette[sp];
- dest[i + 1] = palette[sp + 1];
- dest[i + 2] = palette[sp + 2];
- dest[i + 3] = 255;
- }
-
- return dest;
- };
-
- const rQi = this._sock.get_rQi();
- const rQ = this._sock.rQwhole();
- let cmode, data;
- let cl_header, cl_data;
-
- const handlePalette = () => {
- const numColors = rQ[rQi + 2] + 1;
- const paletteSize = numColors * 3;
- this._FBU.bytes += paletteSize;
- if (this._sock.rQwait("TIGHT palette " + cmode, this._FBU.bytes)) { return false; }
-
- const bpp = (numColors <= 2) ? 1 : 8;
- const rowSize = Math.floor((this._FBU.width * bpp + 7) / 8);
- let raw = false;
- if (rowSize * this._FBU.height < 12) {
- raw = true;
- cl_header = 0;
- cl_data = rowSize * this._FBU.height;
- //clength = [0, rowSize * this._FBU.height];
- } else {
- // begin inline getTightCLength (returning two-item arrays is bad for performance with GC)
- const cl_offset = rQi + 3 + paletteSize;
- cl_header = 1;
- cl_data = 0;
- cl_data += rQ[cl_offset] & 0x7f;
- if (rQ[cl_offset] & 0x80) {
- cl_header++;
- cl_data += (rQ[cl_offset + 1] & 0x7f) << 7;
- if (rQ[cl_offset + 1] & 0x80) {
- cl_header++;
- cl_data += rQ[cl_offset + 2] << 14;
- }
- }
- // end inline getTightCLength
- }
-
- this._FBU.bytes += cl_header + cl_data;
- if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
-
- // Shift ctl, filter id, num colors, palette entries, and clength off
- this._sock.rQskipBytes(3);
- //const palette = this._sock.rQshiftBytes(paletteSize);
- this._sock.rQshiftTo(this._paletteBuff, paletteSize);
- this._sock.rQskipBytes(cl_header);
-
- if (raw) {
- data = this._sock.rQshiftBytes(cl_data);
- } else {
- data = decompress(this._sock.rQshiftBytes(cl_data), rowSize * this._FBU.height);
- }
-
- // Convert indexed (palette based) image data to RGB
- let rgbx;
- if (numColors == 2) {
- rgbx = indexedToRGBX2Color(data, this._paletteBuff, this._FBU.width, this._FBU.height);
- } else {
- rgbx = indexedToRGBX(data, this._paletteBuff, this._FBU.width, this._FBU.height);
- }
-
- this._display.blitRgbxImage(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, rgbx, 0, false);
-
-
- return true;
- };
-
- const handleCopy = () => {
- let raw = false;
- const uncompressedSize = this._FBU.width * this._FBU.height * 3;
- if (uncompressedSize < 12) {
- raw = true;
- cl_header = 0;
- cl_data = uncompressedSize;
- } else {
- // begin inline getTightCLength (returning two-item arrays is for peformance with GC)
- const cl_offset = rQi + 1;
- cl_header = 1;
- cl_data = 0;
- cl_data += rQ[cl_offset] & 0x7f;
- if (rQ[cl_offset] & 0x80) {
- cl_header++;
- cl_data += (rQ[cl_offset + 1] & 0x7f) << 7;
- if (rQ[cl_offset + 1] & 0x80) {
- cl_header++;
- cl_data += rQ[cl_offset + 2] << 14;
- }
- }
- // end inline getTightCLength
- }
- this._FBU.bytes = 1 + cl_header + cl_data;
- if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
-
- // Shift ctl, clength off
- this._sock.rQshiftBytes(1 + cl_header);
-
- if (raw) {
- data = this._sock.rQshiftBytes(cl_data);
- } else {
- data = decompress(this._sock.rQshiftBytes(cl_data), uncompressedSize);
- }
-
- this._display.blitRgbImage(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, data, 0, false);
-
- return true;
- };
-
- let ctl = this._sock.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 {
- return this._fail("Illegal tight compression received (ctl: " +
- ctl + ")");
- }
-
- if (isTightPNG && (ctl < 0x08)) {
- return this._fail("BasicCompression received in TightPNG rect");
- }
- if (!isTightPNG && (ctl === 0x0A)) {
- return this._fail("PNG received in standard Tight rect");
- }
-
- switch (cmode) {
- // fill use depth because TPIXELs drop the padding byte
- case "fill": // TPIXEL
- this._FBU.bytes += 3;
- break;
- case "jpeg": // max clength
- this._FBU.bytes += 3;
- break;
- case "png": // max clength
- this._FBU.bytes += 3;
- break;
- case "filter": // filter id + num colors if palette
- this._FBU.bytes += 2;
- break;
- case "copy":
- break;
- }
-
- if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
-
- // Determine FBU.bytes
- let cl_offset, filterId;
- switch (cmode) {
- case "fill":
- // skip ctl byte
- this._display.fillRect(this._FBU.x, this._FBU.y, this._FBU.width, this._FBU.height, [rQ[rQi + 3], rQ[rQi + 2], rQ[rQi + 1]], false);
- this._sock.rQskipBytes(4);
- break;
- case "png":
- case "jpeg":
- // begin inline getTightCLength (returning two-item arrays is for peformance with GC)
- cl_offset = rQi + 1;
- cl_header = 1;
- cl_data = 0;
- cl_data += rQ[cl_offset] & 0x7f;
- if (rQ[cl_offset] & 0x80) {
- cl_header++;
- cl_data += (rQ[cl_offset + 1] & 0x7f) << 7;
- if (rQ[cl_offset + 1] & 0x80) {
- cl_header++;
- cl_data += rQ[cl_offset + 2] << 14;
- }
- }
- // end inline getTightCLength
- this._FBU.bytes = 1 + cl_header + cl_data; // ctl + clength size + jpeg-data
- if (this._sock.rQwait("TIGHT " + cmode, this._FBU.bytes)) { return false; }
-
- // We have everything, render it
- this._sock.rQskipBytes(1 + cl_header); // shift off clt + compact length
- data = this._sock.rQshiftBytes(cl_data);
- this._display.imageRect(this._FBU.x, this._FBU.y, "image/" + cmode, data);
- 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 use if jpeg is enabled
- this._fail("Unsupported tight subencoding received " +
- "(filter: " + filterId + ")");
- }
- break;
- case "copy":
- if (!handleCopy()) { return false; }
- break;
- }
-
-
- this._FBU.bytes = 0;
- this._FBU.rects--;
-
- return true;
- },
-
- last_rect() {
- this._FBU.rects = 0;
- return true;
- },
-
- ExtendedDesktopSize() {
- this._FBU.bytes = 1;
- if (this._sock.rQwait("ExtendedDesktopSize", this._FBU.bytes)) { return false; }
-
- const firstUpdate = !this._supportsSetDesktopSize;
- this._supportsSetDesktopSize = true;
-
- // Normally we only apply the current resize mode after a
- // window resize event. However there is no such trigger on the
- // initial connect. And we don't know if the server supports
- // resizing until we've gotten here.
- if (firstUpdate) {
- this._requestRemoteResize();
- }
-
- const number_of_screens = this._sock.rQpeek8();
-
- this._FBU.bytes = 4 + (number_of_screens * 16);
- if (this._sock.rQwait("ExtendedDesktopSize", this._FBU.bytes)) { return false; }
-
- this._sock.rQskipBytes(1); // number-of-screens
- this._sock.rQskipBytes(3); // padding
-
- for (let i = 0; i < number_of_screens; i += 1) {
- // Save the id and flags of the first screen
- if (i === 0) {
- this._screen_id = this._sock.rQshiftBytes(4); // id
- this._sock.rQskipBytes(2); // x-position
- this._sock.rQskipBytes(2); // y-position
- this._sock.rQskipBytes(2); // width
- this._sock.rQskipBytes(2); // height
- this._screen_flags = this._sock.rQshiftBytes(4); // flags
- } else {
- this._sock.rQskipBytes(16);
- }
- }
-
- /*
- * The x-position indicates the reason for the change:
- *
- * 0 - server resized on its own
- * 1 - this client requested the resize
- * 2 - another client requested the resize
- */
-
- // We need to handle errors when we requested the resize.
- if (this._FBU.x === 1 && this._FBU.y !== 0) {
- let msg = "";
- // The y-position indicates the status code from the server
- switch (this._FBU.y) {
- case 1:
- msg = "Resize is administratively prohibited";
- break;
- case 2:
- msg = "Out of resources";
- break;
- case 3:
- msg = "Invalid screen layout";
- break;
- default:
- msg = "Unknown reason";
- break;
- }
- Log.Warn("Server did not accept the resize request: "
- + msg);
- } else {
- this._resize(this._FBU.width, this._FBU.height);
- }
-
- this._FBU.bytes = 0;
- this._FBU.rects -= 1;
- return true;
- },
-
- DesktopSize() {
- this._resize(this._FBU.width, this._FBU.height);
- this._FBU.bytes = 0;
- this._FBU.rects -= 1;
- return true;
- },
-
- Cursor() {
- Log.Debug(">> set_cursor");
- const x = this._FBU.x; // hotspot-x
- const y = this._FBU.y; // hotspot-y
- const w = this._FBU.width;
- const h = this._FBU.height;
-
- const pixelslength = w * h * 4;
- const masklength = Math.floor((w + 7) / 8) * h;
-
- this._FBU.bytes = pixelslength + masklength;
- if (this._sock.rQwait("cursor encoding", this._FBU.bytes)) { return false; }
-
- this._cursor.change(this._sock.rQshiftBytes(pixelslength),
- this._sock.rQshiftBytes(masklength),
- x, y, w, h);
-
- this._FBU.bytes = 0;
- this._FBU.rects--;
-
- Log.Debug("<< set_cursor");
- return true;
+RFB.cursors = {
+ none: {
+ rgbaPixels: new Uint8Array(),
+ w: 0, h: 0,
+ hotx: 0, hoty: 0,
},
- QEMUExtendedKeyEvent() {
- this._FBU.rects--;
-
- // Old Safari doesn't support creating keyboard events
- try {
- const keyboardEvent = document.createEvent("keyboardEvent");
- if (keyboardEvent.code !== undefined) {
- this._qemuExtKeyEventSupported = true;
- }
- } catch (err) {
- // Do nothing
- }
+ dot: {
+ /* eslint-disable indent */
+ rgbaPixels: new Uint8Array([
+ 255, 255, 255, 255, 0, 0, 0, 255, 255, 255, 255, 255,
+ 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 255,
+ 255, 255, 255, 255, 0, 0, 0, 255, 255, 255, 255, 255,
+ ]),
+ /* eslint-enable indent */
+ w: 3, h: 3,
+ hotx: 1, hoty: 1,
}
};
projects / mirror_novnc.git / blobdiff