braid-http 0.3.12 → 0.3.13

package/braid-http-client.js

@@ -73,7 +73,7 @@ function braidify_http (http) {
 
                     // That will run each time we get new data
                     res.orig_on('data', (chunk) => {
-                        parser.read(chunk.toString())
+                        parser.read(chunk)
                     })
                 }
 
@@ -186,7 +186,7 @@ async function braid_fetch (url, params = {}) {
         if (params.patches.length === 1) {
             let patch = params.patches[0]
             params.headers.set('Content-Range', `${patch.unit} ${patch.range}`)
-            params.headers.set('Content-Length', `${patch.content.length}`)
+            params.headers.set('Content-Length', `${(new TextEncoder().encode(patch.content)).length}`)
             params.body = patch.content
         }
 
@@ -194,7 +194,7 @@ async function braid_fetch (url, params = {}) {
         else {
             params.headers.set('Patches', params.patches.length)
             params.body = (params.patches).map(patch => {
-                var length = `content-length: ${patch.content.length}`
+                var length = `content-length: ${(new TextEncoder().encode(patch.content)).length}`
                 var range = `content-range: ${patch.unit} ${patch.range}`
                 return `${length}\r\n${range}\r\n\r\n${patch.content}\r\n`
             }).join('\r\n')
@@ -318,7 +318,6 @@ async function handle_fetch_stream (stream, cb) {
 
     // Set up a reader
     var reader = stream.getReader(),
-        decoder = new TextDecoder('utf-8'),
         parser = subscription_parser(cb)
     
     while (true) {
@@ -341,7 +340,7 @@ async function handle_fetch_stream (stream, cb) {
         }
 
         // Tell the parser to process some more stream
-        parser.read(decoder.decode(value))
+        parser.read(value)
     }
 }
 
@@ -353,7 +352,7 @@ async function handle_fetch_stream (stream, cb) {
 
 var subscription_parser = (cb) => ({
     // A parser keeps some parse state
-    state: {input: ''},
+    state: {input: []},
 
     // And reports back new versions as soon as they are ready
     cb: cb,
@@ -363,10 +362,10 @@ var subscription_parser = (cb) => ({
     read (input) {
 
         // Store the new input!
-        this.state.input += input
+        this.state.input.push(...input)
 
         // Now loop through the input and parse until we hit a dead end
-        while (this.state.input.trim() !== '') {
+        while (this.state.input.length) {
 
             // Try to parse an update
             try {
@@ -445,29 +444,14 @@ function parse_update (state) {
     return parse_body(state)
 }
 
-function swallow_blank_lines (input) {
-    var blank_lines = /(\r\n|\n)*/.exec(input)[0]
-    return input.substr(blank_lines.length)
-}
-
 // Parsing helpers
 function parse_headers (input) {
-    input = swallow_blank_lines(input)
 
-    // First, find the start & end block of the headers.  The headers start
-    // when there are no longer newlines, and end at the first double-newline.
-
-    // Look for the double-newline at the end of the headers
-    var headers_end = input.match(/(\r?\n)\r?\n/)
+    var h = extractHeader(input)
+    if (!h) return {result: 'waiting'}
 
-    // ...if we found none, then we need to wait for more input to complete
-    // the headers..
-    if (!headers_end)
-        return {result: 'waiting'}
-
-    // We now know where the headers are to parse!
-    var headers_length = headers_end.index + headers_end[1].length,
-        headers_source = input.substring(0, headers_length)
+    var headers_source = h.header_string
+    var headers_length = headers_source.length
     
     // Let's parse them!  First define some variables:
     var headers = {},
@@ -504,15 +488,7 @@ function parse_headers (input) {
         headers.patches = JSON.parse(headers.patches)
 
     // Update the input
-    input = input.substring(headers_length)
-
-    // Swallow the final blank line ending the headers
-    if (input.substr(0, 2) === '\r\n')
-        // Swallow \r\n
-        input = input.substr(2)
-    else
-        // Swallow \n
-        input = input.substr(1)
+    input = h.remaining_bytes
 
     // And return the parsed result
     return { result: 'success', headers, input }
@@ -538,7 +514,6 @@ function parse_body (state) {
         }
 
         // We have the whole block!
-        var consumed_length = content_length + 2
         state.result = 'success'
 
         // If we have a content-range, then this is a patch
@@ -553,7 +528,7 @@ function parse_body (state) {
             state.patches = [{
                 unit: match.unit,
                 range: match.range,
-                content: state.input.substring(0, content_length),
+                content: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input.slice(0, content_length))),
 
                 // Question: Perhaps we should include headers here, like we do for
                 // the Patches: N headers below?
@@ -564,9 +539,9 @@ function parse_body (state) {
 
         // Otherwise, this is a snapshot body
         else
-            state.body = state.input.substring(0, content_length)
+            state.body = (new TextDecoder('utf-8')).decode(new Uint8Array(state.input.slice(0, content_length)))
 
-        state.input = state.input.substring(consumed_length)
+        state.input = state.input.slice(content_length)
         return state
     }
 
@@ -581,8 +556,6 @@ function parse_body (state) {
         while (!(state.patches.length === state.headers.patches
                  && (state.patches.length === 0 || 'content' in last_patch))) {
 
-            state.input = state.input.trimStart()
-
             // Are we starting a new patch?
             if (!last_patch || 'content' in last_patch) {
                 last_patch = {}
@@ -614,14 +587,14 @@ function parse_body (state) {
                     return {
                         result: 'error',
                         message: 'no content-length in patch',
-                        patch: last_patch, input: state.input
+                        patch: last_patch, input: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input))
                     }
 
                 if (!('content-range' in last_patch.headers))
                     return {
                         result: 'error',
                         message: 'no content-range in patch',
-                        patch: last_patch, input: state.input
+                        patch: last_patch, input: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input))
                     }
 
                 var content_length = parseInt(last_patch.headers['content-length'])
@@ -637,17 +610,17 @@ function parse_body (state) {
                     return {
                         result: 'error',
                         message: 'cannot parse content-range in patch',
-                        patch: last_patch, input: state.input
+                        patch: last_patch, input: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input))
                     }
 
                 last_patch.unit = match.unit
                 last_patch.range = match.range
-                last_patch.content = state.input.substr(0, content_length)
+                last_patch.content = (new TextDecoder('utf-8')).decode(new Uint8Array(state.input.slice(0, content_length)))
                 last_patch.extra_headers = extra_headers(last_patch.headers)
                 delete last_patch.headers  // We only keep the extra headers ^^
 
                 // Consume the parsed input
-                state.input = state.input.substring(content_length)
+                state.input = state.input.slice(content_length)
             }
         }
 
@@ -684,6 +657,60 @@ function extra_headers (headers) {
     return result
 }
 
+// a parsing utility function that will inspect a byte array of incoming data
+// to see if there is header information at the beginning,
+// namely some non-newline characters followed by two newlines
+function extractHeader(input) {
+    // Find the start of the headers
+    let begin_headers_i = 0;
+    while (input[begin_headers_i] === 13 || input[begin_headers_i] === 10) {
+        begin_headers_i++;
+    }
+    if (begin_headers_i === input.length) {
+        return null; // Incomplete headers
+    }
+
+    // Look for the double-newline at the end of the headers
+    let end_headers_i = begin_headers_i;
+    let size_of_tail = 0;
+    while (end_headers_i < input.length) {
+        if (input[end_headers_i] === 10 && input[end_headers_i + 1] === 10) {
+            size_of_tail = 2;
+            break;
+        }
+        if (input[end_headers_i] === 10 && input[end_headers_i + 1] === 13 && input[end_headers_i + 2] === 10) {
+            size_of_tail = 3;
+            break;
+        }
+        if (input[end_headers_i] === 13 && input[end_headers_i + 1] === 10 && input[end_headers_i + 2] === 10) {
+            size_of_tail = 3;
+            break;
+        }
+        if (input[end_headers_i] === 13 && input[end_headers_i + 1] === 10 && input[end_headers_i + 2] === 13 && input[end_headers_i + 3] === 10) {
+            size_of_tail = 4;
+            break;
+        }
+
+        end_headers_i++;
+    }
+
+    // If no double-newline is found, wait for more input
+    if (end_headers_i === input.length) {
+        return null; // Incomplete headers
+    }
+
+    // Extract the header string
+    const headerBytes = input.slice(begin_headers_i, end_headers_i);
+    const headerString = new TextDecoder('utf-8').decode(new Uint8Array(headerBytes));
+
+    // Return the remaining bytes and the header string
+    const remainingBytes = input.slice(end_headers_i + size_of_tail);
+    return {
+        remaining_bytes: remainingBytes,
+        header_string: headerString
+    };
+}
+
 // ****************************
 // Exports
 // ****************************

package/braid-http-server.js

@@ -54,7 +54,7 @@ function generate_patches(res, patches) {
 
         let extra_headers = Object.fromEntries(Object.entries(patch).filter(([k, v]) => k != 'unit' && k != 'range' && k != 'content'))
 
-        result += `Content-Length: ${patch.content.length}\r
+        result += `Content-Length: ${(new TextEncoder().encode(patch.content)).length}\r
 Content-Range: ${patch.unit} ${patch.range}\r
 ${Object.entries(extra_headers).map(([k, v]) => `${k}: ${v}\r\n`).join('')}\r
 ${patch.content}`
@@ -89,12 +89,12 @@ function parse_patches (req, cb) {
         var [unit, range] = parse_content_range(req.headers['content-range'])
 
         // The contents of the patch is in the request body
-        var buffer = ''
+        var buffer = []
         // Read the body one chunk at a time
-        req.on('data', chunk => buffer = buffer + chunk)
+        req.on('data', chunk => buffer.push(chunk))
         // Then return it
         req.on('end', () => {
-            patches = [{unit, range, content: buffer}]
+            patches = [{unit, range, content: Buffer.concat(buffer).toString('utf8')}]
             cb(patches)
         })
     }
@@ -103,7 +103,7 @@ function parse_patches (req, cb) {
     else {
         num_patches = parseInt(num_patches)
         let patches = []
-        let buffer = ""
+        let buffer = []
 
         // We check to send send patches each time we parse one.  But if there
         // are zero to parse, we will never check to send them.
@@ -113,57 +113,39 @@ function parse_patches (req, cb) {
         req.on('data', function parse (chunk) {
 
             // Merge the latest chunk into our buffer
-            buffer = (buffer + chunk)
+            buffer.push(...chunk)
 
             while (patches.length < num_patches) {
-                // We might have extra newlines at the start, because patches
-                // can be separated by arbitrary numbers of newlines
-                buffer = buffer.trimStart()
-
-                // First parse the patch headers.  It ends with a double-newline.
-                // Let's see where that is.
-                var headers_end = buffer.match(/(\r?\n)(\r?\n)/)
-
-                // Give up if we don't have a set of headers yet.
-                if (!headers_end)
-                    return
-
-                // Now we know where things end
-                var first_newline = headers_end[1],
-                    headers_length = headers_end.index + first_newline.length,
-                    blank_line = headers_end[2]
+                let h = extractHeader(buffer)
+                if (!h) return
 
                 // Now let's parse those headers.
-                var headers = require('parse-headers')(
-                    buffer.substring(0, headers_length)
-                )
+                var headers = require('parse-headers')(h.header_string)
 
                 // We require `content-length` to declare the length of the patch.
                 if (!('content-length' in headers)) {
                     // Print a nice error if it's missing
                     console.error('No content-length in', JSON.stringify(headers),
-                                  'from', {buffer, headers_length})
+                                  'from', {buffer})
                     process.exit(1)
                 }
 
                 var body_length = parseInt(headers['content-length'])
 
                 // Give up if we don't have the full patch yet.
-                if (buffer.length < headers_length + blank_line.length + body_length)
+                if (h.remaining_bytes.length < body_length)
                     return
 
                 // XX Todo: support custom patch types beyond content-range.
 
                 // Content-range is of the form '<unit> <range>' e.g. 'json .index'
                 var [unit, range] = parse_content_range(headers['content-range'])
-                var patch_content =
-                    buffer.substring(headers_length + blank_line.length,
-                                     headers_length + blank_line.length + body_length)
+                var patch_content = new TextDecoder('utf-8').decode(new Uint8Array(h.remaining_bytes.slice(0, body_length)))
 
                 // We've got our patch!
                 patches.push({unit, range, content: patch_content})
 
-                buffer = buffer.substring(headers_length + blank_line.length + body_length)
+                buffer = h.remaining_bytes.slice(body_length)
             }
 
             // We got all the patches!  Pause the stream and tell the callback!
@@ -375,5 +357,58 @@ function send_update(res, data, url, peer) {
     }
 }
 
+// a parsing utility function that will inspect a byte array of incoming data
+// to see if there is header information at the beginning,
+// namely some non-newline characters followed by two newlines
+function extractHeader(input) {
+    // Find the start of the headers
+    let begin_headers_i = 0;
+    while (input[begin_headers_i] === 13 || input[begin_headers_i] === 10) {
+        begin_headers_i++;
+    }
+    if (begin_headers_i === input.length) {
+        return null; // Incomplete headers
+    }
+
+    // Look for the double-newline at the end of the headers
+    let end_headers_i = begin_headers_i;
+    let size_of_tail = 0;
+    while (end_headers_i < input.length) {
+        if (input[end_headers_i] === 10 && input[end_headers_i + 1] === 10) {
+            size_of_tail = 2;
+            break;
+        }
+        if (input[end_headers_i] === 10 && input[end_headers_i + 1] === 13 && input[end_headers_i + 2] === 10) {
+            size_of_tail = 3;
+            break;
+        }
+        if (input[end_headers_i] === 13 && input[end_headers_i + 1] === 10 && input[end_headers_i + 2] === 10) {
+            size_of_tail = 3;
+            break;
+        }
+        if (input[end_headers_i] === 13 && input[end_headers_i + 1] === 10 && input[end_headers_i + 2] === 13 && input[end_headers_i + 3] === 10) {
+            size_of_tail = 4;
+            break;
+        }
+
+        end_headers_i++;
+    }
+
+    // If no double-newline is found, wait for more input
+    if (end_headers_i === input.length) {
+        return null; // Incomplete headers
+    }
+
+    // Extract the header string
+    const headerBytes = input.slice(begin_headers_i, end_headers_i);
+    const headerString = new TextDecoder('utf-8').decode(new Uint8Array(headerBytes));
+
+    // Return the remaining bytes and the header string
+    const remainingBytes = input.slice(end_headers_i + size_of_tail);
+    return {
+        remaining_bytes: remainingBytes,
+        header_string: headerString
+    };
+}
 
 module.exports = braidify

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-http",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "description": "An implementation of Braid-HTTP for Node.js and Browsers",
   "scripts": {
     "test": "node test/server.js"