@fairwords/websocket 1.0.35

package/lib/WebSocketRouterRequest.js

@@ -0,0 +1,54 @@
+/************************************************************************
+ *  Copyright 2010-2015 Brian McKelvey.
+ *
+ *  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.
+ ***********************************************************************/
+
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+
+function WebSocketRouterRequest(webSocketRequest, resolvedProtocol) {
+    // Superclass Constructor
+    EventEmitter.call(this);
+
+    this.webSocketRequest = webSocketRequest;
+    if (resolvedProtocol === '____no_protocol____') {
+        this.protocol = null;
+    }
+    else {
+        this.protocol = resolvedProtocol;
+    }
+    this.origin = webSocketRequest.origin;
+    this.resource = webSocketRequest.resource;
+    this.resourceURL = webSocketRequest.resourceURL;
+    this.httpRequest = webSocketRequest.httpRequest;
+    this.remoteAddress = webSocketRequest.remoteAddress;
+    this.webSocketVersion = webSocketRequest.webSocketVersion;
+    this.requestedExtensions = webSocketRequest.requestedExtensions;
+    this.cookies = webSocketRequest.cookies;
+}
+
+util.inherits(WebSocketRouterRequest, EventEmitter);
+
+WebSocketRouterRequest.prototype.accept = function(origin, cookies) {
+    var connection = this.webSocketRequest.accept(this.protocol, origin, cookies);
+    this.emit('requestAccepted', connection);
+    return connection;
+};
+
+WebSocketRouterRequest.prototype.reject = function(status, reason, extraHeaders) {
+    this.webSocketRequest.reject(status, reason, extraHeaders);
+    this.emit('requestRejected', this);
+};
+
+module.exports = WebSocketRouterRequest;

package/lib/WebSocketServer.js

