248 lines
7.3 KiB
JavaScript
248 lines
7.3 KiB
JavaScript
/**
|
|
* WebSocket transport. Needed because browsers can't handle TCP sockets
|
|
* so we use separate WebSocket server to proxy messages into TCP data
|
|
* packets. Available for both Node.js and Browser platforms.
|
|
* **NOTE**: `WsTransport` is exported as a module.
|
|
* @example var WsTransport = require("bitmessage/lib/net/ws");
|
|
* @module bitmessage/net/ws
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
var objectAssign = Object.assign || require("object-assign");
|
|
var inherits = require("inherits");
|
|
var WebSocket = require("ws"); // jshint ignore:line
|
|
var assert = require("../_util").assert;
|
|
var PPromise = require("../platform").Promise;
|
|
var structs = require("../structs");
|
|
var messages = require("../messages");
|
|
var BaseTransport = require("./base");
|
|
|
|
var WebSocketServer = WebSocket.Server;
|
|
var ServicesBitfield = structs.ServicesBitfield;
|
|
var getmsg = BaseTransport._getmsg;
|
|
var unmap = BaseTransport._unmap;
|
|
|
|
/**
|
|
* WebSocket transport class. Implements
|
|
* [base transport interface]{@link
|
|
* module:bitmessage/net/base.BaseTransport}.
|
|
* @param {Object=} opts - Transport options
|
|
* @param {Array} opts.seeds - Bootstrap nodes (none by default)
|
|
* @param {Object} opts.services -
|
|
* [Service features]{@link module:bitmessage/structs.ServicesBitfield}
|
|
* provided by this node (`NODE_MOBILE` for Browser and `NODE_MOBILE` +
|
|
* `NODE_GATEWAY` for Node by default)
|
|
* @param {(Array|string|Buffer)} opts.userAgent -
|
|
* [User agent]{@link module:bitmessage/user-agent} of this node
|
|
* (user agent of bitmessage library by default)
|
|
* @param {number[]} opts.streams - Streams accepted by this node ([1]
|
|
* by default)
|
|
* @param {number} opts.port - Incoming port of this node, makes sence
|
|
* only on Node platform (18444 by default)
|
|
* @constructor
|
|
* @static
|
|
*/
|
|
function WsTransport(opts) {
|
|
WsTransport.super_.call(this);
|
|
objectAssign(this, opts);
|
|
this.seeds = this.seeds || [];
|
|
this.services = this.services || ServicesBitfield().set([
|
|
ServicesBitfield.NODE_MOBILE,
|
|
ServicesBitfield.NODE_GATEWAY,
|
|
]);
|
|
this.streams = this.streams || [1];
|
|
this.port = this.port || 18444;
|
|
}
|
|
|
|
inherits(WsTransport, BaseTransport);
|
|
|
|
WsTransport.prototype._sendVersion = function() {
|
|
return this.send(messages.version.encode({
|
|
services: this.services,
|
|
userAgent: this.userAgent,
|
|
streams: this.streams,
|
|
port: this.port,
|
|
remoteHost: this._client._socket.remoteAddress,
|
|
remotePort: this._client._socket.remotePort,
|
|
}));
|
|
};
|
|
|
|
WsTransport.prototype._handleTimeout = function() {
|
|
var client = this._client;
|
|
// TODO(Kagami): We may also want to close connection if it wasn't
|
|
// established within minute.
|
|
client._socket.setTimeout(20000);
|
|
client._socket.on("timeout", function() {
|
|
client.close();
|
|
});
|
|
this.on("established", function() {
|
|
// Raise timeout up to 10 minutes per spec.
|
|
// TODO(Kagami): Send ping frame every 5 minutes as PyBitmessage.
|
|
client._socket.setTimeout(600000);
|
|
});
|
|
};
|
|
|
|
WsTransport.prototype._setupClient = function(client, incoming) {
|
|
var self = this;
|
|
self._client = client;
|
|
var verackSent = false;
|
|
var verackReceived = false;
|
|
var established = false;
|
|
|
|
client.on("open", function() {
|
|
// NOTE(Kagami): This handler shouldn't be called at all for
|
|
// incoming connections but let's be sure.
|
|
if (!incoming) {
|
|
// NOTE(Kagami): We may set timeout only after connection was
|
|
// opened because socket may not yet be available when
|
|
// `_setupClient` is called.
|
|
self._handleTimeout();
|
|
self.emit("open");
|
|
self._sendVersion();
|
|
}
|
|
});
|
|
|
|
client.on("message", function(data, flags) {
|
|
var decoded;
|
|
if (!flags.binary) {
|
|
// TODO(Kagami): Send `error` message and ban node for some time
|
|
// if there were too many errors?
|
|
return self.emit("warning", new Error("Peer sent non-binary data"));
|
|
}
|
|
try {
|
|
decoded = structs.message.decode(data);
|
|
} catch (err) {
|
|
return self.emit("warning", new Error(
|
|
"Message decoding error: " + err.message
|
|
));
|
|
}
|
|
self.emit("message", decoded.command, decoded.payload);
|
|
});
|
|
|
|
// High-level message processing.
|
|
self.on("message", function(command, payload) {
|
|
var version;
|
|
var veropts = incoming ? {mobile: true} : {gateway: true};
|
|
if (!established) {
|
|
if (command === "version") {
|
|
if (verackSent) {
|
|
return;
|
|
}
|
|
try {
|
|
version = self._decodeVersion(payload, veropts);
|
|
} catch(err) {
|
|
self.emit("error", err);
|
|
return client.close();
|
|
}
|
|
self.send("verack");
|
|
verackSent = true;
|
|
if (incoming) {
|
|
self._sendVersion();
|
|
} else if (verackReceived) {
|
|
established = true;
|
|
self.emit("established", version);
|
|
}
|
|
} else if (command === "verack") {
|
|
verackReceived = true;
|
|
if (verackSent) {
|
|
established = true;
|
|
self.emit("established", version);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
client.on("error", function(err) {
|
|
self.emit("error", err);
|
|
});
|
|
|
|
client.on("close", function() {
|
|
self.emit("close");
|
|
delete self._client;
|
|
});
|
|
};
|
|
|
|
WsTransport.prototype.bootstrap = function() {
|
|
return PPromise.resolve([].concat(this.seeds));
|
|
};
|
|
|
|
/**
|
|
* Connect to a WebSocket node. Connection arguments are the same as for
|
|
* [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket).
|
|
*/
|
|
WsTransport.prototype.connect = function(address, protocols, options) {
|
|
assert(!this._client, "Already connected");
|
|
assert(!this._server, "Already listening");
|
|
// `new` doesn't work with `apply`, so passing all possible arguments
|
|
// manually.
|
|
this._setupClient(new WebSocket(address, protocols, options));
|
|
};
|
|
|
|
/**
|
|
* Listen for incoming WebSocket connections. Listen arguments are the
|
|
* same as for
|
|
* [WebSocketServer](https://github.com/websockets/ws#server-example).
|
|
* Available only for Node platform.
|
|
*/
|
|
WsTransport.prototype.listen = function(options, callback) {
|
|
assert(!this._client, "Already connected");
|
|
assert(!this._server, "Already listening");
|
|
|
|
var self = this;
|
|
var server = self._server = new WebSocketServer(options, callback);
|
|
|
|
server.on("connection", function(client) {
|
|
var opts = objectAssign({}, self);
|
|
delete opts._server;
|
|
var transport = new self.constructor(opts);
|
|
var incoming = true;
|
|
transport._setupClient(client, incoming);
|
|
transport._handleTimeout();
|
|
var addr = client._socket.remoteAddress;
|
|
var port = client._socket.remotePort;
|
|
self.emit("connection", transport, unmap(addr), port);
|
|
});
|
|
|
|
server.on("error", function(err) {
|
|
self.emit("error", err);
|
|
});
|
|
|
|
// `ws` doesn't emit "close" event by default.
|
|
server._server.on("close", function() {
|
|
self.emit("close");
|
|
delete self._server;
|
|
});
|
|
};
|
|
|
|
WsTransport.prototype.send = function() {
|
|
if (this._client) {
|
|
// TODO(Kagami): `mask: true` doesn't work with Chromium 40. File a
|
|
// bug to ws bugtracker.
|
|
this._client.send(getmsg(arguments), {binary: true});
|
|
} else {
|
|
throw new Error("Not connected");
|
|
}
|
|
};
|
|
|
|
WsTransport.prototype.broadcast = function() {
|
|
var data = getmsg(arguments);
|
|
if (this._server) {
|
|
this._server.clients.forEach(function(client) {
|
|
client.send(data, {binary: true});
|
|
});
|
|
} else {
|
|
throw new Error("Not listening");
|
|
}
|
|
};
|
|
|
|
WsTransport.prototype.close = function() {
|
|
if (this._client) {
|
|
this._client.close();
|
|
} else if (this._server) {
|
|
this._server.close();
|
|
}
|
|
};
|
|
|
|
module.exports = WsTransport;
|