08-27-周三_17-09-29

node_modules/faye-websocket/lib/faye/eventsource.js

@@ -0,0 +1,110 @@
+var API   = require('./websocket/api'),
+    Event = require('./websocket/api/event');
+
+var isSecureConnection = function(request) {
+  if (request.headers['x-forwarded-proto']) {
+    return request.headers['x-forwarded-proto'] === 'https';
+  } else {
+    return (request.connection && request.connection.authorized !== undefined) ||
+           (request.socket && request.socket.secure);
+  }
+};
+
+var EventSource = function(request, response, options) {
+  options = options || {};
+
+  this._request  = request;
+  this._response = response;
+  this._stream   = response.socket;
+  this._ping     = options.ping  || this.DEFAULT_PING;
+  this._retry    = options.retry || this.DEFAULT_RETRY;
+
+  var scheme = isSecureConnection(request) ? 'https:' : 'http:';
+  this.url = scheme + '//' + request.headers.host + request.url;
+
+  this.lastEventId = request.headers['last-event-id'] || '';
+
+  var self = this;
+  this.readyState = API.CONNECTING;
+  this._sendBuffer = [];
+  process.nextTick(function() { self._open() });
+
+  var handshake = 'HTTP/1.1 200 OK\r\n' +
+                  'Content-Type: text/event-stream\r\n' +
+                  'Cache-Control: no-cache, no-store\r\n' +
+                  'Connection: close\r\n' +
+                  '\r\n\r\n' +
+                  'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
+
+  this.readyState = API.OPEN;
+
+  if (this._ping)
+    this._pingLoop = setInterval(function() { self.ping() }, this._ping * 1000);
+
+  if (!this._stream || !this._stream.writable) return;
+
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
+  try { this._stream.write(handshake, 'utf8') } catch (e) {}
+
+  ['close', 'end', 'error'].forEach(function(event) {
+    self._stream.addListener(event, function() { self.close() });
+  });
+};
+
+EventSource.isEventSource = function(request) {
+  var accept = (request.headers.accept || '').split(/\s*,\s*/);
+  return accept.indexOf('text/event-stream') >= 0;
+};
+
+var instance = {
+  DEFAULT_PING:   10,
+  DEFAULT_RETRY:  5,
+
+  send: function(message, options) {
+    if (this.readyState !== API.OPEN) return false;
+
+    message = String(message).replace(/(\r\n|\r|\n)/g, '$1data: ');
+    options = options || {};
+
+    var frame = '';
+    if (options.event) frame += 'event: ' + options.event + '\r\n';
+    if (options.id)    frame += 'id: '    + options.id    + '\r\n';
+    frame += 'data: ' + message + '\r\n\r\n';
+
+    try {
+      this._stream.write(frame, 'utf8');
+      return true;
+    } catch (e) {
+      return false;
+    }
+  },
+
+  ping: function() {
+    try {
+      this._stream.write(':\r\n\r\n', 'utf8');
+      return true;
+    } catch (e) {
+      return false;
+    }
+  },
+
+  close: function() {
+    if (this.readyState === API.CLOSING || this.readyState === API.CLOSED)
+      return;
+
+    this.readyState = API.CLOSED;
+    clearInterval(this._pingLoop);
+    this._response.end();
+
+    var event = new Event('close');
+    event.initEvent('close', false, false);
+    this.dispatchEvent(event);
+  }
+};
+
+for (var key in API) EventSource.prototype[key] = API[key];
+for (var key in instance) EventSource.prototype[key] = instance[key];
+module.exports = EventSource;
+

node_modules/faye-websocket/lib/faye/websocket.js

