pax_global_header 0000666 0000000 0000000 00000000064 12356212133 0014510 g ustar 00root root 0000000 0000000 52 comment=dbedb370b791a6af9ca5dcb939123552cdd88990
websocket-driver-node-0.3.5/ 0000775 0000000 0000000 00000000000 12356212133 0015717 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/.gitignore 0000664 0000000 0000000 00000000015 12356212133 0017703 0 ustar 00root root 0000000 0000000 node_modules
websocket-driver-node-0.3.5/.npmignore 0000664 0000000 0000000 00000000071 12356212133 0017714 0 ustar 00root root 0000000 0000000 .git
.gitignore
.npmignore
.travis.yml
node_modules
spec
websocket-driver-node-0.3.5/.travis.yml 0000664 0000000 0000000 00000000253 12356212133 0020030 0 ustar 00root root 0000000 0000000 language: node_js
node_js:
- "0.6"
- "0.8"
- "0.10"
- "0.11"
before_install:
- '[ "${TRAVIS_NODE_VERSION}" = "0.6" ] && npm conf set strict-ssl false || true'
websocket-driver-node-0.3.5/CHANGELOG.md 0000664 0000000 0000000 00000002401 12356212133 0017525 0 ustar 00root root 0000000 0000000 ### 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.3.5/README.md 0000664 0000000 0000000 00000025723 12356212133 0017207 0 ustar 00root root 0000000 0000000 # websocket-driver [](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`
* 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 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.createConnection(80, 'www.example.com');
tcp.pipe(driver.io).pipe(tcp);
driver.messages.on('data', function(message) {
console.log('Got a message', message);
});
tcp.on('connect', function() {
driver.start();
});
```
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
### 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) {})`
Sets the callback to execute when the socket becomes open.
#### `driver.on('message', function(event) {})`
Sets the 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) {})`
Sets the 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) {})`
Sets the callback to execute when the socket becomes closed. The `event` object
has `code` and `reason` attributes.
#### `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` iff 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.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.
## License
(The MIT License)
Copyright (c) 2010-2014 James Coglan
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the 'Software'), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
websocket-driver-node-0.3.5/examples/ 0000775 0000000 0000000 00000000000 12356212133 0017535 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/examples/tcp_server.js 0000664 0000000 0000000 00000000774 12356212133 0022257 0 ustar 00root root 0000000 0000000 var net = require('net'),
websocket = require('../lib/websocket/driver');
var server = net.createServer(function(connection) {
var driver = websocket.server();
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.3.5/lib/ 0000775 0000000 0000000 00000000000 12356212133 0016465 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/lib/websocket/ 0000775 0000000 0000000 00000000000 12356212133 0020453 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/lib/websocket/driver.js 0000664 0000000 0000000 00000002326 12356212133 0022307 0 ustar 00root root 0000000 0000000 // 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 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) {
if (request.method !== 'GET') return false;
var connection = request.headers.connection || '',
upgrade = request.headers.upgrade || '';
return request.method === 'GET' &&
connection.toLowerCase().split(/\s*,\s*/).indexOf('upgrade') >= 0 &&
upgrade.toLowerCase() === 'websocket';
}
};
module.exports = Driver;
websocket-driver-node-0.3.5/lib/websocket/driver/ 0000775 0000000 0000000 00000000000 12356212133 0021746 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/lib/websocket/driver/base.js 0000664 0000000 0000000 00000005561 12356212133 0023225 0 ustar 00root root 0000000 0000000 var Emitter = require('events').EventEmitter,
util = require('util'),
streams = require('../streams'),
Headers = require('./headers');
var Base = function(request, url, options) {
Emitter.call(this);
this._request = request;
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);
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;
},
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;
this._write(this._handshakeResponse());
if (this._stage !== -1) this._open();
return true;
},
text: function(message) {
return this.frame(message);
},
binary: function(message) {
return false;
},
ping: 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);
}
};
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;
};
module.exports = Base;
websocket-driver-node-0.3.5/lib/websocket/driver/client.js 0000664 0000000 0000000 00000006701 12356212133 0023566 0 ustar 00root root 0000000 0000000 var url = require('url'),
util = require('util'),
HttpParser = require('./http_parser'),
Base = require('./base'),
Hybi = require('./hybi');
var Client = function(url, options) {
this.version = 'hybi-13';
Hybi.call(this, null, url, options);
this.readyState = -1;
this._key = Client.generateKey();
this._accept = Hybi.generateAccept(this._key);
this._http = new HttpParser('response');
};
util.inherits(Client, Hybi);
Client.generateKey = function() {
var buffer = new Buffer(16), i = buffer.length;
while (i--) buffer[i] = Math.floor(Math.random() * 256);
return buffer.toString('base64');
};
var instance = {
start: function() {
if (this.readyState !== -1) return false;
this._write(this._handshakeRequest());
this.readyState = 0;
return true;
},
parse: function(data) {
if (this.readyState > 0) return Hybi.prototype.parse.call(this, data);
this._http.parse(data);
if (!this._http.isComplete()) return;
this._validateHandshake();
this.parse(this._http.body);
},
_handshakeRequest: function() {
var uri = url.parse(this.url);
var headers = [ 'GET ' + (uri.pathname || '/') + (uri.search || '') + ' HTTP/1.1',
'Host: ' + uri.hostname + (uri.port ? ':' + uri.port : ''),
'Upgrade: websocket',
'Connection: Upgrade',
'Sec-WebSocket-Key: ' + this._key,
'Sec-WebSocket-Version: 13'
];
if (this._protocols.length > 0)
headers.push('Sec-WebSocket-Protocol: ' + this._protocols.join(', '));
if (uri.auth)
headers.push('Authorization: Basic ' + new Buffer(uri.auth, 'utf8').toString('base64'));
return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
},
_failHandshake: function(message) {
message = 'Error during WebSocket handshake: ' + message;
this.emit('error', new Error(message));
this.readyState = 3;
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.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;
}
this._open();
}
};
for (var key in instance)
Client.prototype[key] = instance[key];
module.exports = Client;
websocket-driver-node-0.3.5/lib/websocket/driver/draft75.js 0000664 0000000 0000000 00000005727 12356212133 0023573 0 ustar 00root root 0000000 0000000 var Base = require('./base'),
util = require('util');
var Draft75 = function(request, url, options) {
Base.apply(this, arguments);
this._stage = 0;
this.version = 'hixie-75';
};
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(buffer) {
if (this.readyState > 1) return;
var data, message, value;
for (var i = 0, n = buffer.length; i < n; i++) {
data = buffer[i];
switch (this._stage) {
case -1:
this._body.push(data);
this._sendHandshakeBody();
break;
case 0:
this._parseLeadingByte(data);
break;
case 1:
value = (data & 0x7F);
this._length = value + 128 * this._length;
if (this._closing && this._length === 0) {
return this.close();
}
else if ((0x80 & data) !== 0x80) {
if (this._length === 0) {
this._stage = 0;
}
else {
this._skipped = 0;
this._stage = 2;
}
}
break;
case 2:
if (data === 0xFF) {
message = new Buffer(this._buffer).toString('utf8', 0, this._buffer.length);
this.emit('message', new Base.MessageEvent(message));
this._stage = 0;
}
else {
if (this._length) {
this._skipped += 1;
if (this._skipped === this._length)
this._stage = 0;
} else {
this._buffer.push(data);
if (this._buffer.length > this._maxLength) return this.close();
}
}
break;
}
}
},
frame: function(data) {
if (this.readyState === 0) return this._queue([data]);
if (this.readyState > 1) return false;
var buffer = new Buffer(data, 'utf8'),
frame = new Buffer(buffer.length + 2);
frame[0] = 0x00;
frame[buffer.length + 1] = 0xFF;
buffer.copy(frame, 1);
this._write(frame);
return true;
},
_handshakeResponse: function() {
return new Buffer('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
'Upgrade: WebSocket\r\n' +
'Connection: Upgrade\r\n' +
'WebSocket-Origin: ' + this._request.headers.origin + '\r\n' +
'WebSocket-Location: ' + this.url + '\r\n' +
this.__headers.toString() +
'\r\n',
'utf8');
},
_parseLeadingByte: function(data) {
if ((0x80 & data) === 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.3.5/lib/websocket/driver/draft76.js 0000664 0000000 0000000 00000005410 12356212133 0023561 0 ustar 00root root 0000000 0000000 var 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 bigEndian = function(number) {
var string = '';
[24, 16, 8, 0].forEach(function(offset) {
string += String.fromCharCode(number >> offset & 0xFF);
});
return string;
};
var Draft76 = function(request, url, options) {
Draft75.apply(this, arguments);
this._stage = -1;
this._body = [];
this.version = 'hixie-76';
};
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;
this._write(new Buffer([0xFF, 0x00]));
this.readyState = 3;
this.emit('close', new Base.CloseEvent(null, null));
return true;
},
_handshakeResponse: function() {
return new Buffer('HTTP/1.1 101 WebSocket Protocol Handshake\r\n' +
'Upgrade: WebSocket\r\n' +
'Connection: Upgrade\r\n' +
'Sec-WebSocket-Origin: ' + this._request.headers.origin + '\r\n' +
'Sec-WebSocket-Location: ' + this.url + '\r\n' +
this.__headers.toString() +
'\r\n',
'binary');
},
_handshakeSignature: function() {
if (this._body.length < this.BODY_SIZE) return null;
var body = new Buffer(this._body.slice(0, this.BODY_SIZE));
var headers = this._request.headers,
key1 = headers['sec-websocket-key1'],
value1 = numberFromKey(key1) / spacesInKey(key1),
key2 = headers['sec-websocket-key2'],
value2 = numberFromKey(key2) / spacesInKey(key2),
md5 = crypto.createHash('md5');
md5.update(bigEndian(value1));
md5.update(bigEndian(value2));
md5.update(body.toString('binary'));
return new Buffer(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(data) {
if (data !== 0xFF)
return Draft75.prototype._parseLeadingByte.call(this, data);
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.3.5/lib/websocket/driver/headers.js 0000664 0000000 0000000 00000001343 12356212133 0023720 0 ustar 00root root 0000000 0000000 var Headers = function() {
this._sent = {};
this._lines = [];
};
Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate']
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.3.5/lib/websocket/driver/http_parser.js 0000664 0000000 0000000 00000004001 12356212133 0024632 0 ustar 00root root 0000000 0000000 var HTTPParser = process.binding('http_parser').HTTPParser,
version = HTTPParser.RESPONSE ? 6 : 4;
var HttpParser = function(type) {
if (type === 'request')
this._parser = new HTTPParser(HTTPParser.REQUEST || 'request');
else
this._parser = new HTTPParser(HTTPParser.RESPONSE || 'response');
this._type = 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) {
self.headers[current] = b.toString('utf8', start, start + length);
};
this._parser.onHeadersComplete = this._parser[HTTPParser.kOnHeadersComplete] = function(info) {
self.method = (typeof info.method === 'number') ? HttpParser.METHODS[info.method] : info.method;
self.statusCode = info.statusCode;
self.url = info.url;
var headers = info.headers;
if (!headers) return;
for (var i = 0, n = headers.length; i < n; i += 2)
self.headers[headers[i].toLowerCase()] = headers[i+1];
};
this._parser.onMessageComplete = this._parser[HTTPParser.kOnMessageComplete] = function() {
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: 'REPORT',
17: 'MKACTIVITY',
18: 'CHECKOUT',
19: 'MERGE',
24: 'PATCH'
};
HttpParser.prototype.isComplete = function() {
return this._complete;
};
HttpParser.prototype.parse = function(data) {
var offset = (version < 6) ? 1 : 0,
consumed = this._parser.execute(data, 0, data.length) + offset;
if (this._complete)
this.body = (consumed < data.length)
? data.slice(consumed)
: new Buffer(0);
};
module.exports = HttpParser;
websocket-driver-node-0.3.5/lib/websocket/driver/hybi.js 0000664 0000000 0000000 00000030635 12356212133 0023246 0 ustar 00root root 0000000 0000000 var crypto = require('crypto'),
util = require('util'),
Base = require('./base'),
Reader = require('./hybi/stream_reader');
var Hybi = function(request, url, options) {
Base.apply(this, arguments);
this._reset();
this._reader = new Reader();
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(/\s*,\s*/);
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(/\s*,\s*/);
this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
}
var version = this._request.headers['sec-websocket-version'];
this.version = 'hybi-' + version;
};
util.inherits(Hybi, Base);
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 = {
BYTE: 255,
FIN: 128,
MASK: 128,
RSV1: 64,
RSV2: 32,
RSV3: 16,
OPCODE: 15,
LENGTH: 127,
OPCODES: {
continuation: 0,
text: 1,
binary: 2,
close: 8,
ping: 9,
pong: 10
},
OPCODE_CODES: [0, 1, 2, 8, 9, 10],
FRAGMENTED_OPCODES: [0, 1, 2],
OPENING_OPCODES: [1, 2],
TWO_POWERS: [0, 1, 2, 3, 4, 5, 6, 7].map(function(n) { return Math.pow(2, 8 * n) }),
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],
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})*$/,
parse: function(data) {
this._reader.put(data);
var buffer = true;
while (buffer) {
switch (this._stage) {
case 0:
buffer = this._reader.read(1);
if (buffer) this._parseOpcode(buffer[0]);
break;
case 1:
buffer = this._reader.read(1);
if (buffer) this._parseLength(buffer[0]);
break;
case 2:
buffer = this._reader.read(this._lengthSize);
if (buffer) this._parseExtendedLength(buffer);
break;
case 3:
buffer = this._reader.read(4);
if (buffer) {
this._mask = buffer;
this._stage = 4;
}
break;
case 4:
buffer = this._reader.read(this._length);
if (buffer) {
this._emitFrame(buffer);
this._stage = 0;
}
break;
default:
buffer = null;
}
}
},
frame: function(data, type, code) {
if (this.readyState <= 0) return this._queue([data, type, code]);
if (this.readyState !== 1) return false;
if (data instanceof Array) data = new Buffer(data);
var isText = (typeof data === 'string'),
opcode = this.OPCODES[type || (isText ? 'text' : 'binary')],
buffer = isText ? new Buffer(data, 'utf8') : data,
insert = code ? 2 : 0,
length = buffer.length + insert,
header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
offset = header + (this._masking ? 4 : 0),
masked = this._masking ? this.MASK : 0,
frame = new Buffer(length + offset),
BYTE = this.BYTE,
mask, i;
frame[0] = this.FIN | opcode;
if (length <= 125) {
frame[1] = masked | length;
} else if (length <= 65535) {
frame[1] = masked | 126;
frame[2] = Math.floor(length / 256);
frame[3] = length & BYTE;
} else {
frame[1] = masked | 127;
frame[2] = Math.floor(length / Math.pow(2,56)) & BYTE;
frame[3] = Math.floor(length / Math.pow(2,48)) & BYTE;
frame[4] = Math.floor(length / Math.pow(2,40)) & BYTE;
frame[5] = Math.floor(length / Math.pow(2,32)) & BYTE;
frame[6] = Math.floor(length / Math.pow(2,24)) & BYTE;
frame[7] = Math.floor(length / Math.pow(2,16)) & BYTE;
frame[8] = Math.floor(length / Math.pow(2,8)) & BYTE;
frame[9] = length & BYTE;
}
if (code) {
frame[offset] = Math.floor(code / 256) & BYTE;
frame[offset+1] = code & BYTE;
}
buffer.copy(frame, offset + insert);
if (this._masking) {
mask = [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256),
Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)];
new Buffer(mask).copy(frame, header);
Hybi.mask(frame, mask, offset);
}
this._write(frame);
return true;
},
text: function(message) {
return this.frame(message, 'text');
},
binary: function(message) {
return this.frame(message, 'binary');
},
ping: function(message, callback) {
message = message || '';
if (callback) this._pingCallbacks[message] = callback;
return this.frame(message, 'ping');
},
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.frame(reason, 'close', code);
this.readyState = 2;
return true;
} else {
return false;
}
},
_handshakeResponse: function() {
var secKey = this._request.headers['sec-websocket-key'];
if (!secKey) return '';
var headers = [
'HTTP/1.1 101 Switching Protocols',
'Upgrade: websocket',
'Connection: Upgrade',
'Sec-WebSocket-Accept: ' + Hybi.generateAccept(secKey)
];
if (this.protocol)
headers.push('Sec-WebSocket-Protocol: ' + this.protocol);
return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
},
_shutdown: function(code, reason) {
this.frame(reason, 'close', code);
this.readyState = 3;
this._stage = 5;
this.emit('close', new Base.CloseEvent(code, reason));
},
_fail: function(type, message) {
this.emit('error', new Error(message));
this._shutdown(this.ERRORS[type], message);
},
_parseOpcode: function(data) {
var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
return (data & rsv) === rsv;
});
if (rsvs.filter(function(rsv) { return rsv }).length > 0)
return this._fail('protocol_error',
'One or more reserved bits are on: reserved1 = ' + (rsvs[0] ? 1 : 0) +
', reserved2 = ' + (rsvs[1] ? 1 : 0) +
', reserved3 = ' + (rsvs[2] ? 1 : 0));
this._final = (data & this.FIN) === this.FIN;
this._opcode = (data & this.OPCODE);
if (this.OPCODE_CODES.indexOf(this._opcode) < 0)
return this._fail('protocol_error', 'Unrecognized frame opcode: ' + this._opcode);
if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && !this._final)
return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + this._opcode);
if (this._mode && this.OPENING_OPCODES.indexOf(this._opcode) >= 0)
return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
this._stage = 1;
},
_parseLength: function(data) {
this._masked = (data & this.MASK) === this.MASK;
if (this._requireMasking && !this._masked)
return this._fail('unacceptable', 'Received unmasked frame but masking is required');
this._length = (data & this.LENGTH);
if (this._length >= 0 && this._length <= 125) {
if (!this._checkFrameLength()) return;
this._stage = this._masked ? 3 : 4;
} else {
this._lengthSize = (this._length === 126 ? 2 : 8);
this._stage = 2;
}
},
_parseExtendedLength: function(buffer) {
this._length = this._getInteger(buffer);
if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && this._length > 125)
return this._fail('protocol_error', 'Received control frame having too long payload: ' + this._length);
if (!this._checkFrameLength()) return;
this._stage = this._masked ? 3 : 4;
},
_checkFrameLength: function() {
if (this.__blength + this._length > this._maxLength) {
this._fail('too_large', 'WebSocket frame length too large');
return false;
} else {
return true;
}
},
_emitFrame: function(buffer) {
var payload = Hybi.mask(buffer, this._mask),
isFinal = this._final,
opcode = this._opcode;
this._final = this._opcode = this._length = this._lengthSize = this._masked = this._mask = null;
if (opcode === this.OPCODES.continuation) {
if (!this._mode) return this._fail('protocol_error', 'Received unexpected continuation frame');
this._buffer(payload);
if (isFinal) {
var message = this._concatBuffer();
if (this._mode === 'text') message = this._encode(message);
this._reset();
if (message === null)
this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
else
this.emit('message', new Base.MessageEvent(message));
}
}
else if (opcode === this.OPCODES.text) {
if (isFinal) {
var message = this._encode(payload);
if (message === null)
this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
else
this.emit('message', new Base.MessageEvent(message));
} else {
this._mode = 'text';
this._buffer(payload);
}
}
else if (opcode === this.OPCODES.binary) {
if (isFinal) {
this.emit('message', new Base.MessageEvent(payload));
} else {
this._mode = 'binary';
this._buffer(payload);
}
}
else if (opcode === this.OPCODES.close) {
var code = (payload.length >= 2) ? 256 * payload[0] + payload[1] : null,
reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
if (!(payload.length === 0) &&
!(code !== null && code >= 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, reason || '');
}
else if (opcode === this.OPCODES.ping) {
this.frame(payload, 'pong');
}
else if (opcode === this.OPCODES.pong) {
var callbacks = this._pingCallbacks,
message = this._encode(payload),
callback = callbacks[message];
delete callbacks[message];
if (callback) callback()
}
},
_buffer: function(fragment) {
this.__buffer.push(fragment);
this.__blength += fragment.length;
},
_concatBuffer: function() {
var buffer = new Buffer(this.__blength),
offset = 0;
for (var i = 0, n = this.__buffer.length; i < n; i++) {
this.__buffer[i].copy(buffer, offset);
offset += this.__buffer[i].length;
}
return buffer;
},
_reset: function() {
this._mode = null;
this.__buffer = [];
this.__blength = 0;
},
_encode: function(buffer) {
try {
var string = buffer.toString('binary', 0, buffer.length);
if (!this.UTF8_MATCH.test(string)) return null;
} catch (e) {}
return buffer.toString('utf8', 0, buffer.length);
},
_getInteger: function(bytes) {
var number = 0;
for (var i = 0, n = bytes.length; i < n; i++)
number += bytes[i] * this.TWO_POWERS[n - 1 - i];
return number;
}
};
for (var key in instance)
Hybi.prototype[key] = instance[key];
module.exports = Hybi;
websocket-driver-node-0.3.5/lib/websocket/driver/hybi/ 0000775 0000000 0000000 00000000000 12356212133 0022701 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/lib/websocket/driver/hybi/stream_reader.js 0000664 0000000 0000000 00000001745 12356212133 0026063 0 ustar 00root root 0000000 0000000 var StreamReader = function() {
this._queue = [];
this._queueSize = 0;
this._cursor = 0;
};
StreamReader.prototype.put = function(buffer) {
if (!buffer || buffer.length === 0) return;
if (!buffer.copy) buffer = new Buffer(buffer);
this._queue.push(buffer);
this._queueSize += buffer.length;
};
StreamReader.prototype.read = function(length) {
if (length > this._queueSize) return null;
var buffer = new Buffer(length),
queue = this._queue,
remain = length,
n = queue.length,
i = 0,
chunk, size;
while (remain > 0 && i < n) {
chunk = queue[i];
size = Math.min(remain, chunk.length - this._cursor);
chunk.copy(buffer, length - remain, this._cursor, this._cursor + size);
remain -= size;
this._queueSize -= size;
this._cursor = (this._cursor + size) % chunk.length;
i += 1;
}
queue.splice(0, this._cursor === 0 ? i : i - 1);
return buffer;
};
module.exports = StreamReader;
websocket-driver-node-0.3.5/lib/websocket/driver/server.js 0000664 0000000 0000000 00000006045 12356212133 0023617 0 ustar 00root root 0000000 0000000 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'],
_bindEventListeners: function() {
this.messages.on('error', function() {});
this.on('error', function() {});
},
parse: function(data) {
if (this._delegate) return this._delegate.parse(data);
this._http.parse(data);
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._delegate.on('open', function() { self._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 = [];
}
};
['setHeader', 'start', 'state', '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,
url = this.determineUrl(request);
if (headers['sec-websocket-version'])
return new Hybi(request, url, options);
else if (headers['sec-websocket-key1'])
return new Draft76(request, url, options);
else
return new Draft75(request, url, options);
};
module.exports = Server;
websocket-driver-node-0.3.5/lib/websocket/streams.js 0000664 0000000 0000000 00000011327 12356212133 0022473 0 ustar 00root root 0000000 0000000 /**
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;
this._driver.frame(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.3.5/package.json 0000664 0000000 0000000 00000001375 12356212133 0020213 0 ustar 00root root 0000000 0000000 { "name" : "websocket-driver"
, "description" : "WebSocket protocol handler with pluggable I/O"
, "homepage" : "http://github.com/faye/websocket-driver-node"
, "author" : "James Coglan (http://jcoglan.com/)"
, "keywords" : ["websocket"]
, "license" : "MIT"
, "version" : "0.3.5"
, "engines" : {"node": ">=0.4.0"}
, "main" : "./lib/websocket/driver"
, "devDependencies" : {"jstest": ""}
, "scripts" : {"test": "jstest spec/runner.js"}
, "repository" : { "type" : "git"
, "url" : "git://github.com/faye/websocket-driver-node.git"
}
, "bugs" : "http://github.com/faye/websocket-driver-node/issues"
}
websocket-driver-node-0.3.5/spec/ 0000775 0000000 0000000 00000000000 12356212133 0016651 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/spec/runner.js 0000664 0000000 0000000 00000002221 12356212133 0020515 0 ustar 00root root 0000000 0000000 var test = require('jstest').Test,
Stream = require('stream').Stream,
util = require('util')
var BufferMatcher = function(data) {
this._data = (typeof data === 'string')
? new Buffer(data, 'utf8')
: new Buffer(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.3.5/spec/websocket/ 0000775 0000000 0000000 00000000000 12356212133 0020637 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/spec/websocket/driver/ 0000775 0000000 0000000 00000000000 12356212133 0022132 5 ustar 00root root 0000000 0000000 websocket-driver-node-0.3.5/spec/websocket/driver/client_spec.js 0000664 0000000 0000000 00000021707 12356212133 0024767 0 ustar 00root root 0000000 0000000 var Client = require("../../../lib/websocket/driver/client"),
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("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 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("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(new Buffer(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 = new Buffer(response().length + 4)
new Buffer(response()).copy(resp)
new Buffer([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(new Buffer(resp))
})
it("changes the state to closed", function() { with(this) {
assertEqual( false, open )
assertEqual( "Error during WebSocket handshake: Unexpected response code: 4", error.message )
assertEqual( [1002, "Error during WebSocket handshake: Unexpected response code: 4"], 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(new Buffer(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(new Buffer(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(new Buffer(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(new Buffer(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.3.5/spec/websocket/driver/draft75_examples.js 0000664 0000000 0000000 00000007753 12356212133 0025656 0 ustar 00root root 0000000 0000000 var 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("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("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.3.5/spec/websocket/driver/draft75_spec.js 0000664 0000000 0000000 00000006314 12356212133 0024762 0 ustar 00root root 0000000 0000000 var Draft75 = require("../../../lib/websocket/driver/draft75"),
test = require('jstest').Test
test.describe("Draft75", function() { with(this) {
define("request", function() {
return this._request = this._request || {
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.3.5/spec/websocket/driver/draft76_spec.js 0000664 0000000 0000000 00000014433 12356212133 0024764 0 ustar 00root root 0000000 0000000 var Draft76 = require("../../../lib/websocket/driver/draft76"),
test = require('jstest').Test
test.describe("Draft76", function() { with(this) {
BODY = new Buffer([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 || {
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('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("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 new Buffer([])
})
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.3.5/spec/websocket/driver/hybi_spec.js 0000664 0000000 0000000 00000044751 12356212133 0024450 0 ustar 00root root 0000000 0000000 var Hybi = require("../../../lib/websocket/driver/hybi"),
test = require('jstest').Test
test.describe("Hybi", function() { with(this) {
define("request", function() {
return this._request = this._request || {
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 custom headers", function() { with(this) {
before(function() { with(this) {
driver().setHeader("Authorization", "Bearer WAT")
}})
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" +
"Authorization: Bearer WAT\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("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 )
}})
}})
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("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("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("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("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 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("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() )
}})
}})
}})
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("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() )
}})
}})
}})
}})