tor-browser

ip.js (10282B)

---

'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) );
};