@@ -0,0 +1,93 @@
+// API and protocol references:
+// 
+// * http://dev.w3.org/html5/websockets/
+// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
+// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
+// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+// * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
+
+var Draft75Parser = require('./websocket/draft75_parser'),
+    Draft76Parser = require('./websocket/draft76_parser'),
+    HybiParser    = require('./websocket/hybi_parser'),
+    API           = require('./websocket/api'),
+    Event         = require('./websocket/api/event');
+
+var getParser = function(request) {
+  var headers = request.headers;
+  return headers['sec-websocket-version']
+       ? HybiParser
+       : (headers['sec-websocket-key1'] && headers['sec-websocket-key2'])
+       ? Draft76Parser
+       : Draft75Parser;
+};
+
+var isSecureConnection = function(request) {
+  if (request.headers['x-forwarded-proto']) {
+    return request.headers['x-forwarded-proto'] === 'https';
+  } else {
+    return (request.connection && request.connection.authorized !== undefined) ||
+           (request.socket && request.socket.secure);
+  }
+};
+
+var WebSocket = function(request, socket, head, supportedProtos, options) {
+  this.request = request;
+  this._stream = request.socket;
+  this._ping   = options && options.ping;
+  this._pingId = 0;
+
+  var scheme = isSecureConnection(request) ? 'wss:' : 'ws:';
+  this.url = scheme + '//' + request.headers.host + request.url;
+  this.readyState = API.CONNECTING;
+  this.bufferedAmount = 0;
+
+  var Parser = getParser(request);
+  this._parser = new Parser(this, {protocols: supportedProtos});
+
+  var self = this;
+  this._sendBuffer = [];
+  process.nextTick(function() { self._open() });
+
+  var handshake = this._parser.handshakeResponse(head);
+  if (this._parser.isOpen()) this.readyState = API.OPEN;
+
+  if (this._ping)
+    this._pingLoop = setInterval(function() {
+      self._pingId += 1;
+      self.ping(self._pingId.toString());
+    }, this._ping * 1000);
+
+  this.protocol = this._parser.protocol || '';
+  this.version = this._parser.getVersion();
+
+  if (!this._stream || !this._stream.writable) return;
+
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
+  try { this._stream.write(handshake, 'binary') } catch (e) {}
+
+  this._stream.addListener('data', function(data) {
+    var response = self._parser.parse(data);
+    if (!response) return;
+    try { self._stream.write(response, 'binary') } catch (e) {}
+    self._open();
+  });
+  ['close', 'end', 'error'].forEach(function(event) {
+    self._stream.addListener(event, function() { self.close(1006, '', false) });
+  });
+};
+
+WebSocket.prototype.ping = function(message, callback, context) {
+  if (!this._parser.ping) return false;
+  return this._parser.ping(message, callback, context);
+};
+
+for (var key in API) WebSocket.prototype[key] = API[key];
+
+WebSocket.WebSocket   = WebSocket;
+WebSocket.Client      = require('./websocket/client');
+WebSocket.EventSource = require('./eventsource');
+module.exports        = WebSocket;
+

node_modules/faye-websocket/lib/faye/websocket/api.js

@@ -0,0 +1,88 @@
+var EventTarget = require('./api/event_target'),
+    Event       = require('./api/event');
+
+var API = {
+  CONNECTING:   0,
+  OPEN:         1,
+  CLOSING:      2,
+  CLOSED:       3,
+
+  _open: function() {
+    if (this._parser && !this._parser.isOpen()) return;
+    this.readyState = API.OPEN;
+
+    var buffer = this._sendBuffer || [],
+        message;
+
+    while (message = buffer.shift())
+      this.send.apply(this, message);
+
+    var event = new Event('open');
+    event.initEvent('open', false, false);
+    this.dispatchEvent(event);
+  },
+
+  receive: function(data) {
+    if (this.readyState !== API.OPEN) return false;
+    var event = new Event('message');
+    event.initEvent('message', false, false);
+    event.data = data;
+    this.dispatchEvent(event);
+  },
+
+  send: function(data, type, errorType) {
+    if (this.readyState === API.CONNECTING) {
+      if (this._sendBuffer) {
+        this._sendBuffer.push(arguments);
+        return true;
+      } else {
+        throw new Error('Cannot call send(), socket is not open yet');
+      }
+    }
+
+    if (this.readyState === API.CLOSED)
+      return false;
+
+    if (!(data instanceof Buffer)) data = String(data);
+
+    var frame = this._parser.frame(data, type, errorType);
+    try {
+      this._stream.write(frame, 'binary');
+      return true;
+    } catch (e) {
+      return false;
+    }
+  },
+
+  close: function(code, reason, ack) {
+    if (this.readyState === API.CLOSED) return;
+    if (this.readyState === API.CLOSING && ack !== false) return;
+
+    var finalize = function() {
+      this.readyState = API.CLOSED;
+      if (this._pingLoop) clearInterval(this._pingLoop);
+      if (this._stream) this._stream.end();
+      var event = new Event('close', {code: code || 1000, reason: reason || ''});
+      event.initEvent('close', false, false);
+      this.dispatchEvent(event);
+    };
+
+    if (this.readyState === API.CONNECTING)
+      return finalize.call(this);
+
+    this.readyState = API.CLOSING;
+
+    if (ack === false) {
+      if (this._parser.close) this._parser.close(code, reason);
+      finalize.call(this);
+    } else {
+      if (this._parser.close) this._parser.close(code, reason, finalize, this);
+      else finalize.call(this);
+    }
+  }
+};
+
+for (var key in EventTarget) API[key] = EventTarget[key];
+
+module.exports = API;
+