@@ -0,0 +1,256 @@
+/************************************************************************
+ *  Copyright 2010-2015 Brian McKelvey.
+ *
+ *  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.
+ ***********************************************************************/
+
+var extend = require('./utils').extend;
+var utils = require('./utils');
+var util = require('util');
+var debug = require('debug')('websocket:server');
+var EventEmitter = require('events').EventEmitter;
+var WebSocketRequest = require('./WebSocketRequest');
+
+var WebSocketServer = function WebSocketServer(config) {
+    // Superclass Constructor
+    EventEmitter.call(this);
+
+    this._handlers = {
+        upgrade: this.handleUpgrade.bind(this),
+        requestAccepted: this.handleRequestAccepted.bind(this),
+        requestResolved: this.handleRequestResolved.bind(this)
+    };
+    this.connections = [];
+    this.pendingRequests = [];
+    if (config) {
+        this.mount(config);
+    }
+};
+
+util.inherits(WebSocketServer, EventEmitter);
+
+WebSocketServer.prototype.mount = function(config) {
+    this.config = {
+        // The http server instance to attach to.  Required.
+        httpServer: null,
+
+        // 64KiB max frame size.
+        maxReceivedFrameSize: 0x10000,
+
+        // 1MiB max message size, only applicable if
+        // assembleFragments is true
+        maxReceivedMessageSize: 0x100000,
+
+        // Outgoing messages larger than fragmentationThreshold will be
+        // split into multiple fragments.
+        fragmentOutgoingMessages: true,
+
+        // Outgoing frames are fragmented if they exceed this threshold.
+        // Default is 16KiB
+        fragmentationThreshold: 0x4000,
+
+        // If true, the server will automatically send a ping to all
+        // clients every 'keepaliveInterval' milliseconds.  The timer is
+        // reset on any received data from the client.
+        keepalive: true,
+
+        // The interval to send keepalive pings to connected clients if the
+        // connection is idle.  Any received data will reset the counter.
+        keepaliveInterval: 20000,
+
+        // If true, the server will consider any connection that has not
+        // received any data within the amount of time specified by
+        // 'keepaliveGracePeriod' after a keepalive ping has been sent to
+        // be dead, and will drop the connection.
+        // Ignored if keepalive is false.
+        dropConnectionOnKeepaliveTimeout: true,
+
+        // The amount of time to wait after sending a keepalive ping before
+        // closing the connection if the connected peer does not respond.
+        // Ignored if keepalive is false.
+        keepaliveGracePeriod: 10000,
+
+        // Whether to use native TCP keep-alive instead of WebSockets ping
+        // and pong packets.  Native TCP keep-alive sends smaller packets
+        // on the wire and so uses bandwidth more efficiently.  This may
+        // be more important when talking to mobile devices.
+        // If this value is set to true, then these values will be ignored:
+        //   keepaliveGracePeriod
+        //   dropConnectionOnKeepaliveTimeout
+        useNativeKeepalive: false,
+
+        // If true, fragmented messages will be automatically assembled
+        // and the full message will be emitted via a 'message' event.
+        // If false, each frame will be emitted via a 'frame' event and
+        // the application will be responsible for aggregating multiple
+        // fragmented frames.  Single-frame messages will emit a 'message'
+        // event in addition to the 'frame' event.
+        // Most users will want to leave this set to 'true'
+        assembleFragments: true,
+
+        // If this is true, websocket connections will be accepted
+        // regardless of the path and protocol specified by the client.
+        // The protocol accepted will be the first that was requested
+        // by the client.  Clients from any origin will be accepted.
+        // This should only be used in the simplest of cases.  You should
+        // probably leave this set to 'false' and inspect the request
+        // object to make sure it's acceptable before accepting it.
+        autoAcceptConnections: false,
+
+        // Whether or not the X-Forwarded-For header should be respected.
+        // It's important to set this to 'true' when accepting connections
+        // from untrusted clients, as a malicious client could spoof its
+        // IP address by simply setting this header.  It's meant to be added
+        // by a trusted proxy or other intermediary within your own
+        // infrastructure.
+        // See:  http://en.wikipedia.org/wiki/X-Forwarded-For
+        ignoreXForwardedFor: false,
+
+        // If this is true, 'cookie' headers are parsed and exposed as WebSocketRequest.cookies
+        parseCookies: true,
+
+        // If this is true, 'sec-websocket-extensions' headers are parsed and exposed as WebSocketRequest.requestedExtensions
+        parseExtensions: true,
+
+        // The Nagle Algorithm makes more efficient use of network resources
+        // by introducing a small delay before sending small packets so that
+        // multiple messages can be batched together before going onto the
+        // wire.  This however comes at the cost of latency, so the default
+        // is to disable it.  If you don't need low latency and are streaming
+        // lots of small messages, you can change this to 'false'
+        disableNagleAlgorithm: true,
+
+        // The number of milliseconds to wait after sending a close frame
+        // for an acknowledgement to come back before giving up and just
+        // closing the socket.
+        closeTimeout: 5000
+    };
+    extend(this.config, config);
+
+    if (this.config.httpServer) {
+        if (!Array.isArray(this.config.httpServer)) {
+            this.config.httpServer = [this.config.httpServer];
+        }
+        var upgradeHandler = this._handlers.upgrade;
+        this.config.httpServer.forEach(function(httpServer) {
+            httpServer.on('upgrade', upgradeHandler);
+        });
+    }
+    else {
+        throw new Error('You must specify an httpServer on which to mount the WebSocket server.');
+    }
+};
+
+WebSocketServer.prototype.unmount = function() {
+    var upgradeHandler = this._handlers.upgrade;
+    this.config.httpServer.forEach(function(httpServer) {
+        httpServer.removeListener('upgrade', upgradeHandler);
+    });
+};
+
+WebSocketServer.prototype.closeAllConnections = function() {
+    this.connections.forEach(function(connection) {
+        connection.close();
+    });
+    this.pendingRequests.forEach(function(request) {
+        process.nextTick(function() {
+          request.reject(503); // HTTP 503 Service Unavailable
+        });
+    });
+};
+
+WebSocketServer.prototype.broadcast = function(data) {
+    if (Buffer.isBuffer(data)) {
+        this.broadcastBytes(data);
+    }
+    else if (typeof(data.toString) === 'function') {
+        this.broadcastUTF(data);
+    }
+};
+
+WebSocketServer.prototype.broadcastUTF = function(utfData) {
+    this.connections.forEach(function(connection) {
+        connection.sendUTF(utfData);
+    });
+};
+
+WebSocketServer.prototype.broadcastBytes = function(binaryData) {
+    this.connections.forEach(function(connection) {
+        connection.sendBytes(binaryData);
+    });
+};
+
+WebSocketServer.prototype.shutDown = function() {
+    this.unmount();
+    this.closeAllConnections();
+};
+
+WebSocketServer.prototype.handleUpgrade = function(request, socket) {
+    var self = this;
+    var wsRequest = new WebSocketRequest(socket, request, this.config);
+    try {
+        wsRequest.readHandshake();
+    }
+    catch(e) {
+        wsRequest.reject(
+            e.httpCode ? e.httpCode : 400,
+            e.message,
+            e.headers
+        );
+        debug('Invalid handshake: %s', e.message);
+        this.emit('upgradeError', e);
+        return;
+    }
+
+    this.pendingRequests.push(wsRequest);
+
+    wsRequest.once('requestAccepted', this._handlers.requestAccepted);
+    wsRequest.once('requestResolved', this._handlers.requestResolved);
+    socket.once('close', function () {
+        self._handlers.requestResolved(wsRequest);
+    });
+
+    if (!this.config.autoAcceptConnections && utils.eventEmitterListenerCount(this, 'request') > 0) {
+        this.emit('request', wsRequest);
+    }
+    else if (this.config.autoAcceptConnections) {
+        wsRequest.accept(wsRequest.requestedProtocols[0], wsRequest.origin);
+    }
+    else {
+        wsRequest.reject(404, 'No handler is configured to accept the connection.');
+    }
+};
+
+WebSocketServer.prototype.handleRequestAccepted = function(connection) {
+    var self = this;
+    connection.once('close', function(closeReason, description) {
+        self.handleConnectionClose(connection, closeReason, description);
+    });
+    this.connections.push(connection);
+    this.emit('connect', connection);
+};
+
+WebSocketServer.prototype.handleConnectionClose = function(connection, closeReason, description) {
+    var index = this.connections.indexOf(connection);
+    if (index !== -1) {
+        this.connections.splice(index, 1);
+    }
+    this.emit('close', connection, closeReason, description);
+};
+
+WebSocketServer.prototype.handleRequestResolved = function(request) {
+    var index = this.pendingRequests.indexOf(request);
+    if (index !== -1) { this.pendingRequests.splice(index, 1); }
+};
+
+module.exports = WebSocketServer;

