You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
416 lines
10 KiB
416 lines
10 KiB
'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');
|
|
}
|
|
|
|
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 || 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
|
|
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 = 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
|
|
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) );
|
|
};
|