node_modules/faye-websocket/lib/faye/websocket/api/event.js

@@ -0,0 +1,21 @@
+var Event = function(eventType, options) {
+  this.type = eventType;
+  for (var key in options)
+    this[key] = options[key];
+};
+
+Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
+  this.type       = eventType;
+  this.bubbles    = canBubble;
+  this.cancelable = cancelable;
+};
+
+Event.prototype.stopPropagation = function() {};
+Event.prototype.preventDefault  = function() {};
+
+Event.CAPTURING_PHASE = 1;
+Event.AT_TARGET       = 2;
+Event.BUBBLING_PHASE  = 3;
+
+module.exports = Event;
+

node_modules/faye-websocket/lib/faye/websocket/api/event_target.js

@@ -0,0 +1,47 @@
+var Event = require('./event');
+
+var EventTarget = {
+  onopen:     null,
+  onmessage:  null,
+  onerror:    null,
+  onclose:    null,
+
+  addEventListener: function(eventType, listener, useCapture) {
+    this._listeners = this._listeners || {};
+    var list = this._listeners[eventType] = this._listeners[eventType] || [];
+    list.push(listener);
+  },
+
+  removeEventListener: function(eventType, listener, useCapture) {
+    if (!this._listeners || !this._listeners[eventType]) return;
+
+    if (!listener) {
+      delete this._listeners[eventType];
+      return;
+    }
+    var list = this._listeners[eventType],
+        i    = list.length;
+
+    while (i--) {
+      if (listener !== list[i]) continue;
+      list.splice(i,1);
+    }
+  },
+
+  dispatchEvent: function(event) {
+    event.target = event.currentTarget = this;
+    event.eventPhase = Event.AT_TARGET;
+
+    if (this['on' + event.type])
+      this['on' + event.type](event);
+
+    if (!this._listeners || !this._listeners[event.type]) return;
+
+    this._listeners[event.type].forEach(function(listener) {
+      listener(event);
+    }, this);
+  }
+};
+
+module.exports = EventTarget;
+

node_modules/faye-websocket/lib/faye/websocket/client.js

@@ -0,0 +1,86 @@
+var net = require('net'),
+    tls = require('tls');
+
+var HybiParser = require('./hybi_parser'),
+    API        = require('./api'),
+    Event      = require('./api/event');
+
+var Client = function(url, protocols, options) {
+  this.url  = url;
+  this._uri = require('url').parse(url);
+
+  this.protocol = '';
+  this.readyState = API.CONNECTING;
+  this.bufferedAmount = 0;
+
+  var secure     = (this._uri.protocol === 'wss:'),
+      self       = this,
+      onConnect  = function() { self._onConnect() },
+      tlsOptions = {};
+
+  if (options && options.verify === false) tlsOptions.rejectUnauthorized = false;
+
+  var connection = secure
+                 ? tls.connect(this._uri.port || 443, this._uri.hostname, tlsOptions, onConnect)
+                 : net.createConnection(this._uri.port || 80, this._uri.hostname);
+
+  this._parser = new HybiParser(this, {masking: true, protocols: protocols});
+  this._stream = connection;
+
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
+  if (!secure) connection.addListener('connect', onConnect);
+
+  connection.addListener('data', function(data) {
+    self._onData(data);
+  });
+  ['close', 'end', 'error'].forEach(function(event) {
+    connection.addListener(event, function() { self.close(1006, '', false) });
+  });
+};
+
+Client.prototype._onConnect = function() {
+  this._handshake = this._parser.createHandshake(this._uri, this._stream);
+  this._message = [];
+  try {
+    this._stream.write(this._handshake.requestData(), 'binary');
+  } catch (e) {}
+};
+
+Client.prototype._onData = function(data) {
+  switch (this.readyState) {
+    case API.CONNECTING:
+      var bytes = this._handshake.parse(data);
+      for (var i = 0, n = bytes.length; i < n; i++)
+        this._message.push(bytes[i]);
+
+      if (!this._handshake.isComplete()) return;
+
+      if (this._handshake.isValid()) {
+        this.protocol = this._handshake.protocol || '';
+        this.readyState = API.OPEN;
+        var event = new Event('open');
+        event.initEvent('open', false, false);
+        this.dispatchEvent(event);
+
+        this._parser.parse(this._message);
+
+      } else {
+        this.readyState = API.CLOSED;
+        var event = new Event('close', {code: 1006, reason: ''});
+        event.initEvent('close', false, false);
+        this.dispatchEvent(event);
+      }
+      break;
+
+    case API.OPEN:
+    case API.CLOSING:
+      this._parser.parse(data);
+  }
+};
+
+for (var key in API) Client.prototype[key] = API[key];
+
+module.exports = Client;
+