package/lib/browser.js

@@ -0,0 +1,54 @@
+var _globalThis;
+if (typeof globalThis === 'object') {
+	_globalThis = globalThis;
+} else {
+	try {
+		_globalThis = require('es5-ext/global');
+	} catch (error) {
+	} finally {
+		if (!_globalThis && typeof window !== 'undefined') { _globalThis = window; }
+		if (!_globalThis) { throw new Error('Could not determine global this'); }
+	}
+}
+
+var NativeWebSocket = _globalThis.WebSocket || _globalThis.MozWebSocket;
+var websocket_version = require('./version');
+
+
+/**
+ * Expose a W3C WebSocket class with just one or two arguments.
+ */
+function W3CWebSocket(uri, protocols) {
+	var native_instance;
+
+	if (protocols) {
+		native_instance = new NativeWebSocket(uri, protocols);
+	}
+	else {
+		native_instance = new NativeWebSocket(uri);
+	}
+
+	/**
+	 * 'native_instance' is an instance of nativeWebSocket (the browser's WebSocket
+	 * class). Since it is an Object it will be returned as it is when creating an
+	 * instance of W3CWebSocket via 'new W3CWebSocket()'.
+	 *
+	 * ECMAScript 5: http://bclary.com/2004/11/07/#a-13.2.2
+	 */
+	return native_instance;
+}
+if (NativeWebSocket) {
+	['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'].forEach(function(prop) {
+		Object.defineProperty(W3CWebSocket, prop, {
+			get: function() { return NativeWebSocket[prop]; }
+		});
+	});
+}
+
+/**
+ * Module exports.
+ */
+module.exports = {
+    'w3cwebsocket' : NativeWebSocket ? W3CWebSocket : null,
+    'version'      : websocket_version
+};

