www.aleph1.co.uk Git - yaffs-website/blob - node_modules/websocket-driver/lib/websocket/driver/hybi.js

   1 'use strict';
   2
   3 var crypto     = require('crypto'),
   4     util       = require('util'),
   5     Extensions = require('websocket-extensions'),
   6     Base       = require('./base'),
   7     Frame      = require('./hybi/frame'),
   8     Message    = require('./hybi/message');
   9
  10 var Hybi = function(request, url, options) {
  11   Base.apply(this, arguments);
  12
  13   this._extensions     = new Extensions();
  14   this._stage          = 0;
  15   this._masking        = this._options.masking;
  16   this._protocols      = this._options.protocols || [];
  17   this._requireMasking = this._options.requireMasking;
  18   this._pingCallbacks  = {};
  19
  20   if (typeof this._protocols === 'string')
  21     this._protocols = this._protocols.split(/ *, */);
  22
  23   if (!this._request) return;
  24
  25   var secKey    = this._request.headers['sec-websocket-key'],
  26       protos    = this._request.headers['sec-websocket-protocol'],
  27       version   = this._request.headers['sec-websocket-version'],
  28       supported = this._protocols;
  29
  30   this._headers.set('Upgrade', 'websocket');
  31   this._headers.set('Connection', 'Upgrade');
  32   this._headers.set('Sec-WebSocket-Accept', Hybi.generateAccept(secKey));
  33
  34   if (protos !== undefined) {
  35     if (typeof protos === 'string') protos = protos.split(/ *, */);
  36     this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
  37     if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol);
  38   }
  39
  40   this.version = 'hybi-' + version;
  41 };
  42 util.inherits(Hybi, Base);
  43
  44 Hybi.mask = function(payload, mask, offset) {
  45   if (!mask || mask.length === 0) return payload;
  46   offset = offset || 0;
  47
  48   for (var i = 0, n = payload.length - offset; i < n; i++) {
  49     payload[offset + i] = payload[offset + i] ^ mask[i % 4];
  50   }
  51   return payload;
  52 };
  53
  54 Hybi.generateAccept = function(key) {
  55   var sha1 = crypto.createHash('sha1');
  56   sha1.update(key + Hybi.GUID);
  57   return sha1.digest('base64');
  58 };
  59
  60 Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
  61
  62 var instance = {
  63   FIN:    0x80,
  64   MASK:   0x80,
  65   RSV1:   0x40,
  66   RSV2:   0x20,
  67   RSV3:   0x10,
  68   OPCODE: 0x0F,
  69   LENGTH: 0x7F,
  70
  71   OPCODES: {
  72     continuation: 0,
  73     text:         1,
  74     binary:       2,
  75     close:        8,
  76     ping:         9,
  77     pong:         10
  78   },
  79
  80   OPCODE_CODES:    [0, 1, 2, 8, 9, 10],
  81   MESSAGE_OPCODES: [0, 1, 2],
  82   OPENING_OPCODES: [1, 2],
  83
  84   ERRORS: {
  85     normal_closure:       1000,
  86     going_away:           1001,
  87     protocol_error:       1002,
  88     unacceptable:         1003,
  89     encoding_error:       1007,
  90     policy_violation:     1008,
  91     too_large:            1009,
  92     extension_error:      1010,
  93     unexpected_condition: 1011
  94   },
  95
  96   ERROR_CODES:        [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011],
  97   DEFAULT_ERROR_CODE: 1000,
  98   MIN_RESERVED_ERROR: 3000,
  99   MAX_RESERVED_ERROR: 4999,
 100
 101   // http://www.w3.org/International/questions/qa-forms-utf-8.en.php
 102   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})*$/,
 103
 104   addExtension: function(extension) {
 105     this._extensions.add(extension);
 106     return true;
 107   },
 108
 109   parse: function(chunk) {
 110     this._reader.put(chunk);
 111     var buffer = true;
 112     while (buffer) {
 113       switch (this._stage) {
 114         case 0:
 115           buffer = this._reader.read(1);
 116           if (buffer) this._parseOpcode(buffer[0]);
 117           break;
 118
 119         case 1:
 120           buffer = this._reader.read(1);
 121           if (buffer) this._parseLength(buffer[0]);
 122           break;
 123
 124         case 2:
 125           buffer = this._reader.read(this._frame.lengthBytes);
 126           if (buffer) this._parseExtendedLength(buffer);
 127           break;
 128
 129         case 3:
 130           buffer = this._reader.read(4);
 131           if (buffer) {
 132             this._stage = 4;
 133             this._frame.maskingKey = buffer;
 134           }
 135           break;
 136
 137         case 4:
 138           buffer = this._reader.read(this._frame.length);
 139           if (buffer) {
 140             this._stage = 0;
 141             this._emitFrame(buffer);
 142           }
 143           break;
 144
 145         default:
 146           buffer = null;
 147       }
 148     }
 149   },
 150
 151   text: function(message) {
 152     if (this.readyState > 1) return false;
 153     return this.frame(message, 'text');
 154   },
 155
 156   binary: function(message) {
 157     if (this.readyState > 1) return false;
 158     return this.frame(message, 'binary');
 159   },
 160
 161   ping: function(message, callback) {
 162     if (this.readyState > 1) return false;
 163     message = message || '';
 164     if (callback) this._pingCallbacks[message] = callback;
 165     return this.frame(message, 'ping');
 166   },
 167
 168   pong: function(message) {
 169       if (this.readyState > 1) return false;
 170       message = message ||'';
 171       return this.frame(message, 'pong');
 172   },
 173
 174   close: function(reason, code) {
 175     reason = reason || '';
 176     code   = code   || this.ERRORS.normal_closure;
 177
 178     if (this.readyState <= 0) {
 179       this.readyState = 3;
 180       this.emit('close', new Base.CloseEvent(code, reason));
 181       return true;
 182     } else if (this.readyState === 1) {
 183       this.readyState = 2;
 184       this._extensions.close(function() { this.frame(reason, 'close', code) }, this);
 185       return true;
 186     } else {
 187       return false;
 188     }
 189   },
 190
 191   frame: function(buffer, type, code) {
 192     if (this.readyState <= 0) return this._queue([buffer, type, code]);
 193     if (this.readyState > 2) return false;
 194
 195     if (buffer instanceof Array)    buffer = new Buffer(buffer);
 196     if (typeof buffer === 'number') buffer = buffer.toString();
 197
 198     var message = new Message(),
 199         isText  = (typeof buffer === 'string'),
 200         payload, copy;
 201
 202     message.rsv1   = message.rsv2 = message.rsv3 = false;
 203     message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')];
 204
 205     payload = isText ? new Buffer(buffer, 'utf8') : buffer;
 206
 207     if (code) {
 208       copy = payload;
 209       payload = new Buffer(2 + copy.length);
 210       payload.writeUInt16BE(code, 0);
 211       copy.copy(payload, 2);
 212     }
 213     message.data = payload;
 214
 215     var onMessageReady = function(message) {
 216       var frame = new Frame();
 217
 218       frame.final   = true;
 219       frame.rsv1    = message.rsv1;
 220       frame.rsv2    = message.rsv2;
 221       frame.rsv3    = message.rsv3;
 222       frame.opcode  = message.opcode;
 223       frame.masked  = !!this._masking;
 224       frame.length  = message.data.length;
 225       frame.payload = message.data;
 226
 227       if (frame.masked) frame.maskingKey = crypto.randomBytes(4);
 228
 229       this._sendFrame(frame);
 230     };
 231
 232     if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0)
 233       this._extensions.processOutgoingMessage(message, function(error, message) {
 234         if (error) return this._fail('extension_error', error.message);
 235         onMessageReady.call(this, message);
 236       }, this);
 237     else
 238       onMessageReady.call(this, message);
 239
 240     return true;
 241   },
 242
 243   _sendFrame: function(frame) {
 244     var length = frame.length,
 245         header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
 246         offset = header + (frame.masked ? 4 : 0),
 247         buffer = new Buffer(offset + length),
 248         masked = frame.masked ? this.MASK : 0;
 249
 250     buffer[0] = (frame.final ? this.FIN : 0) |
 251                 (frame.rsv1 ? this.RSV1 : 0) |
 252                 (frame.rsv2 ? this.RSV2 : 0) |
 253                 (frame.rsv3 ? this.RSV3 : 0) |
 254                 frame.opcode;
 255
 256     if (length <= 125) {
 257       buffer[1] = masked | length;
 258     } else if (length <= 65535) {
 259       buffer[1] = masked | 126;
 260       buffer.writeUInt16BE(length, 2);
 261     } else {
 262       buffer[1] = masked | 127;
 263       buffer.writeUInt32BE(Math.floor(length / 0x100000000), 2);
 264       buffer.writeUInt32BE(length % 0x100000000, 6);
 265     }
 266
 267     frame.payload.copy(buffer, offset);
 268
 269     if (frame.masked) {
 270       frame.maskingKey.copy(buffer, header);
 271       Hybi.mask(buffer, frame.maskingKey, offset);
 272     }
 273
 274     this._write(buffer);
 275   },
 276
 277   _handshakeResponse: function() {
 278     try {
 279       var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']);
 280     } catch (e) {
 281       return this._fail('protocol_error', e.message);
 282     }
 283
 284     if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions);
 285
 286     var start   = 'HTTP/1.1 101 Switching Protocols',
 287         headers = [start, this._headers.toString(), ''];
 288
 289     return new Buffer(headers.join('\r\n'), 'utf8');
 290   },
 291
 292   _shutdown: function(code, reason, error) {
 293     delete this._frame;
 294     delete this._message;
 295     this._stage = 5;
 296
 297     var sendCloseFrame = (this.readyState === 1);
 298     this.readyState = 2;
 299
 300     this._extensions.close(function() {
 301       if (sendCloseFrame) this.frame(reason, 'close', code);
 302       this.readyState = 3;
 303       if (error) this.emit('error', new Error(reason));
 304       this.emit('close', new Base.CloseEvent(code, reason));
 305     }, this);
 306   },
 307
 308   _fail: function(type, message) {
 309     if (this.readyState > 1) return;
 310     this._shutdown(this.ERRORS[type], message, true);
 311   },
 312
 313   _parseOpcode: function(octet) {
 314     var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
 315       return (octet & rsv) === rsv;
 316     });
 317
 318     var frame = this._frame = new Frame();
 319
 320     frame.final  = (octet & this.FIN) === this.FIN;
 321     frame.rsv1   = rsvs[0];
 322     frame.rsv2   = rsvs[1];
 323     frame.rsv3   = rsvs[2];
 324     frame.opcode = (octet & this.OPCODE);
 325
 326     this._stage = 1;
 327
 328     if (!this._extensions.validFrameRsv(frame))
 329       return this._fail('protocol_error',
 330           'One or more reserved bits are on: reserved1 = ' + (frame.rsv1 ? 1 : 0) +
 331           ', reserved2 = ' + (frame.rsv2 ? 1 : 0) +
 332           ', reserved3 = ' + (frame.rsv3 ? 1 : 0));
 333
 334     if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
 335       return this._fail('protocol_error', 'Unrecognized frame opcode: ' + frame.opcode);
 336
 337     if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && !frame.final)
 338       return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + frame.opcode);
 339
 340     if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
 341       return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
 342   },
 343
 344   _parseLength: function(octet) {
 345     var frame = this._frame;
 346     frame.masked = (octet & this.MASK) === this.MASK;
 347     frame.length = (octet & this.LENGTH);
 348
 349     if (frame.length >= 0 && frame.length <= 125) {
 350       this._stage = frame.masked ? 3 : 4;
 351       if (!this._checkFrameLength()) return;
 352     } else {
 353       this._stage = 2;
 354       frame.lengthBytes = (frame.length === 126 ? 2 : 8);
 355     }
 356
 357     if (this._requireMasking && !frame.masked)
 358       return this._fail('unacceptable', 'Received unmasked frame but masking is required');
 359   },
 360
 361   _parseExtendedLength: function(buffer) {
 362     var frame = this._frame;
 363     frame.length = this._readUInt(buffer);
 364
 365     this._stage = frame.masked ? 3 : 4;
 366
 367     if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125)
 368       return this._fail('protocol_error', 'Received control frame having too long payload: ' + frame.length);
 369
 370     if (!this._checkFrameLength()) return;
 371   },
 372
 373   _checkFrameLength: function() {
 374     var length = this._message ? this._message.length : 0;
 375
 376     if (length + this._frame.length > this._maxLength) {
 377       this._fail('too_large', 'WebSocket frame length too large');
 378       return false;
 379     } else {
 380       return true;
 381     }
 382   },
 383
 384   _emitFrame: function(buffer) {
 385     var frame   = this._frame,
 386         payload = frame.payload = Hybi.mask(buffer, frame.maskingKey),
 387         opcode  = frame.opcode,
 388         message,
 389         code, reason,
 390         callbacks, callback;
 391
 392     delete this._frame;
 393
 394     if (opcode === this.OPCODES.continuation) {
 395       if (!this._message) return this._fail('protocol_error', 'Received unexpected continuation frame');
 396       this._message.pushFrame(frame);
 397     }
 398
 399     if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
 400       this._message = new Message();
 401       this._message.pushFrame(frame);
 402     }
 403
 404     if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
 405       return this._emitMessage(this._message);
 406
 407     if (opcode === this.OPCODES.close) {
 408       code   = (payload.length >= 2) ? payload.readUInt16BE(0) : null;
 409       reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
 410
 411       if (!(payload.length === 0) &&
 412           !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) &&
 413           this.ERROR_CODES.indexOf(code) < 0)
 414         code = this.ERRORS.protocol_error;
 415
 416       if (payload.length > 125 || (payload.length > 2 && !reason))
 417         code = this.ERRORS.protocol_error;
 418
 419       this._shutdown(code || this.DEFAULT_ERROR_CODE, reason || '');
 420     }
 421
 422     if (opcode === this.OPCODES.ping) {
 423       this.frame(payload, 'pong');
 424     }
 425
 426     if (opcode === this.OPCODES.pong) {
 427       callbacks = this._pingCallbacks;
 428       message   = this._encode(payload);
 429       callback  = callbacks[message];
 430
 431       delete callbacks[message];
 432       if (callback) callback()
 433     }
 434   },
 435
 436   _emitMessage: function(message) {
 437     var message = this._message;
 438     message.read();
 439
 440     delete this._message;
 441
 442     this._extensions.processIncomingMessage(message, function(error, message) {
 443       if (error) return this._fail('extension_error', error.message);
 444
 445       var payload = message.data;
 446       if (message.opcode === this.OPCODES.text) payload = this._encode(payload);
 447
 448       if (payload === null)
 449         return this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
 450       else
 451         this.emit('message', new Base.MessageEvent(payload));
 452     }, this);
 453   },
 454
 455   _encode: function(buffer) {
 456     try {
 457       var string = buffer.toString('binary', 0, buffer.length);
 458       if (!this.UTF8_MATCH.test(string)) return null;
 459     } catch (e) {}
 460     return buffer.toString('utf8', 0, buffer.length);
 461   },
 462
 463   _readUInt: function(buffer) {
 464     if (buffer.length === 2) return buffer.readUInt16BE(0);
 465
 466     return buffer.readUInt32BE(0) * 0x100000000 +
 467            buffer.readUInt32BE(4);
 468   }
 469 };
 470
 471 for (var key in instance)
 472   Hybi.prototype[key] = instance[key];
 473
 474 module.exports = Hybi;