Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

8 files changed, 1086 insertions, 0 deletions

diff --git a/testing/xpcshell/node_ip/.gitignore b/testing/xpcshell/node_ip/.gitignore
new file mode 100644
index 0000000000..1ca957177f
--- /dev/null
+++ b/testing/xpcshell/node_ip/.gitignore
@@ -0,0 +1,2 @@
+node_modules/
+npm-debug.log
diff --git a/testing/xpcshell/node_ip/.jscsrc b/testing/xpcshell/node_ip/.jscsrc
new file mode 100644
index 0000000000..dbaae20574
--- /dev/null
+++ b/testing/xpcshell/node_ip/.jscsrc
@@ -0,0 +1,46 @@
+{
+  "disallowKeywordsOnNewLine": [ "else" ],
+  "disallowMixedSpacesAndTabs": true,
+  "disallowMultipleLineStrings": true,
+  "disallowMultipleVarDecl": true,
+  "disallowNewlineBeforeBlockStatements": true,
+  "disallowQuotedKeysInObjects": true,
+  "disallowSpaceAfterObjectKeys": true,
+  "disallowSpaceAfterPrefixUnaryOperators": true,
+  "disallowSpaceBeforePostfixUnaryOperators": true,
+  "disallowSpacesInCallExpression": true,
+  "disallowTrailingComma": true,
+  "disallowTrailingWhitespace": true,
+  "disallowYodaConditions": true,
+
+  "requireCommaBeforeLineBreak": true,
+  "requireOperatorBeforeLineBreak": true,
+  "requireSpaceAfterBinaryOperators": true,
+  "requireSpaceAfterKeywords": [ "if", "for", "while", "else", "try", "catch" ],
+  "requireSpaceAfterLineComment": true,
+  "requireSpaceBeforeBinaryOperators": true,
+  "requireSpaceBeforeBlockStatements": true,
+  "requireSpaceBeforeKeywords": [ "else", "catch" ],
+  "requireSpaceBeforeObjectValues": true,
+  "requireSpaceBetweenArguments": true,
+  "requireSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningCurlyBrace": true
+  },
+  "requireSpacesInFunctionDeclaration": {
+    "beforeOpeningCurlyBrace": true
+  },
+  "requireSpacesInFunctionExpression": {
+    "beforeOpeningCurlyBrace": true
+  },
+  "requireSpacesInConditionalExpression": true,
+  "requireSpacesInForStatement": true,
+  "requireSpacesInsideArrayBrackets": "all",
+  "requireSpacesInsideObjectBrackets": "all",
+  "requireDotNotation": true,
+
+  "maximumLineLength": 80,
+  "validateIndentation": 2,
+  "validateLineBreaks": "LF",
+  "validateParameterSeparator": ", ",
+  "validateQuoteMarks": "'"
+}
diff --git a/testing/xpcshell/node_ip/.jshintrc b/testing/xpcshell/node_ip/.jshintrc
new file mode 100644
index 0000000000..7e97390295
--- /dev/null
+++ b/testing/xpcshell/node_ip/.jshintrc
@@ -0,0 +1,89 @@
+{
+    // JSHint Default Configuration File (as on JSHint website)
+    // See http://jshint.com/docs/ for more details
+
+    "maxerr"        : 50,       // {int} Maximum error before stopping
+
+    // Enforcing
+    "bitwise"       : false,     // true: Prohibit bitwise operators (&, |, ^, etc.)
+    "camelcase"     : false,     // true: Identifiers must be in camelCase
+    "curly"         : false,     // true: Require {} for every new block or scope
+    "eqeqeq"        : true,     // true: Require triple equals (===) for comparison
+    "forin"         : true,     // true: Require filtering for..in loops with obj.hasOwnProperty()
+    "freeze"        : true,     // true: prohibits overwriting prototypes of native objects such as Array, Date etc.
+    "immed"         : false,    // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
+    "indent"        : 2,        // {int} Number of spaces to use for indentation
+    "latedef"       : true,     // true: Require variables/functions to be defined before being used
+    "newcap"        : true,     // true: Require capitalization of all constructor functions e.g. `new F()`
+    "noarg"         : true,     // true: Prohibit use of `arguments.caller` and `arguments.callee`
+    "noempty"       : false,    // true: Prohibit use of empty blocks
+    "nonbsp"        : true,     // true: Prohibit "non-breaking whitespace" characters.
+    "nonew"         : false,    // true: Prohibit use of constructors for side-effects (without assignment)
+    "plusplus"      : false,    // true: Prohibit use of `++` & `--`
+    "quotmark"      : "single", // Quotation mark consistency:
+                                //   false    : do nothing (default)
+                                //   true     : ensure whatever is used is consistent
+                                //   "single" : require single quotes
+                                //   "double" : require double quotes
+    "undef"         : true,     // true: Require all non-global variables to be declared (prevents global leaks)
+    "unused"        : true,     // true: Require all defined variables be used
+    "strict"        : true,     // true: Requires all functions run in ES5 Strict Mode
+    "maxparams"     : false,    // {int} Max number of formal params allowed per function
+    "maxdepth"      : 3,        // {int} Max depth of nested blocks (within functions)
+    "maxstatements" : false,    // {int} Max number statements per function
+    "maxcomplexity" : false,    // {int} Max cyclomatic complexity per function
+    "maxlen"        : false,    // {int} Max number of characters per line
+
+    // Relaxing
+    "asi"           : false,     // true: Tolerate Automatic Semicolon Insertion (no semicolons)
+    "boss"          : false,     // true: Tolerate assignments where comparisons would be expected
+    "debug"         : false,     // true: Allow debugger statements e.g. browser breakpoints.
+    "eqnull"        : false,     // true: Tolerate use of `== null`
+    "es5"           : false,     // true: Allow ES5 syntax (ex: getters and setters)
+    "esnext"        : false,     // true: Allow ES.next (ES6) syntax (ex: `const`)
+    "moz"           : false,     // true: Allow Mozilla specific syntax (extends and overrides esnext features)
+                                 // (ex: `for each`, multiple try/catch, function expression…)
+    "evil"          : false,     // true: Tolerate use of `eval` and `new Function()`
+    "expr"          : false,     // true: Tolerate `ExpressionStatement` as Programs
+    "funcscope"     : false,     // true: Tolerate defining variables inside control statements
+    "globalstrict"  : false,     // true: Allow global "use strict" (also enables 'strict')
+    "iterator"      : false,     // true: Tolerate using the `__iterator__` property
+    "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
+    "laxbreak"      : false,     // true: Tolerate possibly unsafe line breakings
+    "laxcomma"      : false,     // true: Tolerate comma-first style coding
+    "loopfunc"      : false,     // true: Tolerate functions being defined in loops
+    "multistr"      : false,     // true: Tolerate multi-line strings
+    "noyield"       : false,     // true: Tolerate generator functions with no yield statement in them.
+    "notypeof"      : false,     // true: Tolerate invalid typeof operator values
+    "proto"         : false,     // true: Tolerate using the `__proto__` property
+    "scripturl"     : false,     // true: Tolerate script-targeted URLs
+    "shadow"        : true,      // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
+    "sub"           : false,     // true: Tolerate using `[]` notation when it can still be expressed in dot notation
+    "supernew"      : false,     // true: Tolerate `new function () { ... };` and `new Object;`
+    "validthis"     : false,     // true: Tolerate using this in a non-constructor function
+
+    // Environments
+    "browser"       : true,     // Web Browser (window, document, etc)
+    "browserify"    : true,     // Browserify (node.js code in the browser)
+    "couch"         : false,    // CouchDB
+    "devel"         : true,     // Development/debugging (alert, confirm, etc)
+    "dojo"          : false,    // Dojo Toolkit
+    "jasmine"       : false,    // Jasmine
+    "jquery"        : false,    // jQuery
+    "mocha"         : true,     // Mocha
+    "mootools"      : false,    // MooTools
+    "node"          : true,     // Node.js
+    "nonstandard"   : false,    // Widely adopted globals (escape, unescape, etc)
+    "prototypejs"   : false,    // Prototype and Scriptaculous
+    "qunit"         : false,    // QUnit
+    "rhino"         : false,    // Rhino
+    "shelljs"       : false,    // ShellJS
+    "worker"        : false,    // Web Workers
+    "wsh"           : false,    // Windows Scripting Host
+    "yui"           : false,    // Yahoo User Interface
+
+    // Custom Globals
+    "globals"       : {
+        "module": true
+    }        // additional predefined global variables
+}
diff --git a/testing/xpcshell/node_ip/.travis.yml b/testing/xpcshell/node_ip/.travis.yml
new file mode 100644
index 0000000000..a3a8fad6b6
--- /dev/null
+++ b/testing/xpcshell/node_ip/.travis.yml
@@ -0,0 +1,15 @@
+sudo: false
+language: node_js
+node_js:
+  - "0.8"
+  - "0.10"
+  - "0.12"
+  - "4"
+  - "6"
+
+before_install:
+  - travis_retry npm install -g npm@2.14.5
+  - travis_retry npm install
+
+script:
+  - npm test
diff --git a/testing/xpcshell/node_ip/README.md b/testing/xpcshell/node_ip/README.md
new file mode 100644
index 0000000000..22e5819ffa
--- /dev/null
+++ b/testing/xpcshell/node_ip/README.md
@@ -0,0 +1,90 @@
+# IP  
+[![](https://badge.fury.io/js/ip.svg)](https://www.npmjs.com/package/ip)  
+
+IP address utilities for node.js
+
+## Installation
+
+###  npm
+```shell
+npm install ip
+```
+
+### git
+
+```shell
+git clone https://github.com/indutny/node-ip.git
+```
+  
+## Usage
+Get your ip address, compare ip addresses, validate ip addresses, etc.
+
+```js
+var ip = require('ip');
+
+ip.address() // my ip address
+ip.isEqual('::1', '::0:1'); // true
+ip.toBuffer('127.0.0.1') // Buffer([127, 0, 0, 1])
+ip.toString(new Buffer([127, 0, 0, 1])) // 127.0.0.1
+ip.fromPrefixLen(24) // 255.255.255.0
+ip.mask('192.168.1.134', '255.255.255.0') // 192.168.1.0
+ip.cidr('192.168.1.134/26') // 192.168.1.128
+ip.not('255.255.255.0') // 0.0.0.255
+ip.or('192.168.1.134', '0.0.0.255') // 192.168.1.255
+ip.isPrivate('127.0.0.1') // true
+ip.isV4Format('127.0.0.1'); // true
+ip.isV6Format('::ffff:127.0.0.1'); // true
+
+// operate on buffers in-place
+var buf = new Buffer(128);
+var offset = 64;
+ip.toBuffer('127.0.0.1', buf, offset);  // [127, 0, 0, 1] at offset 64
+ip.toString(buf, offset, 4);            // '127.0.0.1'
+
+// subnet information
+ip.subnet('192.168.1.134', '255.255.255.192')
+// { networkAddress: '192.168.1.128',
+//   firstAddress: '192.168.1.129',
+//   lastAddress: '192.168.1.190',
+//   broadcastAddress: '192.168.1.191',
+//   subnetMask: '255.255.255.192',
+//   subnetMaskLength: 26,
+//   numHosts: 62,
+//   length: 64,
+//   contains: function(addr){...} }
+ip.cidrSubnet('192.168.1.134/26')
+// Same as previous.
+
+// range checking
+ip.cidrSubnet('192.168.1.134/26').contains('192.168.1.190') // true
+
+
+// ipv4 long conversion
+ip.toLong('127.0.0.1'); // 2130706433
+ip.fromLong(2130706433); // '127.0.0.1'
+```
+
+### License
+
+This software is licensed under the MIT License.
+
+Copyright Fedor Indutny, 2012.
+
+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.
diff --git a/testing/xpcshell/node_ip/lib/ip.js b/testing/xpcshell/node_ip/lib/ip.js
new file mode 100644
index 0000000000..a66a2555c6
--- /dev/null
+++ b/testing/xpcshell/node_ip/lib/ip.js
@@ -0,0 +1,416 @@
+'use strict';
+
+var ip = exports;
+var Buffer = require('buffer').Buffer;
+var os = require('os');
+
+ip.toBuffer = function(ip, buff, offset) {
+  offset = ~~offset;
+
+  var result;
+
+  if (this.isV4Format(ip)) {
+    result = buff || Buffer.alloc(offset + 4);
+    ip.split(/\./g).map(function(byte) {
+      result[offset++] = parseInt(byte, 10) & 0xff;
+    });
+  } else if (this.isV6Format(ip)) {
+    var sections = ip.split(':', 8);
+
+    var i;
+    for (i = 0; i < sections.length; i++) {
+      var isv4 = this.isV4Format(sections[i]);
+      var v4Buffer;
+
+      if (isv4) {
+        v4Buffer = this.toBuffer(sections[i]);
+        sections[i] = v4Buffer.slice(0, 2).toString('hex');
+      }
+
+      if (v4Buffer && ++i < 8) {
+        sections.splice(i, 0, v4Buffer.slice(2, 4).toString('hex'));
+      }
+    }
+
+    if (sections[0] === '') {
+      while (sections.length < 8) sections.unshift('0');
+    } else if (sections[sections.length - 1] === '') {
+      while (sections.length < 8) sections.push('0');
+    } else if (sections.length < 8) {
+      for (i = 0; i < sections.length && sections[i] !== ''; i++);
+      var argv = [ i, 1 ];
+      for (i = 9 - sections.length; i > 0; i--) {
+        argv.push('0');
+      }
+      sections.splice.apply(sections, argv);
+    }
+
+    result = buff || Buffer.alloc(offset + 16);
+    for (i = 0; i < sections.length; i++) {
+      var word = parseInt(sections[i], 16);
+      result[offset++] = (word >> 8) & 0xff;
+      result[offset++] = word & 0xff;
+    }
+  }
+
+  if (!result) {
+    throw Error('Invalid ip address: ' + ip);
+  }
+
+  return result;
+};
+
+ip.toString = function(buff, offset, length) {
+  offset = ~~offset;
+  length = length || (buff.length - offset);
+
+  var result = [];
+  if (length === 4) {
+    // IPv4
+    for (var i = 0; i < length; i++) {
+      result.push(buff[offset + i]);
+    }
+    result = result.join('.');
+  } else if (length === 16) {
+    // IPv6
+    for (var i = 0; i < length; i += 2) {
+      result.push(buff.readUInt16BE(offset + i).toString(16));
+    }
+    result = result.join(':');
+    result = result.replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3');
+    result = result.replace(/:{3,4}/, '::');
+  }
+
+  return result;
+};
+
+var ipv4Regex = /^(\d{1,3}\.){3,3}\d{1,3}$/;
+var ipv6Regex =
+    /^(::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?$/i;
+
+ip.isV4Format = function(ip) {
+  return ipv4Regex.test(ip);
+};
+
+ip.isV6Format = function(ip) {
+  return ipv6Regex.test(ip);
+};
+function _normalizeFamily(family) {
+  return family ? family.toLowerCase() : 'ipv4';
+}
+
+ip.fromPrefixLen = function(prefixlen, family) {
+  if (prefixlen > 32) {
+    family = 'ipv6';
+  } else {
+    family = _normalizeFamily(family);
+  }
+
+  var len = 4;
+  if (family === 'ipv6') {
+    len = 16;
+  }
+  var buff = Buffer.alloc(len);
+
+  for (var i = 0, n = buff.length; i < n; ++i) {
+    var bits = 8;
+    if (prefixlen < 8) {
+      bits = prefixlen;
+    }
+    prefixlen -= bits;
+
+    buff[i] = ~(0xff >> bits) & 0xff;
+  }
+
+  return ip.toString(buff);
+};
+
+ip.mask = function(addr, mask) {
+  addr = ip.toBuffer(addr);
+  mask = ip.toBuffer(mask);
+
+  var result = Buffer.alloc(Math.max(addr.length, mask.length));
+
+  var i = 0;
+  // Same protocol - do bitwise and
+  if (addr.length === mask.length) {
+    for (i = 0; i < addr.length; i++) {
+      result[i] = addr[i] & mask[i];
+    }
+  } else if (mask.length === 4) {
+    // IPv6 address and IPv4 mask
+    // (Mask low bits)
+    for (i = 0; i < mask.length; i++) {
+      result[i] = addr[addr.length - 4  + i] & mask[i];
+    }
+  } else {
+    // IPv6 mask and IPv4 addr
+    for (var i = 0; i < result.length - 6; i++) {
+      result[i] = 0;
+    }
+
+    // ::ffff:ipv4
+    result[10] = 0xff;
+    result[11] = 0xff;
+    for (i = 0; i < addr.length; i++) {
+      result[i + 12] = addr[i] & mask[i + 12];
+    }
+    i = i + 12;
+  }
+  for (; i < result.length; i++)
+    result[i] = 0;
+
+  return ip.toString(result);
+};
+
+ip.cidr = function(cidrString) {
+  var cidrParts = cidrString.split('/');
+
+  var addr = cidrParts[0];
+  if (cidrParts.length !== 2)
+    throw new Error('invalid CIDR subnet: ' + addr);
+
+  var mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
+
+  return ip.mask(addr, mask);
+};
+
+ip.subnet = function(addr, mask) {
+  var networkAddress = ip.toLong(ip.mask(addr, mask));
+
+  // Calculate the mask's length.
+  var maskBuffer = ip.toBuffer(mask);
+  var maskLength = 0;
+
+  for (var i = 0; i < maskBuffer.length; i++) {
+    if (maskBuffer[i] === 0xff) {
+      maskLength += 8;
+    } else {
+      var octet = maskBuffer[i] & 0xff;
+      while (octet) {
+        octet = (octet << 1) & 0xff;
+        maskLength++;
+      }
+    }
+  }
+
+  var numberOfAddresses = Math.pow(2, 32 - maskLength);
+
+  return {
+    networkAddress: ip.fromLong(networkAddress),
+    firstAddress: numberOfAddresses <= 2 ?
+                    ip.fromLong(networkAddress) :
+                    ip.fromLong(networkAddress + 1),
+    lastAddress: numberOfAddresses <= 2 ?
+                    ip.fromLong(networkAddress + numberOfAddresses - 1) :
+                    ip.fromLong(networkAddress + numberOfAddresses - 2),
+    broadcastAddress: ip.fromLong(networkAddress + numberOfAddresses - 1),
+    subnetMask: mask,
+    subnetMaskLength: maskLength,
+    numHosts: numberOfAddresses <= 2 ?
+                numberOfAddresses : numberOfAddresses - 2,
+    length: numberOfAddresses,
+    contains: function(other) {
+      return networkAddress === ip.toLong(ip.mask(other, mask));
+    }
+  };
+};
+
+ip.cidrSubnet = function(cidrString) {
+  var cidrParts = cidrString.split('/');
+
+  var addr = cidrParts[0];
+  if (cidrParts.length !== 2)
+    throw new Error('invalid CIDR subnet: ' + addr);
+
+  var mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
+
+  return ip.subnet(addr, mask);
+};
+
+ip.not = function(addr) {
+  var buff = ip.toBuffer(addr);
+  for (var i = 0; i < buff.length; i++) {
+    buff[i] = 0xff ^ buff[i];
+  }
+  return ip.toString(buff);
+};
+
+ip.or = function(a, b) {
+  a = ip.toBuffer(a);
+  b = ip.toBuffer(b);
+
+  // same protocol
+  if (a.length === b.length) {
+    for (var i = 0; i < a.length; ++i) {
+      a[i] |= b[i];
+    }
+    return ip.toString(a);
+
+  // mixed protocols
+  } else {
+    var buff = a;
+    var other = b;
+    if (b.length > a.length) {
+      buff = b;
+      other = a;
+    }
+
+    var offset = buff.length - other.length;
+    for (var i = offset; i < buff.length; ++i) {
+      buff[i] |= other[i - offset];
+    }
+
+    return ip.toString(buff);
+  }
+};
+
+ip.isEqual = function(a, b) {
+  a = ip.toBuffer(a);
+  b = ip.toBuffer(b);
+
+  // Same protocol
+  if (a.length === b.length) {
+    for (var i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+
+  // Swap
+  if (b.length === 4) {
+    var t = b;
+    b = a;
+    a = t;
+  }
+
+  // a - IPv4, b - IPv6
+  for (var i = 0; i < 10; i++) {
+    if (b[i] !== 0) return false;
+  }
+
+  var word = b.readUInt16BE(10);
+  if (word !== 0 && word !== 0xffff) return false;
+
+  for (var i = 0; i < 4; i++) {
+    if (a[i] !== b[i + 12]) return false;
+  }
+
+  return true;
+};
+
+ip.isPrivate = function(addr) {
+  return /^(::f{4}:)?10\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i
+      .test(addr) ||
+    /^(::f{4}:)?192\.168\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+    /^(::f{4}:)?172\.(1[6-9]|2\d|30|31)\.([0-9]{1,3})\.([0-9]{1,3})$/i
+      .test(addr) ||
+    /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+    /^(::f{4}:)?169\.254\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+    /^f[cd][0-9a-f]{2}:/i.test(addr) ||
+    /^fe80:/i.test(addr) ||
+    /^::1$/.test(addr) ||
+    /^::$/.test(addr);
+};
+
+ip.isPublic = function(addr) {
+  return !ip.isPrivate(addr);
+};
+
+ip.isLoopback = function(addr) {
+  return /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/
+      .test(addr) ||
+    /^fe80::1$/.test(addr) ||
+    /^::1$/.test(addr) ||
+    /^::$/.test(addr);
+};
+
+ip.loopback = function(family) {
+  //
+  // Default to `ipv4`
+  //
+  family = _normalizeFamily(family);
+
+  if (family !== 'ipv4' && family !== 'ipv6') {
+    throw new Error('family must be ipv4 or ipv6');
+  }
+
+  return family === 'ipv4' ? '127.0.0.1' : 'fe80::1';
+};
+
+//
+// ### function address (name, family)
+// #### @name {string|'public'|'private'} **Optional** Name or security
+//      of the network interface.
+// #### @family {ipv4|ipv6} **Optional** IP family of the address (defaults
+//      to ipv4).
+//
+// Returns the address for the network interface on the current system with
+// the specified `name`:
+//   * String: First `family` address of the interface.
+//             If not found see `undefined`.
+//   * 'public': the first public ip address of family.
+//   * 'private': the first private ip address of family.
+//   * undefined: First address with `ipv4` or loopback address `127.0.0.1`.
+//
+ip.address = function(name, family) {
+  var interfaces = os.networkInterfaces();
+  var all;
+
+  //
+  // Default to `ipv4`
+  //
+  family = _normalizeFamily(family);
+
+  //
+  // If a specific network interface has been named,
+  // return the address.
+  //
+  if (name && name !== 'private' && name !== 'public') {
+    var res = interfaces[name].filter(function(details) {
+      var itemFamily = details.family.toLowerCase();
+      return itemFamily === family;
+    });
+    if (res.length === 0)
+      return undefined;
+    return res[0].address;
+  }
+
+  var all = Object.keys(interfaces).map(function (nic) {
+    //
+    // Note: name will only be `public` or `private`
+    // when this is called.
+    //
+    var addresses = interfaces[nic].filter(function (details) {
+      details.family = details.family.toLowerCase();
+      if (details.family !== family || ip.isLoopback(details.address)) {
+        return false;
+      } else if (!name) {
+        return true;
+      }
+
+      return name === 'public' ? ip.isPrivate(details.address) :
+          ip.isPublic(details.address);
+    });
+
+    return addresses.length ? addresses[0].address : undefined;
+  }).filter(Boolean);
+
+  return !all.length ? ip.loopback(family) : all[0];
+};
+
+ip.toLong = function(ip) {
+  var ipl = 0;
+  ip.split('.').forEach(function(octet) {
+    ipl <<= 8;
+    ipl += parseInt(octet);
+  });
+  return(ipl >>> 0);
+};
+
+ip.fromLong = function(ipl) {
+  return ((ipl >>> 24) + '.' +
+      (ipl >> 16 & 255) + '.' +
+      (ipl >> 8 & 255) + '.' +
+      (ipl & 255) );
+};
diff --git a/testing/xpcshell/node_ip/package.json b/testing/xpcshell/node_ip/package.json
new file mode 100644
index 0000000000..c783fdd437
--- /dev/null
+++ b/testing/xpcshell/node_ip/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "ip",
+  "version": "1.1.5",
+  "author": "Fedor Indutny <fedor@indutny.com>",
+  "homepage": "https://github.com/indutny/node-ip",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/indutny/node-ip.git"
+  },
+  "main": "lib/ip",
+  "devDependencies": {
+    "jscs": "^2.1.1",
+    "jshint": "^2.8.0",
+    "mocha": "~1.3.2"
+  },
+  "scripts": {
+    "test": "jscs lib/*.js test/*.js && jshint lib/*.js && mocha --reporter spec test/*-test.js",
+    "fix": "jscs lib/*.js test/*.js --fix"
+  },
+  "license": "MIT"
+}
diff --git a/testing/xpcshell/node_ip/test/api-test.js b/testing/xpcshell/node_ip/test/api-test.js
new file mode 100644
index 0000000000..1af09a4f6f
--- /dev/null
+++ b/testing/xpcshell/node_ip/test/api-test.js
@@ -0,0 +1,407 @@
+'use strict';
+
+var ip = require('..');
+var assert = require('assert');
+var net = require('net');
+var os = require('os');
+
+describe('IP library for node.js', function() {
+  describe('toBuffer()/toString() methods', function() {
+    it('should convert to buffer IPv4 address', function() {
+      var buf = ip.toBuffer('127.0.0.1');
+      assert.equal(buf.toString('hex'), '7f000001');
+      assert.equal(ip.toString(buf), '127.0.0.1');
+    });
+
+    it('should convert to buffer IPv4 address in-place', function() {
+      var buf = Buffer.alloc(128);
+      var offset = 64;
+      ip.toBuffer('127.0.0.1', buf, offset);
+      assert.equal(buf.toString('hex', offset, offset + 4), '7f000001');
+      assert.equal(ip.toString(buf, offset, 4), '127.0.0.1');
+    });
+
+    it('should convert to buffer IPv6 address', function() {
+      var buf = ip.toBuffer('::1');
+      assert(/(00){15,15}01/.test(buf.toString('hex')));
+      assert.equal(ip.toString(buf), '::1');
+      assert.equal(ip.toString(ip.toBuffer('1::')), '1::');
+      assert.equal(ip.toString(ip.toBuffer('abcd::dcba')), 'abcd::dcba');
+    });
+
+    it('should convert to buffer IPv6 address in-place', function() {
+      var buf = Buffer.alloc(128);
+      var offset = 64;
+      ip.toBuffer('::1', buf, offset);
+      assert(/(00){15,15}01/.test(buf.toString('hex', offset, offset + 16)));
+      assert.equal(ip.toString(buf, offset, 16), '::1');
+      assert.equal(ip.toString(ip.toBuffer('1::', buf, offset),
+                               offset, 16), '1::');
+      assert.equal(ip.toString(ip.toBuffer('abcd::dcba', buf, offset),
+                               offset, 16), 'abcd::dcba');
+    });
+
+    it('should convert to buffer IPv6 mapped IPv4 address', function() {
+      var buf = ip.toBuffer('::ffff:127.0.0.1');
+      assert.equal(buf.toString('hex'), '00000000000000000000ffff7f000001');
+      assert.equal(ip.toString(buf), '::ffff:7f00:1');
+
+      buf = ip.toBuffer('ffff::127.0.0.1');
+      assert.equal(buf.toString('hex'), 'ffff000000000000000000007f000001');
+      assert.equal(ip.toString(buf), 'ffff::7f00:1');
+
+      buf = ip.toBuffer('0:0:0:0:0:ffff:127.0.0.1');
+      assert.equal(buf.toString('hex'), '00000000000000000000ffff7f000001');
+      assert.equal(ip.toString(buf), '::ffff:7f00:1');
+    });
+  });
+
+  describe('fromPrefixLen() method', function() {
+    it('should create IPv4 mask', function() {
+      assert.equal(ip.fromPrefixLen(24), '255.255.255.0');
+    });
+    it('should create IPv6 mask', function() {
+      assert.equal(ip.fromPrefixLen(64), 'ffff:ffff:ffff:ffff::');
+    });
+    it('should create IPv6 mask explicitly', function() {
+      assert.equal(ip.fromPrefixLen(24, 'IPV6'), 'ffff:ff00::');
+    });
+  });
+
+  describe('not() method', function() {
+    it('should reverse bits in address', function() {
+      assert.equal(ip.not('255.255.255.0'), '0.0.0.255');
+    });
+  });
+
+  describe('or() method', function() {
+    it('should or bits in ipv4 addresses', function() {
+      assert.equal(ip.or('0.0.0.255', '192.168.1.10'), '192.168.1.255');
+    });
+    it('should or bits in ipv6 addresses', function() {
+      assert.equal(ip.or('::ff', '::abcd:dcba:abcd:dcba'),
+                   '::abcd:dcba:abcd:dcff');
+    });
+    it('should or bits in mixed addresses', function() {
+      assert.equal(ip.or('0.0.0.255', '::abcd:dcba:abcd:dcba'),
+                   '::abcd:dcba:abcd:dcff');
+    });
+  });
+
+  describe('mask() method', function() {
+    it('should mask bits in address', function() {
+      assert.equal(ip.mask('192.168.1.134', '255.255.255.0'), '192.168.1.0');
+      assert.equal(ip.mask('192.168.1.134', '::ffff:ff00'), '::ffff:c0a8:100');
+    });
+
+    it('should not leak data', function() {
+      for (var i = 0; i < 10; i++)
+        assert.equal(ip.mask('::1', '0.0.0.0'), '::');
+    });
+  });
+
+  describe('subnet() method', function() {
+    // Test cases calculated with http://www.subnet-calculator.com/
+    var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.192');
+
+    it('should compute ipv4 network address', function() {
+      assert.equal(ipv4Subnet.networkAddress, '192.168.1.128');
+    });
+
+    it('should compute ipv4 network\'s first address', function() {
+      assert.equal(ipv4Subnet.firstAddress, '192.168.1.129');
+    });
+
+    it('should compute ipv4 network\'s last address', function() {
+      assert.equal(ipv4Subnet.lastAddress, '192.168.1.190');
+    });
+
+    it('should compute ipv4 broadcast address', function() {
+      assert.equal(ipv4Subnet.broadcastAddress, '192.168.1.191');
+    });
+
+    it('should compute ipv4 subnet number of addresses', function() {
+      assert.equal(ipv4Subnet.length, 64);
+    });
+
+    it('should compute ipv4 subnet number of addressable hosts', function() {
+      assert.equal(ipv4Subnet.numHosts, 62);
+    });
+
+    it('should compute ipv4 subnet mask', function() {
+      assert.equal(ipv4Subnet.subnetMask, '255.255.255.192');
+    });
+
+    it('should compute ipv4 subnet mask\'s length', function() {
+      assert.equal(ipv4Subnet.subnetMaskLength, 26);
+    });
+
+    it('should know whether a subnet contains an address', function() {
+      assert.equal(ipv4Subnet.contains('192.168.1.180'), true);
+    });
+
+    it('should know whether a subnet does not contain an address', function() {
+      assert.equal(ipv4Subnet.contains('192.168.1.195'), false);
+    });
+  });
+
+  describe('subnet() method with mask length 32', function() {
+    // Test cases calculated with http://www.subnet-calculator.com/
+    var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.255');
+    it('should compute ipv4 network\'s first address', function() {
+      assert.equal(ipv4Subnet.firstAddress, '192.168.1.134');
+    });
+
+    it('should compute ipv4 network\'s last address', function() {
+      assert.equal(ipv4Subnet.lastAddress, '192.168.1.134');
+    });
+
+    it('should compute ipv4 subnet number of addressable hosts', function() {
+      assert.equal(ipv4Subnet.numHosts, 1);
+    });
+  });
+
+  describe('subnet() method with mask length 31', function() {
+    // Test cases calculated with http://www.subnet-calculator.com/
+    var ipv4Subnet = ip.subnet('192.168.1.134', '255.255.255.254');
+    it('should compute ipv4 network\'s first address', function() {
+      assert.equal(ipv4Subnet.firstAddress, '192.168.1.134');
+    });
+
+    it('should compute ipv4 network\'s last address', function() {
+      assert.equal(ipv4Subnet.lastAddress, '192.168.1.135');
+    });
+
+    it('should compute ipv4 subnet number of addressable hosts', function() {
+      assert.equal(ipv4Subnet.numHosts, 2);
+    });
+  });
+
+  describe('cidrSubnet() method', function() {
+    // Test cases calculated with http://www.subnet-calculator.com/
+    var ipv4Subnet = ip.cidrSubnet('192.168.1.134/26');
+
+    it('should compute an ipv4 network address', function() {
+      assert.equal(ipv4Subnet.networkAddress, '192.168.1.128');
+    });
+
+    it('should compute an ipv4 network\'s first address', function() {
+      assert.equal(ipv4Subnet.firstAddress, '192.168.1.129');
+    });
+
+    it('should compute an ipv4 network\'s last address', function() {
+      assert.equal(ipv4Subnet.lastAddress, '192.168.1.190');
+    });
+
+    it('should compute an ipv4 broadcast address', function() {
+      assert.equal(ipv4Subnet.broadcastAddress, '192.168.1.191');
+    });
+
+    it('should compute an ipv4 subnet number of addresses', function() {
+      assert.equal(ipv4Subnet.length, 64);
+    });
+
+    it('should compute an ipv4 subnet number of addressable hosts', function() {
+      assert.equal(ipv4Subnet.numHosts, 62);
+    });
+
+    it('should compute an ipv4 subnet mask', function() {
+      assert.equal(ipv4Subnet.subnetMask, '255.255.255.192');
+    });
+
+    it('should compute an ipv4 subnet mask\'s length', function() {
+      assert.equal(ipv4Subnet.subnetMaskLength, 26);
+    });
+
+    it('should know whether a subnet contains an address', function() {
+      assert.equal(ipv4Subnet.contains('192.168.1.180'), true);
+    });
+
+    it('should know whether a subnet contains an address', function() {
+      assert.equal(ipv4Subnet.contains('192.168.1.195'), false);
+    });
+
+  });
+
+  describe('cidr() method', function() {
+    it('should mask address in CIDR notation', function() {
+      assert.equal(ip.cidr('192.168.1.134/26'), '192.168.1.128');
+      assert.equal(ip.cidr('2607:f0d0:1002:51::4/56'), '2607:f0d0:1002::');
+    });
+  });
+
+  describe('isEqual() method', function() {
+    it('should check if addresses are equal', function() {
+      assert(ip.isEqual('127.0.0.1', '::7f00:1'));
+      assert(!ip.isEqual('127.0.0.1', '::7f00:2'));
+      assert(ip.isEqual('127.0.0.1', '::ffff:7f00:1'));
+      assert(!ip.isEqual('127.0.0.1', '::ffaf:7f00:1'));
+      assert(ip.isEqual('::ffff:127.0.0.1', '::ffff:127.0.0.1'));
+      assert(ip.isEqual('::ffff:127.0.0.1', '127.0.0.1'));
+    });
+  });
+
+
+  describe('isPrivate() method', function() {
+    it('should check if an address is localhost', function() {
+      assert.equal(ip.isPrivate('127.0.0.1'), true);
+    });
+
+    it('should check if an address is from a 192.168.x.x network', function() {
+      assert.equal(ip.isPrivate('192.168.0.123'), true);
+      assert.equal(ip.isPrivate('192.168.122.123'), true);
+      assert.equal(ip.isPrivate('192.162.1.2'), false);
+    });
+
+    it('should check if an address is from a 172.16.x.x network', function() {
+      assert.equal(ip.isPrivate('172.16.0.5'), true);
+      assert.equal(ip.isPrivate('172.16.123.254'), true);
+      assert.equal(ip.isPrivate('171.16.0.5'), false);
+      assert.equal(ip.isPrivate('172.25.232.15'), true);
+      assert.equal(ip.isPrivate('172.15.0.5'), false);
+      assert.equal(ip.isPrivate('172.32.0.5'), false);
+    });
+
+    it('should check if an address is from a 169.254.x.x network', function() {
+      assert.equal(ip.isPrivate('169.254.2.3'), true);
+      assert.equal(ip.isPrivate('169.254.221.9'), true);
+      assert.equal(ip.isPrivate('168.254.2.3'), false);
+    });
+
+    it('should check if an address is from a 10.x.x.x network', function() {
+      assert.equal(ip.isPrivate('10.0.2.3'), true);
+      assert.equal(ip.isPrivate('10.1.23.45'), true);
+      assert.equal(ip.isPrivate('12.1.2.3'), false);
+    });
+
+    it('should check if an address is from a private IPv6 network', function() {
+      assert.equal(ip.isPrivate('fd12:3456:789a:1::1'), true);
+      assert.equal(ip.isPrivate('fe80::f2de:f1ff:fe3f:307e'), true);
+      assert.equal(ip.isPrivate('::ffff:10.100.1.42'), true);
+      assert.equal(ip.isPrivate('::FFFF:172.16.200.1'), true);
+      assert.equal(ip.isPrivate('::ffff:192.168.0.1'), true);
+    });
+
+    it('should check if an address is from the internet', function() {
+      assert.equal(ip.isPrivate('165.225.132.33'), false); // joyent.com
+    });
+
+    it('should check if an address is a loopback IPv6 address', function() {
+      assert.equal(ip.isPrivate('::'), true);
+      assert.equal(ip.isPrivate('::1'), true);
+      assert.equal(ip.isPrivate('fe80::1'), true);
+    });
+  });
+
+  describe('loopback() method', function() {
+    describe('undefined', function() {
+      it('should respond with 127.0.0.1', function() {
+        assert.equal(ip.loopback(), '127.0.0.1')
+      });
+    });
+
+    describe('ipv4', function() {
+      it('should respond with 127.0.0.1', function() {
+        assert.equal(ip.loopback('ipv4'), '127.0.0.1')
+      });
+    });
+
+    describe('ipv6', function() {
+      it('should respond with fe80::1', function() {
+        assert.equal(ip.loopback('ipv6'), 'fe80::1')
+      });
+    });
+  });
+
+  describe('isLoopback() method', function() {
+    describe('127.0.0.1', function() {
+      it('should respond with true', function() {
+        assert.ok(ip.isLoopback('127.0.0.1'))
+      });
+    });
+
+    describe('127.8.8.8', function () {
+      it('should respond with true', function () {
+        assert.ok(ip.isLoopback('127.8.8.8'))
+      });
+    });
+
+    describe('8.8.8.8', function () {
+      it('should respond with false', function () {
+        assert.equal(ip.isLoopback('8.8.8.8'), false);
+      });
+    });
+
+    describe('fe80::1', function() {
+      it('should respond with true', function() {
+        assert.ok(ip.isLoopback('fe80::1'))
+      });
+    });
+
+    describe('::1', function() {
+      it('should respond with true', function() {
+        assert.ok(ip.isLoopback('::1'))
+      });
+    });
+
+    describe('::', function() {
+      it('should respond with true', function() {
+        assert.ok(ip.isLoopback('::'))
+      });
+    });
+  });
+
+  describe('address() method', function() {
+    describe('undefined', function() {
+      it('should respond with a private ip', function() {
+        assert.ok(ip.isPrivate(ip.address()));
+      });
+    });
+
+    describe('private', function() {
+      [ undefined, 'ipv4', 'ipv6' ].forEach(function(family) {
+        describe(family, function() {
+          it('should respond with a private ip', function() {
+            assert.ok(ip.isPrivate(ip.address('private', family)));
+          });
+        });
+      });
+    });
+
+    var interfaces = os.networkInterfaces();
+
+    Object.keys(interfaces).forEach(function(nic) {
+      describe(nic, function() {
+        [ undefined, 'ipv4' ].forEach(function(family) {
+          describe(family, function() {
+            it('should respond with an ipv4 address', function() {
+              var addr = ip.address(nic, family);
+              assert.ok(!addr || net.isIPv4(addr));
+            });
+          });
+        });
+
+        describe('ipv6', function() {
+          it('should respond with an ipv6 address', function() {
+            var addr = ip.address(nic, 'ipv6');
+            assert.ok(!addr || net.isIPv6(addr));
+          });
+        })
+      });
+    });
+  });
+
+  describe('toLong() method', function() {
+    it('should respond with a int', function() {
+      assert.equal(ip.toLong('127.0.0.1'), 2130706433);
+      assert.equal(ip.toLong('255.255.255.255'), 4294967295);
+    });
+  });
+
+  describe('fromLong() method', function() {
+    it('should repond with ipv4 address', function() {
+      assert.equal(ip.fromLong(2130706433), '127.0.0.1');
+      assert.equal(ip.fromLong(4294967295), '255.255.255.255');
+    });
+  })
+});