From ead5a713dae4fdb6671a722d9da823a1c5130eae Mon Sep 17 00:00:00 2001
From: AJ ONeal <awesome@coolaj86.com>
Date: Thu, 22 Sep 2016 11:06:34 -0600
Subject: [PATCH] works all-at-once and byte-by-byte

---
 machine.js      |  99 ++++++++++++++++++++++++++++++++++++------------
 sni.hello.bin   | Bin 0 -> 199 bytes
 test-machine.js |  56 +++++++++++++++++++++++++++
 3 files changed, 130 insertions(+), 25 deletions(-)
 create mode 100644 sni.hello.bin
 create mode 100644 test-machine.js

diff --git a/machine.js b/machine.js
index cb64140..3920a10 100644
--- a/machine.js
+++ b/machine.js
@@ -19,18 +19,26 @@ function debug(chunk, i, len) {
 }
 
 machine.fns.version = function (chunk) {
+  console.log('');
+  console.log('[version]');
   if ((255 - machine._version) !== chunk[machine.chunkIndex]) {
     console.error("not v" + machine._version + " (or data is corrupt)");
     // no idea how to fix this yet
   }
   machine.chunkIndex += 1;
+
+  return true;
 };
 
 
 machine.headerLen = 0;
 machine.fns.headerLength = function (chunk) {
+  console.log('');
+  console.log('[headerLength]');
   machine.headerLen = chunk[machine.chunkIndex];
   machine.chunkIndex += 1;
+
+  return true;
 };
 
 
@@ -38,9 +46,12 @@ machine.buf = null;
 machine.bufIndex = 0;
 //var buf = Buffer.alloc(4096);
 machine.fns.header = function (chunk) {
+  console.log('');
+  console.log('[header]');
   var curSize = machine.bufIndex + (chunk.length - machine.chunkIndex);
   var partLen = 0;
   var str = '';
+  var part;
 
   if (curSize < machine.headerLen) {
     // I still don't have the whole header,
@@ -48,66 +59,97 @@ machine.fns.header = function (chunk) {
     // write these bits, and wait for the next chunk.
     if (!machine.buf) {
       machine.buf = Buffer.alloc(machine.headerLen);
+      console.log('[1a] machine.headerLen:', machine.headerLen);
     }
-    partLen = machine.headerLen - machine.bufIndex;
-    machine.buf.write(chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen), machine.bufIndex);
+    // WHERE I STOPPED LAST NIGHT:
+    // partLen should be no more than the available size
+    partLen = Math.min(machine.headerLen - machine.bufIndex, chunk.length - machine.chunkIndex);
+    console.log('[1a] chunkIndex:', machine.chunkIndex);
+    console.log('[1a] chunk.length:', chunk.length);
+    console.log('[1a] partLen:', partLen);
+    console.log('[1a] bufIndex:', machine.bufIndex, typeof machine.bufIndex);
+    part = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
+    console.log('[1a] part:', part, typeof part);
+    //machine.buf.write(part.toString('binary'), machine.bufIndex, 'binary');
+    //part.copy(machine.buf, machine.bufIndex, machine.bufIndex, machine.bufIndex + part.length);
+    chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
     machine.chunkIndex += partLen; // this MUST be chunk.length
     machine.bufIndex += partLen;
+    console.log('[1a] chunkIndex:', machine.chunkIndex);
+    console.log('[1a] bufIndex:', machine.bufIndex);
+
+    return false;
   }
   else {
     // it's now ready to discover the whole header
     if (machine.buf) {
       str += machine.buf.slice(0, machine.bufIndex).toString();
     }
+    console.log('machine.headerLen:', machine.headerLen);
+    console.log('machine.chunkIndex:', machine.chunkIndex);
     partLen = machine.headerLen - str.length;
-    str += chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen).toString();
+    console.log('[1b] partLen:', partLen);
+    part = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
+    str += part.toString();
     machine.chunkIndex += partLen;
+    console.log('machine.chunkIndex:', machine.chunkIndex);
     // TODO maybe just use maxlen of buffer
     machine.buf = null; // back to null
     machine.bufIndex = 0; // back to 0
 
     machine._headers = str.split(/,/g);
-    console.log(partLen);
-    console.log('');
-    console.log(chunk.toString());
-    console.log('');
-    console.log(str);
-    console.log(machine._headers);
+    //console.log(chunk.toString());
+    console.log('str:', str);
+    console.log('headers:', machine._headers);
     machine.family = machine._headers[0];
     machine.address = machine._headers[1];
     machine.port = machine._headers[2];
-    machine.bodyLen = machine._headers[3];
+    machine.bodyLen = parseInt(machine._headers[3], 10) || -1;
+
+    return true;
   }
 };
 
 machine.fns.data = function (chunk) {
+  console.log('');
+  console.log('[data]');
   var curSize = machine.bufIndex + (chunk.length - machine.chunkIndex);
+  console.log('curSize:', curSize);
+  console.log('bodyLen:', machine.bodyLen, typeof machine.bodyLen);
   var partLen = 0;
   var buf;
 
+  partLen = Math.min(machine.bodyLen - machine.bufIndex, chunk.length - machine.chunkIndex);
+
   if (curSize < machine.bodyLen) {
+    console.log('curSize < bodyLen');
     // I still don't have the whole header,
     // so just create a large enough buffer,
     // write these bits, and wait for the next chunk.
     if (!machine.buf) {
       machine.buf = Buffer.alloc(machine.bodyLen);
     }
-    partLen = machine.bodyLen - machine.bufIndex;
-    machine.buf.write(chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen), machine.bufIndex);
-    //machine.chunkIndex += partLen; // this MUST be chunk.length
+    console.log('bufIndex:', machine.bufIndex);
+    console.log('chunkIndex:', machine.chunkIndex);
+    console.log('chunk.length:', chunk.length);
+    console.log('partLen:', partLen);
+    //machine.buf.write(chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen), machine.bufIndex);
+    chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
+    machine.chunkIndex += partLen; // this MUST be chunk.length
     machine.bufIndex += partLen;
-    return;
+    return false;
   }
 