node_modules/faye-websocket/lib/faye/websocket/draft75_parser.js

@@ -0,0 +1,98 @@
+var Draft75Parser = function(webSocket) {
+  this._socket = webSocket;
+  this._stage  = 0;
+};
+
+var instance = {
+  getVersion: function() {
+    return 'hixie-75';
+  },
+
+  handshakeResponse: function() {
+    return new Buffer('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
+                      'Upgrade: WebSocket\r\n' +
+                      'Connection: Upgrade\r\n' +
+                      'WebSocket-Origin: ' + this._socket.request.headers.origin + '\r\n' +
+                      'WebSocket-Location: ' + this._socket.url + '\r\n\r\n',
+                      'utf8');
+  },
+
+  isOpen: function() {
+    return true;
+  },
+
+  parse: function(buffer) {
+    var data, message, value;
+    for (var i = 0, n = buffer.length; i < n; i++) {
+      data = buffer[i];
+
+      switch (this._stage) {
+        case 0:
+          this._parseLeadingByte(data);
+          break;
+
+        case 1:
+          value = (data & 0x7F);
+          this._length = value + 128 * this._length;
+
+          if (this._closing && this._length === 0) {
+            this._socket.close(null, null, false);
+          }
+          else if ((0x80 & data) !== 0x80) {
+            if (this._length === 0) {
+              this._socket.receive('');
+              this._stage = 0;
+            }
+            else {
+              this._buffer = [];
+              this._stage = 2;
+            }
+          }
+          break;
+
+        case 2:
+          if (data === 0xFF) {
+            message = new Buffer(this._buffer);
+            this._socket.receive(message.toString('utf8', 0, this._buffer.length));
+            this._stage = 0;
+          }
+          else {
+            this._buffer.push(data);
+            if (this._length && this._buffer.length === this._length)
+              this._stage = 0;
+          }
+          break;
+      }
+    }
+  },
+
+  _parseLeadingByte: function(data) {
+    if ((0x80 & data) === 0x80) {
+      this._length = 0;
+      this._stage = 1;
+    } else {
+      delete this._length;
+      this._buffer = [];
+      this._stage = 2;
+    }
+  },
+
+  frame: function(data) {
+    if (Buffer.isBuffer(data)) return data;
+
+    var buffer = new Buffer(data, 'utf8'),
+        frame  = new Buffer(buffer.length + 2);
+
+    frame[0] = 0x00;
+    frame[buffer.length + 1] = 0xFF;
+    buffer.copy(frame, 1);
+
+    return frame;
+  }
+};
+
+for (var key in instance)
+  Draft75Parser.prototype[key] = instance[key];
+
+module.exports = Draft75Parser;
+

node_modules/faye-websocket/lib/faye/websocket/draft76_parser.js