package/lib/utils.js

@@ -0,0 +1,66 @@
+var noop = exports.noop = function(){};
+
+exports.extend = function extend(dest, source) {
+    for (var prop in source) {
+        dest[prop] = source[prop];
+    }
+};
+
+exports.eventEmitterListenerCount =
+    require('events').EventEmitter.listenerCount ||
+    function(emitter, type) { return emitter.listeners(type).length; };
+
+exports.bufferAllocUnsafe = Buffer.allocUnsafe ?
+    Buffer.allocUnsafe :
+    function oldBufferAllocUnsafe(size) { return new Buffer(size); };
+
+exports.bufferFromString = Buffer.from ?
+    Buffer.from :
+    function oldBufferFromString(string, encoding) {
+      return new Buffer(string, encoding);
+    };
+
+exports.BufferingLogger = function createBufferingLogger(identifier, uniqueID) {
+    var logFunction = require('debug')(identifier);
+    if (logFunction.enabled) {
+        var logger = new BufferingLogger(identifier, uniqueID, logFunction);
+        var debug = logger.log.bind(logger);
+        debug.printOutput = logger.printOutput.bind(logger);
+        debug.enabled = logFunction.enabled;
+        return debug;
+    }
+    logFunction.printOutput = noop;
+    return logFunction;
+};
+
+function BufferingLogger(identifier, uniqueID, logFunction) {
+    this.logFunction = logFunction;
+    this.identifier = identifier;
+    this.uniqueID = uniqueID;
+    this.buffer = [];
+}
+
+BufferingLogger.prototype.log = function() {
+  this.buffer.push([ new Date(), Array.prototype.slice.call(arguments) ]);
+  return this;
+};
+
+BufferingLogger.prototype.clear = function() {
+  this.buffer = [];
+  return this;
+};
+
+BufferingLogger.prototype.printOutput = function(logFunction) {
+    if (!logFunction) { logFunction = this.logFunction; }
+    var uniqueID = this.uniqueID;
+    this.buffer.forEach(function(entry) {
+        var date = entry[0].toLocaleString();
+        var args = entry[1].slice();
+        var formatString = args[0];
+        if (formatString !== (void 0) && formatString !== null) {
+            formatString = '%s - %s - ' + formatString.toString();
+            args.splice(0, 1, formatString, date, uniqueID);
+            logFunction.apply(global, args);
+        }
+    });
+};

package/lib/version.js

@@ -0,0 +1 @@
+module.exports = require('../package.json').version;

package/lib/websocket.js