-  // it's now ready to discover the whole header
+  // it's now ready to discover the whole body
   if (!machine.buf) {
-    buf = chunk;
-    machine.chunkIndex = chunk.length;
+    buf = chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen);
+    machine.chunkIndex += partLen;
   }
   else {
-    partLen = machine.bodyLen - machine.bufIndex;
-    machine.buf.write(chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen), machine.bufIndex);
+    //machine.buf.write(chunk.slice(machine.chunkIndex, machine.chunkIndex + partLen), machine.bufIndex);
+    chunk.copy(machine.buf, machine.bufIndex, machine.chunkIndex, machine.chunkIndex + partLen);
     machine.chunkIndex += partLen;
+    buf = machine.buf;
   }
 
   machine.onMessage({
@@ -120,19 +162,26 @@ machine.fns.data = function (chunk) {
   // TODO maybe just use maxlen of buffer
   machine.buf = null; // back to null
   machine.bufIndex = 0; // back to 0
+
+  return true;
 };
 machine.fns.addChunk = function (chunk) {
+  console.log('');
+  console.log('[addChunk]');
   machine.chunkIndex = 0;
   while (machine.chunkIndex < chunk.length) {
-    console.log(machine.state);
-    machine.fns[machine.states[machine.state]](chunk);
-    machine.state += 1;
-    machine.state %= machine.states_length;
+    console.log('chunkIndex:', machine.chunkIndex, 'state:', machine.state);
+
+    if (true === machine.fns[machine.states[machine.state]](chunk)) {
+      machine.state += 1;
+      machine.state %= machine.states_length;
+    }
   }
 };
 
 module.exports = machine;
 
-process.on('uncaughtException', function () {
-  debug(Buffer.from('0'));
+process.on('uncaughtException', function (err) {
+  console.error(err);
+  debug(Buffer.from([0]));
 });
diff --git a/sni.hello.bin b/sni.hello.bin
new file mode 100644
index 0000000000000000000000000000000000000000..85b03446ca75e33d245d1df0eb02c6a17342118c
GIT binary patch
literal 199
zcmWNKy-GrH07uXN{_oZ6O$|TLnzJv78<7q|(JM3+M2m%ea1|ZG#nDae0eXdoglG%m
zhf~ks(jY`bn-5TTKId>s)-W^hVeR>%e|lrTp8A!~gYO@|7QGGL_m<`7%iq*|KD>B^
zGyYW3h61JJYe(BEs-V2Kv?))ntg718s<O%uaZ7_kN*r@UoqYl&m6M}19xhW}cx1we
yalAhP)+s}=*Ns}8W-q*JwcE|B`-kwl+abUw5#zO3TEU5f3~2(-xW+NAb?iSPdNu6;

literal 0
HcmV?d00001

diff --git a/test-machine.js b/test-machine.js
new file mode 100644
index 0000000..863cb33
--- /dev/null
+++ b/test-machine.js
@@ -0,0 +1,56 @@
+'use strict';
+
+var sni = require('sni');
+var machine = require('./machine.js');
+var hello = require('fs').readFileSync('./sni.hello.bin');
+var version = 1;
+var header = 'IPv4,127.0.0.1,443,' + hello.byteLength;
+var buf = Buffer.concat([
+  Buffer.from([ 255 - version, header.length ])
+, Buffer.from(header)
+, hello
+]);
+
+console.log('sni(hello):', sni(hello));
+console.log('hello.byteLength:', hello.byteLength);
+
+var services = { 'ssh': 22, 'http': 4080, 'https': 8443 };
+//var clients = {};
+
+machine.onMessage = function (opts) {
+  var id = opts.family + ',' + opts.address + ',' + opts.port;
+  var service = 'https';
+  var port = services[service];
+
+  /*
+  if (clients[id]) {
+    clients[id].write(opts.data);
+    return;
+  }
+  */
+
+  var servername = sni(opts.data);
+
+  console.log('');
+  console.log('');
+  console.log('[onMessage]');
+  console.log('equal:', opts.data.equals(hello));
+  console.log('byteLength:', opts.data.byteLength);
+  console.log('port:', port);
+  if (!servername) {
+    console.warn("no servername found for '" + id + "'");
+    return;
+  }
+
+  console.log("servername: '" + servername + "'");
+};
+
+// full message in one go
+machine.fns.addChunk(buf);
+console.log('');
+console.log('');
+
+// messages one byte at a time
+buf.forEach(function (byte) {
+  machine.fns.addChunk(Buffer.from([ byte ]));
+});