@@ -0,0 +1,99 @@
+var crypto        = require('crypto'),
+    Draft75Parser = require('./draft75_parser'),
+    Draft76Parser = function() { Draft75Parser.apply(this, arguments) };
+
+var bridge = function() {};
+bridge.prototype = Draft75Parser.prototype;
+Draft76Parser.prototype = new bridge();
+
+var numberFromKey = function(key) {
+  return parseInt(key.match(/[0-9]/g).join(''), 10);
+};
+
+var spacesInKey = function(key) {
+  return key.match(/ /g).length;
+};
+
+var bigEndian = function(number) {
+  var string = '';
+  [24,16,8,0].forEach(function(offset) {
+    string += String.fromCharCode(number >> offset & 0xFF);
+  });
+  return string;
+};
+
+Draft76Parser.prototype.getVersion = function() {
+  return 'hixie-76';
+};
+
+Draft76Parser.prototype.handshakeResponse = function(head) {
+  var request = this._socket.request, tmp;
+
+  var response = new Buffer('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
+                            'Upgrade: WebSocket\r\n' +
+                            'Connection: Upgrade\r\n' +
+                            'Sec-WebSocket-Origin: ' + request.headers.origin + '\r\n' +
+                            'Sec-WebSocket-Location: ' + this._socket.url + '\r\n\r\n',
+                            'binary');
+
+  var signature = this.handshakeSignature(head);
+  if (signature) {
+    tmp = new Buffer(response.length + signature.length);
+    response.copy(tmp, 0);
+    signature.copy(tmp, response.length);
+    response = tmp;
+  }
+
+  return response;
+};
+
+Draft76Parser.prototype.isOpen = function() {
+  return !!this._handshakeComplete;
+};
+
+Draft76Parser.prototype.handshakeSignature = function(head) {
+  if (head.length === 0) return null;
+
+  var request = this._socket.request,
+
+      key1    = request.headers['sec-websocket-key1'],
+      value1  = numberFromKey(key1) / spacesInKey(key1),
+
+      key2    = request.headers['sec-websocket-key2'],
+      value2  = numberFromKey(key2) / spacesInKey(key2),
+
+      MD5     = crypto.createHash('md5');
+
+  MD5.update(bigEndian(value1));
+  MD5.update(bigEndian(value2));
+  MD5.update(head.toString('binary'));
+
+  this._handshakeComplete = true;
+  return new Buffer(MD5.digest('binary'), 'binary');
+};
+
+Draft76Parser.prototype.parse = function(data) {
+  if (this._handshakeComplete)
+    return Draft75Parser.prototype.parse.call(this, data);
+
+  return this.handshakeSignature(data);
+};
+
+Draft76Parser.prototype._parseLeadingByte = function(data) {
+  if (data !== 0xFF)
+    return Draft75Parser.prototype._parseLeadingByte.call(this, data);
+
+  this._closing = true;
+  this._length = 0;
+  this._stage = 1;
+};
+
+Draft76Parser.prototype.close = function(code, reason, callback, context) {
+  if (this._closed) return;
+  if (this._closing) this._socket.send(new Buffer([0xFF, 0x00]));
+  this._closed = true;
+  if (callback) callback.call(context);
+};
+
+module.exports = Draft76Parser;
+

node_modules/faye-websocket/lib/faye/websocket/hybi_parser.js