@@ -0,0 +1,11 @@
+module.exports = {
+    'server'       : require('./WebSocketServer'),
+    'client'       : require('./WebSocketClient'),
+    'router'       : require('./WebSocketRouter'),
+    'frame'        : require('./WebSocketFrame'),
+    'request'      : require('./WebSocketRequest'),
+    'connection'   : require('./WebSocketConnection'),
+    'w3cwebsocket' : require('./W3CWebSocket'),
+    'deprecation'  : require('./Deprecation'),
+    'version'      : require('./version')
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@fairwords/websocket",
+  "description": "Websocket Client & Server Library implementing the WebSocket protocol as specified in RFC 6455.",
+  "keywords": [
+    "websocket",
+    "websockets",
+    "socket",
+    "networking",
+    "comet",
+    "push",
+    "RFC-6455",
+    "realtime",
+    "server",
+    "client"
+  ],
+  "author": "Brian McKelvey <theturtle32@gmail.com> (https://github.com/theturtle32)",
+  "contributors": [
+    "Iñaki Baz Castillo <ibc@aliax.net> (http://dev.sipdoc.net)"
+  ],
+  "version": "1.0.35",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/theturtle32/WebSocket-Node.git"
+  },
+  "homepage": "https://github.com/theturtle32/WebSocket-Node",
+  "engines": {
+    "node": ">=4.0.0"
+  },
+  "dependencies": {
+    "bufferutil": "^4.0.1",
+    "debug": "^2.2.0",
+    "es5-ext": "^0.10.50",
+    "typedarray-to-buffer": "^3.1.5",
+    "utf-8-validate": "^5.0.2",
+    "yaeti": "^0.0.6"
+  },
+  "devDependencies": {
+    "buffer-equal": "^1.0.0",
+    "gulp": "^4.0.2",
+    "gulp-jshint": "^2.0.4",
+    "jshint-stylish": "^2.2.1",
+    "jshint": "^2.0.0",
+    "tape": "^4.9.1"
+  },
+  "config": {
+    "verbose": false
+  },
+  "scripts": {
+    "test": "tape test/unit/*.js",
+    "gulp": "gulp"
+  },
+  "main": "index",
+  "directories": {
+    "lib": "./lib"
+  },
+  "browser": "lib/browser.js",
+  "license": "Apache-2.0"
+}

package/vendor/FastBufferList.js

