Merge pull request #272 from bookchin/master

v2.0.5

lib/datachannel/errorcodes.js

@@ -0,0 +1,20 @@
+/**
+ * @module storj/datachannel/errors
+ */
+
+'use strict';
+
+/** @static {Number} UNEXPECTED */
+module.exports.UNEXPECTED = 1011;
+
+/** @static {Number} INVALID_MESSAGE */
+module.exports.INVALID_MESSAGE = 3100;
+
+/** @static {Number} UNAUTHORIZED_TOKEN */
+module.exports.UNAUTHORIZED_TOKEN = 3101;
+
+/** @static {Number} FAILED_INTEGRITY */
+module.exports.FAILED_INTEGRITY = 3102;
+
+/** @static {Number} INVALID_OPERATION */
+module.exports.INVALID_OPERATION = 3103;

lib/datachannel/server.js

@@ -9,6 +9,7 @@ var inherits = require('util').inherits;
 var crypto = require('crypto');
 var utils = require('../utils');
 var constants = require('../constants');
+var DataChannelErrors = require('../../lib/datachannel/errorcodes');
 
 /**
  * Creates a data channel server for sending and receiving consigned file shards
@@ -105,22 +106,25 @@ DataChannelServer.prototype._handleConnection = function(socket) {
 
   socket.on('error', function(err) {
     self._log.error('data channel connection error: %s', err.message);
-    socket.close(500, err.message);
+    socket.close(DataChannelErrors.UNEXPECTED, err.message);
   });
 
   socket.on('message', function(data) {
     try {
       data = JSON.parse(data);
     } catch (err) {
-      return socket.close(400, 'Failed to parse message');
+      return socket.close(
+        DataChannelErrors.INVALID_MESSAGE,
+        'Failed to parse message'
+      );
     }
 
     token = data.token;
 
     try {
       self._authorize(token, data.hash);
     } catch (err) {
-      return socket.close(401, err.message);
+      return socket.close(DataChannelErrors.UNAUTHORIZED_TOKEN, err.message);
     }
 
     self._allowed[token].client = socket;
@@ -175,7 +179,7 @@ DataChannelServer.prototype._handleConsignStream = function(socket, token) {
 
   this._manager.load(hash, function(err, item) {
     if (err) {
-      socket.close(500, err.message);
+      socket.close(DataChannelErrors.UNEXPECTED, err.message);
       return self.reject(token);
     }
 
@@ -206,7 +210,10 @@ DataChannelServer.prototype._handleConsignStream = function(socket, token) {
     passthrough.on('end', function() {
       if (utils.rmd160(hasher.digest('hex')) !== hash) {
         self._log.warn('calculated hash does not match the expected result');
-        socket.close(400, 'Calculated hash does not match the expected result');
+        socket.close(
+          DataChannelErrors.FAILED_INTEGRITY,
+          'Calculated hash does not match the expected result'
+        );
         return self.reject(token);
       }
 
@@ -230,7 +237,7 @@ DataChannelServer.prototype._handleRetrieveStream = function(socket, token) {
 
   this._manager.load(hash, function(err, item) {
     if (err) {
-      socket.close(500, err.message);
+      socket.close(DataChannelErrors.UNEXPECTED, err.message);
       return self.reject(token);
     }
 
@@ -264,7 +271,10 @@ DataChannelServer.prototype._handleRetrieveStream = function(socket, token) {
 DataChannelServer.prototype._handleUnknownStream = function(stream, token) {
   var client = this._allowed[token].client;
 
-  client.close(400, 'Failed to handle the defined operation');
+  client.close(
+    DataChannelErrors.INVALID_OPERATION,
+    'Failed to handle the defined operation'
+  );
   this.reject(token);
 };
 

lib/tunnel/errorcodes.js

@@ -0,0 +1,14 @@
+/**
+ * @module storj/tunnel/errors
+ */
+
+'use strict';
+
+/** @static {Number} UNEXPECTED */
+module.exports.UNEXPECTED = 1011;
+
+/** @static {Number} GATEWAY_CLOSED */
+module.exports.GATEWAY_CLOSED = 4100;
+
+/** @static {Number} INVALID_FRAME_TYPE */
+module.exports.INVALID_FRAME_TYPE = 4101;

