pax_global_header00006660000000000000000000000064136617644120014524gustar00rootroot0000000000000052 comment=5f711f089234a46f8d1e50054115ea169257eaa4 websocket-driver-node-0.7.4/000077500000000000000000000000001366176441200157365ustar00rootroot00000000000000websocket-driver-node-0.7.4/.gitignore000066400000000000000000000000371366176441200177260ustar00rootroot00000000000000node_modules package-lock.json websocket-driver-node-0.7.4/.travis.yml000066400000000000000000000003771366176441200200560ustar00rootroot00000000000000sudo: false language: node_js node_js: - "0.8" - "0.10" - "0.12" - "4" - "5" - "6" - "7" - "8" - "9" - "10" - "11" - "12" - "13" - "14" before_install: - '[ "${TRAVIS_NODE_VERSION}" != "0.8" ] || npm install -g npm@~1.4.0' websocket-driver-node-0.7.4/CHANGELOG.md000066400000000000000000000100441366176441200175460ustar00rootroot00000000000000### 0.7.4 / 2020-05-22 - Avoid crashing if `process.version` does not contain any digits - Emit `ping` and `pong` events from the `Server` driver - Require http-parser-js >=0.5.1 which fixes the bug we addressed in 0.7.3 ### 0.7.3 / 2019-06-13 - Cap version of http-parser-js below 0.4.11, which introduced a bug that prevents us from handling messages that are part of the same input buffer as the handshake response if chunked encoding is specified ### 0.7.2 / 2019-06-13 (This version was pulled due to an error when publishing) ### 0.7.1 / 2019-06-10 - Catch any exceptions produced while generating a handshake response and send a `400 Bad Request` response to the client - Pick the RFC-6455 protocol version if the request contains any of the headers used by that version - Use the `Buffer.alloc()` and `Buffer.from()` functions instead of the unsafe `Buffer()` constructor - Handle errors encountered while handling malformed draft-76 requests - Change license from MIT to Apache 2.0 ### 0.7.0 / 2017-09-11 - Add `ping` and `pong` to the set of events users can listen to - Replace the bindings to Node's HTTP parser with `http-parser-js` ### 0.6.5 / 2016-05-20 - Don't mutate buffers passed in by the application when masking ### 0.6.4 / 2016-01-07 - If a number is given as input for a frame payload, send it as a string ### 0.6.3 / 2015-11-06 - Reject draft-76 handshakes if their Sec-WebSocket-Key headers are invalid - Throw a more helpful error if a client is created with an invalid URL ### 0.6.2 / 2015-07-18 - When the peer sends a close frame with no error code, emit 1000 ### 0.6.1 / 2015-07-13 - Use the `buffer.{read,write}UInt{16,32}BE` methods for reading/writing numbers to buffers rather than including duplicate logic for this ### 0.6.0 / 2015-07-08 - Allow the parser to recover cleanly if event listeners raise an error - Add a `pong` method for sending unsolicited pong frames ### 0.5.4 / 2015-03-29 - Don't emit extra close frames if we receive a close frame after we already sent one - Fail the connection when the driver receives an invalid `Sec-WebSocket-Extensions` header ### 0.5.3 / 2015-02-22 - Don't treat incoming data as WebSocket frames if a client driver is closed before receiving the server handshake ### 0.5.2 / 2015-02-19 - Fix compatibility with the HTTP parser on io.js - Use `websocket-extensions` to make sure messages and close frames are kept in order - Don't emit multiple `error` events ### 0.5.1 / 2014-12-18 - Don't allow drivers to be created with unrecognized options ### 0.5.0 / 2014-12-13 - Support protocol extensions via the websocket-extensions module ### 0.4.0 / 2014-11-08 - Support connection via HTTP proxies using `CONNECT` ### 0.3.6 / 2014-10-04 - It is now possible to call `close()` before `start()` and close the driver ### 0.3.5 / 2014-07-06 - Don't hold references to frame buffers after a message has been emitted - Make sure that `protocol` and `version` are exposed properly by the TCP driver ### 0.3.4 / 2014-05-08 - Don't hold memory-leaking references to I/O buffers after they have been parsed ### 0.3.3 / 2014-04-24 - Correct the draft-76 status line reason phrase ### 0.3.2 / 2013-12-29 - Expand `maxLength` to cover sequences of continuation frames and `draft-{75,76}` - Decrease default maximum frame buffer size to 64MB - Stop parsing when the protocol enters a failure mode, to save CPU cycles ### 0.3.1 / 2013-12-03 - Add a `maxLength` option to limit allowed frame size - Don't pre-allocate a message buffer until the whole frame has arrived - Fix compatibility with Node v0.11 `HTTPParser` ### 0.3.0 / 2013-09-09 - Support client URLs with Basic Auth credentials ### 0.2.2 / 2013-07-05 - No functional changes, just updates to package.json ### 0.2.1 / 2013-05-17 - Export the isSecureRequest() method since faye-websocket relies on it - Queue sent messages in the client's initial state ### 0.2.0 / 2013-05-12 - Add API for setting and reading headers - Add Driver.server() method for getting a driver for TCP servers ### 0.1.0 / 2013-05-04 - First stable release websocket-driver-node-0.7.4/CODE_OF_CONDUCT.md000066400000000000000000000002421366176441200205330ustar00rootroot00000000000000# Code of Conduct All projects under the [Faye](https://github.com/faye) umbrella are covered by the [Code of Conduct](https://github.com/faye/code-of-conduct). websocket-driver-node-0.7.4/LICENSE.md000066400000000000000000000010561366176441200173440ustar00rootroot00000000000000Copyright 2010-2020 James Coglan Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. websocket-driver-node-0.7.4/README.md000066400000000000000000000314321366176441200172200ustar00rootroot00000000000000# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.svg)](https://travis-ci.org/faye/websocket-driver-node) This module provides a complete implementation of the WebSocket protocols that can be hooked up to any I/O stream. It aims to simplify things by decoupling the protocol details from the I/O layer, such that users only need to implement code to stream data in and out of it without needing to know anything about how the protocol actually works. Think of it as a complete WebSocket system with pluggable I/O. Due to this design, you get a lot of things for free. In particular, if you hook this module up to some I/O object, it will do all of this for you: - Select the correct server-side driver to talk to the client - Generate and send both server- and client-side handshakes - Recognize when the handshake phase completes and the WS protocol begins - Negotiate subprotocol selection based on `Sec-WebSocket-Protocol` - Negotiate and use extensions via the [websocket-extensions](https://github.com/faye/websocket-extensions-node) module - Buffer sent messages until the handshake process is finished - Deal with proxies that defer delivery of the draft-76 handshake body - Notify you when the socket is open and closed and when messages arrive - Recombine fragmented messages - Dispatch text, binary, ping, pong and close frames - Manage the socket-closing handshake process - Automatically reply to ping frames with a matching pong - Apply masking to messages sent by the client This library was originally extracted from the [Faye](http://faye.jcoglan.com) project but now aims to provide simple WebSocket support for any Node-based project. ## Installation ``` $ npm install websocket-driver ``` ## Usage This module provides protocol drivers that have the same interface on the server and on the client. A WebSocket driver is an object with two duplex streams attached; one for incoming/outgoing messages and one for managing the wire protocol over an I/O stream. The full API is described below. ### Server-side with HTTP A Node webserver emits a special event for 'upgrade' requests, and this is where you should handle WebSockets. You first check whether the request is a WebSocket, and if so you can create a driver and attach the request's I/O stream to it. ```js var http = require('http'), websocket = require('websocket-driver'); var server = http.createServer(); server.on('upgrade', function(request, socket, body) { if (!websocket.isWebSocket(request)) return; var driver = websocket.http(request); driver.io.write(body); socket.pipe(driver.io).pipe(socket); driver.messages.on('data', function(message) { console.log('Got a message', message); }); driver.start(); }); ``` Note the line `driver.io.write(body)` - you must pass the `body` buffer to the socket driver in order to make certain versions of the protocol work. ### Server-side with TCP You can also handle WebSocket connections in a bare TCP server, if you're not using an HTTP server and don't want to implement HTTP parsing yourself. The driver will emit a `connect` event when a request is received, and at this point you can detect whether it's a WebSocket and handle it as such. Here's an example using the Node `net` module: ```js var net = require('net'), websocket = require('websocket-driver'); var server = net.createServer(function(connection) { var driver = websocket.server(); driver.on('connect', function() { if (websocket.isWebSocket(driver)) { driver.start(); } else { // handle other HTTP requests } }); driver.on('close', function() { connection.end() }); connection.on('error', function() {}); connection.pipe(driver.io).pipe(connection); driver.messages.pipe(driver.messages); }); server.listen(4180); ``` In the `connect` event, the driver gains several properties to describe the request, similar to a Node request object, such as `method`, `url` and `headers`. However you should remember it's not a real request object; you cannot write data to it, it only tells you what request data we parsed from the input. If the request has a body, it will be in the `driver.body` buffer, but only as much of the body as has been piped into the driver when the `connect` event fires. ### Client-side Similarly, to implement a WebSocket client you just need to make a driver by passing in a URL. After this you use the driver API as described below to process incoming data and send outgoing data. ```js var net = require('net'), websocket = require('websocket-driver'); var driver = websocket.client('ws://www.example.com/socket'), tcp = net.connect(80, 'www.example.com'); tcp.pipe(driver.io).pipe(tcp); tcp.on('connect', function() { driver.start(); }); driver.messages.on('data', function(message) { console.log('Got a message', message); }); ``` Client drivers have two additional properties for reading the HTTP data that was sent back by the server: - `driver.statusCode` - the integer value of the HTTP status code - `driver.headers` - an object containing the response headers ### HTTP Proxies The client driver supports connections via HTTP proxies using the `CONNECT` method. Instead of sending the WebSocket handshake immediately, it will send a `CONNECT` request, wait for a `200` response, and then proceed as normal. To use this feature, call `driver.proxy(url)` where `url` is the origin of the proxy, including a username and password if required. This produces a duplex stream that you should pipe in and out of your TCP connection to the proxy server. When the proxy emits `connect`, you can then pipe `driver.io` to your TCP stream and call `driver.start()`. ```js var net = require('net'), websocket = require('websocket-driver'); var driver = websocket.client('ws://www.example.com/socket'), proxy = driver.proxy('http://username:password@proxy.example.com'), tcp = net.connect(80, 'proxy.example.com'); tcp.pipe(proxy).pipe(tcp, { end: false }); tcp.on('connect', function() { proxy.start(); }); proxy.on('connect', function() { driver.io.pipe(tcp).pipe(driver.io); driver.start(); }); driver.messages.on('data', function(message) { console.log('Got a message', message); }); ``` The proxy's `connect` event is also where you should perform a TLS handshake on your TCP stream, if you are connecting to a `wss:` endpoint. In the event that proxy connection fails, `proxy` will emit an `error`. You can inspect the proxy's response via `proxy.statusCode` and `proxy.headers`. ```js proxy.on('error', function(error) { console.error(error.message); console.log(proxy.statusCode); console.log(proxy.headers); }); ``` Before calling `proxy.start()` you can set custom headers using `proxy.setHeader()`: ```js proxy.setHeader('User-Agent', 'node'); proxy.start(); ``` ### Driver API Drivers are created using one of the following methods: ```js driver = websocket.http(request, options) driver = websocket.server(options) driver = websocket.client(url, options) ``` The `http` method returns a driver chosen using the headers from a Node HTTP request object. The `server` method returns a driver that will parse an HTTP request and then decide which driver to use for it using the `http` method. The `client` method always returns a driver for the RFC version of the protocol with masking enabled on outgoing frames. The `options` argument is optional, and is an object. It may contain the following fields: - `maxLength` - the maximum allowed size of incoming message frames, in bytes. The default value is `2^26 - 1`, or 1 byte short of 64 MiB. - `protocols` - an array of strings representing acceptable subprotocols for use over the socket. The driver will negotiate one of these to use via the `Sec-WebSocket-Protocol` header if supported by the other peer. A driver has two duplex streams attached to it: - **`driver.io`** - this stream should be attached to an I/O socket like a TCP stream. Pipe incoming TCP chunks to this stream for them to be parsed, and pipe this stream back into TCP to send outgoing frames. - **`driver.messages`** - this stream emits messages received over the WebSocket. Writing to it sends messages to the other peer by emitting frames via the `driver.io` stream. All drivers respond to the following API methods, but some of them are no-ops depending on whether the client supports the behaviour. Note that most of these methods are commands: if they produce data that should be sent over the socket, they will give this to you by emitting `data` events on the `driver.io` stream. #### `driver.on('open', function(event) {})` Adds a callback to execute when the socket becomes open. #### `driver.on('message', function(event) {})` Adds a callback to execute when a message is received. `event` will have a `data` attribute containing either a string in the case of a text message or a `Buffer` in the case of a binary message. You can also listen for messages using the `driver.messages.on('data')` event, which emits strings for text messages and buffers for binary messages. #### `driver.on('error', function(event) {})` Adds a callback to execute when a protocol error occurs due to the other peer sending an invalid byte sequence. `event` will have a `message` attribute describing the error. #### `driver.on('close', function(event) {})` Adds a callback to execute when the socket becomes closed. The `event` object has `code` and `reason` attributes. #### `driver.on('ping', function(event) {})` Adds a callback block to execute when a ping is received. You do not need to handle this by sending a pong frame yourself; the driver handles this for you. #### `driver.on('pong', function(event) {})` Adds a callback block to execute when a pong is received. If this was in response to a ping you sent, you can also handle this event via the `driver.ping(message, function() { ... })` callback. #### `driver.addExtension(extension)` Registers a protocol extension whose operation will be negotiated via the `Sec-WebSocket-Extensions` header. `extension` is any extension compatible with the [websocket-extensions](https://github.com/faye/websocket-extensions-node) framework. #### `driver.setHeader(name, value)` Sets a custom header to be sent as part of the handshake response, either from the server or from the client. Must be called before `start()`, since this is when the headers are serialized and sent. #### `driver.start()` Initiates the protocol by sending the handshake - either the response for a server-side driver or the request for a client-side one. This should be the first method you invoke. Returns `true` if and only if a handshake was sent. #### `driver.parse(string)` Takes a string and parses it, potentially resulting in message events being emitted (see `on('message')` above) or in data being sent to `driver.io`. You should send all data you receive via I/O to this method by piping a stream into `driver.io`. #### `driver.text(string)` Sends a text message over the socket. If the socket handshake is not yet complete, the message will be queued until it is. Returns `true` if the message was sent or queued, and `false` if the socket can no longer send messages. This method is equivalent to `driver.messages.write(string)`. #### `driver.binary(buffer)` Takes a `Buffer` and sends it as a binary message. Will queue and return `true` or `false` the same way as the `text` method. It will also return `false` if the driver does not support binary messages. This method is equivalent to `driver.messages.write(buffer)`. #### `driver.ping(string = '', function() {})` Sends a ping frame over the socket, queueing it if necessary. `string` and the callback are both optional. If a callback is given, it will be invoked when the socket receives a pong frame whose content matches `string`. Returns `false` if frames can no longer be sent, or if the driver does not support ping/pong. #### `driver.pong(string = '')` Sends a pong frame over the socket, queueing it if necessary. `string` is optional. Returns `false` if frames can no longer be sent, or if the driver does not support ping/pong. You don't need to call this when a ping frame is received; pings are replied to automatically by the driver. This method is for sending unsolicited pongs. #### `driver.close()` Initiates the closing handshake if the socket is still open. For drivers with no closing handshake, this will result in the immediate execution of the `on('close')` driver. For drivers with a closing handshake, this sends a closing frame and `emit('close')` will execute when a response is received or a protocol error occurs. #### `driver.version` Returns the WebSocket version in use as a string. Will either be `hixie-75`, `hixie-76` or `hybi-$version`. #### `driver.protocol` Returns a string containing the selected subprotocol, if any was agreed upon using the `Sec-WebSocket-Protocol` mechanism. This value becomes available after `emit('open')` has fired. websocket-driver-node-0.7.4/examples/000077500000000000000000000000001366176441200175545ustar00rootroot00000000000000websocket-driver-node-0.7.4/examples/net_client.js000066400000000000000000000013571366176441200222440ustar00rootroot00000000000000'use strict'; var net = require('net'), url = require('url'), websocket = require('..'), deflate = require('permessage-deflate'); var DEFAULT_PORTS = { 'ws:': 80, 'wss:': 443 }; var uri = url.parse(process.argv[2]), port = uri.port || DEFAULT_PORTS[uri.protocol], conn = net.connect({ host: uri.hostname, port: port }); var driver = websocket.client(uri.href); driver.addExtension(deflate); driver.on('open', function() { driver.text('Hello, world'); }); driver.on('message', function(event) { console.log(['message', event.data]); }); driver.on('close', function(event) { console.log(['close', event.code, event.reason]); conn.end(); }); conn.pipe(driver.io); driver.io.pipe(conn); driver.start(); websocket-driver-node-0.7.4/examples/net_server.js000066400000000000000000000011051366176441200222630ustar00rootroot00000000000000'use strict'; var net = require('net'), websocket = require('..'), deflate = require('permessage-deflate'); var server = net.createServer(function(connection) { var driver = websocket.server(); driver.addExtension(deflate); driver.on('connect', function() { if (websocket.isWebSocket(driver)) driver.start(); }); driver.on('close', function() { connection.end() }); connection.on('error', function() {}); connection.pipe(driver.io); driver.io.pipe(connection); driver.messages.pipe(driver.messages); }); server.listen(process.argv[2]); websocket-driver-node-0.7.4/lib/000077500000000000000000000000001366176441200165045ustar00rootroot00000000000000websocket-driver-node-0.7.4/lib/websocket/000077500000000000000000000000001366176441200204725ustar00rootroot00000000000000websocket-driver-node-0.7.4/lib/websocket/driver.js000066400000000000000000000021211366176441200223170ustar00rootroot00000000000000'use strict'; // Protocol references: // // * 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 Base = require('./driver/base'), Client = require('./driver/client'), Server = require('./driver/server'); var Driver = { client: function(url, options) { options = options || {}; if (options.masking === undefined) options.masking = true; return new Client(url, options); }, server: function(options) { options = options || {}; if (options.requireMasking === undefined) options.requireMasking = true; return new Server(options); }, http: function() { return Server.http.apply(Server, arguments); }, isSecureRequest: function(request) { return Server.isSecureRequest(request); }, isWebSocket: function(request) { return Base.isWebSocket(request); }, validateOptions: function(options, validKeys) { Base.validateOptions(options, validKeys); } }; module.exports = Driver; websocket-driver-node-0.7.4/lib/websocket/driver/000077500000000000000000000000001366176441200217655ustar00rootroot00000000000000websocket-driver-node-0.7.4/lib/websocket/driver/base.js000066400000000000000000000110531366176441200232350ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer, Emitter = require('events').EventEmitter, util = require('util'), streams = require('../streams'), Headers = require('./headers'), Reader = require('./stream_reader'); var Base = function(request, url, options) { Emitter.call(this); Base.validateOptions(options || {}, ['maxLength', 'masking', 'requireMasking', 'protocols']); this._request = request; this._reader = new Reader(); this._options = options || {}; this._maxLength = this._options.maxLength || this.MAX_LENGTH; this._headers = new Headers(); this.__queue = []; this.readyState = 0; this.url = url; this.io = new streams.IO(this); this.messages = new streams.Messages(this); this._bindEventListeners(); }; util.inherits(Base, Emitter); Base.isWebSocket = function(request) { var connection = request.headers.connection || '', upgrade = request.headers.upgrade || ''; return request.method === 'GET' && connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 && upgrade.toLowerCase() === 'websocket'; }; Base.validateOptions = function(options, validKeys) { for (var key in options) { if (validKeys.indexOf(key) < 0) throw new Error('Unrecognized option: ' + key); } }; var instance = { // This is 64MB, small enough for an average VPS to handle without // crashing from process out of memory MAX_LENGTH: 0x3ffffff, STATES: ['connecting', 'open', 'closing', 'closed'], _bindEventListeners: function() { var self = this; // Protocol errors are informational and do not have to be handled this.messages.on('error', function() {}); this.on('message', function(event) { var messages = self.messages; if (messages.readable) messages.emit('data', event.data); }); this.on('error', function(error) { var messages = self.messages; if (messages.readable) messages.emit('error', error); }); this.on('close', function() { var messages = self.messages; if (!messages.readable) return; messages.readable = messages.writable = false; messages.emit('end'); }); }, getState: function() { return this.STATES[this.readyState] || null; }, addExtension: function(extension) { return false; }, setHeader: function(name, value) { if (this.readyState > 0) return false; this._headers.set(name, value); return true; }, start: function() { if (this.readyState !== 0) return false; if (!Base.isWebSocket(this._request)) return this._failHandshake(new Error('Not a WebSocket request')); var response; try { response = this._handshakeResponse(); } catch (error) { return this._failHandshake(error); } this._write(response); if (this._stage !== -1) this._open(); return true; }, _failHandshake: function(error) { var headers = new Headers(); headers.set('Content-Type', 'text/plain'); headers.set('Content-Length', Buffer.byteLength(error.message, 'utf8')); headers = ['HTTP/1.1 400 Bad Request', headers.toString(), error.message]; this._write(Buffer.from(headers.join('\r\n'), 'utf8')); this._fail('protocol_error', error.message); return false; }, text: function(message) { return this.frame(message); }, binary: function(message) { return false; }, ping: function() { return false; }, pong: function() { return false; }, close: function(reason, code) { if (this.readyState !== 1) return false; this.readyState = 3; this.emit('close', new Base.CloseEvent(null, null)); return true; }, _open: function() { this.readyState = 1; this.__queue.forEach(function(args) { this.frame.apply(this, args) }, this); this.__queue = []; this.emit('open', new Base.OpenEvent()); }, _queue: function(message) { this.__queue.push(message); return true; }, _write: function(chunk) { var io = this.io; if (io.readable) io.emit('data', chunk); }, _fail: function(type, message) { this.readyState = 2; this.emit('error', new Error(message)); this.close(); } }; for (var key in instance) Base.prototype[key] = instance[key]; Base.ConnectEvent = function() {}; Base.OpenEvent = function() {}; Base.CloseEvent = function(code, reason) { this.code = code; this.reason = reason; }; Base.MessageEvent = function(data) { this.data = data; }; Base.PingEvent = function(data) { this.data = data; }; Base.PongEvent = function(data) { this.data = data; }; module.exports = Base; websocket-driver-node-0.7.4/lib/websocket/driver/client.js000066400000000000000000000103421366176441200236010ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer, crypto = require('crypto'), url = require('url'), util = require('util'), HttpParser = require('../http_parser'), Base = require('./base'), Hybi = require('./hybi'), Proxy = require('./proxy'); var Client = function(_url, options) { this.version = 'hybi-' + Hybi.VERSION; Hybi.call(this, null, _url, options); this.readyState = -1; this._key = Client.generateKey(); this._accept = Hybi.generateAccept(this._key); this._http = new HttpParser('response'); var uri = url.parse(this.url), auth = uri.auth && Buffer.from(uri.auth, 'utf8').toString('base64'); if (this.VALID_PROTOCOLS.indexOf(uri.protocol) < 0) throw new Error(this.url + ' is not a valid WebSocket URL'); this._pathname = (uri.pathname || '/') + (uri.search || ''); this._headers.set('Host', uri.host); this._headers.set('Upgrade', 'websocket'); this._headers.set('Connection', 'Upgrade'); this._headers.set('Sec-WebSocket-Key', this._key); this._headers.set('Sec-WebSocket-Version', Hybi.VERSION); if (this._protocols.length > 0) this._headers.set('Sec-WebSocket-Protocol', this._protocols.join(', ')); if (auth) this._headers.set('Authorization', 'Basic ' + auth); }; util.inherits(Client, Hybi); Client.generateKey = function() { return crypto.randomBytes(16).toString('base64'); }; var instance = { VALID_PROTOCOLS: ['ws:', 'wss:'], proxy: function(origin, options) { return new Proxy(this, origin, options); }, start: function() { if (this.readyState !== -1) return false; this._write(this._handshakeRequest()); this.readyState = 0; return true; }, parse: function(chunk) { if (this.readyState === 3) return; if (this.readyState > 0) return Hybi.prototype.parse.call(this, chunk); this._http.parse(chunk); if (!this._http.isComplete()) return; this._validateHandshake(); if (this.readyState === 3) return; this._open(); this.parse(this._http.body); }, _handshakeRequest: function() { var extensions = this._extensions.generateOffer(); if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions); var start = 'GET ' + this._pathname + ' HTTP/1.1', headers = [start, this._headers.toString(), '']; return Buffer.from(headers.join('\r\n'), 'utf8'); }, _failHandshake: function(message) { message = 'Error during WebSocket handshake: ' + message; this.readyState = 3; this.emit('error', new Error(message)); this.emit('close', new Base.CloseEvent(this.ERRORS.protocol_error, message)); }, _validateHandshake: function() { this.statusCode = this._http.statusCode; this.headers = this._http.headers; if (this._http.error) return this._failHandshake(this._http.error.message); if (this._http.statusCode !== 101) return this._failHandshake('Unexpected response code: ' + this._http.statusCode); var headers = this._http.headers, upgrade = headers['upgrade'] || '', connection = headers['connection'] || '', accept = headers['sec-websocket-accept'] || '', protocol = headers['sec-websocket-protocol'] || ''; if (upgrade === '') return this._failHandshake("'Upgrade' header is missing"); if (upgrade.toLowerCase() !== 'websocket') return this._failHandshake("'Upgrade' header value is not 'WebSocket'"); if (connection === '') return this._failHandshake("'Connection' header is missing"); if (connection.toLowerCase() !== 'upgrade') return this._failHandshake("'Connection' header value is not 'Upgrade'"); if (accept !== this._accept) return this._failHandshake('Sec-WebSocket-Accept mismatch'); this.protocol = null; if (protocol !== '') { if (this._protocols.indexOf(protocol) < 0) return this._failHandshake('Sec-WebSocket-Protocol mismatch'); else this.protocol = protocol; } try { this._extensions.activate(this.headers['sec-websocket-extensions']); } catch (e) { return this._failHandshake(e.message); } } }; for (var key in instance) Client.prototype[key] = instance[key]; module.exports = Client; websocket-driver-node-0.7.4/lib/websocket/driver/draft75.js000066400000000000000000000060401366176441200235770ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer, Base = require('./base'), util = require('util'); var Draft75 = function(request, url, options) { Base.apply(this, arguments); this._stage = 0; this.version = 'hixie-75'; this._headers.set('Upgrade', 'WebSocket'); this._headers.set('Connection', 'Upgrade'); this._headers.set('WebSocket-Origin', this._request.headers.origin); this._headers.set('WebSocket-Location', this.url); }; util.inherits(Draft75, Base); var instance = { close: function() { if (this.readyState === 3) return false; this.readyState = 3; this.emit('close', new Base.CloseEvent(null, null)); return true; }, parse: function(chunk) { if (this.readyState > 1) return; this._reader.put(chunk); this._reader.eachByte(function(octet) { var message; switch (this._stage) { case -1: this._body.push(octet); this._sendHandshakeBody(); break; case 0: this._parseLeadingByte(octet); break; case 1: this._length = (octet & 0x7F) + 128 * this._length; if (this._closing && this._length === 0) { return this.close(); } else if ((octet & 0x80) !== 0x80) { if (this._length === 0) { this._stage = 0; } else { this._skipped = 0; this._stage = 2; } } break; case 2: if (octet === 0xFF) { this._stage = 0; message = Buffer.from(this._buffer).toString('utf8', 0, this._buffer.length); this.emit('message', new Base.MessageEvent(message)); } else { if (this._length) { this._skipped += 1; if (this._skipped === this._length) this._stage = 0; } else { this._buffer.push(octet); if (this._buffer.length > this._maxLength) return this.close(); } } break; } }, this); }, frame: function(buffer) { if (this.readyState === 0) return this._queue([buffer]); if (this.readyState > 1) return false; if (typeof buffer !== 'string') buffer = buffer.toString(); var length = Buffer.byteLength(buffer), frame = Buffer.allocUnsafe(length + 2); frame[0] = 0x00; frame.write(buffer, 1); frame[frame.length - 1] = 0xFF; this._write(frame); return true; }, _handshakeResponse: function() { var start = 'HTTP/1.1 101 Web Socket Protocol Handshake', headers = [start, this._headers.toString(), '']; return Buffer.from(headers.join('\r\n'), 'utf8'); }, _parseLeadingByte: function(octet) { if ((octet & 0x80) === 0x80) { this._length = 0; this._stage = 1; } else { delete this._length; delete this._skipped; this._buffer = []; this._stage = 2; } } }; for (var key in instance) Draft75.prototype[key] = instance[key]; module.exports = Draft75; websocket-driver-node-0.7.4/lib/websocket/driver/draft76.js000066400000000000000000000061621366176441200236050ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer, Base = require('./base'), Draft75 = require('./draft75'), crypto = require('crypto'), util = require('util'); var numberFromKey = function(key) { return parseInt((key.match(/[0-9]/g) || []).join(''), 10); }; var spacesInKey = function(key) { return (key.match(/ /g) || []).length; }; var Draft76 = function(request, url, options) { Draft75.apply(this, arguments); this._stage = -1; this._body = []; this.version = 'hixie-76'; this._headers.clear(); this._headers.set('Upgrade', 'WebSocket'); this._headers.set('Connection', 'Upgrade'); this._headers.set('Sec-WebSocket-Origin', this._request.headers.origin); this._headers.set('Sec-WebSocket-Location', this.url); }; util.inherits(Draft76, Draft75); var instance = { BODY_SIZE: 8, start: function() { if (!Draft75.prototype.start.call(this)) return false; this._started = true; this._sendHandshakeBody(); return true; }, close: function() { if (this.readyState === 3) return false; if (this.readyState === 1) this._write(Buffer.from([0xFF, 0x00])); this.readyState = 3; this.emit('close', new Base.CloseEvent(null, null)); return true; }, _handshakeResponse: function() { var headers = this._request.headers, key1 = headers['sec-websocket-key1'], key2 = headers['sec-websocket-key2']; if (!key1) throw new Error('Missing required header: Sec-WebSocket-Key1'); if (!key2) throw new Error('Missing required header: Sec-WebSocket-Key2'); var number1 = numberFromKey(key1), spaces1 = spacesInKey(key1), number2 = numberFromKey(key2), spaces2 = spacesInKey(key2); if (number1 % spaces1 !== 0 || number2 % spaces2 !== 0) throw new Error('Client sent invalid Sec-WebSocket-Key headers'); this._keyValues = [number1 / spaces1, number2 / spaces2]; var start = 'HTTP/1.1 101 WebSocket Protocol Handshake', headers = [start, this._headers.toString(), '']; return Buffer.from(headers.join('\r\n'), 'binary'); }, _handshakeSignature: function() { if (this._body.length < this.BODY_SIZE) return null; var md5 = crypto.createHash('md5'), buffer = Buffer.allocUnsafe(8 + this.BODY_SIZE); buffer.writeUInt32BE(this._keyValues[0], 0); buffer.writeUInt32BE(this._keyValues[1], 4); Buffer.from(this._body).copy(buffer, 8, 0, this.BODY_SIZE); md5.update(buffer); return Buffer.from(md5.digest('binary'), 'binary'); }, _sendHandshakeBody: function() { if (!this._started) return; var signature = this._handshakeSignature(); if (!signature) return; this._write(signature); this._stage = 0; this._open(); if (this._body.length > this.BODY_SIZE) this.parse(this._body.slice(this.BODY_SIZE)); }, _parseLeadingByte: function(octet) { if (octet !== 0xFF) return Draft75.prototype._parseLeadingByte.call(this, octet); this._closing = true; this._length = 0; this._stage = 1; } }; for (var key in instance) Draft76.prototype[key] = instance[key]; module.exports = Draft76; websocket-driver-node-0.7.4/lib/websocket/driver/headers.js000066400000000000000000000014571366176441200237450ustar00rootroot00000000000000'use strict'; var Headers = function() { this.clear(); }; Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate']; Headers.prototype.clear = function() { this._sent = {}; this._lines = []; }; Headers.prototype.set = function(name, value) { if (value === undefined) return; name = this._strip(name); value = this._strip(value); var key = name.toLowerCase(); if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) >= 0) { this._sent[key] = true; this._lines.push(name + ': ' + value + '\r\n'); } }; Headers.prototype.toString = function() { return this._lines.join(''); }; Headers.prototype._strip = function(string) { return string.toString().replace(/^ */, '').replace(/ *$/, ''); }; module.exports = Headers; websocket-driver-node-0.7.4/lib/websocket/driver/hybi.js000066400000000000000000000341441366176441200232640ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer, crypto = require('crypto'), util = require('util'), Extensions = require('websocket-extensions'), Base = require('./base'), Frame = require('./hybi/frame'), Message = require('./hybi/message'); var Hybi = function(request, url, options) { Base.apply(this, arguments); this._extensions = new Extensions(); this._stage = 0; this._masking = this._options.masking; this._protocols = this._options.protocols || []; this._requireMasking = this._options.requireMasking; this._pingCallbacks = {}; if (typeof this._protocols === 'string') this._protocols = this._protocols.split(/ *, */); if (!this._request) return; var protos = this._request.headers['sec-websocket-protocol'], supported = this._protocols; if (protos !== undefined) { if (typeof protos === 'string') protos = protos.split(/ *, */); this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0]; } this.version = 'hybi-' + Hybi.VERSION; }; util.inherits(Hybi, Base); Hybi.VERSION = '13'; Hybi.mask = function(payload, mask, offset) { if (!mask || 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; }; Hybi.generateAccept = function(key) { var sha1 = crypto.createHash('sha1'); sha1.update(key + Hybi.GUID); return sha1.digest('base64'); }; Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'; var instance = { FIN: 0x80, MASK: 0x80, RSV1: 0x40, RSV2: 0x20, RSV3: 0x10, OPCODE: 0x0F, LENGTH: 0x7F, OPCODES: { continuation: 0, text: 1, binary: 2, close: 8, ping: 9, pong: 10 }, OPCODE_CODES: [0, 1, 2, 8, 9, 10], MESSAGE_OPCODES: [0, 1, 2], OPENING_OPCODES: [1, 2], 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 }, ERROR_CODES: [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011], DEFAULT_ERROR_CODE: 1000, MIN_RESERVED_ERROR: 3000, MAX_RESERVED_ERROR: 4999, // http://www.w3.org/International/questions/qa-forms-utf-8.en.php 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})*$/, addExtension: function(extension) { this._extensions.add(extension); return true; }, parse: function(chunk) { this._reader.put(chunk); 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._frame.lengthBytes); if (buffer) this._parseExtendedLength(buffer); break; case 3: buffer = this._reader.read(4); if (buffer) { this._stage = 4; this._frame.maskingKey = buffer; } break; case 4: buffer = this._reader.read(this._frame.length); if (buffer) { this._stage = 0; this._emitFrame(buffer); } break; default: buffer = null; } } }, text: function(message) { if (this.readyState > 1) return false; return this.frame(message, 'text'); }, binary: function(message) { if (this.readyState > 1) return false; return this.frame(message, 'binary'); }, ping: function(message, callback) { if (this.readyState > 1) return false; message = message || ''; if (callback) this._pingCallbacks[message] = callback; return this.frame(message, 'ping'); }, pong: function(message) { if (this.readyState > 1) return false; message = message ||''; return this.frame(message, 'pong'); }, close: function(reason, code) { reason = reason || ''; code = code || this.ERRORS.normal_closure; if (this.readyState <= 0) { this.readyState = 3; this.emit('close', new Base.CloseEvent(code, reason)); return true; } else if (this.readyState === 1) { this.readyState = 2; this._extensions.close(function() { this.frame(reason, 'close', code) }, this); return true; } else { return false; } }, frame: function(buffer, type, code) { if (this.readyState <= 0) return this._queue([buffer, type, code]); if (this.readyState > 2) return false; if (buffer instanceof Array) buffer = Buffer.from(buffer); if (typeof buffer === 'number') buffer = buffer.toString(); var message = new Message(), isText = (typeof buffer === 'string'), payload, copy; message.rsv1 = message.rsv2 = message.rsv3 = false; message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')]; payload = isText ? Buffer.from(buffer, 'utf8') : buffer; if (code) { copy = payload; payload = Buffer.allocUnsafe(2 + copy.length); payload.writeUInt16BE(code, 0); copy.copy(payload, 2); } message.data = payload; var onMessageReady = function(message) { var frame = new Frame(); frame.final = true; frame.rsv1 = message.rsv1; frame.rsv2 = message.rsv2; frame.rsv3 = message.rsv3; frame.opcode = message.opcode; frame.masked = !!this._masking; frame.length = message.data.length; frame.payload = message.data; if (frame.masked) frame.maskingKey = crypto.randomBytes(4); this._sendFrame(frame); }; if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0) this._extensions.processOutgoingMessage(message, function(error, message) { if (error) return this._fail('extension_error', error.message); onMessageReady.call(this, message); }, this); else onMessageReady.call(this, message); return true; }, _sendFrame: function(frame) { var length = frame.length, header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10), offset = header + (frame.masked ? 4 : 0), buffer = Buffer.allocUnsafe(offset + length), masked = frame.masked ? this.MASK : 0; buffer[0] = (frame.final ? this.FIN : 0) | (frame.rsv1 ? this.RSV1 : 0) | (frame.rsv2 ? this.RSV2 : 0) | (frame.rsv3 ? this.RSV3 : 0) | frame.opcode; if (length <= 125) { buffer[1] = masked | length; } else if (length <= 65535) { buffer[1] = masked | 126; buffer.writeUInt16BE(length, 2); } else { buffer[1] = masked | 127; buffer.writeUInt32BE(Math.floor(length / 0x100000000), 2); buffer.writeUInt32BE(length % 0x100000000, 6); } frame.payload.copy(buffer, offset); if (frame.masked) { frame.maskingKey.copy(buffer, header); Hybi.mask(buffer, frame.maskingKey, offset); } this._write(buffer); }, _handshakeResponse: function() { var secKey = this._request.headers['sec-websocket-key'], version = this._request.headers['sec-websocket-version']; if (version !== Hybi.VERSION) throw new Error('Unsupported WebSocket version: ' + version); if (typeof secKey !== 'string') throw new Error('Missing handshake request header: Sec-WebSocket-Key'); this._headers.set('Upgrade', 'websocket'); this._headers.set('Connection', 'Upgrade'); this._headers.set('Sec-WebSocket-Accept', Hybi.generateAccept(secKey)); if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol); var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']); if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions); var start = 'HTTP/1.1 101 Switching Protocols', headers = [start, this._headers.toString(), '']; return Buffer.from(headers.join('\r\n'), 'utf8'); }, _shutdown: function(code, reason, error) { delete this._frame; delete this._message; this._stage = 5; var sendCloseFrame = (this.readyState === 1); this.readyState = 2; this._extensions.close(function() { if (sendCloseFrame) this.frame(reason, 'close', code); this.readyState = 3; if (error) this.emit('error', new Error(reason)); this.emit('close', new Base.CloseEvent(code, reason)); }, this); }, _fail: function(type, message) { if (this.readyState > 1) return; this._shutdown(this.ERRORS[type], message, true); }, _parseOpcode: function(octet) { var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) { return (octet & rsv) === rsv; }); var frame = this._frame = new Frame(); frame.final = (octet & this.FIN) === this.FIN; frame.rsv1 = rsvs[0]; frame.rsv2 = rsvs[1]; frame.rsv3 = rsvs[2]; frame.opcode = (octet & this.OPCODE); this._stage = 1; if (!this._extensions.validFrameRsv(frame)) return this._fail('protocol_error', 'One or more reserved bits are on: reserved1 = ' + (frame.rsv1 ? 1 : 0) + ', reserved2 = ' + (frame.rsv2 ? 1 : 0) + ', reserved3 = ' + (frame.rsv3 ? 1 : 0)); if (this.OPCODE_CODES.indexOf(frame.opcode) < 0) return this._fail('protocol_error', 'Unrecognized frame opcode: ' + frame.opcode); if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && !frame.final) return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + frame.opcode); if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0) return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished'); }, _parseLength: function(octet) { var frame = this._frame; frame.masked = (octet & this.MASK) === this.MASK; frame.length = (octet & this.LENGTH); if (frame.length >= 0 && frame.length <= 125) { this._stage = frame.masked ? 3 : 4; if (!this._checkFrameLength()) return; } else { this._stage = 2; frame.lengthBytes = (frame.length === 126 ? 2 : 8); } if (this._requireMasking && !frame.masked) return this._fail('unacceptable', 'Received unmasked frame but masking is required'); }, _parseExtendedLength: function(buffer) { var frame = this._frame; frame.length = this._readUInt(buffer); this._stage = frame.masked ? 3 : 4; if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125) return this._fail('protocol_error', 'Received control frame having too long payload: ' + frame.length); if (!this._checkFrameLength()) return; }, _checkFrameLength: function() { var length = this._message ? this._message.length : 0; if (length + this._frame.length > this._maxLength) { this._fail('too_large', 'WebSocket frame length too large'); return false; } else { return true; } }, _emitFrame: function(buffer) { var frame = this._frame, payload = frame.payload = Hybi.mask(buffer, frame.maskingKey), opcode = frame.opcode, message, code, reason, callbacks, callback; delete this._frame; if (opcode === this.OPCODES.continuation) { if (!this._message) return this._fail('protocol_error', 'Received unexpected continuation frame'); this._message.pushFrame(frame); } if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) { this._message = new Message(); this._message.pushFrame(frame); } if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0) return this._emitMessage(this._message); if (opcode === this.OPCODES.close) { code = (payload.length >= 2) ? payload.readUInt16BE(0) : null; reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null; if (!(payload.length === 0) && !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) && 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._shutdown(code || this.DEFAULT_ERROR_CODE, reason || ''); } if (opcode === this.OPCODES.ping) { this.frame(payload, 'pong'); this.emit('ping', new Base.PingEvent(payload.toString())) } if (opcode === this.OPCODES.pong) { callbacks = this._pingCallbacks; message = this._encode(payload); callback = callbacks[message]; delete callbacks[message]; if (callback) callback() this.emit('pong', new Base.PongEvent(payload.toString())) } }, _emitMessage: function(message) { var message = this._message; message.read(); delete this._message; this._extensions.processIncomingMessage(message, function(error, message) { if (error) return this._fail('extension_error', error.message); var payload = message.data; if (message.opcode === this.OPCODES.text) payload = this._encode(payload); if (payload === null) return this._fail('encoding_error', 'Could not decode a text frame as UTF-8'); else this.emit('message', new Base.MessageEvent(payload)); }, this); }, _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); }, _readUInt: function(buffer) { if (buffer.length === 2) return buffer.readUInt16BE(0); return buffer.readUInt32BE(0) * 0x100000000 + buffer.readUInt32BE(4); } }; for (var key in instance) Hybi.prototype[key] = instance[key]; module.exports = Hybi; websocket-driver-node-0.7.4/lib/websocket/driver/hybi/000077500000000000000000000000001366176441200227205ustar00rootroot00000000000000websocket-driver-node-0.7.4/lib/websocket/driver/hybi/frame.js000066400000000000000000000005651366176441200243560ustar00rootroot00000000000000'use strict'; var Frame = function() {}; var instance = { final: false, rsv1: false, rsv2: false, rsv3: false, opcode: null, masked: false, maskingKey: null, lengthBytes: 1, length: 0, payload: null }; for (var key in instance) Frame.prototype[key] = instance[key]; module.exports = Frame; websocket-driver-node-0.7.4/lib/websocket/driver/hybi/message.js000066400000000000000000000013411366176441200247010ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer; var Message = function() { this.rsv1 = false; this.rsv2 = false; this.rsv3 = false; this.opcode = null; this.length = 0; this._chunks = []; }; var instance = { read: function() { return this.data = this.data || Buffer.concat(this._chunks, this.length); }, pushFrame: function(frame) { this.rsv1 = this.rsv1 || frame.rsv1; this.rsv2 = this.rsv2 || frame.rsv2; this.rsv3 = this.rsv3 || frame.rsv3; if (this.opcode === null) this.opcode = frame.opcode; this._chunks.push(frame.payload); this.length += frame.length; } }; for (var key in instance) Message.prototype[key] = instance[key]; module.exports = Message; websocket-driver-node-0.7.4/lib/websocket/driver/proxy.js000066400000000000000000000051551366176441200235120ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer, Stream = require('stream').Stream, url = require('url'), util = require('util'), Base = require('./base'), Headers = require('./headers'), HttpParser = require('../http_parser'); var PORTS = { 'ws:': 80, 'wss:': 443 }; var Proxy = function(client, origin, options) { this._client = client; this._http = new HttpParser('response'); this._origin = (typeof client.url === 'object') ? client.url : url.parse(client.url); this._url = (typeof origin === 'object') ? origin : url.parse(origin); this._options = options || {}; this._state = 0; this.readable = this.writable = true; this._paused = false; this._headers = new Headers(); this._headers.set('Host', this._origin.host); this._headers.set('Connection', 'keep-alive'); this._headers.set('Proxy-Connection', 'keep-alive'); var auth = this._url.auth && Buffer.from(this._url.auth, 'utf8').toString('base64'); if (auth) this._headers.set('Proxy-Authorization', 'Basic ' + auth); }; util.inherits(Proxy, Stream); var instance = { setHeader: function(name, value) { if (this._state !== 0) return false; this._headers.set(name, value); return true; }, start: function() { if (this._state !== 0) return false; this._state = 1; var origin = this._origin, port = origin.port || PORTS[origin.protocol], start = 'CONNECT ' + origin.hostname + ':' + port + ' HTTP/1.1'; var headers = [start, this._headers.toString(), '']; this.emit('data', Buffer.from(headers.join('\r\n'), 'utf8')); return true; }, pause: function() { this._paused = true; }, resume: function() { this._paused = false; this.emit('drain'); }, write: function(chunk) { if (!this.writable) return false; this._http.parse(chunk); if (!this._http.isComplete()) return !this._paused; this.statusCode = this._http.statusCode; this.headers = this._http.headers; if (this.statusCode === 200) { this.emit('connect', new Base.ConnectEvent()); } else { var message = "Can't establish a connection to the server at " + this._origin.href; this.emit('error', new Error(message)); } this.end(); return !this._paused; }, end: function(chunk) { if (!this.writable) return; if (chunk !== undefined) this.write(chunk); this.readable = this.writable = false; this.emit('close'); this.emit('end'); }, destroy: function() { this.end(); } }; for (var key in instance) Proxy.prototype[key] = instance[key]; module.exports = Proxy; websocket-driver-node-0.7.4/lib/websocket/driver/server.js000066400000000000000000000063001366176441200236300ustar00rootroot00000000000000'use strict'; var util = require('util'), HttpParser = require('../http_parser'), Base = require('./base'), Draft75 = require('./draft75'), Draft76 = require('./draft76'), Hybi = require('./hybi'); var Server = function(options) { Base.call(this, null, null, options); this._http = new HttpParser('request'); }; util.inherits(Server, Base); var instance = { EVENTS: ['open', 'message', 'error', 'close', 'ping', 'pong'], _bindEventListeners: function() { this.messages.on('error', function() {}); this.on('error', function() {}); }, parse: function(chunk) { if (this._delegate) return this._delegate.parse(chunk); this._http.parse(chunk); if (!this._http.isComplete()) return; this.method = this._http.method; this.url = this._http.url; this.headers = this._http.headers; this.body = this._http.body; var self = this; this._delegate = Server.http(this, this._options); this._delegate.messages = this.messages; this._delegate.io = this.io; this._open(); this.EVENTS.forEach(function(event) { this._delegate.on(event, function(e) { self.emit(event, e) }); }, this); this.protocol = this._delegate.protocol; this.version = this._delegate.version; this.parse(this._http.body); this.emit('connect', new Base.ConnectEvent()); }, _open: function() { this.__queue.forEach(function(msg) { this._delegate[msg[0]].apply(this._delegate, msg[1]); }, this); this.__queue = []; } }; ['addExtension', 'setHeader', 'start', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) { instance[method] = function() { if (this._delegate) { return this._delegate[method].apply(this._delegate, arguments); } else { this.__queue.push([method, arguments]); return true; } }; }); for (var key in instance) Server.prototype[key] = instance[key]; Server.isSecureRequest = function(request) { if (request.connection && request.connection.authorized !== undefined) return true; if (request.socket && request.socket.secure) return true; var headers = request.headers; if (!headers) return false; if (headers['https'] === 'on') return true; if (headers['x-forwarded-ssl'] === 'on') return true; if (headers['x-forwarded-scheme'] === 'https') return true; if (headers['x-forwarded-proto'] === 'https') return true; return false; }; Server.determineUrl = function(request) { var scheme = this.isSecureRequest(request) ? 'wss:' : 'ws:'; return scheme + '//' + request.headers.host + request.url; }; Server.http = function(request, options) { options = options || {}; if (options.requireMasking === undefined) options.requireMasking = true; var headers = request.headers, version = headers['sec-websocket-version'], key = headers['sec-websocket-key'], key1 = headers['sec-websocket-key1'], key2 = headers['sec-websocket-key2'], url = this.determineUrl(request); if (version || key) return new Hybi(request, url, options); else if (key1 || key2) return new Draft76(request, url, options); else return new Draft75(request, url, options); }; module.exports = Server; websocket-driver-node-0.7.4/lib/websocket/driver/stream_reader.js000066400000000000000000000031061366176441200251400ustar00rootroot00000000000000'use strict'; var Buffer = require('safe-buffer').Buffer; var StreamReader = function() { this._queue = []; this._queueSize = 0; this._offset = 0; }; StreamReader.prototype.put = function(buffer) { if (!buffer || buffer.length === 0) return; if (!Buffer.isBuffer(buffer)) buffer = Buffer.from(buffer); this._queue.push(buffer); this._queueSize += buffer.length; }; StreamReader.prototype.read = function(length) { if (length > this._queueSize) return null; if (length === 0) return Buffer.alloc(0); this._queueSize -= length; var queue = this._queue, remain = length, first = queue[0], buffers, buffer; if (first.length >= length) { if (first.length === length) { return queue.shift(); } else { buffer = first.slice(0, length); queue[0] = first.slice(length); return buffer; } } for (var i = 0, n = queue.length; i < n; i++) { if (remain < queue[i].length) break; remain -= queue[i].length; } buffers = queue.splice(0, i); if (remain > 0 && queue.length > 0) { buffers.push(queue[0].slice(0, remain)); queue[0] = queue[0].slice(remain); } return Buffer.concat(buffers, length); }; StreamReader.prototype.eachByte = function(callback, context) { var buffer, n, index; while (this._queue.length > 0) { buffer = this._queue[0]; n = buffer.length; while (this._offset < n) { index = this._offset; this._offset += 1; callback.call(context, buffer[index]); } this._offset = 0; this._queue.shift(); } }; module.exports = StreamReader; websocket-driver-node-0.7.4/lib/websocket/http_parser.js000066400000000000000000000063301366176441200233650ustar00rootroot00000000000000'use strict'; var NodeHTTPParser = require('http-parser-js').HTTPParser, Buffer = require('safe-buffer').Buffer; var TYPES = { request: NodeHTTPParser.REQUEST || 'request', response: NodeHTTPParser.RESPONSE || 'response' }; var HttpParser = function(type) { this._type = type; this._parser = new NodeHTTPParser(TYPES[type]); this._complete = false; this.headers = {}; var current = null, self = this; this._parser.onHeaderField = function(b, start, length) { current = b.toString('utf8', start, start + length).toLowerCase(); }; this._parser.onHeaderValue = function(b, start, length) { var value = b.toString('utf8', start, start + length); if (self.headers.hasOwnProperty(current)) self.headers[current] += ', ' + value; else self.headers[current] = value; }; this._parser.onHeadersComplete = this._parser[NodeHTTPParser.kOnHeadersComplete] = function(majorVersion, minorVersion, headers, method, pathname, statusCode) { var info = arguments[0]; if (typeof info === 'object') { method = info.method; pathname = info.url; statusCode = info.statusCode; headers = info.headers; } self.method = (typeof method === 'number') ? HttpParser.METHODS[method] : method; self.statusCode = statusCode; self.url = pathname; if (!headers) return; for (var i = 0, n = headers.length, key, value; i < n; i += 2) { key = headers[i].toLowerCase(); value = headers[i+1]; if (self.headers.hasOwnProperty(key)) self.headers[key] += ', ' + value; else self.headers[key] = value; } self._complete = true; }; }; HttpParser.METHODS = { 0: 'DELETE', 1: 'GET', 2: 'HEAD', 3: 'POST', 4: 'PUT', 5: 'CONNECT', 6: 'OPTIONS', 7: 'TRACE', 8: 'COPY', 9: 'LOCK', 10: 'MKCOL', 11: 'MOVE', 12: 'PROPFIND', 13: 'PROPPATCH', 14: 'SEARCH', 15: 'UNLOCK', 16: 'BIND', 17: 'REBIND', 18: 'UNBIND', 19: 'ACL', 20: 'REPORT', 21: 'MKACTIVITY', 22: 'CHECKOUT', 23: 'MERGE', 24: 'M-SEARCH', 25: 'NOTIFY', 26: 'SUBSCRIBE', 27: 'UNSUBSCRIBE', 28: 'PATCH', 29: 'PURGE', 30: 'MKCALENDAR', 31: 'LINK', 32: 'UNLINK' }; var VERSION = process.version ? process.version.match(/[0-9]+/g).map(function(n) { return parseInt(n, 10) }) : []; if (VERSION[0] === 0 && VERSION[1] === 12) { HttpParser.METHODS[16] = 'REPORT'; HttpParser.METHODS[17] = 'MKACTIVITY'; HttpParser.METHODS[18] = 'CHECKOUT'; HttpParser.METHODS[19] = 'MERGE'; HttpParser.METHODS[20] = 'M-SEARCH'; HttpParser.METHODS[21] = 'NOTIFY'; HttpParser.METHODS[22] = 'SUBSCRIBE'; HttpParser.METHODS[23] = 'UNSUBSCRIBE'; HttpParser.METHODS[24] = 'PATCH'; HttpParser.METHODS[25] = 'PURGE'; } HttpParser.prototype.isComplete = function() { return this._complete; }; HttpParser.prototype.parse = function(chunk) { var consumed = this._parser.execute(chunk, 0, chunk.length); if (typeof consumed !== 'number') { this.error = consumed; this._complete = true; return; } if (this._complete) this.body = (consumed < chunk.length) ? chunk.slice(consumed) : Buffer.alloc(0); }; module.exports = HttpParser; websocket-driver-node-0.7.4/lib/websocket/streams.js000066400000000000000000000114531366176441200225120ustar00rootroot00000000000000'use strict'; /** Streams in a WebSocket connection --------------------------------- We model a WebSocket as two duplex streams: one stream is for the wire protocol over an I/O socket, and the other is for incoming/outgoing messages. +----------+ +---------+ +----------+ [1] write(chunk) -->| ~~~~~~~~ +----->| parse() +----->| ~~~~~~~~ +--> emit('data') [2] | | +----+----+ | | | | | | | | IO | | [5] | Messages | | | V | | | | +---------+ | | [4] emit('data') <--+ ~~~~~~~~ |<-----+ frame() |<-----+ ~~~~~~~~ |<-- write(chunk) [3] +----------+ +---------+ +----------+ Message transfer in each direction is simple: IO receives a byte stream [1] and sends this stream for parsing. The parser will periodically emit a complete message text on the Messages stream [2]. Similarly, when messages are written to the Messages stream [3], they are framed using the WebSocket wire format and emitted via IO [4]. There is a feedback loop via [5] since some input from [1] will be things like ping, pong and close frames. In these cases the protocol responds by emitting responses directly back to [4] rather than emitting messages via [2]. For the purposes of flow control, we consider the sources of each Readable stream to be as follows: * [2] receives input from [1] * [4] receives input from [1] and [3] The classes below express the relationships described above without prescribing anything about how parse() and frame() work, other than assuming they emit 'data' events to the IO and Messages streams. They will work with any protocol driver having these two methods. **/ var Stream = require('stream').Stream, util = require('util'); var IO = function(driver) { this.readable = this.writable = true; this._paused = false; this._driver = driver; }; util.inherits(IO, Stream); // The IO pause() and resume() methods will be called when the socket we are // piping to gets backed up and drains. Since IO output [4] comes from IO input // [1] and Messages input [3], we need to tell both of those to return false // from write() when this stream is paused. IO.prototype.pause = function() { this._paused = true; this._driver.messages._paused = true; }; IO.prototype.resume = function() { this._paused = false; this.emit('drain'); var messages = this._driver.messages; messages._paused = false; messages.emit('drain'); }; // When we receive input from a socket, send it to the parser and tell the // source whether to back off. IO.prototype.write = function(chunk) { if (!this.writable) return false; this._driver.parse(chunk); return !this._paused; }; // The IO end() method will be called when the socket piping into it emits // 'close' or 'end', i.e. the socket is closed. In this situation the Messages // stream will not emit any more data so we emit 'end'. IO.prototype.end = function(chunk) { if (!this.writable) return; if (chunk !== undefined) this.write(chunk); this.writable = false; var messages = this._driver.messages; if (messages.readable) { messages.readable = messages.writable = false; messages.emit('end'); } }; IO.prototype.destroy = function() { this.end(); }; var Messages = function(driver) { this.readable = this.writable = true; this._paused = false; this._driver = driver; }; util.inherits(Messages, Stream); // The Messages pause() and resume() methods will be called when the app that's // processing the messages gets backed up and drains. If we're emitting // messages too fast we should tell the source to slow down. Message output [2] // comes from IO input [1]. Messages.prototype.pause = function() { this._driver.io._paused = true; }; Messages.prototype.resume = function() { this._driver.io._paused = false; this._driver.io.emit('drain'); }; // When we receive messages from the user, send them to the formatter and tell // the source whether to back off. Messages.prototype.write = function(message) { if (!this.writable) return false; if (typeof message === 'string') this._driver.text(message); else this._driver.binary(message); return !this._paused; }; // The Messages end() method will be called when a stream piping into it emits // 'end'. Many streams may be piped into the WebSocket and one of them ending // does not mean the whole socket is done, so just process the input and move // on leaving the socket open. Messages.prototype.end = function(message) { if (message !== undefined) this.write(message); }; Messages.prototype.destroy = function() {}; exports.IO = IO; exports.Messages = Messages; websocket-driver-node-0.7.4/package.json000066400000000000000000000022641366176441200202300ustar00rootroot00000000000000{ "name": "websocket-driver", "description": "WebSocket protocol handler with pluggable I/O", "homepage": "https://github.com/faye/websocket-driver-node", "author": "James Coglan (http://jcoglan.com/)", "keywords": [ "websocket" ], "license": "Apache-2.0", "version": "0.7.4", "engines": { "node": ">=0.8.0" }, "files": [ "lib" ], "main": "./lib/websocket/driver", "dependencies": { "http-parser-js": ">=0.5.1", "safe-buffer": ">=5.1.0", "websocket-extensions": ">=0.1.1" }, "devDependencies": { "jstest": "*", "permessage-deflate": "*" }, "scripts": { "test": "jstest spec/runner.js" }, "repository": { "type": "git", "url": "git://github.com/faye/websocket-driver-node.git" }, "bugs": "https://github.com/faye/websocket-driver-node/issues" } websocket-driver-node-0.7.4/spec/000077500000000000000000000000001366176441200166705ustar00rootroot00000000000000websocket-driver-node-0.7.4/spec/runner.js000066400000000000000000000021541366176441200205410ustar00rootroot00000000000000var Buffer = require('safe-buffer').Buffer, test = require('jstest').Test, Stream = require('stream').Stream, util = require('util') var BufferMatcher = function(data) { this._data = Buffer.from(data) } BufferMatcher.prototype.equals = function(other) { if (this._data.length !== other.length) return false; for (var i = 0, n = other.length; i < n; i++) { if (other[i] !== this._data[i]) return false; } return true; } var Collector = function() { this.bytes = [] this.writable = true } util.inherits(Collector, Stream) Collector.prototype.write = function(buffer) { this.bytes = [] for (var i = 0, n = buffer.length; i < n; i++) { this.bytes[i] = buffer[i] } return true } test.Unit.TestCase.include({ buffer: function(data) { return new BufferMatcher(data) }, collector: function() { return this._collector = this._collector || new Collector() } }) require('./websocket/driver/draft75_examples') require('./websocket/driver/draft75_spec') require('./websocket/driver/draft76_spec') require('./websocket/driver/hybi_spec') require('./websocket/driver/client_spec') websocket-driver-node-0.7.4/spec/websocket/000077500000000000000000000000001366176441200206565ustar00rootroot00000000000000websocket-driver-node-0.7.4/spec/websocket/driver/000077500000000000000000000000001366176441200221515ustar00rootroot00000000000000websocket-driver-node-0.7.4/spec/websocket/driver/client_spec.js000066400000000000000000000303101366176441200247740ustar00rootroot00000000000000var Client = require("../../../lib/websocket/driver/client"), Buffer = require('safe-buffer').Buffer, test = require('jstest').Test test.describe("Client", function() { with(this) { define("options", function() { return this._options = this._options || { protocols: this.protocols() } }) define("protocols", function() { null }) define("url", function() { return "ws://www.example.com/socket" }) define("driver", function() { if (this._driver) return this._driver this._driver = new Client(this.url(), this.options()) var self = this this._driver.on('open', function(e) { self.open = true }) this._driver.on('message', function(e) { self.message += e.data }) this._driver.on('error', function(e) { self.error = e }) this._driver.on('close', function(e) { self.close = [e.code, e.reason] }) var collector = this.collector() this._driver.io.on("data", function(d) { collector.write(d) }) return this._driver }) define("key", function() { return "2vBVWg4Qyk3ZoM/5d3QD9Q==" }) define("response", function() { return "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: QV3I5XUXU2CdhtjixE7QCkCcMZM=\r\n" + "\r\n" }) before(function() { this.stub(Client, "generateKey").returns(this.key()) this.open = this.error = this.close = false this.message = "" }) describe("in the beginning state", function() { with(this) { it("starts in no state", function() { with(this) { assertEqual( null, driver().getState() ) }}) describe("close", function() { with(this) { it("changes the state to closed", function() { with(this) { driver().close() assertEqual( "closed", driver().getState() ) assertEqual( [1000, ''], close ) }}) }}) describe("start", function() { with(this) { it("writes the handshake request to the socket", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "GET /socket HTTP/1.1\r\n" + "Host: www.example.com\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" + "Sec-WebSocket-Version: 13\r\n" + "\r\n")) driver().start() }}) it("returns true", function() { with(this) { assertEqual( true, driver().start() ) }}) describe("with subprotocols", function() { with(this) { define("protocols", function() { return ["foo", "bar", "xmpp"] }) it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "GET /socket HTTP/1.1\r\n" + "Host: www.example.com\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" + "Sec-WebSocket-Version: 13\r\n" + "Sec-WebSocket-Protocol: foo, bar, xmpp\r\n" + "\r\n")) driver().start() }}) }}) describe("with basic auth", function() { with(this) { define("url", function() { return "ws://user:pass@www.example.com/socket" }) it("writes the handshake with Authorization", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "GET /socket HTTP/1.1\r\n" + "Host: www.example.com\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" + "Sec-WebSocket-Version: 13\r\n" + "Authorization: Basic dXNlcjpwYXNz\r\n" + "\r\n")) driver().start() }}) }}) describe("with an invalid URL", function() { with(this) { define("url", function() { return "stream.wikimedia.org/rc" }) it("throws an error", function() { with(this) { var message try { driver() } catch (e) { message = e.message } assertEqual( "stream.wikimedia.org/rc is not a valid WebSocket URL", message ) }}) }}) describe("with custom headers", function() { with(this) { before(function() { with(this) { driver().setHeader("User-Agent", "Chrome") }}) it("writes the handshake with custom headers", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "GET /socket HTTP/1.1\r\n" + "Host: www.example.com\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" + "Sec-WebSocket-Version: 13\r\n" + "User-Agent: Chrome\r\n" + "\r\n")) driver().start() }}) }}) it("changes the state to connecting", function() { with(this) { driver().start() assertEqual( "connecting", driver().getState() ) }}) }}) }}) describe("using a proxy", function() { with(this) { it("sends a CONNECT request", function() { with(this) { var proxy = driver().proxy("http://proxy.example.com") expect(proxy, "emit").given("data", buffer( "CONNECT www.example.com:80 HTTP/1.1\r\n" + "Host: www.example.com\r\n" + "Connection: keep-alive\r\n" + "Proxy-Connection: keep-alive\r\n" + "\r\n")) proxy.start() }}) it("sends an authenticated CONNECT request", function() { with(this) { var proxy = driver().proxy("http://user:pass@proxy.example.com") expect(proxy, "emit").given("data", buffer( "CONNECT www.example.com:80 HTTP/1.1\r\n" + "Host: www.example.com\r\n" + "Connection: keep-alive\r\n" + "Proxy-Connection: keep-alive\r\n" + "Proxy-Authorization: Basic dXNlcjpwYXNz\r\n" + "\r\n")) proxy.start() }}) it("sends a CONNECT request with custom headers", function() { with(this) { var proxy = driver().proxy("http://user:pass@proxy.example.com") proxy.setHeader("User-Agent", "Chrome") expect(proxy, "emit").given("data", buffer( "CONNECT www.example.com:80 HTTP/1.1\r\n" + "Host: www.example.com\r\n" + "Connection: keep-alive\r\n" + "Proxy-Connection: keep-alive\r\n" + "Proxy-Authorization: Basic dXNlcjpwYXNz\r\n" + "User-Agent: Chrome\r\n" + "\r\n")) proxy.start() }}) describe("receiving a response", function() { with(this) { before(function() { with(this) { this.proxy = driver().proxy("http://proxy.example.com") }}) it("returns true when the response is written", function() { with(this) { // this prevents downstream connections suddenly closing for no reason assertEqual( true, proxy.write(Buffer.from("HTTP/1.1 200 OK\r\n\r\n")) ) }}) it("emits a 'connect' event when the proxy connects", function() { with(this) { expect(proxy, "emit").given("connect", anything()) expect(proxy, "emit").given("close") expect(proxy, "emit").given("end") proxy.write(Buffer.from("HTTP/1.1 200 OK\r\n\r\n")) }}) it("emits an 'error' event if the proxy does not connect", function() { with(this) { expect(proxy, "emit").given("error", objectIncluding({ message: "Can't establish a connection to the server at ws://www.example.com/socket" })) expect(proxy, "emit").given("close") expect(proxy, "emit").given("end") proxy.write(Buffer.from("HTTP/1.1 403 Forbidden\r\n\r\n")) }}) }}) }}) describe("in the connecting state", function() { with(this) { before(function() { this.driver().start() }) describe("with a valid response", function() { with(this) { before(function() { this.driver().parse(Buffer.from(this.response())) }) it("changes the state to open", function() { with(this) { assertEqual( true, open ) assertEqual( false, close ) assertEqual( "open", driver().getState() ) }}) it("makes the response status available", function() { with(this) { assertEqual( 101, driver().statusCode ) }}) it("makes the response headers available", function() { with(this) { assertEqual( "websocket", driver().headers.upgrade ) }}) }}) describe("with a valid response followed by a frame", function() { with(this) { before(function() { with(this) { var resp = Buffer.alloc(response().length + 4) Buffer.from(response()).copy(resp) Buffer.from([0x81, 0x02, 72, 105]).copy(resp, resp.length - 4) driver().parse(resp) }}) it("changes the state to open", function() { with(this) { assertEqual( true, open ) assertEqual( false, close ) assertEqual( "open", driver().getState() ) }}) it("parses the frame", function() { with(this) { assertEqual( "Hi", message ) }}) }}) describe("with a bad status line", function() { with(this) { before(function() { var resp = this.response().replace(/101/g, "4") this.driver().parse(Buffer.from(resp)) }) it("changes the state to closed", function() { with(this) { assertEqual( false, open ) assertEqual( "Error during WebSocket handshake: Parse Error", error.message ) assertEqual( [1002, "Error during WebSocket handshake: Parse Error"], close ) assertEqual( "closed", driver().getState() ) }}) }}) describe("with a bad Upgrade header", function() { with(this) { before(function() { var resp = this.response().replace(/websocket/g, "wrong") this.driver().parse(Buffer.from(resp)) }) it("changes the state to closed", function() { with(this) { assertEqual( false, open ) assertEqual( "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'", error.message ) assertEqual( [1002, "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'"], close ) assertEqual( "closed", driver().getState() ) }}) }}) describe("with a bad Accept header", function() { with(this) { before(function() { var resp = this.response().replace(/QV3/g, "wrong") this.driver().parse(Buffer.from(resp)) }) it("changes the state to closed", function() { with(this) { assertEqual( false, open ) assertEqual( "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch", error.message ) assertEqual( [1002, "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch"], close ) assertEqual( "closed", driver().getState() ) }}) }}) describe("with valid subprotocols", function() { with(this) { define("protocols", function() { return ["foo", "xmpp"] }) before(function() { var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: xmpp\r\n\r\n") this.driver().parse(Buffer.from(resp)) }) it("changs the state to open", function() { with(this) { assertEqual( true, open ) assertEqual( false, close ) assertEqual( "open", driver().getState() ) }}) it("selects the subprotocol", function() { with(this) { assertEqual( "xmpp", driver().protocol ) }}) }}) describe("with invalid subprotocols", function() { with(this) { define("protocols", function() { return ["foo", "xmpp"] }) before(function() { var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: irc\r\n\r\n") this.driver().parse(Buffer.from(resp)) }) it("changs the state to closed", function() { with(this) { assertEqual( false, open ) assertEqual( "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch", error.message ) assertEqual( [1002, "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch"], close ) assertEqual( "closed", driver().getState() ) }}) it("selects no subprotocol", function() { with(this) { assertEqual( null, driver().protocol ) }}) }}) }}) }}) websocket-driver-node-0.7.4/spec/websocket/driver/draft75_examples.js000066400000000000000000000120401366176441200256560ustar00rootroot00000000000000var test = require('jstest').Test test.describe("draft-75", function() { with(this) { sharedExamplesFor("draft-75 protocol", function() { with(this) { describe("in the open state", function() { with(this) { before(function() { this.driver().start() }) describe("parse", function() { with(this) { it("parses text frames", function() { with(this) { driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]) assertEqual( "Hello", message ) }}) it("parses multiple frames from the same packet", function() { with(this) { driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]) assertEqual( "HelloHello", message ) }}) it("parses text frames beginning 0x00-0x7F", function() { with(this) { driver().parse([0x66, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]) assertEqual( "Hello", message ) }}) it("ignores frames with a length header", function() { with(this) { driver().parse([0x80, 0x02, 0x48, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]) assertEqual( "Hello", message ) }}) it("parses multibyte text frames", function() { with(this) { driver().parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]) assertEqual( "Apple = ", message ) }}) it("parses frames received in several packets", function() { with(this) { driver().parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65]) driver().parse([0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]) assertEqual( "Apple = ", message ) }}) it("parses fragmented frames", function() { with(this) { driver().parse([0x00, 0x48, 0x65, 0x6c]) driver().parse([0x6c, 0x6f, 0xff]) assertEqual( "Hello", message ) }}) describe("when a message listener throws an error", function() { with(this) { before(function() { with(this) { this.messages = [] driver().on("message", function(msg) { messages.push(msg.data) throw new Error("an error") }) }}) it("is not trapped by the parser", function() { with(this) { var buffer = [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff] assertThrows(Error, function() { driver().parse(buffer) }) }}) it("parses text frames without dropping input", function() { with(this) { try { driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x57]) } catch (e) {} try { driver().parse([0x6f, 0x72, 0x6c, 0x64, 0xff]) } catch (e) {} assertEqual( ["Hello", "World"], messages ) }}) }}) }}) describe("frame", function() { with(this) { it("formats the given string as a WebSocket frame", function() { with(this) { driver().frame("Hello") assertEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], collector().bytes ) }}) it("encodes multibyte characters correctly", function() { with(this) { driver().frame("Apple = ") assertEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], collector().bytes ) }}) it("converts numbers to strings", function() { with(this) { driver().frame(50) assertEqual( [0x00, 0x35, 0x30, 0xff], collector().bytes ) }}) it("returns true", function() { with(this) { assertEqual( true, driver().frame("lol") ) }}) }}) describe("ping", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().ping() }}) it("returns false", function() { with(this) { assertEqual( false, driver().ping() ) }}) }}) describe("close", function() { with(this) { it("triggers the onclose event", function() { with(this) { driver().close() assertEqual( true, close ) }}) it("returns true", function() { with(this) { assertEqual( true, driver().close() ) }}) it("changes the state to closed", function() { with(this) { driver().close() assertEqual( "closed", driver().getState() ) }}) }}) }}) describe("in the closed state", function() { with(this) { before(function() { this.driver().start() this.driver().close() }) describe("close", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().close() }}) it("returns false", function() { with(this) { assertEqual( false, driver().close() ) }}) it("leaves the protocol in the closed state", function() { with(this) { driver().close() assertEqual( "closed", driver().getState() ) }}) }}) }}) }}) }}) websocket-driver-node-0.7.4/spec/websocket/driver/draft75_spec.js000066400000000000000000000063431366176441200250030ustar00rootroot00000000000000var Draft75 = require("../../../lib/websocket/driver/draft75"), test = require('jstest').Test test.describe("Draft75", function() { with(this) { define("request", function() { return this._request = this._request || { method: "GET", headers: { "connection": "Upgrade", "upgrade": "WebSocket", "origin": "http://www.example.com" } } }) define("options", function() { return this._options = this._options || { masking: false } }) define("driver", function() { if (this._driver) return this._driver this._driver = new Draft75(this.request(), "ws://www.example.com/socket", this.options()) var self = this this._driver.on('open', function(e) { self.open = true }) this._driver.on('message', function(e) { self.message += e.data }) this._driver.on('close', function(e) { self.close = true }) this._driver.io.pipe(this.collector()) return this._driver }) before(function() { this.open = this.close = false this.message = "" }) describe("in the connecting state", function() { with(this) { it("starts in the connecting state", function() { with(this) { assertEqual( "connecting", driver().getState() ) }}) describe("start", function() { with(this) { it("writes the handshake response to the socket", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" + "Upgrade: WebSocket\r\n" + "Connection: Upgrade\r\n" + "WebSocket-Origin: http://www.example.com\r\n" + "WebSocket-Location: ws://www.example.com/socket\r\n" + "\r\n")) driver().start() }}) it("returns true", function() { with(this) { assertEqual( true, driver().start() ) }}) it("triggers the onopen event", function() { with(this) { driver().start() assertEqual( true, open ) }}) it("changes the state to open", function() { with(this) { driver().start() assertEqual( "open", driver().getState() ) }}) it("sets the protocol version", function() { with(this) { driver().start() assertEqual( "hixie-75", driver().version ) }}) }}) describe("frame", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().frame("Hello, world") }}) it("returns true", function() { with(this) { assertEqual( true, driver().frame("whatever") ) }}) it("queues the frames until the handshake has been sent", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" + "Upgrade: WebSocket\r\n" + "Connection: Upgrade\r\n" + "WebSocket-Origin: http://www.example.com\r\n" + "WebSocket-Location: ws://www.example.com/socket\r\n" + "\r\n")) expect(driver().io, "emit").given("data", buffer([0x00, 0x48, 0x69, 0xff])) driver().frame("Hi") driver().start() }}) }}) }}) itShouldBehaveLike("draft-75 protocol") }}) websocket-driver-node-0.7.4/spec/websocket/driver/draft76_spec.js000066400000000000000000000172211366176441200250010ustar00rootroot00000000000000var Draft76 = require("../../../lib/websocket/driver/draft76"), Buffer = require('safe-buffer').Buffer, test = require('jstest').Test test.describe("Draft76", function() { with(this) { BODY = Buffer.from([0x91, 0x25, 0x3e, 0xd3, 0xa9, 0xe7, 0x6a, 0x88]) define("body", function() { return BODY }) define("response", function() { return [0xb4, 0x9c, 0x6e, 0x40, 0x53, 0x04, 0x04, 0x26, 0xe5, 0x1b, 0xbf, 0x6c, 0xb7, 0x9f, 0x1d, 0xf9] }) define("request", function() { return this._request = this._request || { method: "GET", headers: { "connection": "Upgrade", "upgrade": "WebSocket", "origin": "http://www.example.com", "sec-websocket-key1": "1 38 wZ3f9 23O0 3l 0r", "sec-websocket-key2": "27 0E 6 2 1665:< ;U 1H" } } }) define("options", function() { return this._options = this._options || { masking: false } }) define("driver", function() { if (this._driver) return this._driver this._driver = new Draft76(this.request(), "ws://www.example.com/socket", this.options()) var self = this this._driver.on('open', function(e) { self.open = true }) this._driver.on('message', function(e) { self.message += e.data }) this._driver.on('error', function(e) { self.error = e }) this._driver.on('close', function(e) { self.close = true }) this._driver.io.pipe(this.collector()) this._driver.io.write(this.body()) return this._driver }) before(function() { this.open = this.close = false this.message = "" }) describe("in the connecting state", function() { with(this) { it("starts in the connecting state", function() { with(this) { assertEqual( "connecting", driver().getState() ) }}) describe("start", function() { with(this) { it("writes the handshake response to the socket", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" + "Upgrade: WebSocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Origin: http://www.example.com\r\n" + "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" + "\r\n")) expect(driver().io, "emit").given("data", buffer(response())) driver().start() }}) it("returns true", function() { with(this) { assertEqual( true, driver().start() ) }}) it("triggers the onopen event", function() { with(this) { driver().start() assertEqual( true, open ) }}) it("changes the state to open", function() { with(this) { driver().start() assertEqual( "open", driver().getState() ) }}) it("sets the protocol version", function() { with(this) { driver().start() assertEqual( "hixie-76", driver().version ) }}) describe("with an invalid key header", function() { with(this) { before(function() { with(this) { request().headers["sec-websocket-key1"] = "2 L785 8o% s9Sy9@V. 4<1P5" }}) it("writes a handshake error response", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 400 Bad Request\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 45\r\n" + "\r\n" + "Client sent invalid Sec-WebSocket-Key headers")) driver().start() }}) it("does not trigger the onopen event", function() { with(this) { driver().start() assertEqual( false, open ) }}) it("triggers the onerror event", function() { with(this) { driver().start() assertEqual( "Client sent invalid Sec-WebSocket-Key headers", error.message ) }}) it("triggers the onclose event", function() { with(this) { driver().start() assertEqual( true, close ) }}) it("changes the state to closed", function() { with(this) { driver().start() assertEqual( "closed", driver().getState() ) }}) }}) }}) describe("frame", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().frame("Hello, world") }}) it("returns true", function() { with(this) { assertEqual( true, driver().frame("whatever") ) }}) it("queues the frames until the handshake has been sent", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" + "Upgrade: WebSocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Origin: http://www.example.com\r\n" + "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" + "\r\n")) expect(driver().io, "emit").given("data", buffer(response())) expect(driver().io, "emit").given("data", buffer([0x00, 72, 105, 0xff])) driver().frame("Hi") driver().start() }}) }}) describe("with no request body", function() { with(this) { define("body", function() { return Buffer.alloc(0) }) it("writes the handshake response with no body", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" + "Upgrade: WebSocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Origin: http://www.example.com\r\n" + "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" + "\r\n")) driver().start() }}) it("does not trigger the onopen event", function() { with(this) { driver().start() assertEqual( false, open ) }}) it("leaves the protocol in the connecting state", function() { with(this) { driver().start() assertEqual( "connecting", driver().getState() ) }}) describe("when the request body is received", function() { with(this) { before(function() { this.driver().start() }) it("sends the response body", function() { with(this) { expect(driver().io, "emit").given("data", buffer(response())) driver().parse(BODY) }}) it("triggers the onopen event", function() { with(this) { driver().parse(BODY) assertEqual( true, open ) }}) it("changes the state to open", function() { with(this) { driver().parse(BODY) assertEqual( "open", driver().getState() ) }}) it("sends any frames queued before the handshake was complete", function() { with(this) { expect(driver().io, "emit").given("data", buffer(response())) expect(driver().io, "emit").given("data", buffer([0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xff])) driver().frame("hello") driver().parse(BODY) }}) }}) }}) }}) itShouldBehaveLike("draft-75 protocol") describe("in the open state", function() { with(this) { before(function() { this.driver().start() }) describe("parse", function() { with(this) { it("closes the socket if a close frame is received", function() { with(this) { driver().parse([0xff, 0x00]) assertEqual( true, close ) assertEqual( "closed", driver().getState() ) }}) }}) describe("close", function() { with(this) { it("writes a close message to the socket", function() { with(this) { expect(driver().io, "emit").given("data", buffer([0xff, 0x00])) driver().close() }}) }}) }}) }}) websocket-driver-node-0.7.4/spec/websocket/driver/hybi_spec.js000066400000000000000000000612041366176441200244570ustar00rootroot00000000000000var Hybi = require("../../../lib/websocket/driver/hybi"), test = require('jstest').Test test.describe("Hybi", function() { with(this) { define("request", function() { return this._request = this._request || { method: "GET", headers: { "connection": "Upgrade", "upgrade": "websocket", "origin": "http://www.example.com", // "sec-websocket-extensions": "x-webkit-deflate-frame", "sec-websocket-key": "JFBCWHksyIpXV+6Wlq/9pw==", "sec-websocket-version": "13" } } }) define("options", function() { return this._options = this._options || { masking: false } }) define("driver", function() { if (this._driver) return this._driver this._driver = new Hybi(this.request(), "ws://www.example.com/socket", this.options()) var self = this this._driver.on('open', function(e) { self.open = true }) this._driver.on('message', function(e) { self.message += e.data }) this._driver.on('error', function(e) { self.error = e }) this._driver.on('close', function(e) { self.close = [e.code, e.reason] }) this._driver.io.pipe(this.collector()) return this._driver }) before(function() { this.open = this.error = this.close = false this.message = "" }) describe("in the connecting state", function() { with(this) { it("starts in the connecting state", function() { with(this) { assertEqual( "connecting", driver().getState() ) }}) describe("start", function() { with(this) { it("writes the handshake response to the socket", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" + "\r\n")) driver().start() }}) it("returns true", function() { with(this) { assertEqual( true, driver().start() ) }}) describe("with subprotocols", function() { with(this) { before(function() { with(this) { request().headers["sec-websocket-protocol"] = "foo, bar, xmpp" options().protocols = ["xmpp"] }}) it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" + "Sec-WebSocket-Protocol: xmpp\r\n" + "\r\n")) driver().start() }}) it("sets the subprotocol", function() { with(this) { driver().start() assertEqual( "xmpp", driver().protocol ) }}) }}) describe("with invalid extensions", function() { with(this) { before(function() { with(this) { request().headers["sec-websocket-extensions"] = "x-webkit- -frame" }}) it("writes a handshake error response", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 400 Bad Request\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 57\r\n" + "\r\n" + "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame")) driver().start() }}) it("does not trigger the onopen event", function() { with(this) { driver().start() assertEqual( false, open ) }}) it("triggers the onerror event", function() { with(this) { driver().start() assertEqual( "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame", error.message ) }}) it("triggers the onclose event", function() { with(this) { driver().start() assertEqual( [1002, "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame"], close ) }}) it("changes the state to closed", function() { with(this) { driver().start() assertEqual( "closed", driver().getState() ) }}) }}) describe("with custom headers", function() { with(this) { before(function() { with(this) { driver().setHeader("Authorization", "Bearer WAT") }}) it("writes the handshake with the custom headers", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Switching Protocols\r\n" + "Authorization: Bearer WAT\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" + "\r\n")) driver().start() }}) }}) it("triggers the onopen event", function() { with(this) { driver().start() assertEqual( true, open ) }}) it("changes the state to open", function() { with(this) { driver().start() assertEqual( "open", driver().getState() ) }}) it("sets the protocol version", function() { with(this) { driver().start() assertEqual( "hybi-13", driver().version ) }}) }}) describe("frame", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().frame("Hello, world") }}) it("returns true", function() { with(this) { assertEqual( true, driver().frame("whatever") ) }}) it("queues the frames until the handshake has been send", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" + "\r\n")) expect(driver().io, "emit").given("data", buffer([0x81, 0x02, 72, 105])) driver().frame("Hi") driver().start() }}) }}) describe("ping", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().ping() }}) it("returns true", function() { with(this) { assertEqual( true, driver().ping() ) }}) it("queues the ping until the handshake has been send", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" + "\r\n")) expect(driver().io, "emit").given("data", buffer([0x89, 0])) driver().ping() driver().start() }}) }}) describe("pong", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().pong() }}) it("returns true", function() { with(this) { assertEqual( true, driver().pong() ) }}) it("queues the pong until the handshake has been sent", function() { with(this) { expect(driver().io, "emit").given("data", buffer( "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" + "\r\n")) expect(driver().io, "emit").given("data", buffer([0x8a, 0])) driver().pong() driver().start() }}) }}) describe("close", function() { with(this) { it("does not write anything to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().close() }}) it("returns true", function() { with(this) { assertEqual( true, driver().close() ) }}) it("triggers the onclose event", function() { with(this) { driver().close() assertEqual( [1000, ""], close ) }}) it("changes the state to closed", function() { with(this) { driver().close() assertEqual( "closed", driver().getState() ) }}) }}) }}) describe("in the open state", function() { with(this) { before(function() { this.driver().start() }) describe("parse", function() { with(this) { define("mask", function() { return this._mask = this._mask || [1,2,3,4].map(function() { return Math.floor(Math.random() * 256) }) }) define("maskMessage", function(bytes) { var output = [] for (var i = 0, n = bytes.length; i < n; i++) { output[i] = bytes[i] ^ this.mask()[i % 4] } return output }) it("parses unmasked text frames", function() { with(this) { driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]) assertEqual( "Hello", message ) }}) it("parses multiple frames from the same packet", function() { with(this) { driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]) assertEqual( "HelloHello", message ) }}) it("parses empty text frames", function() { with(this) { driver().parse([0x81, 0x00]) assertEqual( "", message ) }}) it("parses fragmented text frames", function() { with(this) { driver().parse([0x01, 0x03, 0x48, 0x65, 0x6c]) driver().parse([0x80, 0x02, 0x6c, 0x6f]) assertEqual( "Hello", message ) }}) it("parses masked text frames", function() { with(this) { driver().parse([0x81, 0x85]) driver().parse(mask()) driver().parse(maskMessage([0x48, 0x65, 0x6c, 0x6c, 0x6f])) assertEqual( "Hello", message ) }}) it("parses masked empty text frames", function() { with(this) { driver().parse([0x81, 0x80]) driver().parse(mask()) driver().parse(maskMessage([])) assertEqual( "", message ) }}) it("parses masked fragmented text frames", function() { with(this) { driver().parse([0x01, 0x81]) driver().parse(mask()) driver().parse(maskMessage([0x48])) driver().parse([0x80, 0x84]) driver().parse(mask()) driver().parse(maskMessage([0x65, 0x6c, 0x6c, 0x6f])) assertEqual( "Hello", message ) }}) it("closes the socket if the frame has an unrecognized opcode", function() { with(this) { driver().parse([0x83, 0x00]) assertEqual( [0x88, 0x1e, 0x03, 0xea], collector().bytes.slice(0,4) ) assertEqual( "Unrecognized frame opcode: 3", error.message ) assertEqual( [1002, "Unrecognized frame opcode: 3"], close ) assertEqual( "closed", driver().getState() ) }}) it("closes the socket if a close frame is received", function() { with(this) { driver().parse([0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f]) assertEqual( [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes ) assertEqual( [1000, "Hello"], close ) assertEqual( "closed", driver().getState() ) }}) it("parses unmasked multibyte text frames", function() { with(this) { driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]) assertEqual( "Apple = ", message ) }}) it("parses frames received in several packets", function() { with(this) { driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c]) driver().parse([0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]) assertEqual( "Apple = ", message ) }}) it("parses fragmented multibyte text frames", function() { with(this) { driver().parse([0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]) driver().parse([0x80, 0x01, 0xbf]) assertEqual( "Apple = ", message ) }}) it("parse masked multibyte text frames", function() { with(this) { driver().parse([0x81, 0x8b]) driver().parse(mask()) driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])) assertEqual( "Apple = ", message ) }}) it("parses masked fragmented multibyte text frames", function() { with(this) { driver().parse([0x01, 0x8a]) driver().parse(mask()) driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3])) driver().parse([0x80, 0x81]) driver().parse(mask()) driver().parse(maskMessage([0xbf])) assertEqual( "Apple = ", message ) }}) it("parses unmasked medium-length text frames", function() { with(this) { driver().parse([0x81, 0x7e, 0x00, 0xc8]) var i = 40, result = "" while (i--) { driver().parse([0x48, 0x65, 0x6c, 0x6c, 0x6f]) result += "Hello" } assertEqual( result, message ) }}) it("returns an error for too-large frames", function() { with(this) { driver().parse([0x81, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00]) assertEqual( "WebSocket frame length too large", error.message ) assertEqual( [1009, "WebSocket frame length too large"], close ) assertEqual( "closed", driver().getState() ) }}) it("parses masked medium-length text frames", function() { with(this) { driver().parse([0x81, 0xfe, 0x00, 0xc8]) driver().parse(mask()) var i = 40, result = "", packet = [] while (i--) { packet = packet.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f]) result += "Hello" } driver().parse(maskMessage(packet)) assertEqual( result, message ) }}) it("replies to pings with a pong", function() { with(this) { driver().parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49]) assertEqual( [0x8a, 0x04, 0x4f, 0x48, 0x41, 0x49], collector().bytes ) }}) it("triggers the onping event when a ping arrives", function() { with(this) { var ping, pong driver().on("ping", function(event) { ping = event }) driver().on("pong", function(event) { pong = event }) driver().parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49]) assertEqual( "OHAI", ping.data ) assertEqual( undefined, pong ) }}) describe("when a message listener throws an error", function() { with(this) { before(function() { with(this) { this.messages = [] driver().on("message", function(msg) { messages.push(msg.data) throw new Error("an error") }) }}) it("is not trapped by the parser", function() { with(this) { var buffer = [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f] assertThrows(Error, function() { driver().parse(buffer) }) }}) it("parses unmasked text frames without dropping input", function() { with(this) { try { driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05]) } catch (e) {} try { driver().parse([0x57, 0x6f, 0x72, 0x6c, 0x64]) } catch (e) {} assertEqual( ["Hello", "World"], messages ) }}) }}) }}) describe("frame", function() { with(this) { it("formats the given string as a WebSocket frame", function() { with(this) { driver().frame("Hello") assertEqual( [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes ) }}) it("formats a byte array as a binary WebSocket frame", function() { with(this) { driver().frame([0x48, 0x65, 0x6c]) assertEqual( [0x82, 0x03, 0x48, 0x65, 0x6c], collector().bytes ) }}) it("converts numbers to strings", function() { with(this) { driver().frame(50) assertEqual( [0x81, 0x02, 0x35, 0x30], collector().bytes ) }}) it("encodes multibyte characters correctly", function() { with(this) { driver().frame("Apple = ") assertEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], collector().bytes ) }}) it("encodes medium-length strings using extra length bytes", function() { with(this) { var i = 40, frame = [0x81, 0x7e, 0x00, 0xc8], string = "" while (i--) { string += "Hello" frame = frame.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f]) } driver().frame(string) assertEqual( frame, collector(). bytes ) }}) it("encodes close frames with an error code", function() { with(this) { driver().frame("Hello", "close", 1002) assertEqual( [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes ) }}) it("encodes pong frames", function() { with(this) { driver().frame("", "pong") assertEqual( [0x8a, 0x00], collector().bytes ) }}) }}) describe("ping", function() { with(this) { it("writes a ping frame to the socket", function() { with(this) { driver().ping("mic check") assertEqual( [0x89, 0x09, 0x6d, 0x69, 0x63, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b], collector().bytes ) }}) it("converts numbers to strings", function() { with(this) { driver().ping(50) assertEqual( [0x89, 0x02, 0x35, 0x30], collector().bytes ) }}) it("returns true", function() { with(this) { assertEqual( true, driver().ping() ) }}) it("runs the given callback on mathing pong", function() { with(this) { var reply = null driver().ping("Hi", function() { reply = true }) driver().parse([0x8a, 0x02, 72, 105]) assert( reply ) }}) it("triggers the onpong event when a pong arrives", function() { with(this) { var ping, pong driver().on("ping", function(event) { ping = event }) driver().on("pong", function(event) { pong = event }) driver().parse([0x8a, 0x02, 72, 105]) assertEqual( undefined, ping ) assertEqual( "Hi", pong.data ) }}) it("does not run the callback on non-matching pong", function() { with(this) { var reply = null driver().ping("Hi", function() { reply = true }) driver().parse([0x8a, 0x03, 119, 97, 116]) assert( !reply ) }}) }}) describe("pong", function() { with(this) { it("writes a pong frame to the socket", function() { with(this) { driver().pong("mic check") assertEqual([0x8a, 0x09, 0x6d, 0x69, 0x63, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b], collector().bytes) }}) it("returns true", function() { with(this) { assertEqual(true, driver().pong()) }}) }}) describe("close", function() { with(this) { it("writes a close frame to the socket", function() { with(this) { driver().close("<%= reasons %>", 1003) assertEqual( [0x88, 0x10, 0x03, 0xeb, 0x3c, 0x25, 0x3d, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x20, 0x25, 0x3e], collector().bytes ) }}) it("returns true", function() { with(this) { assertEqual( true, driver().close() ) }}) it("does not trigger the close event", function() { with(this) { driver().close() assertEqual( false, close ) }}) it("does not trigger the onerror event", function() { with(this) { driver().close() assertEqual( false, error ) }}) it("changes the state to closing", function() { with(this) { driver().close() assertEqual( "closing", driver().getState() ) }}) }}) }}) describe("when masking is required", function() { with(this) { before(function() { this.options().requireMasking = true this.driver().start() }) it("does not emit a message", function() { with(this) { driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]) assertEqual( "", message ) }}) it("returns an error", function() { with(this) { driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]) assertEqual( "Received unmasked frame but masking is required", error.message ) assertEqual( [1003, "Received unmasked frame but masking is required"], close ) }}) }}) describe("in the closing state", function() { with(this) { before(function() { this.driver().start() this.driver().close() }) describe("frame", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().frame("dropped") }}) it("returns true", function() { with(this) { assertEqual( true, driver().frame("wut") ) }}) }}) describe("ping", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().ping() }}) it("returns false", function() { with(this) { assertEqual( false, driver().ping() ) }}) }}) describe("pong", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().pong() }}) it("returns false", function() { with(this) { assertEqual( false, driver().pong() ) }}) }}) describe("close", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().close() }}) it("returns false", function() { with(this) { assertEqual( false, driver().close() ) }}) }}) describe("receiving a close frame", function() { with(this) { before(function() { this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b]) }) it("triggers the onclose event", function() { with(this) { assertEqual( [1001, "OK"], close ) }}) it("changes the state to closed", function() { with(this) { assertEqual( "closed", driver().getState() ) }}) it("does not write another close frame", function() { with(this) { expect(driver().io, "emit").exactly(0) this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b]) }}) }}) describe("receiving a close frame with a too-short payload", function() { with(this) { before(function() { this.driver().parse([0x88, 0x01, 0x03]) }) it("triggers the onclose event with a protocol error", function() { with(this) { assertEqual( [1002, ""], close ) }}) it("changes the state to closed", function() { with(this) { assertEqual( "closed", driver().getState() ) }}) }}) describe("receiving a close frame with no code", function() { with(this) { before(function() { with(this) { this.driver().parse([0x88, 0x00]) }}) it("triggers the onclose event with code 1000", function() { with(this) { assertEqual( [1000, ""], close ) }}) it("changes the state to closed", function() { with(this) { assertEqual( "closed", driver().getState() ) }}) }}) }}) describe("in the closed state", function() { with(this) { before(function() { this.driver().start() this.driver().close() this.driver().parse([0x88, 0x02, 0x03, 0xea]) }) describe("frame", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().frame("dropped") }}) it("returns false", function() { with(this) { assertEqual( false, driver().frame("wut") ) }}) }}) describe("ping", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().ping() }}) it("returns false", function() { with(this) { assertEqual( false, driver().ping() ) }}) }}) describe("pong", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().pong() }}) it("returns false", function() { with(this) { assertEqual( false, driver().pong() ) }}) }}) describe("close", function() { with(this) { it("does not write to the socket", function() { with(this) { expect(driver().io, "emit").exactly(0) driver().close() }}) it("returns false", function() { with(this) { assertEqual( false, driver().close() ) }}) it("leaves the state as closed", function() { with(this) { driver().close() assertEqual( "closed", driver().getState() ) }}) }}) }}) }})