@@ -0,0 +1,191 @@
+// This file was copied from https://github.com/substack/node-bufferlist
+// and modified to be able to copy bytes from the bufferlist directly into
+// a pre-existing fixed-size buffer without an additional memory allocation.
+
+// bufferlist.js
+// Treat a linked list of buffers as a single variable-size buffer.
+var Buffer = require('buffer').Buffer;
+var EventEmitter = require('events').EventEmitter;
+var bufferAllocUnsafe = require('../lib/utils').bufferAllocUnsafe;
+
+module.exports = BufferList;
+module.exports.BufferList = BufferList; // backwards compatibility
+
+function BufferList(opts) {
+    if (!(this instanceof BufferList)) return new BufferList(opts);
+    EventEmitter.call(this);
+    var self = this;
+    
+    if (typeof(opts) == 'undefined') opts = {};
+    
+    // default encoding to use for take(). Leaving as 'undefined'
+    // makes take() return a Buffer instead.
+    self.encoding = opts.encoding;
+    
+    var head = { next : null, buffer : null };
+    var last = { next : null, buffer : null };
+    
+    // length can get negative when advanced past the end
+    // and this is the desired behavior
+    var length = 0;
+    self.__defineGetter__('length', function () {
+        return length;
+    });
+    
+    // keep an offset of the head to decide when to head = head.next
+    var offset = 0;
+    
+    // Write to the bufferlist. Emits 'write'. Always returns true.
+    self.write = function (buf) {
+        if (!head.buffer) {
+            head.buffer = buf;
+            last = head;
+        }
+        else {
+            last.next = { next : null, buffer : buf };
+            last = last.next;
+        }
+        length += buf.length;
+        self.emit('write', buf);
+        return true;
+    };
+    
+    self.end = function (buf) {
+        if (Buffer.isBuffer(buf)) self.write(buf);
+    };
+    
+    // Push buffers to the end of the linked list. (deprecated)
+    // Return this (self).
+    self.push = function () {
+        var args = [].concat.apply([], arguments);
+        args.forEach(self.write);
+        return self;
+    };
+    
+    // For each buffer, perform some action.
+    // If fn's result is a true value, cut out early.
+    // Returns this (self).
+    self.forEach = function (fn) {
+        if (!head.buffer) return bufferAllocUnsafe(0);
+        
+        if (head.buffer.length - offset <= 0) return self;
+        var firstBuf = head.buffer.slice(offset);
+        
+        var b = { buffer : firstBuf, next : head.next };
+        
+        while (b && b.buffer) {
+            var r = fn(b.buffer);
+            if (r) break;
+            b = b.next;
+        }
+        
+        return self;
+    };
+    
+    // Create a single Buffer out of all the chunks or some subset specified by
+    // start and one-past the end (like slice) in bytes.
+    self.join = function (start, end) {
+        if (!head.buffer) return bufferAllocUnsafe(0);
+        if (start == undefined) start = 0;
+        if (end == undefined) end = self.length;
+        
+        var big = bufferAllocUnsafe(end - start);
+        var ix = 0;
+        self.forEach(function (buffer) {
+            if (start < (ix + buffer.length) && ix < end) {
+                // at least partially contained in the range
+                buffer.copy(
+                    big,
+                    Math.max(0, ix - start),
+                    Math.max(0, start - ix),
+                    Math.min(buffer.length, end - ix)
+                );
+            }
+            ix += buffer.length;
+            if (ix > end) return true; // stop processing past end
+        });
+        
+        return big;
+    };
+    
+    self.joinInto = function (targetBuffer, targetStart, sourceStart, sourceEnd) {
+        if (!head.buffer) return new bufferAllocUnsafe(0);
+        if (sourceStart == undefined) sourceStart = 0;
+        if (sourceEnd == undefined) sourceEnd = self.length;
+        
+        var big = targetBuffer;
+        if (big.length - targetStart < sourceEnd - sourceStart) {
+            throw new Error("Insufficient space available in target Buffer.");
+        }
+        var ix = 0;
+        self.forEach(function (buffer) {
+            if (sourceStart < (ix + buffer.length) && ix < sourceEnd) {
+                // at least partially contained in the range
+                buffer.copy(
+                    big,
+                    Math.max(targetStart, targetStart + ix - sourceStart),
+                    Math.max(0, sourceStart - ix),
+                    Math.min(buffer.length, sourceEnd - ix)
+                );
+            }
+            ix += buffer.length;
+            if (ix > sourceEnd) return true; // stop processing past end
+        });
+        
+        return big;
+    };
+    
+    // Advance the buffer stream by n bytes.
+    // If n the aggregate advance offset passes the end of the buffer list,
+    // operations such as .take() will return empty strings until enough data is
+    // pushed.
+    // Returns this (self).
+    self.advance = function (n) {
+        offset += n;
+        length -= n;
+        while (head.buffer && offset >= head.buffer.length) {
+            offset -= head.buffer.length;
+            head = head.next
+                ? head.next
+                : { buffer : null, next : null }
+            ;
+        }
+        if (head.buffer === null) last = { next : null, buffer : null };
+        self.emit('advance', n);
+        return self;
+    };
+    
+    // Take n bytes from the start of the buffers.
+    // Returns a string.
+    // If there are less than n bytes in all the buffers or n is undefined,
+    // returns the entire concatenated buffer string.
+    self.take = function (n, encoding) {
+        if (n == undefined) n = self.length;
+        else if (typeof n !== 'number') {
+            encoding = n;
+            n = self.length;
+        }
+        var b = head;
+        if (!encoding) encoding = self.encoding;
+        if (encoding) {
+            var acc = '';
+            self.forEach(function (buffer) {
+                if (n <= 0) return true;
+                acc += buffer.toString(
+                    encoding, 0, Math.min(n,buffer.length)
+                );
+                n -= buffer.length;
+            });
+            return acc;
+        } else {
+            // If no 'encoding' is specified, then return a Buffer.
+            return self.join(0, n);
+        }
+    };
+    
+    // The entire concatenated buffer as a string.
+    self.toString = function () {
+        return self.take('binary');
+    };
+}
+require('util').inherits(BufferList, EventEmitter);