@@ -0,0 +1,355 @@
+var crypto    = require('crypto'),
+    Handshake = require('./hybi_parser/handshake'),
+    Reader    = require('./hybi_parser/stream_reader');
+
+var HybiParser = function(webSocket, options) {
+  this._reset();
+  this._socket    = webSocket;
+  this._reader    = new Reader();
+  this._stage     = 0;
+  this._masking   = options && options.masking;
+  this._protocols = options && options.protocols;
+
+  this._pingCallbacks = {};
+
+  if (typeof this._protocols === 'string')
+    this._protocols = this._protocols.split(/\s*,\s*/);
+};
+
+HybiParser.mask = function(payload, mask, offset) {
+  if (mask.length === 0) return payload;
+  offset = offset || 0;
+
+  for (var i = 0, n = payload.length - offset; i < n; i++) {
+    payload[offset + i] = payload[offset + i] ^ mask[i % 4];
+  }
+  return payload;
+};
+
+var instance = {
+  BYTE:   255,
+  FIN:    128,
+  MASK:   128,
+  RSV1:   64,
+  RSV2:   32,
+  RSV3:   16,
+  OPCODE: 15,
+  LENGTH: 127,
+
+  OPCODES: {
+    continuation: 0,
+    text:         1,
+    binary:       2,
+    close:        8,
+    ping:         9,
+    pong:         10
+  },
+
+  ERRORS: {
+    normal_closure:       1000,
+    going_away:           1001,
+    protocol_error:       1002,
+    unacceptable:         1003,
+    encoding_error:       1007,
+    policy_violation:     1008,
+    too_large:            1009,
+    extension_error:      1010,
+    unexpected_condition: 1011
+  },
+
+  FRAGMENTED_OPCODES: [0,1,2],
+  OPENING_OPCODES:    [1,2],
+
+  ERROR_CODES: [1000,1001,1002,1003,1007,1008,1009,1010,1011],
+
+  UTF8_MATCH: /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/,
+
+  getVersion: function() {
+    var version = this._socket.request.headers['sec-websocket-version'];
+    return 'hybi-' + version;
+  },
+
+  handshakeResponse: function() {
+    var secKey = this._socket.request.headers['sec-websocket-key'];
+    if (!secKey) return null;
+
+    var SHA1 = crypto.createHash('sha1');
+    SHA1.update(secKey + Handshake.GUID);
+
+    var accept    = SHA1.digest('base64'),
+        protos    = this._socket.request.headers['sec-websocket-protocol'],
+        supported = this._protocols,
+        proto,
+
+        headers = [
+          'HTTP/1.1 101 Switching Protocols',
+          'Upgrade: websocket',
+          'Connection: Upgrade',
+          'Sec-WebSocket-Accept: ' + accept
+        ];
+
+    if (protos !== undefined && supported !== undefined) {
+      if (typeof protos === 'string') protos = protos.split(/\s*,\s*/);
+      proto = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
+      if (proto) {
+        this.protocol = proto;
+        headers.push('Sec-WebSocket-Protocol: ' + proto);
+      }
+    }
+
+    return new Buffer(headers.concat('','').join('\r\n'), 'utf8');
+  },
+
+  isOpen: function() {
+    return true;
+  },
+
+  createHandshake: function(uri) {
+    return new Handshake(uri, this._protocols);
+  },
+
+  parse: function(data) {
+    this._reader.put(data);
+    var buffer = true;
+    while (buffer) {
+      switch (this._stage) {
+        case 0:
+          buffer = this._reader.read(1);
+          if (buffer) this._parseOpcode(buffer[0]);
+          break;
+
+        case 1:
+          buffer = this._reader.read(1);
+          if (buffer) this._parseLength(buffer[0]);
+          break;
+
+        case 2:
+          buffer = this._reader.read(this._lengthSize);
+          if (buffer) this._parseExtendedLength(buffer);
+          break;
+
+        case 3:
+          buffer = this._reader.read(4);
+          if (buffer) {
+            this._mask  = buffer;
+            this._stage = 4;
+          }
+          break;
+
+        case 4:
+          buffer = this._reader.read(this._length);
+          if (buffer) {
+            this._payload = buffer;
+            this._emitFrame();
+            this._stage = 0;
+          }
+          break;
+      }
+    }
+  },
+
+  _parseOpcode: function(data) {
+    var rsvs = [this.RSV1, this.RSV2, this.RSV3].filter(function(rsv) {
+      return (data & rsv) === rsv;
+    }, this);
+
+    if (rsvs.length > 0) return this._socket.close(this.ERRORS.protocol_error, null, false);
+
+    this._final   = (data & this.FIN) === this.FIN;
+    this._opcode  = (data & this.OPCODE);
+    this._mask    = [];
+    this._payload = [];
+
+    var valid = false;
+
+    for (var key in this.OPCODES) {
+      if (this.OPCODES[key] === this._opcode)
+        valid = true;
+    }
+    if (!valid) return this._socket.close(this.ERRORS.protocol_error, null, false);
+
+    if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && !this._final)
+      return this._socket.close(this.ERRORS.protocol_error, null, false);
+
+    if (this._mode && this.OPENING_OPCODES.indexOf(this._opcode) >= 0)
+      return this._socket.close(this.ERRORS.protocol_error, null, false);
+
+    this._stage = 1;
+  },
+
+  _parseLength: function(data) {
+    this._masked = (data & this.MASK) === this.MASK;
+    this._length = (data & this.LENGTH);
+
+    if (this._length >= 0 && this._length <= 125) {
+      this._stage = this._masked ? 3 : 4;
+    } else {
+      this._lengthBuffer = [];
+      this._lengthSize   = (this._length === 126 ? 2 : 8);
+      this._stage        = 2;
+    }
+  },
+
+  _parseExtendedLength: function(buffer) {
+    this._length = this._getInteger(buffer);
+    this._stage  = this._masked ? 3 : 4;
+  },
+
+  frame: function(data, type, code) {
+    if (this._closed) return null;
+
+    var isText = (typeof data === 'string'),
+        opcode = this.OPCODES[type || (isText ? 'text' : 'binary')],
+        buffer = isText ? new Buffer(data, 'utf8') : data,
+        insert = code ? 2 : 0,
+        length = buffer.length + insert,
+        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
+        offset = header + (this._masking ? 4 : 0),
+        masked = this._masking ? this.MASK : 0,
+        frame  = new Buffer(length + offset),
+        BYTE   = this.BYTE,
+        mask, i;
+
+    frame[0] = this.FIN | opcode;
+
+    if (length <= 125) {
+      frame[1] = masked | length;
+    } else if (length <= 65535) {
+      frame[1] = masked | 126;
+      frame[2] = Math.floor(length / 256);
+      frame[3] = length & BYTE;
+    } else {
+      frame[1] = masked | 127;
+      frame[2] = Math.floor(length / Math.pow(2,56)) & BYTE;
+      frame[3] = Math.floor(length / Math.pow(2,48)) & BYTE;
+      frame[4] = Math.floor(length / Math.pow(2,40)) & BYTE;
+      frame[5] = Math.floor(length / Math.pow(2,32)) & BYTE;
+      frame[6] = Math.floor(length / Math.pow(2,24)) & BYTE;
+      frame[7] = Math.floor(length / Math.pow(2,16)) & BYTE;
+      frame[8] = Math.floor(length / Math.pow(2,8))  & BYTE;
+      frame[9] = length & BYTE;
+    }
+
+    if (code) {
+      frame[offset]   = Math.floor(code / 256) & BYTE;
+      frame[offset+1] = code & BYTE;
+    }
+    buffer.copy(frame, offset + insert);
+
+    if (this._masking) {
+      mask = [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256),
+              Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)];
+      new Buffer(mask).copy(frame, header);
+      HybiParser.mask(frame, mask, offset);
+    }
+
+    return frame;
+  },
+
+  ping: function(message, callback, context) {
+    message = message || '';
+    if (callback) this._pingCallbacks[message] = [callback, context];
+    return this._socket.send(message, 'ping');
+  },
+
+  close: function(code, reason, callback, context) {
+    if (this._closed) return;
+    if (callback) this._closingCallback = [callback, context];
+    this._socket.send(reason || '', 'close', code || this.ERRORS.normal_closure);
+    this._closed = true;
+  },
+
+  buffer: function(fragment) {
+    for (var i = 0, n = fragment.length; i < n; i++)
+      this._buffer.push(fragment[i]);
+  },
+
+  _emitFrame: function() {
+    var payload = HybiParser.mask(this._payload, this._mask),
+        opcode  = this._opcode;
+
+    if (opcode === this.OPCODES.continuation) {
+      if (!this._mode) return this._socket.close(this.ERRORS.protocol_error, null, false);
+      this.buffer(payload);
+      if (this._final) {
+        var message = new Buffer(this._buffer);
+        if (this._mode === 'text') message = this._encode(message);
+        this._reset();
+        if (message !== null) this._socket.receive(message);
+        else this._socket.close(this.ERRORS.encoding_error, null, false);
+      }
+    }
+    else if (opcode === this.OPCODES.text) {
+      if (this._final) {
+        var message = this._encode(payload);
+        if (message !== null) this._socket.receive(message);
+        else this._socket.close(this.ERRORS.encoding_error, null, false);
+      } else {
+        this._mode = 'text';
+        this.buffer(payload);
+      }
+    }
+    else if (opcode === this.OPCODES.binary) {
+      if (this._final) {
+        this._socket.receive(payload);
+      } else {
+        this._mode = 'binary';
+        this.buffer(payload);
+      }
+    }
+    else if (opcode === this.OPCODES.close) {
+      var code   = (payload.length >= 2) ? 256 * payload[0] + payload[1] : null,
+          reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
+
+      if (!(payload.length === 0) &&
+          !(code !== null && code >= 3000 && code < 5000) &&
+          this.ERROR_CODES.indexOf(code) < 0)
+        code = this.ERRORS.protocol_error;
+
+      if (payload.length > 125 || (payload.length > 2 && !reason))
+        code = this.ERRORS.protocol_error;
+
+      this._socket.close(code, (payload.length > 2) ? reason : null, false);
+      if (this._closingCallback)
+        this._closingCallback[0].call(this._closingCallback[1]);
+    }
+    else if (opcode === this.OPCODES.ping) {
+      if (payload.length > 125) return this._socket.close(this.ERRORS.protocol_error, null, false);
+      this._socket.send(payload, 'pong');
+    }
+    else if (opcode === this.OPCODES.pong) {
+      var callbacks = this._pingCallbacks,
+          message   = this._encode(payload),
+          callback  = callbacks[message];
+
+      delete callbacks[message];
+      if (callback) callback[0].call(callback[1]);
+    }
+  },
+
+  _reset: function() {
+    this._mode   = null;
+    this._buffer = [];
+  },
+
+  _encode: function(buffer) {
+    try {
+      var string = buffer.toString('binary', 0, buffer.length);
+      if (!this.UTF8_MATCH.test(string)) return null;
+    } catch (e) {}
+    return buffer.toString('utf8', 0, buffer.length);
+  },
+
+  _getInteger: function(bytes) {
+    var number = 0;
+    for (var i = 0, n = bytes.length; i < n; i++)
+      number += bytes[i] << (8 * (n - 1 - i));
+    return number;
+  }
+};
+
+for (var key in instance)
+  HybiParser.prototype[key] = instance[key];
+
+module.exports = HybiParser;
+