lib/tunnel/server.js

@@ -10,18 +10,19 @@ var qs = require('querystring');
 var events = require('events');
 var inherits = require('util').inherits;
 var async = require('async');
+var TunnelErrors = require('./errorcodes');
 
 /**
  * Creates a Tunnel server for NATed or firewalled clients to use to join the
  * overlay network.
  * @constructor
- * @param {Object}      options
+ * @param {Object} options
  * @param {http.Server} options.server - Transport adapter to bind to
- * @param {Number}      options.port - Port to bind if no server provided
- * @param {Number}      options.maxTunnels - Maximum number of gateways to open
- * @param {Object}      options.portRange
- * @param {Number}      options.portRange.min - Starting port to allow gateways
- * @param {Number}      options.portRange.max - Ending port to allow gateways
+ * @param {Number} options.port - Port to bind if no server provided
+ * @param {Number} options.maxTunnels - Maximum number of gateways to open
+ * @param {Object} options.portRange
+ * @param {Number} options.portRange.min - Starting port to allow gateways
+ * @param {Number} options.portRange.max - Ending port to allow gateways
  */
 function TunnelServer(options) {
   if (!(this instanceof TunnelServer)) {
@@ -235,7 +236,10 @@ TunnelServer.prototype._handleClient = function(client) {
   var token = this._extractTokenFromRequest(client.upgradeReq);
 
   if (!this._gateways[token]) {
-    return client.close(404, { error: 'Gateway no longer open' });
+    return client.close(
+      TunnelErrors.GATEWAY_CLOSED,
+      'Gateway no longer open'
+    );
   }
 
   var gateway = this._gateways[token];
@@ -250,7 +254,7 @@ TunnelServer.prototype._handleClient = function(client) {
 
   demuxer
     .on('error', function(err) {
-      client.close(400, { error: err.message });
+      client.close(TunnelErrors.UNEXPECTED, err.message);
     })
     .on('data', function(object) {
       switch (object.type) {
@@ -259,13 +263,16 @@ TunnelServer.prototype._handleClient = function(client) {
         case 'datachannel':
           return gateway.transfer(object.flags.quid, object.data);
         default:
-          client.close(400, { error: 'Cannot handle tunnel frame type' });
+          client.close(
+            TunnelErrors.INVALID_FRAME_TYPE,
+            'Cannot handle tunnel frame type'
+          );
       }
     });
 
   muxer
     .on('error', function(err) {
-      client.close(400, { error: err.message });
+      client.close(TunnelErrors.UNEXPECTED, err.message);
     })
     .on('data', function(data) {
       if (ws.OPEN !== client.readyState) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "storj",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "implementation of the storj protocol for node.js and the browser",
   "main": "index.js",
   "directories": {

test/datachannel/server.unit.js

@@ -7,6 +7,7 @@ var RAMStorageAdapter = require('../../lib/storage/adapters/ram');
 var Manager = require('../../lib/manager');
 var Logger = require('kad').Logger;
 var DataChannelServer = require('../../lib/datachannel/server');
+var DataChannelErrors = require('../../lib/datachannel/errorcodes');
 var sinon = require('sinon');
 var EventEmitter = require('events').EventEmitter;
 var http = require('http');
@@ -66,7 +67,7 @@ describe('DataChannelServer', function() {
       });
       var socket = new EventEmitter();
       socket.close = function(code, message) {
-        expect(code).to.equal(500);
+        expect(code).to.equal(DataChannelErrors.UNEXPECTED);
         expect(message).to.equal('Socket error');
         done();
       };
@@ -84,7 +85,7 @@ describe('DataChannelServer', function() {
       });
       var socket = new EventEmitter();
       socket.close = function(code, message) {
-        expect(code).to.equal(400);
+        expect(code).to.equal(DataChannelErrors.INVALID_MESSAGE);
         expect(message).to.equal('Failed to parse message');
         done();
       };
@@ -102,7 +103,7 @@ describe('DataChannelServer', function() {
       });
       var socket = new EventEmitter();
       socket.close = function(code, message) {
-        expect(code).to.equal(401);
+        expect(code).to.equal(DataChannelErrors.UNAUTHORIZED_TOKEN);
         expect(message).to.equal('The supplied token is not accepted');
         done();
       };
@@ -128,7 +129,7 @@ describe('DataChannelServer', function() {
       };
       var socket = new EventEmitter();
       socket.close = function(code, message) {
-        expect(code).to.equal(400);
+        expect(code).to.equal(DataChannelErrors.INVALID_OPERATION);
         expect(message).to.equal('Failed to handle the defined operation');
         done();
       };
@@ -330,7 +331,7 @@ describe('DataChannelServer', function() {
       (function() {
         socket.close = function(code, message) {
           _load.restore();
-          expect(code).to.equal(400);
+          expect(code).to.equal(DataChannelErrors.FAILED_INTEGRITY);
           expect(message).to.equal(
             'Calculated hash does not match the expected result'
           );

test/tunnel/server.unit.js

@@ -6,6 +6,7 @@ var TunnelServer = require('../../lib/tunnel/server');
 var EventEmitter = require('events').EventEmitter;
 var proxyquire = require('proxyquire');
 var sinon = require('sinon');
+var TunnelErrors = require('../../lib/tunnel/errorcodes');
 
 describe('TunnelServer', function() {
 
@@ -136,8 +137,8 @@ describe('TunnelServer', function() {
       ts._handleClient({
         upgradeReq: { url: 'ws://127.0.0.1:1337/tun?token=sometoken' },
         close: function(code, result) {
-          expect(code).to.equal(404);
-          expect(result.error).to.equal('Gateway no longer open');
+          expect(code).to.equal(TunnelErrors.GATEWAY_CLOSED);
+          expect(result).to.equal('Gateway no longer open');
           done();
         }
       });
@@ -172,8 +173,8 @@ describe('TunnelServer', function() {
       var client = new EventEmitter();
       client.upgradeReq = { url: 'ws://127.0.0.1:1337/tun?token=sometoken' };
       client.close = function(code, result) {
-        expect(code).to.equal(400);
-        expect(result.error).to.equal('Muxer error');
+        expect(code).to.equal(TunnelErrors.UNEXPECTED);
+        expect(result).to.equal('Muxer error');
         done();
       };
       var ts = new BadMuxTunServer({ server: http.Server() });
@@ -192,8 +193,8 @@ describe('TunnelServer', function() {
       var client = new EventEmitter();
       client.upgradeReq = { url: 'ws://127.0.0.1:1337/tun?token=sometoken' };
       client.close = function(code, result) {
-        expect(code).to.equal(400);
-        expect(result.error).to.equal('Demuxer error');
+        expect(code).to.equal(TunnelErrors.UNEXPECTED);
+        expect(result).to.equal('Demuxer error');
         done();
       };
       var ts = new BadDemuxTunServer({ server: http.Server() });
@@ -212,8 +213,8 @@ describe('TunnelServer', function() {
       var client = new EventEmitter();
       client.upgradeReq = { url: 'ws://127.0.0.1:1337/tun?token=sometoken' };
       client.close = function(code, result) {
-        expect(code).to.equal(400);
-        expect(result.error).to.equal('Cannot handle tunnel frame type');
+        expect(code).to.equal(TunnelErrors.INVALID_FRAME_TYPE);
+        expect(result).to.equal('Cannot handle tunnel frame type');
         done();
       };
       var ts = new BadDemuxTunServer({ server: http.Server() });