You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
468 lines
13 KiB
JavaScript
468 lines
13 KiB
JavaScript
(function() {
|
|
var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root;
|
|
|
|
ipaddr = {};
|
|
|
|
root = this;
|
|
|
|
if ((typeof module !== "undefined" && module !== null) && module.exports) {
|
|
module.exports = ipaddr;
|
|
} else {
|
|
root['ipaddr'] = ipaddr;
|
|
}
|
|
|
|
matchCIDR = function(first, second, partSize, cidrBits) {
|
|
var part, shift;
|
|
if (first.length !== second.length) {
|
|
throw new Error("ipaddr: cannot match CIDR for objects with different lengths");
|
|
}
|
|
part = 0;
|
|
while (cidrBits > 0) {
|
|
shift = partSize - cidrBits;
|
|
if (shift < 0) {
|
|
shift = 0;
|
|
}
|
|
if (first[part] >> shift !== second[part] >> shift) {
|
|
return false;
|
|
}
|
|
cidrBits -= partSize;
|
|
part += 1;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
ipaddr.subnetMatch = function(address, rangeList, defaultName) {
|
|
var rangeName, rangeSubnets, subnet, _i, _len;
|
|
if (defaultName == null) {
|
|
defaultName = 'unicast';
|
|
}
|
|
for (rangeName in rangeList) {
|
|
rangeSubnets = rangeList[rangeName];
|
|
if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) {
|
|
rangeSubnets = [rangeSubnets];
|
|
}
|
|
for (_i = 0, _len = rangeSubnets.length; _i < _len; _i++) {
|
|
subnet = rangeSubnets[_i];
|
|
if (address.match.apply(address, subnet)) {
|
|
return rangeName;
|
|
}
|
|
}
|
|
}
|
|
return defaultName;
|
|
};
|
|
|
|
ipaddr.IPv4 = (function() {
|
|
function IPv4(octets) {
|
|
var octet, _i, _len;
|
|
if (octets.length !== 4) {
|
|
throw new Error("ipaddr: ipv4 octet count should be 4");
|
|
}
|
|
for (_i = 0, _len = octets.length; _i < _len; _i++) {
|
|
octet = octets[_i];
|
|
if (!((0 <= octet && octet <= 255))) {
|
|
throw new Error("ipaddr: ipv4 octet is a byte");
|
|
}
|
|
}
|
|
this.octets = octets;
|
|
}
|
|
|
|
IPv4.prototype.kind = function() {
|
|
return 'ipv4';
|
|
};
|
|
|
|
IPv4.prototype.toString = function() {
|
|
return this.octets.join(".");
|
|
};
|
|
|
|
IPv4.prototype.toByteArray = function() {
|
|
return this.octets.slice(0);
|
|
};
|
|
|
|
IPv4.prototype.match = function(other, cidrRange) {
|
|
var _ref;
|
|
if (cidrRange === void 0) {
|
|
_ref = other, other = _ref[0], cidrRange = _ref[1];
|
|
}
|
|
if (other.kind() !== 'ipv4') {
|
|
throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");
|
|
}
|
|
return matchCIDR(this.octets, other.octets, 8, cidrRange);
|
|
};
|
|
|
|
IPv4.prototype.SpecialRanges = {
|
|
unspecified: [[new IPv4([0, 0, 0, 0]), 8]],
|
|
broadcast: [[new IPv4([255, 255, 255, 255]), 32]],
|
|
multicast: [[new IPv4([224, 0, 0, 0]), 4]],
|
|
linkLocal: [[new IPv4([169, 254, 0, 0]), 16]],
|
|
loopback: [[new IPv4([127, 0, 0, 0]), 8]],
|
|
"private": [[new IPv4([10, 0, 0, 0]), 8], [new IPv4([172, 16, 0, 0]), 12], [new IPv4([192, 168, 0, 0]), 16]],
|
|
reserved: [[new IPv4([192, 0, 0, 0]), 24], [new IPv4([192, 0, 2, 0]), 24], [new IPv4([192, 88, 99, 0]), 24], [new IPv4([198, 51, 100, 0]), 24], [new IPv4([203, 0, 113, 0]), 24], [new IPv4([240, 0, 0, 0]), 4]]
|
|
};
|
|
|
|
IPv4.prototype.range = function() {
|
|
return ipaddr.subnetMatch(this, this.SpecialRanges);
|
|
};
|
|
|
|
IPv4.prototype.toIPv4MappedAddress = function() {
|
|
return ipaddr.IPv6.parse("::ffff:" + (this.toString()));
|
|
};
|
|
|
|
return IPv4;
|
|
|
|
})();
|
|
|
|
ipv4Part = "(0?\\d+|0x[a-f0-9]+)";
|
|
|
|
ipv4Regexes = {
|
|
fourOctet: new RegExp("^" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$", 'i'),
|
|
longValue: new RegExp("^" + ipv4Part + "$", 'i')
|
|
};
|
|
|
|
ipaddr.IPv4.parser = function(string) {
|
|
var match, parseIntAuto, part, shift, value;
|
|
parseIntAuto = function(string) {
|
|
if (string[0] === "0" && string[1] !== "x") {
|
|
return parseInt(string, 8);
|
|
} else {
|
|
return parseInt(string);
|
|
}
|
|
};
|
|
if (match = string.match(ipv4Regexes.fourOctet)) {
|
|
return (function() {
|
|
var _i, _len, _ref, _results;
|
|
_ref = match.slice(1, 6);
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
part = _ref[_i];
|
|
_results.push(parseIntAuto(part));
|
|
}
|
|
return _results;
|
|
})();
|
|
} else if (match = string.match(ipv4Regexes.longValue)) {
|
|
value = parseIntAuto(match[1]);
|
|
if (value > 0xffffffff || value < 0) {
|
|
throw new Error("ipaddr: address outside defined range");
|
|
}
|
|
return ((function() {
|
|
var _i, _results;
|
|
_results = [];
|
|
for (shift = _i = 0; _i <= 24; shift = _i += 8) {
|
|
_results.push((value >> shift) & 0xff);
|
|
}
|
|
return _results;
|
|
})()).reverse();
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
ipaddr.IPv6 = (function() {
|
|
function IPv6(parts) {
|
|
var part, _i, _len;
|
|
if (parts.length !== 8) {
|
|
throw new Error("ipaddr: ipv6 part count should be 8");
|
|
}
|
|
for (_i = 0, _len = parts.length; _i < _len; _i++) {
|
|
part = parts[_i];
|
|
if (!((0 <= part && part <= 0xffff))) {
|
|
throw new Error("ipaddr: ipv6 part should fit to two octets");
|
|
}
|
|
}
|
|
this.parts = parts;
|
|
}
|
|
|
|
IPv6.prototype.kind = function() {
|
|
return 'ipv6';
|
|
};
|
|
|
|
IPv6.prototype.toString = function() {
|
|
var compactStringParts, part, pushPart, state, stringParts, _i, _len;
|
|
stringParts = (function() {
|
|
var _i, _len, _ref, _results;
|
|
_ref = this.parts;
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
part = _ref[_i];
|
|
_results.push(part.toString(16));
|
|
}
|
|
return _results;
|
|
}).call(this);
|
|
compactStringParts = [];
|
|
pushPart = function(part) {
|
|
return compactStringParts.push(part);
|
|
};
|
|
state = 0;
|
|
for (_i = 0, _len = stringParts.length; _i < _len; _i++) {
|
|
part = stringParts[_i];
|
|
switch (state) {
|
|
case 0:
|
|
if (part === '0') {
|
|
pushPart('');
|
|
} else {
|
|
pushPart(part);
|
|
}
|
|
state = 1;
|
|
break;
|
|
case 1:
|
|
if (part === '0') {
|
|
state = 2;
|
|
} else {
|
|
pushPart(part);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (part !== '0') {
|
|
pushPart('');
|
|
pushPart(part);
|
|
state = 3;
|
|
}
|
|
break;
|
|
case 3:
|
|
pushPart(part);
|
|
}
|
|
}
|
|
if (state === 2) {
|
|
pushPart('');
|
|
pushPart('');
|
|
}
|
|
return compactStringParts.join(":");
|
|
};
|
|
|
|
IPv6.prototype.toByteArray = function() {
|
|
var bytes, part, _i, _len, _ref;
|
|
bytes = [];
|
|
_ref = this.parts;
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
part = _ref[_i];
|
|
bytes.push(part >> 8);
|
|
bytes.push(part & 0xff);
|
|
}
|
|
return bytes;
|
|
};
|
|
|
|
IPv6.prototype.toNormalizedString = function() {
|
|
var part;
|
|
return ((function() {
|
|
var _i, _len, _ref, _results;
|
|
_ref = this.parts;
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
part = _ref[_i];
|
|
_results.push(part.toString(16));
|
|
}
|
|
return _results;
|
|
}).call(this)).join(":");
|
|
};
|
|
|
|
IPv6.prototype.match = function(other, cidrRange) {
|
|
var _ref;
|
|
if (cidrRange === void 0) {
|
|
_ref = other, other = _ref[0], cidrRange = _ref[1];
|
|
}
|
|
if (other.kind() !== 'ipv6') {
|
|
throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");
|
|
}
|
|
return matchCIDR(this.parts, other.parts, 16, cidrRange);
|
|
};
|
|
|
|
IPv6.prototype.SpecialRanges = {
|
|
unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128],
|
|
linkLocal: [new IPv6([0xfe80, 0, 0, 0, 0, 0, 0, 0]), 10],
|
|
multicast: [new IPv6([0xff00, 0, 0, 0, 0, 0, 0, 0]), 8],
|
|
loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128],
|
|
uniqueLocal: [new IPv6([0xfc00, 0, 0, 0, 0, 0, 0, 0]), 7],
|
|
ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 0xffff, 0, 0]), 96],
|
|
rfc6145: [new IPv6([0, 0, 0, 0, 0xffff, 0, 0, 0]), 96],
|
|
rfc6052: [new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96],
|
|
'6to4': [new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16],
|
|
teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32],
|
|
reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]]
|
|
};
|
|
|
|
IPv6.prototype.range = function() {
|
|
return ipaddr.subnetMatch(this, this.SpecialRanges);
|
|
};
|
|
|
|
IPv6.prototype.isIPv4MappedAddress = function() {
|
|
return this.range() === 'ipv4Mapped';
|
|
};
|
|
|
|
IPv6.prototype.toIPv4Address = function() {
|
|
var high, low, _ref;
|
|
if (!this.isIPv4MappedAddress()) {
|
|
throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4");
|
|
}
|
|
_ref = this.parts.slice(-2), high = _ref[0], low = _ref[1];
|
|
return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff]);
|
|
};
|
|
|
|
return IPv6;
|
|
|
|
})();
|
|
|
|
ipv6Part = "(?:[0-9a-f]+::?)+";
|
|
|
|
ipv6Regexes = {
|
|
"native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?$", 'i'),
|
|
transitional: new RegExp(("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)") + ("" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$"), 'i')
|
|
};
|
|
|
|
expandIPv6 = function(string, parts) {
|
|
var colonCount, lastColon, part, replacement, replacementCount;
|
|
if (string.indexOf('::') !== string.lastIndexOf('::')) {
|
|
return null;
|
|
}
|
|
colonCount = 0;
|
|
lastColon = -1;
|
|
while ((lastColon = string.indexOf(':', lastColon + 1)) >= 0) {
|
|
colonCount++;
|
|
}
|
|
if (string.substr(0, 2) === '::') {
|
|
colonCount--;
|
|
}
|
|
if (string.substr(-2, 2) === '::') {
|
|
colonCount--;
|
|
}
|
|
if (colonCount > parts) {
|
|
return null;
|
|
}
|
|
replacementCount = parts - colonCount;
|
|
replacement = ':';
|
|
while (replacementCount--) {
|
|
replacement += '0:';
|
|
}
|
|
string = string.replace('::', replacement);
|
|
if (string[0] === ':') {
|
|
string = string.slice(1);
|
|
}
|
|
if (string[string.length - 1] === ':') {
|
|
string = string.slice(0, -1);
|
|
}
|
|
return (function() {
|
|
var _i, _len, _ref, _results;
|
|
_ref = string.split(":");
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
part = _ref[_i];
|
|
_results.push(parseInt(part, 16));
|
|
}
|
|
return _results;
|
|
})();
|
|
};
|
|
|
|
ipaddr.IPv6.parser = function(string) {
|
|
var match, parts;
|
|
if (string.match(ipv6Regexes['native'])) {
|
|
return expandIPv6(string, 8);
|
|
} else if (match = string.match(ipv6Regexes['transitional'])) {
|
|
parts = expandIPv6(match[1].slice(0, -1), 6);
|
|
if (parts) {
|
|
parts.push(parseInt(match[2]) << 8 | parseInt(match[3]));
|
|
parts.push(parseInt(match[4]) << 8 | parseInt(match[5]));
|
|
return parts;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = function(string) {
|
|
return this.parser(string) !== null;
|
|
};
|
|
|
|
ipaddr.IPv4.isValid = function(string) {
|
|
var e;
|
|
try {
|
|
new this(this.parser(string));
|
|
return true;
|
|
} catch (_error) {
|
|
e = _error;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
ipaddr.IPv6.isValid = function(string) {
|
|
var e;
|
|
if (typeof string === "string" && string.indexOf(":") === -1) {
|
|
return false;
|
|
}
|
|
try {
|
|
new this(this.parser(string));
|
|
return true;
|
|
} catch (_error) {
|
|
e = _error;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
ipaddr.IPv4.parse = ipaddr.IPv6.parse = function(string) {
|
|
var parts;
|
|
parts = this.parser(string);
|
|
if (parts === null) {
|
|
throw new Error("ipaddr: string is not formatted like ip address");
|
|
}
|
|
return new this(parts);
|
|
};
|
|
|
|
ipaddr.IPv4.parseCIDR = function(string) {
|
|
var maskLength, match;
|
|
if (match = string.match(/^(.+)\/(\d+)$/)) {
|
|
maskLength = parseInt(match[2]);
|
|
if (maskLength >= 0 && maskLength <= 32) {
|
|
return [this.parse(match[1]), maskLength];
|
|
}
|
|
}
|
|
throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range");
|
|
};
|
|
|
|
ipaddr.IPv6.parseCIDR = function(string) {
|
|
var maskLength, match;
|
|
if (match = string.match(/^(.+)\/(\d+)$/)) {
|
|
maskLength = parseInt(match[2]);
|
|
if (maskLength >= 0 && maskLength <= 128) {
|
|
return [this.parse(match[1]), maskLength];
|
|
}
|
|
}
|
|
throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");
|
|
};
|
|
|
|
ipaddr.isValid = function(string) {
|
|
return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string);
|
|
};
|
|
|
|
ipaddr.parse = function(string) {
|
|
if (ipaddr.IPv6.isValid(string)) {
|
|
return ipaddr.IPv6.parse(string);
|
|
} else if (ipaddr.IPv4.isValid(string)) {
|
|
return ipaddr.IPv4.parse(string);
|
|
} else {
|
|
throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format");
|
|
}
|
|
};
|
|
|
|
ipaddr.parseCIDR = function(string) {
|
|
var e;
|
|
try {
|
|
return ipaddr.IPv6.parseCIDR(string);
|
|
} catch (_error) {
|
|
e = _error;
|
|
try {
|
|
return ipaddr.IPv4.parseCIDR(string);
|
|
} catch (_error) {
|
|
e = _error;
|
|
throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format");
|
|
}
|
|
}
|
|
};
|
|
|
|
ipaddr.process = function(string) {
|
|
var addr;
|
|
addr = this.parse(string);
|
|
if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) {
|
|
return addr.toIPv4Address();
|
|
} else {
|
|
return addr;
|
|
}
|
|
};
|
|
|
|
}).call(this);
|