node_modules/faye-websocket/lib/faye/websocket/hybi_parser/handshake.js

@@ -0,0 +1,91 @@
+var crypto = require('crypto');
+
+var Handshake = function(uri, protocols) {
+  this._uri = uri;
+  this._protocols = protocols;
+
+  var buffer = new Buffer(16), i = 16;
+  while (i--) buffer[i] = Math.floor(Math.random() * 256);
+  this._key = buffer.toString('base64');
+
+  var SHA1 = crypto.createHash('sha1');
+  SHA1.update(this._key + Handshake.GUID);
+  this._accept = SHA1.digest('base64');
+
+  var HTTPParser = process.binding('http_parser').HTTPParser,
+      parser     = new HTTPParser(HTTPParser.RESPONSE || 'response'),
+      current    = null,
+      self       = this;
+
+  this._nodeVersion = HTTPParser.RESPONSE ? 6 : 4;
+  this._complete    = false;
+  this._headers     = {};
+  this._parser      = parser;
+
+  parser.onHeaderField = function(b, start, length) {
+    current = b.toString('utf8', start, start + length);
+  };
+  parser.onHeaderValue = function(b, start, length) {
+    self._headers[current] = b.toString('utf8', start, start + length);
+  };
+  parser.onHeadersComplete = function(info) {
+    self._status = info.statusCode;
+    var headers = info.headers;
+    if (!headers) return;
+    for (var i = 0, n = headers.length; i < n; i += 2)
+      self._headers[headers[i]] = headers[i+1];
+  };
+  parser.onMessageComplete = function() {
+    self._complete = true;
+  };
+};
+
+Handshake.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+
+Handshake.prototype.requestData = function() {
+  var u = this._uri;
+
+  var headers = [
+    'GET ' + (u.pathname || '/') + (u.search || '') + ' HTTP/1.1',
+    'Host: ' + u.hostname + (u.port ? ':' + u.port : ''),
+    'Upgrade: websocket',
+    'Connection: Upgrade',
+    'Sec-WebSocket-Key: ' + this._key,
+    'Sec-WebSocket-Version: 13'
+  ];
+
+  if (this._protocols)
+    headers.push('Sec-WebSocket-Protocol: ' + this._protocols.join(', '));
+
+  return new Buffer(headers.concat('','').join('\r\n'), 'utf8');
+};
+
+Handshake.prototype.parse = function(data) {
+  var consumed = this._parser.execute(data, 0, data.length),
+      offset   = (this._nodeVersion < 6) ? 1 : 0;
+
+  return (consumed === data.length) ? [] : data.slice(consumed + offset);
+};
+
+Handshake.prototype.isComplete = function() {
+  return this._complete;
+};
+
+Handshake.prototype.isValid = function() {
+  if (this._status !== 101) return false;
+
+  var upgrade    = this._headers.Upgrade,
+      connection = this._headers.Connection,
+      protocol   = this._headers['Sec-WebSocket-Protocol'];
+
+  this.protocol = this._protocols && this._protocols.indexOf(protocol) >= 0
+                ? protocol
+                : null;
+
+  return upgrade && /^websocket$/i.test(upgrade) &&
+         connection && connection.split(/\s*,\s*/).indexOf('Upgrade') >= 0 &&
+         ((!this._protocols && !protocol) || this.protocol) &&
+         this._headers['Sec-WebSocket-Accept'] === this._accept;
+};
+
+module.exports = Handshake;

