Add extended clipboard Pseudo-Encoding

Add extended clipboard pseudo-encoding to allow the use of unicode
characters in the clipboard.

kasmweb/core/encodings.js

@@ -53,6 +53,7 @@ export const encodings = {
     pseudoEncodingVideoOutTimeLevel100: -1887,
 
     pseudoEncodingVMwareCursor: 0x574d5664,
+    pseudoEncodingExtendedClipboard: 0xc0a1e5ce,
 };
 
 export function encodingName(num) {

kasmweb/core/rfb.js

@@ -1,18 +1,21 @@
 /*
  * 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 { supportsCursorURIs, isTouchDevice } from './util/browser.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";
@@ -37,6 +40,23 @@ const DEFAULT_BACKGROUND = 'rgb(40, 40, 40)';
 var _videoQuality =  2;
 var _enableWebP = false;
 
+// 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) {
@@ -103,6 +123,10 @@ export default class RFB extends EventTargetMixin {
         this._maxVideoResolutionX = 960;
         this._maxVideoResolutionY = 540;
 
+        this._clipboardText = null;
+        this._clipboardServerCapabilitiesActions = {};
+        this._clipboardServerCapabilitiesFormats = {};
+
         // Internal objects
         this._sock = null;              // Websock object
         this._display = null;           // Display object
@@ -461,7 +485,21 @@ export default class RFB extends EventTargetMixin {
     clipboardPasteFrom(text) {
         if (this._rfb_connection_state !== 'connected' || this._viewOnly) { return; }
         this.sentEventsCounter+=1;
-        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);
+        }
     }
 
     requestBottleneckStats() {
@@ -1413,6 +1451,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._hasWebp())
             encs.push(encodings.pseudoEncodingWEBP);
 
@@ -1495,18 +1534,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(
+        if (length >= 0) {
-            "clipboard",
+            //Standard msg
-            { detail: { text: text } }));
+            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;
     }
 
@@ -2162,8 +2346,102 @@ RFB.messages = {
         sock.flush();
     },
 
-    // TODO(directxman12): make this unicode compatible?
+    // Used to build Notify and Request data.
-    clientCutText(sock, text) {
+    _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;
 
@@ -2173,7 +2451,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;
@@ -2182,24 +2465,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) {

kasmweb/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 () {
+            describe('Clipboard update handling', function () {
-                sinon.spy(RFB.messages, 'clientCutText');
+                beforeEach(function () {
-            });
+                    sinon.spy(RFB.messages, 'clientCutText');
+                    sinon.spy(RFB.messages, 'extendedClipboardNotify');
+                });
 
-            afterEach(function () {
+                afterEach(function () {
-                RFB.messages.clientCutText.restore();
+                    RFB.messages.clientCutText.restore();
-            });
+                    RFB.messages.extendedClipboardNotify.restore();
+                });
 
-            it('should send the given text in a paste event', function () {
+                it('should send the given text in an clipboard update', function () {
-                client.clipboardPasteFrom('abc');
+                    client.clipboardPasteFrom('abc');
-                expect(RFB.messages.clientCutText).to.have.been.calledOnce;
+
-                expect(RFB.messages.clientCutText).to.have.been.calledWith(client._sock, '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 () {
+        describe('Normal Clipboard Handling Receive', function () {
-            const expected_str = 'cheese!';
+            it('should fire the clipboard callback with the retrieved text on ServerCutText', function () {
-            const data = [3, 0, 0, 0];
+                const expected_str = 'cheese!';
-            push32(data, expected_str.length);
+                const data = [3, 0, 0, 0];
-            for (let i = 0; i < expected_str.length; i++) { data.push(expected_str.charCodeAt(i)); }
+                push32(data, expected_str.length);
-            const spy = sinon.spy();
+                for (let i = 0; i < expected_str.length; i++) { data.push(expected_str.charCodeAt(i)); }
-            client.addEventListener("clipboard", spy);
+                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);
+            });
+        });
+    });
+});