LukasMeine / vigilance

'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 || new Buffer(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');

      }

        sections.splice(i, 0, v4Buffer.slice(2, 4).toString('hex'));

      }

    }

    if (sections[0] === '') {

    } else if (sections[sections.length - 1] === '') {

    } else if (sections.length < 8) {

      var argv = [ i, 1 ];

      for (i = 9 - sections.length; i > 0; i--) {

        argv.push('0');

      }

      sections.splice.apply(sections, argv);

    }

    result = buff || new Buffer(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

      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 = new Buffer(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 = new Buffer(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

      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];

    }

  }

  for (; i < result.length; i++)

  return ip.toString(result);

};

ip.cidr = function(cidrString) {

  var cidrParts = cidrString.split('/');

  var addr = cidrParts[0];

  if (cidrParts.length !== 2)

  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)

  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

    var buff = a;

    var other = b;

    if (b.length > a.length) {

      buff = b;

      other = a;

    }

    var offset = buff.length - other.length;

      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++) {

    }

    return true;

  }

  // Swap

  if (b.length === 4) {

    var t = b;

    b = a;

    a = t;

  }

  // a - IPv4, b - IPv6

  }

  var word = b.readUInt16BE(10);

  }

  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 res[0].address;

  }

    //

    // 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) );

};