node_modules/faye-websocket/lib/faye/websocket/hybi_parser/stream_reader.js

@@ -0,0 +1,43 @@
+var StreamReader = function() {
+  this._queue  = [];
+  this._cursor = 0;
+};
+
+StreamReader.prototype.read = function(bytes) {
+  return this._readBuffer(bytes);
+};
+
+StreamReader.prototype.put = function(buffer) {
+  if (!buffer || buffer.length === 0) return;
+  if (!buffer.copy) buffer = new Buffer(buffer);
+  this._queue.push(buffer);
+};
+
+StreamReader.prototype._readBuffer = function(length) {
+  var buffer = new Buffer(length),
+      queue  = this._queue,
+      remain = length,
+      n      = queue.length,
+      i      = 0,
+      chunk, offset, size;
+
+  if (remain === 0) return buffer;
+
+  while (remain > 0 && i < n) {
+    chunk = queue[i];
+    offset = (i === 0) ? this._cursor : 0;
+    size = Math.min(remain, chunk.length - offset);
+    chunk.copy(buffer, length - remain, offset, offset + size);
+    remain -= size;
+    i += 1;
+  }
+
+  if (remain > 0) return null;
+
+  queue.splice(0, i-1);
+  this._cursor = (i === 1 ? this._cursor : 0) + size;
+
+  return buffer;
+};
+
+module.exports = StreamReader;