From f73fdc3ed3db6a47cc95a17200b7a0d1fdc91ab8 Mon Sep 17 00:00:00 2001 From: Niko Lehto Date: Mon, 27 Jan 2020 13:49:07 +0100 Subject: Add extended clipboard Pseudo-Encoding Add extended clipboard pseudo-encoding to allow the use of unicode characters in the clipboard. --- core/encodings.js | 3 +- core/rfb.js | 320 +++++++++++++++++++++++++++++++++++--- tests/test.rfb.js | 457 +++++++++++++++++++++++++++++++++++++++++++++++++++--- 3 files changed, 741 insertions(+), 39 deletions(-) diff --git a/core/encodings.js b/core/encodings.js index c248840..51c0992 100644 --- a/core/encodings.js +++ b/core/encodings.js @@ -27,7 +27,8 @@ export const encodings = { pseudoEncodingContinuousUpdates: -313, pseudoEncodingCompressLevel9: -247, pseudoEncodingCompressLevel0: -256, - pseudoEncodingVMwareCursor: 0x574d5664 + pseudoEncodingVMwareCursor: 0x574d5664, + pseudoEncodingExtendedClipboard: 0xc0a1e5ce }; export function encodingName(num) { diff --git a/core/rfb.js b/core/rfb.js index e3e3a0f..f0d2a79 100644 --- a/core/rfb.js +++ b/core/rfb.js @@ -1,17 +1,20 @@ /* * noVNC: HTML5 VNC client - * Copyright (C) 2019 The noVNC Authors + * Copyright (C) 2020 The noVNC Authors * Licensed under MPL 2.0 (see LICENSE.txt) * * See README.md for usage and integration instructions. * */ +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"; @@ -33,6 +36,23 @@ import TightPNGDecoder from "./decoders/tightpng.js"; const DISCONNECT_TIMEOUT = 3; const DEFAULT_BACKGROUND = 'rgb(40, 40, 40)'; +// 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) { @@ -84,6 +104,10 @@ export default class RFB extends EventTargetMixin { this._qemuExtKeyEventSupported = false; + this._clipboardText = null; + this._clipboardServerCapabilitiesActions = {}; + this._clipboardServerCapabilitiesFormats = {}; + // Internal objects this._sock = null; // Websock object this._display = null; // Display object @@ -390,7 +414,21 @@ export default class RFB extends EventTargetMixin { clipboardPasteFrom(text) { if (this._rfb_connection_state !== 'connected' || this._viewOnly) { return; } - RFB.messages.clientCutText(this._sock, text); + + 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 ===== @@ -1267,6 +1305,7 @@ export default class RFB extends EventTargetMixin { encs.push(encodings.pseudoEncodingFence); encs.push(encodings.pseudoEncodingContinuousUpdates); encs.push(encodings.pseudoEncodingDesktopName); + encs.push(encodings.pseudoEncodingExtendedClipboard); if (this._fb_depth == 24) { encs.push(encodings.pseudoEncodingVMwareCursor); @@ -1325,18 +1364,163 @@ export default class RFB extends EventTargetMixin { 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) { + textData = String.fromCharCode.apply(null, textData); + + 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; } @@ -1966,8 +2150,102 @@ RFB.messages = { 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; @@ -1977,7 +2255,12 @@ RFB.messages = { 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; @@ -1986,24 +2269,25 @@ RFB.messages = { 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)); 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) { diff --git a/tests/test.rfb.js b/tests/test.rfb.js index 0143fe6..42f4fbc 100644 --- a/tests/test.rfb.js +++ b/tests/test.rfb.js @@ -2,7 +2,11 @@ const expect = chai.expect; import RFB from '../core/rfb.js'; import Websock from '../core/websock.js'; +import ZStream from "../vendor/pako/lib/zlib/zstream.js"; +import { deflateInit, deflate } from "../vendor/pako/lib/zlib/deflate.js"; import { encodings } from '../core/encodings.js'; +import { toUnsigned32bit } from '../core/util/int.js'; +import { encodeUTF8 } from '../core/util/strings.js'; import FakeWebSocket from './fake.websocket.js'; @@ -48,6 +52,35 @@ function pushString(arr, string) { } } +function deflateWithSize(data) { + // Adds the size of the string in front before deflating + + let unCompData = []; + unCompData.push((data.length >> 24) & 0xFF, + (data.length >> 16) & 0xFF, + (data.length >> 8) & 0xFF, + (data.length & 0xFF)); + + for (let i = 0; i < data.length; i++) { + unCompData.push(data.charCodeAt(i)); + } + + let strm = new ZStream(); + let chunkSize = 1024 * 10 * 10; + strm.output = new Uint8Array(chunkSize); + deflateInit(strm, 5); + + strm.input = unCompData; + strm.avail_in = strm.input.length; + strm.next_in = 0; + strm.next_out = 0; + strm.avail_out = chunkSize; + + deflate(strm, 3); + + return new Uint8Array(strm.output.buffer, 0, strm.next_out); +} + describe('Remote Frame Buffer Protocol Client', function () { let clock; let raf; @@ -291,18 +324,39 @@ describe('Remote Frame Buffer Protocol Client', function () { }); describe('#clipboardPasteFrom', function () { - beforeEach(function () { - sinon.spy(RFB.messages, 'clientCutText'); - }); + describe('Clipboard update handling', function () { + beforeEach(function () { + sinon.spy(RFB.messages, 'clientCutText'); + sinon.spy(RFB.messages, 'extendedClipboardNotify'); + }); - afterEach(function () { - RFB.messages.clientCutText.restore(); - }); + afterEach(function () { + RFB.messages.clientCutText.restore(); + RFB.messages.extendedClipboardNotify.restore(); + }); - it('should send the given text in a paste event', function () { - client.clipboardPasteFrom('abc'); - expect(RFB.messages.clientCutText).to.have.been.calledOnce; - expect(RFB.messages.clientCutText).to.have.been.calledWith(client._sock, 'abc'); + it('should send the given text in an clipboard update', function () { + client.clipboardPasteFrom('abc'); + + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(client._sock, + new Uint8Array([97, 98, 99])); + }); + + it('should send an notify if extended clipboard is supported by server', function () { + // Send our capabilities + let data = [3, 0, 0, 0]; + const flags = [0x1F, 0x00, 0x00, 0x01]; + let fileSizes = [0x00, 0x00, 0x00, 0x1E]; + + push32(data, toUnsigned32bit(-8)); + data = data.concat(flags); + data = data.concat(fileSizes); + client._sock._websocket._receive_data(new Uint8Array(data)); + + client.clipboardPasteFrom('extended test'); + expect(RFB.messages.extendedClipboardNotify).to.have.been.calledOnce; + }); }); it('should flush multiple times for large clipboards', function () { @@ -2342,17 +2396,217 @@ describe('Remote Frame Buffer Protocol Client', function () { }); }); - it('should fire the clipboard callback with the retrieved text on ServerCutText', function () { - const expected_str = 'cheese!'; - const data = [3, 0, 0, 0]; - push32(data, expected_str.length); - for (let i = 0; i < expected_str.length; i++) { data.push(expected_str.charCodeAt(i)); } - const spy = sinon.spy(); - client.addEventListener("clipboard", spy); + describe('Normal Clipboard Handling Receive', function () { + it('should fire the clipboard callback with the retrieved text on ServerCutText', function () { + const expected_str = 'cheese!'; + const data = [3, 0, 0, 0]; + push32(data, expected_str.length); + for (let i = 0; i < expected_str.length; i++) { data.push(expected_str.charCodeAt(i)); } + const spy = sinon.spy(); + client.addEventListener("clipboard", spy); + + client._sock._websocket._receive_data(new Uint8Array(data)); + expect(spy).to.have.been.calledOnce; + expect(spy.args[0][0].detail.text).to.equal(expected_str); + }); + }); + + describe('Extended clipboard Handling', function () { + + describe('Extended clipboard initialization', function () { + beforeEach(function () { + sinon.spy(RFB.messages, 'extendedClipboardCaps'); + }); + + afterEach(function () { + RFB.messages.extendedClipboardCaps.restore(); + }); + + it('should update capabilities when receiving a Caps message', function () { + let data = [3, 0, 0, 0]; + const flags = [0x1F, 0x00, 0x00, 0x03]; + let fileSizes = [0x00, 0x00, 0x00, 0x1E, + 0x00, 0x00, 0x00, 0x3C]; + + push32(data, toUnsigned32bit(-12)); + data = data.concat(flags); + data = data.concat(fileSizes); + client._sock._websocket._receive_data(new Uint8Array(data)); + + // Check that we give an response caps when we receive one + expect(RFB.messages.extendedClipboardCaps).to.have.been.calledOnce; + + // FIXME: Can we avoid checking internal variables? + expect(client._clipboardServerCapabilitiesFormats[0]).to.not.equal(true); + expect(client._clipboardServerCapabilitiesFormats[1]).to.equal(true); + expect(client._clipboardServerCapabilitiesFormats[2]).to.equal(true); + expect(client._clipboardServerCapabilitiesActions[(1 << 24)]).to.equal(true); + }); + + + }); + + describe('Extended Clipboard Handling Receive', function () { + + beforeEach(function () { + // Send our capabilities + let data = [3, 0, 0, 0]; + const flags = [0x1F, 0x00, 0x00, 0x01]; + let fileSizes = [0x00, 0x00, 0x00, 0x1E]; + + push32(data, toUnsigned32bit(-8)); + data = data.concat(flags); + data = data.concat(fileSizes); + client._sock._websocket._receive_data(new Uint8Array(data)); + }); + + describe('Handle Provide', function () { + it('should update clipboard with correct Unicode data from a Provide message', function () { + let expectedData = "Aå漢字!"; + let data = [3, 0, 0, 0]; + const flags = [0x10, 0x00, 0x00, 0x01]; + + /* The size 10 (utf8 encoded string size) and the + string "Aå漢字!" utf8 encoded and deflated. */ + let deflatedData = [120, 94, 99, 96, 96, 224, 114, 60, + 188, 244, 217, 158, 69, 79, 215, + 78, 87, 4, 0, 35, 207, 6, 66]; + + // How much data we are sending. + push32(data, toUnsigned32bit(-(4 + deflatedData.length))); + + data = data.concat(flags); + data = data.concat(deflatedData); + + const spy = sinon.spy(); + client.addEventListener("clipboard", spy); + + client._sock._websocket._receive_data(new Uint8Array(data)); + expect(spy).to.have.been.calledOnce; + expect(spy.args[0][0].detail.text).to.equal(expectedData); + client.removeEventListener("clipboard", spy); + }); + + it('should update clipboard with correct escape characters from a Provide message ', function () { + let expectedData = "Oh\nmy!"; + let data = [3, 0, 0, 0]; + const flags = [0x10, 0x00, 0x00, 0x01]; + + let text = encodeUTF8("Oh\r\nmy!\0"); + + let deflatedText = deflateWithSize(text); + + // How much data we are sending. + push32(data, toUnsigned32bit(-(4 + deflatedText.length))); + + data = data.concat(flags); + + let sendData = new Uint8Array(data.length + deflatedText.length); + sendData.set(data); + sendData.set(deflatedText, data.length); + + const spy = sinon.spy(); + client.addEventListener("clipboard", spy); + + client._sock._websocket._receive_data(sendData); + expect(spy).to.have.been.calledOnce; + expect(spy.args[0][0].detail.text).to.equal(expectedData); + client.removeEventListener("clipboard", spy); + }); + + }); + + describe('Handle Notify', function () { + beforeEach(function () { + sinon.spy(RFB.messages, 'extendedClipboardRequest'); + }); + + afterEach(function () { + RFB.messages.extendedClipboardRequest.restore(); + }); + + it('should make a request with supported formats when receiving a notify message', function () { + let data = [3, 0, 0, 0]; + const flags = [0x08, 0x00, 0x00, 0x07]; + push32(data, toUnsigned32bit(-4)); + data = data.concat(flags); + let expectedData = [0x01]; + + client._sock._websocket._receive_data(new Uint8Array(data)); + + expect(RFB.messages.extendedClipboardRequest).to.have.been.calledOnce; + expect(RFB.messages.extendedClipboardRequest).to.have.been.calledWith(client._sock, expectedData); + }); + }); + + describe('Handle Peek', function () { + beforeEach(function () { + sinon.spy(RFB.messages, 'extendedClipboardNotify'); + }); + + afterEach(function () { + RFB.messages.extendedClipboardNotify.restore(); + }); + + it('should send an empty Notify when receiving a Peek and no excisting clipboard data', function () { + let data = [3, 0, 0, 0]; + const flags = [0x04, 0x00, 0x00, 0x00]; + push32(data, toUnsigned32bit(-4)); + data = data.concat(flags); + let expectedData = []; + + client._sock._websocket._receive_data(new Uint8Array(data)); + + expect(RFB.messages.extendedClipboardNotify).to.have.been.calledOnce; + expect(RFB.messages.extendedClipboardNotify).to.have.been.calledWith(client._sock, expectedData); + }); + + it('should send a Notify message with supported formats when receiving a Peek', function () { + let data = [3, 0, 0, 0]; + const flags = [0x04, 0x00, 0x00, 0x00]; + push32(data, toUnsigned32bit(-4)); + data = data.concat(flags); + let expectedData = [0x01]; + + // Needed to have clipboard data to read. + // This will trigger a call to Notify, reset history + client.clipboardPasteFrom("HejHej"); + RFB.messages.extendedClipboardNotify.resetHistory(); + + client._sock._websocket._receive_data(new Uint8Array(data)); + + expect(RFB.messages.extendedClipboardNotify).to.have.been.calledOnce; + expect(RFB.messages.extendedClipboardNotify).to.have.been.calledWith(client._sock, expectedData); + }); + }); + + describe('Handle Request', function () { + beforeEach(function () { + sinon.spy(RFB.messages, 'extendedClipboardProvide'); + }); + + afterEach(function () { + RFB.messages.extendedClipboardProvide.restore(); + }); + + it('should send a Provide message with supported formats when receiving a Request', function () { + let data = [3, 0, 0, 0]; + const flags = [0x02, 0x00, 0x00, 0x01]; + push32(data, toUnsigned32bit(-4)); + data = data.concat(flags); + let expectedData = [0x01]; + + client.clipboardPasteFrom("HejHej"); + expect(RFB.messages.extendedClipboardProvide).to.not.have.been.called; + + client._sock._websocket._receive_data(new Uint8Array(data)); + + expect(RFB.messages.extendedClipboardProvide).to.have.been.calledOnce; + expect(RFB.messages.extendedClipboardProvide).to.have.been.calledWith(client._sock, expectedData, ["HejHej"]); + }); + }); + }); - client._sock._websocket._receive_data(new Uint8Array(data)); - expect(spy).to.have.been.calledOnce; - expect(spy.args[0][0].detail.text).to.equal(expected_str); }); it('should fire the bell callback on Bell', function () { @@ -2580,3 +2834,166 @@ describe('Remote Frame Buffer Protocol Client', function () { }); }); }); + +describe('RFB messages', function () { + let sock; + + before(function () { + FakeWebSocket.replace(); + sock = new Websock(); + sock.open(); + }); + + after(function () { + FakeWebSocket.restore(); + }); + + describe('Extended Clipboard Handling Send', function () { + beforeEach(function () { + sinon.spy(RFB.messages, 'clientCutText'); + }); + + afterEach(function () { + RFB.messages.clientCutText.restore(); + }); + + it('should call clientCutText with correct Caps data', function () { + let formats = { + 0: 2, + 2: 4121 + }; + let expectedData = new Uint8Array([0x1F, 0x00, 0x00, 0x05, + 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x10, 0x19]); + let actions = [ + 1 << 24, // Caps + 1 << 25, // Request + 1 << 26, // Peek + 1 << 27, // Notify + 1 << 28 // Provide + ]; + + RFB.messages.extendedClipboardCaps(sock, actions, formats); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData); + }); + + it('should call clientCutText with correct Request data', function () { + let formats = new Uint8Array([0x01]); + let expectedData = new Uint8Array([0x02, 0x00, 0x00, 0x01]); + + RFB.messages.extendedClipboardRequest(sock, formats); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData); + }); + + it('should call clientCutText with correct Notify data', function () { + let formats = new Uint8Array([0x01]); + let expectedData = new Uint8Array([0x08, 0x00, 0x00, 0x01]); + + RFB.messages.extendedClipboardNotify(sock, formats); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData); + }); + + it('should call clientCutText with correct Provide data', function () { + let testText = "Test string"; + let expectedText = encodeUTF8(testText + "\0"); + + let deflatedData = deflateWithSize(expectedText); + + // Build Expected with flags and deflated data + let expectedData = new Uint8Array(4 + deflatedData.length); + expectedData[0] = 0x10; // The client capabilities + expectedData[1] = 0x00; // Reserved flags + expectedData[2] = 0x00; // Reserved flags + expectedData[3] = 0x01; // The formats client supports + expectedData.set(deflatedData, 4); + + RFB.messages.extendedClipboardProvide(sock, [0x01], [testText]); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData, true); + + }); + + describe('End of line characters', function () { + it('Carriage return', function () { + + let testText = "Hello\rworld\r\r!"; + let expectedText = encodeUTF8("Hello\r\nworld\r\n\r\n!\0"); + + let deflatedData = deflateWithSize(expectedText); + + // Build Expected with flags and deflated data + let expectedData = new Uint8Array(4 + deflatedData.length); + expectedData[0] = 0x10; // The client capabilities + expectedData[1] = 0x00; // Reserved flags + expectedData[2] = 0x00; // Reserved flags + expectedData[3] = 0x01; // The formats client supports + expectedData.set(deflatedData, 4); + + RFB.messages.extendedClipboardProvide(sock, [0x01], [testText]); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData, true); + }); + + it('Carriage return Line feed', function () { + + let testText = "Hello\r\n\r\nworld\r\n!"; + let expectedText = encodeUTF8(testText + "\0"); + + let deflatedData = deflateWithSize(expectedText); + + // Build Expected with flags and deflated data + let expectedData = new Uint8Array(4 + deflatedData.length); + expectedData[0] = 0x10; // The client capabilities + expectedData[1] = 0x00; // Reserved flags + expectedData[2] = 0x00; // Reserved flags + expectedData[3] = 0x01; // The formats client supports + expectedData.set(deflatedData, 4); + + RFB.messages.extendedClipboardProvide(sock, [0x01], [testText]); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData, true); + }); + + it('Line feed', function () { + let testText = "Hello\n\n\nworld\n!"; + let expectedText = encodeUTF8("Hello\r\n\r\n\r\nworld\r\n!\0"); + + let deflatedData = deflateWithSize(expectedText); + + // Build Expected with flags and deflated data + let expectedData = new Uint8Array(4 + deflatedData.length); + expectedData[0] = 0x10; // The client capabilities + expectedData[1] = 0x00; // Reserved flags + expectedData[2] = 0x00; // Reserved flags + expectedData[3] = 0x01; // The formats client supports + expectedData.set(deflatedData, 4); + + RFB.messages.extendedClipboardProvide(sock, [0x01], [testText]); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData, true); + }); + + it('Carriage return and Line feed mixed', function () { + let testText = "\rHello\r\n\rworld\n\n!"; + let expectedText = encodeUTF8("\r\nHello\r\n\r\nworld\r\n\r\n!\0"); + + let deflatedData = deflateWithSize(expectedText); + + // Build Expected with flags and deflated data + let expectedData = new Uint8Array(4 + deflatedData.length); + expectedData[0] = 0x10; // The client capabilities + expectedData[1] = 0x00; // Reserved flags + expectedData[2] = 0x00; // Reserved flags + expectedData[3] = 0x01; // The formats client supports + expectedData.set(deflatedData, 4); + + RFB.messages.extendedClipboardProvide(sock, [0x01], [testText]); + expect(RFB.messages.clientCutText).to.have.been.calledOnce; + expect(RFB.messages.clientCutText).to.have.been.calledWith(sock, expectedData, true); + }); + }); + }); +}); -- cgit v1.2.1