GUAC-608: Implement UTF-8 decode in StringReader.

guacamole-common-js/src/main/webapp/modules/StringReader.js

@@ -39,11 +39,104 @@ Guacamole.StringReader = function(stream) {
      */
     var guac_reader = this;
 
-    // Receive blobs as strings
-    stream.onblob = function(data) {
+    /**
+     * Wrapped Guacamole.ArrayBufferReader.
+     * @private
+     * @type Guacamole.ArrayBufferReader
+     */
+    var array_reader = new Guacamole.ArrayBufferReader(stream);
 
-        // Convert to string 
-        var text = window.atob(data);
+    /**
+     * The number of bytes remaining for the current codepoint.
+     * 
+     * @type Number
+     */
+    var bytes_remaining = 0;
+
+    /**
+     * The current codepoint value, as calculated from bytes read so far.
+     * @type Number
+     */
+    var codepoint = 0;
+
+    /**
+     * Decodes the given UTF-8 data into a Unicode string. The data may end in
+     * the middle of a multibyte character.
+     * 
+     * @private
+     * @param {ArrayBuffer} buffer Arbitrary UTF-8 data.
+     * @return {String} A decoded Unicode string.
+     */
+    function __decode_utf8(buffer) {
+
+        var text = "";
+
+        var bytes = new Uint8Array(buffer);
+        for (var i=0; i<bytes.length; i++) {
+
+            // Get current byte
+            var value = bytes[i];
+
+            // Start new codepoint if nothing yet read
+            if (bytes_remaining === 0) {
+
+                // 1 byte (0xxxxxxx)
+                if ((value | 0x7F) === 0x7F)
+                    text += String.fromCharCode(value);
+
+                // 2 byte (110xxxxx)
+                else if ((value | 0x1F) === 0xDF) {
+                    codepoint = value & 0x1F;
+                    bytes_remaining = 1;
+                }
+
+                // 3 byte (1110xxxx)
+                else if ((value | 0x0F )=== 0xEF) {
+                    codepoint = value & 0x0F;
+                    bytes_remaining = 2;
+                }
+
+                // 4 byte (11110xxx)
+                else if ((value | 0x07) === 0xF7) {
+                    codepoint = value & 0x07;
+                    bytes_remaining = 3;
+                }
+
+                // Invalid byte
+                else
+                    text += "\uFFFD";
+
+            }
+
+            // Continue existing codepoint (10xxxxxx)
+            else if ((value | 0x3F) === 0xBF) {
+
+                codepoint = (codepoint << 6) | (value & 0x3F);
+                bytes_remaining--;
+
+                // Write codepoint if finished
+                if (bytes_remaining === 0)
+                    text += String.fromCharCode(codepoint);
+
+            }
+
+            // Invalid byte
+            else {
+                bytes_remaining = 0;
+                text += "\uFFFD";
+            }
+
+        }
+
+        return text;
+
+    }
+
+    // Receive blobs as strings
+    array_reader.ondata = function(buffer) {
+
+        // Decode UTF-8
+        var text = __decode_utf8(buffer);
 
         // Call handler, if present
         if (guac_reader.ontext)
@@ -52,7 +145,7 @@ Guacamole.StringReader = function(stream) {
     };
 
     // Simply call onend when end received
-    stream.onend = function() {
+    array_reader.onend = function() {
         if (guac_reader.onend)
             guac_reader.onend();
     };