change approach again
This commit is contained in:
2
node_modules/ipaddr.js/.npmignore
generated
vendored
Normal file
2
node_modules/ipaddr.js/.npmignore
generated
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
.idea
|
||||
node_modules
|
||||
10
node_modules/ipaddr.js/.travis.yml
generated
vendored
Normal file
10
node_modules/ipaddr.js/.travis.yml
generated
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
language: node_js
|
||||
|
||||
node_js:
|
||||
- "0.10"
|
||||
- "0.11"
|
||||
- "0.12"
|
||||
- "4.0"
|
||||
- "4.1"
|
||||
- "4.2"
|
||||
- "5"
|
||||
14
node_modules/ipaddr.js/Cakefile
generated
vendored
Normal file
14
node_modules/ipaddr.js/Cakefile
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
fs = require 'fs'
|
||||
CoffeeScript = require 'coffee-script'
|
||||
nodeunit = require 'nodeunit'
|
||||
UglifyJS = require 'uglify-js'
|
||||
|
||||
task 'build', 'build javascript files from sources', (cb) ->
|
||||
source = fs.readFileSync 'src/ipaddr.coffee', 'utf-8'
|
||||
fs.writeFileSync 'lib/ipaddr.js', CoffeeScript.compile source.toString()
|
||||
|
||||
source = fs.readFileSync 'lib/ipaddr.js', 'utf-8'
|
||||
fs.writeFileSync('ipaddr.min.js', UglifyJS.minify(source).code)
|
||||
|
||||
task 'test', 'run the bundled tests', (cb) ->
|
||||
nodeunit.reporters.default.run ['test']
|
||||
19
node_modules/ipaddr.js/LICENSE
generated
vendored
Normal file
19
node_modules/ipaddr.js/LICENSE
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
Copyright (C) 2011-2017 whitequark <whitequark@whitequark.org>
|
||||
|
||||
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.
|
||||
233
node_modules/ipaddr.js/README.md
generated
vendored
Normal file
233
node_modules/ipaddr.js/README.md
generated
vendored
Normal file
@ -0,0 +1,233 @@
|
||||
# ipaddr.js — an IPv6 and IPv4 address manipulation library [](https://travis-ci.org/whitequark/ipaddr.js)
|
||||
|
||||
ipaddr.js is a small (1.9K minified and gzipped) library for manipulating
|
||||
IP addresses in JavaScript environments. It runs on both CommonJS runtimes
|
||||
(e.g. [nodejs]) and in a web browser.
|
||||
|
||||
ipaddr.js allows you to verify and parse string representation of an IP
|
||||
address, match it against a CIDR range or range list, determine if it falls
|
||||
into some reserved ranges (examples include loopback and private ranges),
|
||||
and convert between IPv4 and IPv4-mapped IPv6 addresses.
|
||||
|
||||
[nodejs]: http://nodejs.org
|
||||
|
||||
## Installation
|
||||
|
||||
`npm install ipaddr.js`
|
||||
|
||||
or
|
||||
|
||||
`bower install ipaddr.js`
|
||||
|
||||
## API
|
||||
|
||||
ipaddr.js defines one object in the global scope: `ipaddr`. In CommonJS,
|
||||
it is exported from the module:
|
||||
|
||||
```js
|
||||
var ipaddr = require('ipaddr.js');
|
||||
```
|
||||
|
||||
The API consists of several global methods and two classes: ipaddr.IPv6 and ipaddr.IPv4.
|
||||
|
||||
### Global methods
|
||||
|
||||
There are three global methods defined: `ipaddr.isValid`, `ipaddr.parse` and
|
||||
`ipaddr.process`. All of them receive a string as a single parameter.
|
||||
|
||||
The `ipaddr.isValid` method returns `true` if the address is a valid IPv4 or
|
||||
IPv6 address, and `false` otherwise. It does not throw any exceptions.
|
||||
|
||||
The `ipaddr.parse` method returns an object representing the IP address,
|
||||
or throws an `Error` if the passed string is not a valid representation of an
|
||||
IP address.
|
||||
|
||||
The `ipaddr.process` method works just like the `ipaddr.parse` one, but it
|
||||
automatically converts IPv4-mapped IPv6 addresses to their IPv4 counterparts
|
||||
before returning. It is useful when you have a Node.js instance listening
|
||||
on an IPv6 socket, and the `net.ivp6.bindv6only` sysctl parameter (or its
|
||||
equivalent on non-Linux OS) is set to 0. In this case, you can accept IPv4
|
||||
connections on your IPv6-only socket, but the remote address will be mangled.
|
||||
Use `ipaddr.process` method to automatically demangle it.
|
||||
|
||||
### Object representation
|
||||
|
||||
Parsing methods return an object which descends from `ipaddr.IPv6` or
|
||||
`ipaddr.IPv4`. These objects share some properties, but most of them differ.
|
||||
|
||||
#### Shared properties
|
||||
|
||||
One can determine the type of address by calling `addr.kind()`. It will return
|
||||
either `"ipv6"` or `"ipv4"`.
|
||||
|
||||
An address can be converted back to its string representation with `addr.toString()`.
|
||||
Note that this method:
|
||||
* does not return the original string used to create the object (in fact, there is
|
||||
no way of getting that string)
|
||||
* returns a compact representation (when it is applicable)
|
||||
|
||||
A `match(range, bits)` method can be used to check if the address falls into a
|
||||
certain CIDR range.
|
||||
Note that an address can be (obviously) matched only against an address of the same type.
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
var addr = ipaddr.parse("2001:db8:1234::1");
|
||||
var range = ipaddr.parse("2001:db8::");
|
||||
|
||||
addr.match(range, 32); // => true
|
||||
```
|
||||
|
||||
Alternatively, `match` can also be called as `match([range, bits])`. In this way,
|
||||
it can be used together with the `parseCIDR(string)` method, which parses an IP
|
||||
address together with a CIDR range.
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
var addr = ipaddr.parse("2001:db8:1234::1");
|
||||
|
||||
addr.match(ipaddr.parseCIDR("2001:db8::/32")); // => true
|
||||
```
|
||||
|
||||
A `range()` method returns one of predefined names for several special ranges defined
|
||||
by IP protocols. The exact names (and their respective CIDR ranges) can be looked up
|
||||
in the source: [IPv6 ranges] and [IPv4 ranges]. Some common ones include `"unicast"`
|
||||
(the default one) and `"reserved"`.
|
||||
|
||||
You can match against your own range list by using
|
||||
`ipaddr.subnetMatch(address, rangeList, defaultName)` method. It can work with a mix of IPv6 or IPv4 addresses, and accepts a name-to-subnet map as the range list. For example:
|
||||
|
||||
```js
|
||||
var rangeList = {
|
||||
documentationOnly: [ ipaddr.parse('2001:db8::'), 32 ],
|
||||
tunnelProviders: [
|
||||
[ ipaddr.parse('2001:470::'), 32 ], // he.net
|
||||
[ ipaddr.parse('2001:5c0::'), 32 ] // freenet6
|
||||
]
|
||||
};
|
||||
ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown'); // => "tunnelProviders"
|
||||
```
|
||||
|
||||
The addresses can be converted to their byte representation with `toByteArray()`.
|
||||
(Actually, JavaScript mostly does not know about byte buffers. They are emulated with
|
||||
arrays of numbers, each in range of 0..255.)
|
||||
|
||||
```js
|
||||
var bytes = ipaddr.parse('2a00:1450:8007::68').toByteArray(); // ipv6.google.com
|
||||
bytes // => [42, 0x00, 0x14, 0x50, 0x80, 0x07, 0x00, <zeroes...>, 0x00, 0x68 ]
|
||||
```
|
||||
|
||||
The `ipaddr.IPv4` and `ipaddr.IPv6` objects have some methods defined, too. All of them
|
||||
have the same interface for both protocols, and are similar to global methods.
|
||||
|
||||
`ipaddr.IPvX.isValid(string)` can be used to check if the string is a valid address
|
||||
for particular protocol, and `ipaddr.IPvX.parse(string)` is the error-throwing parser.
|
||||
|
||||
`ipaddr.IPvX.isValid(string)` uses the same format for parsing as the POSIX `inet_ntoa` function, which accepts unusual formats like `0xc0.168.1.1` or `0x10000000`. The function `ipaddr.IPv4.isValidFourPartDecimal(string)` validates the IPv4 address and also ensures that it is written in four-part decimal format.
|
||||
|
||||
[IPv6 ranges]: https://github.com/whitequark/ipaddr.js/blob/master/src/ipaddr.coffee#L186
|
||||
[IPv4 ranges]: https://github.com/whitequark/ipaddr.js/blob/master/src/ipaddr.coffee#L71
|
||||
|
||||
#### IPv6 properties
|
||||
|
||||
Sometimes you will want to convert IPv6 not to a compact string representation (with
|
||||
the `::` substitution); the `toNormalizedString()` method will return an address where
|
||||
all zeroes are explicit.
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
var addr = ipaddr.parse("2001:0db8::0001");
|
||||
addr.toString(); // => "2001:db8::1"
|
||||
addr.toNormalizedString(); // => "2001:db8:0:0:0:0:0:1"
|
||||
```
|
||||
|
||||
The `isIPv4MappedAddress()` method will return `true` if this address is an IPv4-mapped
|
||||
one, and `toIPv4Address()` will return an IPv4 object address.
|
||||
|
||||
To access the underlying binary representation of the address, use `addr.parts`.
|
||||
|
||||
```js
|
||||
var addr = ipaddr.parse("2001:db8:10::1234:DEAD");
|
||||
addr.parts // => [0x2001, 0xdb8, 0x10, 0, 0, 0, 0x1234, 0xdead]
|
||||
```
|
||||
|
||||
A IPv6 zone index can be accessed via `addr.zoneId`:
|
||||
|
||||
```js
|
||||
var addr = ipaddr.parse("2001:db8::%eth0");
|
||||
addr.zoneId // => 'eth0'
|
||||
```
|
||||
|
||||
#### IPv4 properties
|
||||
|
||||
`toIPv4MappedAddress()` will return a corresponding IPv4-mapped IPv6 address.
|
||||
|
||||
To access the underlying representation of the address, use `addr.octets`.
|
||||
|
||||
```js
|
||||
var addr = ipaddr.parse("192.168.1.1");
|
||||
addr.octets // => [192, 168, 1, 1]
|
||||
```
|
||||
|
||||
`prefixLengthFromSubnetMask()` will return a CIDR prefix length for a valid IPv4 netmask or
|
||||
false if the netmask is not valid.
|
||||
|
||||
```js
|
||||
ipaddr.IPv4.parse('255.255.255.240').prefixLengthFromSubnetMask() == 28
|
||||
ipaddr.IPv4.parse('255.192.164.0').prefixLengthFromSubnetMask() == null
|
||||
```
|
||||
|
||||
`subnetMaskFromPrefixLength()` will return an IPv4 netmask for a valid CIDR prefix length.
|
||||
|
||||
```js
|
||||
ipaddr.IPv4.subnetMaskFromPrefixLength(24) == "255.255.255.0"
|
||||
ipaddr.IPv4.subnetMaskFromPrefixLength(29) == "255.255.255.248"
|
||||
```
|
||||
|
||||
`broadcastAddressFromCIDR()` will return the broadcast address for a given IPv4 interface and netmask in CIDR notation.
|
||||
```js
|
||||
ipaddr.IPv4.broadcastAddressFromCIDR("172.0.0.1/24") == "172.0.0.255"
|
||||
```
|
||||
`networkAddressFromCIDR()` will return the network address for a given IPv4 interface and netmask in CIDR notation.
|
||||
```js
|
||||
ipaddr.IPv4.networkAddressFromCIDR("172.0.0.1/24") == "172.0.0.0"
|
||||
```
|
||||
|
||||
#### Conversion
|
||||
|
||||
IPv4 and IPv6 can be converted bidirectionally to and from network byte order (MSB) byte arrays.
|
||||
|
||||
The `fromByteArray()` method will take an array and create an appropriate IPv4 or IPv6 object
|
||||
if the input satisfies the requirements. For IPv4 it has to be an array of four 8-bit values,
|
||||
while for IPv6 it has to be an array of sixteen 8-bit values.
|
||||
|
||||
For example:
|
||||
```js
|
||||
var addr = ipaddr.fromByteArray([0x7f, 0, 0, 1]);
|
||||
addr.toString(); // => "127.0.0.1"
|
||||
```
|
||||
|
||||
or
|
||||
|
||||
```js
|
||||
var addr = ipaddr.fromByteArray([0x20, 1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
|
||||
addr.toString(); // => "2001:db8::1"
|
||||
```
|
||||
|
||||
Both objects also offer a `toByteArray()` method, which returns an array in network byte order (MSB).
|
||||
|
||||
For example:
|
||||
```js
|
||||
var addr = ipaddr.parse("127.0.0.1");
|
||||
addr.toByteArray(); // => [0x7f, 0, 0, 1]
|
||||
```
|
||||
|
||||
or
|
||||
|
||||
```js
|
||||
var addr = ipaddr.parse("2001:db8::1");
|
||||
addr.toByteArray(); // => [0x20, 1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
|
||||
```
|
||||
29
node_modules/ipaddr.js/bower.json
generated
vendored
Normal file
29
node_modules/ipaddr.js/bower.json
generated
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
{
|
||||
"name": "ipaddr.js",
|
||||
"version": "1.6.0",
|
||||
"homepage": "https://github.com/whitequark/ipaddr.js",
|
||||
"authors": [
|
||||
"whitequark <whitequark@whitequark.org>"
|
||||
],
|
||||
"description": "IP address manipulation library in JavaScript (CoffeeScript, actually)",
|
||||
"main": "lib/ipaddr.js",
|
||||
"moduleType": [
|
||||
"globals",
|
||||
"node"
|
||||
],
|
||||
"keywords": [
|
||||
"javscript",
|
||||
"ip",
|
||||
"address",
|
||||
"ipv4",
|
||||
"ipv6"
|
||||
],
|
||||
"license": "MIT",
|
||||
"ignore": [
|
||||
"**/.*",
|
||||
"node_modules",
|
||||
"bower_components",
|
||||
"test",
|
||||
"tests"
|
||||
]
|
||||
}
|
||||
1
node_modules/ipaddr.js/ipaddr.min.js
generated
vendored
Normal file
1
node_modules/ipaddr.js/ipaddr.min.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
624
node_modules/ipaddr.js/lib/ipaddr.js
generated
vendored
Normal file
624
node_modules/ipaddr.js/lib/ipaddr.js
generated
vendored
Normal file
@ -0,0 +1,624 @@
|
||||
(function() {
|
||||
var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root, zoneIndex;
|
||||
|
||||
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 k, len, rangeName, rangeSubnets, subnet;
|
||||
if (defaultName == null) {
|
||||
defaultName = 'unicast';
|
||||
}
|
||||
for (rangeName in rangeList) {
|
||||
rangeSubnets = rangeList[rangeName];
|
||||
if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) {
|
||||
rangeSubnets = [rangeSubnets];
|
||||
}
|
||||
for (k = 0, len = rangeSubnets.length; k < len; k++) {
|
||||
subnet = rangeSubnets[k];
|
||||
if (address.kind() === subnet[0].kind()) {
|
||||
if (address.match.apply(address, subnet)) {
|
||||
return rangeName;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return defaultName;
|
||||
};
|
||||
|
||||
ipaddr.IPv4 = (function() {
|
||||
function IPv4(octets) {
|
||||
var k, len, octet;
|
||||
if (octets.length !== 4) {
|
||||
throw new Error("ipaddr: ipv4 octet count should be 4");
|
||||
}
|
||||
for (k = 0, len = octets.length; k < len; k++) {
|
||||
octet = octets[k];
|
||||
if (!((0 <= octet && octet <= 255))) {
|
||||
throw new Error("ipaddr: ipv4 octet should fit in 8 bits");
|
||||
}
|
||||
}
|
||||
this.octets = octets;
|
||||
}
|
||||
|
||||
IPv4.prototype.kind = function() {
|
||||
return 'ipv4';
|
||||
};
|
||||
|
||||
IPv4.prototype.toString = function() {
|
||||
return this.octets.join(".");
|
||||
};
|
||||
|
||||
IPv4.prototype.toNormalizedString = function() {
|
||||
return this.toString();
|
||||
};
|
||||
|
||||
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]],
|
||||
carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]],
|
||||
"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()));
|
||||
};
|
||||
|
||||
IPv4.prototype.prefixLengthFromSubnetMask = function() {
|
||||
var cidr, i, k, octet, stop, zeros, zerotable;
|
||||
zerotable = {
|
||||
0: 8,
|
||||
128: 7,
|
||||
192: 6,
|
||||
224: 5,
|
||||
240: 4,
|
||||
248: 3,
|
||||
252: 2,
|
||||
254: 1,
|
||||
255: 0
|
||||
};
|
||||
cidr = 0;
|
||||
stop = false;
|
||||
for (i = k = 3; k >= 0; i = k += -1) {
|
||||
octet = this.octets[i];
|
||||
if (octet in zerotable) {
|
||||
zeros = zerotable[octet];
|
||||
if (stop && zeros !== 0) {
|
||||
return null;
|
||||
}
|
||||
if (zeros !== 8) {
|
||||
stop = true;
|
||||
}
|
||||
cidr += zeros;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
return 32 - cidr;
|
||||
};
|
||||
|
||||
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 k, len, ref, results;
|
||||
ref = match.slice(1, 6);
|
||||
results = [];
|
||||
for (k = 0, len = ref.length; k < len; k++) {
|
||||
part = ref[k];
|
||||
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 k, results;
|
||||
results = [];
|
||||
for (shift = k = 0; k <= 24; shift = k += 8) {
|
||||
results.push((value >> shift) & 0xff);
|
||||
}
|
||||
return results;
|
||||
})()).reverse();
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.IPv6 = (function() {
|
||||
function IPv6(parts, zoneId) {
|
||||
var i, k, l, len, part, ref;
|
||||
if (parts.length === 16) {
|
||||
this.parts = [];
|
||||
for (i = k = 0; k <= 14; i = k += 2) {
|
||||
this.parts.push((parts[i] << 8) | parts[i + 1]);
|
||||
}
|
||||
} else if (parts.length === 8) {
|
||||
this.parts = parts;
|
||||
} else {
|
||||
throw new Error("ipaddr: ipv6 part count should be 8 or 16");
|
||||
}
|
||||
ref = this.parts;
|
||||
for (l = 0, len = ref.length; l < len; l++) {
|
||||
part = ref[l];
|
||||
if (!((0 <= part && part <= 0xffff))) {
|
||||
throw new Error("ipaddr: ipv6 part should fit in 16 bits");
|
||||
}
|
||||
}
|
||||
if (zoneId) {
|
||||
this.zoneId = zoneId;
|
||||
}
|
||||
}
|
||||
|
||||
IPv6.prototype.kind = function() {
|
||||
return 'ipv6';
|
||||
};
|
||||
|
||||
IPv6.prototype.toString = function() {
|
||||
return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, '::');
|
||||
};
|
||||
|
||||
IPv6.prototype.toByteArray = function() {
|
||||
var bytes, k, len, part, ref;
|
||||
bytes = [];
|
||||
ref = this.parts;
|
||||
for (k = 0, len = ref.length; k < len; k++) {
|
||||
part = ref[k];
|
||||
bytes.push(part >> 8);
|
||||
bytes.push(part & 0xff);
|
||||
}
|
||||
return bytes;
|
||||
};
|
||||
|
||||
IPv6.prototype.toNormalizedString = function() {
|
||||
var addr, part, suffix;
|
||||
addr = ((function() {
|
||||
var k, len, ref, results;
|
||||
ref = this.parts;
|
||||
results = [];
|
||||
for (k = 0, len = ref.length; k < len; k++) {
|
||||
part = ref[k];
|
||||
results.push(part.toString(16));
|
||||
}
|
||||
return results;
|
||||
}).call(this)).join(":");
|
||||
suffix = '';
|
||||
if (this.zoneId) {
|
||||
suffix = '%' + this.zoneId;
|
||||
}
|
||||
return addr + suffix;
|
||||
};
|
||||
|
||||
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]);
|
||||
};
|
||||
|
||||
IPv6.prototype.prefixLengthFromSubnetMask = function() {
|
||||
var cidr, i, k, part, stop, zeros, zerotable;
|
||||
zerotable = {
|
||||
0: 16,
|
||||
32768: 15,
|
||||
49152: 14,
|
||||
57344: 13,
|
||||
61440: 12,
|
||||
63488: 11,
|
||||
64512: 10,
|
||||
65024: 9,
|
||||
65280: 8,
|
||||
65408: 7,
|
||||
65472: 6,
|
||||
65504: 5,
|
||||
65520: 4,
|
||||
65528: 3,
|
||||
65532: 2,
|
||||
65534: 1,
|
||||
65535: 0
|
||||
};
|
||||
cidr = 0;
|
||||
stop = false;
|
||||
for (i = k = 7; k >= 0; i = k += -1) {
|
||||
part = this.parts[i];
|
||||
if (part in zerotable) {
|
||||
zeros = zerotable[part];
|
||||
if (stop && zeros !== 0) {
|
||||
return null;
|
||||
}
|
||||
if (zeros !== 16) {
|
||||
stop = true;
|
||||
}
|
||||
cidr += zeros;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
return 128 - cidr;
|
||||
};
|
||||
|
||||
return IPv6;
|
||||
|
||||
})();
|
||||
|
||||
ipv6Part = "(?:[0-9a-f]+::?)+";
|
||||
|
||||
zoneIndex = "%[0-9a-z]{1,}";
|
||||
|
||||
ipv6Regexes = {
|
||||
zoneIndex: new RegExp(zoneIndex, 'i'),
|
||||
"native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?(" + zoneIndex + ")?$", 'i'),
|
||||
transitional: new RegExp(("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)") + (ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part) + ("(" + zoneIndex + ")?$"), 'i')
|
||||
};
|
||||
|
||||
expandIPv6 = function(string, parts) {
|
||||
var colonCount, lastColon, part, replacement, replacementCount, zoneId;
|
||||
if (string.indexOf('::') !== string.lastIndexOf('::')) {
|
||||
return null;
|
||||
}
|
||||
zoneId = (string.match(ipv6Regexes['zoneIndex']) || [])[0];
|
||||
if (zoneId) {
|
||||
zoneId = zoneId.substring(1);
|
||||
string = string.replace(/%.+$/, '');
|
||||
}
|
||||
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);
|
||||
}
|
||||
parts = (function() {
|
||||
var k, len, ref, results;
|
||||
ref = string.split(":");
|
||||
results = [];
|
||||
for (k = 0, len = ref.length; k < len; k++) {
|
||||
part = ref[k];
|
||||
results.push(parseInt(part, 16));
|
||||
}
|
||||
return results;
|
||||
})();
|
||||
return {
|
||||
parts: parts,
|
||||
zoneId: zoneId
|
||||
};
|
||||
};
|
||||
|
||||
ipaddr.IPv6.parser = function(string) {
|
||||
var addr, k, len, match, octet, octets, zoneId;
|
||||
if (ipv6Regexes['native'].test(string)) {
|
||||
return expandIPv6(string, 8);
|
||||
} else if (match = string.match(ipv6Regexes['transitional'])) {
|
||||
zoneId = match[6] || '';
|
||||
addr = expandIPv6(match[1].slice(0, -1) + zoneId, 6);
|
||||
if (addr.parts) {
|
||||
octets = [parseInt(match[2]), parseInt(match[3]), parseInt(match[4]), parseInt(match[5])];
|
||||
for (k = 0, len = octets.length; k < len; k++) {
|
||||
octet = octets[k];
|
||||
if (!((0 <= octet && octet <= 255))) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
addr.parts.push(octets[0] << 8 | octets[1]);
|
||||
addr.parts.push(octets[2] << 8 | octets[3]);
|
||||
return {
|
||||
parts: addr.parts,
|
||||
zoneId: addr.zoneId
|
||||
};
|
||||
}
|
||||
}
|
||||
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 (error1) {
|
||||
e = error1;
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.IPv4.isValidFourPartDecimal = function(string) {
|
||||
if (ipaddr.IPv4.isValid(string) && string.match(/^\d+(\.\d+){3}$/)) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.IPv6.isValid = function(string) {
|
||||
var addr, e;
|
||||
if (typeof string === "string" && string.indexOf(":") === -1) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
addr = this.parser(string);
|
||||
new this(addr.parts, addr.zoneId);
|
||||
return true;
|
||||
} catch (error1) {
|
||||
e = error1;
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.IPv4.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.IPv6.parse = function(string) {
|
||||
var addr;
|
||||
addr = this.parser(string);
|
||||
if (addr.parts === null) {
|
||||
throw new Error("ipaddr: string is not formatted like ip address");
|
||||
}
|
||||
return new this(addr.parts, addr.zoneId);
|
||||
};
|
||||
|
||||
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.IPv4.subnetMaskFromPrefixLength = function(prefix) {
|
||||
var filledOctetCount, j, octets;
|
||||
prefix = parseInt(prefix);
|
||||
if (prefix < 0 || prefix > 32) {
|
||||
throw new Error('ipaddr: invalid IPv4 prefix length');
|
||||
}
|
||||
octets = [0, 0, 0, 0];
|
||||
j = 0;
|
||||
filledOctetCount = Math.floor(prefix / 8);
|
||||
while (j < filledOctetCount) {
|
||||
octets[j] = 255;
|
||||
j++;
|
||||
}
|
||||
if (filledOctetCount < 4) {
|
||||
octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - (prefix % 8);
|
||||
}
|
||||
return new this(octets);
|
||||
};
|
||||
|
||||
ipaddr.IPv4.broadcastAddressFromCIDR = function(string) {
|
||||
var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets;
|
||||
try {
|
||||
cidr = this.parseCIDR(string);
|
||||
ipInterfaceOctets = cidr[0].toByteArray();
|
||||
subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
|
||||
octets = [];
|
||||
i = 0;
|
||||
while (i < 4) {
|
||||
octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
|
||||
i++;
|
||||
}
|
||||
return new this(octets);
|
||||
} catch (error1) {
|
||||
error = error1;
|
||||
throw new Error('ipaddr: the address does not have IPv4 CIDR format');
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.IPv4.networkAddressFromCIDR = function(string) {
|
||||
var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets;
|
||||
try {
|
||||
cidr = this.parseCIDR(string);
|
||||
ipInterfaceOctets = cidr[0].toByteArray();
|
||||
subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
|
||||
octets = [];
|
||||
i = 0;
|
||||
while (i < 4) {
|
||||
octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
|
||||
i++;
|
||||
}
|
||||
return new this(octets);
|
||||
} catch (error1) {
|
||||
error = error1;
|
||||
throw new Error('ipaddr: the address does not have IPv4 CIDR format');
|
||||
}
|
||||
};
|
||||
|
||||
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 (error1) {
|
||||
e = error1;
|
||||
try {
|
||||
return ipaddr.IPv4.parseCIDR(string);
|
||||
} catch (error1) {
|
||||
e = error1;
|
||||
throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.fromByteArray = function(bytes) {
|
||||
var length;
|
||||
length = bytes.length;
|
||||
if (length === 4) {
|
||||
return new ipaddr.IPv4(bytes);
|
||||
} else if (length === 16) {
|
||||
return new ipaddr.IPv6(bytes);
|
||||
} else {
|
||||
throw new Error("ipaddr: the binary input is neither an IPv6 nor IPv4 address");
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.process = function(string) {
|
||||
var addr;
|
||||
addr = this.parse(string);
|
||||
if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) {
|
||||
return addr.toIPv4Address();
|
||||
} else {
|
||||
return addr;
|
||||
}
|
||||
};
|
||||
|
||||
}).call(this);
|
||||
71
node_modules/ipaddr.js/lib/ipaddr.js.d.ts
generated
vendored
Normal file
71
node_modules/ipaddr.js/lib/ipaddr.js.d.ts
generated
vendored
Normal file
@ -0,0 +1,71 @@
|
||||
|
||||
|
||||
declare module "ipaddr.js" {
|
||||
|
||||
type IPv4Range = 'unspecified' | 'broadcast' | 'multicast' | 'linkLocal' | 'loopback' | 'carrierGradeNat' | 'private' | 'reserved';
|
||||
type IPv6Range = 'unspecified' | 'linkLocal' | 'multicast' | 'loopback' | 'uniqueLocal' | 'ipv4Mapped' | 'rfc6145' | 'rfc6052' | '6to4' | 'teredo' | 'reserved';
|
||||
|
||||
interface RangeList<T> {
|
||||
[name: string]: [T, number] | [T, number][];
|
||||
}
|
||||
|
||||
|
||||
// Common methods/properties for IPv4 and IPv6 classes.
|
||||
class IP {
|
||||
|
||||
prefixLengthFromSubnetMask(): number | false;
|
||||
toByteArray(): number[];
|
||||
toNormalizedString(): string;
|
||||
toString(): string;
|
||||
}
|
||||
|
||||
namespace Address {
|
||||
|
||||
export function isValid(addr: string): boolean;
|
||||
export function fromByteArray(bytes: number[]): IPv4 | IPv6;
|
||||
export function parse(addr: string): IPv4 | IPv6;
|
||||
export function parseCIDR(mask: string): [IPv4 | IPv6, number];
|
||||
export function process(address: string): IPv4 | IPv6;
|
||||
export function subnetMatch(addr: IPv4, rangeList: RangeList<IPv4>, defaultName?: string): boolean;
|
||||
export function subnetMatch(addr: IPv6, rangeList: RangeList<IPv6>, defaultName?: string): boolean;
|
||||
|
||||
export class IPv4 extends IP {
|
||||
static broadcastAddressFromCIDR(addr: string): IPv4;
|
||||
static isIPv4(addr: string): boolean;
|
||||
static isValidFourPartDecimal(addr: string): boolean;
|
||||
static isValid(addr: string): boolean;
|
||||
static networkAddressFromCIDR(addr: string): IPv4;
|
||||
static parse(addr: string): IPv4;
|
||||
static parseCIDR(addr: string): [IPv4, number];
|
||||
static subnetMaskFromPrefixLength(prefix: number): IPv4;
|
||||
constructor(octets: number[]);
|
||||
|
||||
kind(): 'ipv4';
|
||||
match(addr: IPv4, bits: number): boolean;
|
||||
match(mask: [IPv4, number]): boolean;
|
||||
range(): IPv4Range;
|
||||
subnetMatch(rangeList: RangeList<IPv4>, defaultName?: string): boolean;
|
||||
toIPv4MappedAddress(): IPv6;
|
||||
}
|
||||
|
||||
export class IPv6 extends IP {
|
||||
static broadcastAddressFromCIDR(addr: string): IPv6;
|
||||
static isIPv6(addr: string): boolean;
|
||||
static isValid(addr: string): boolean;
|
||||
static parse(addr: string): IPv6;
|
||||
static parseCIDR(addr: string): [IPv6, number];
|
||||
static subnetMaskFromPrefixLength(prefix: number): IPv6;
|
||||
constructor(octets: number[]);
|
||||
|
||||
isIPv4MappedAddress(): boolean;
|
||||
kind(): 'ipv6';
|
||||
match(addr: IPv6, bits: number): boolean;
|
||||
match(mask: [IPv6, number]): boolean;
|
||||
range(): IPv6Range;
|
||||
subnetMatch(rangeList: RangeList<IPv6>, defaultName?: string): boolean;
|
||||
toIPv4Address(): IPv4;
|
||||
}
|
||||
}
|
||||
|
||||
export = Address;
|
||||
}
|
||||
65
node_modules/ipaddr.js/package.json
generated
vendored
Normal file
65
node_modules/ipaddr.js/package.json
generated
vendored
Normal file
@ -0,0 +1,65 @@
|
||||
{
|
||||
"_from": "ipaddr.js@1.6.0",
|
||||
"_id": "ipaddr.js@1.6.0",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha1-4/o1e3c9phnybpXwSdBVxyeW+Gs=",
|
||||
"_location": "/ipaddr.js",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "version",
|
||||
"registry": true,
|
||||
"raw": "ipaddr.js@1.6.0",
|
||||
"name": "ipaddr.js",
|
||||
"escapedName": "ipaddr.js",
|
||||
"rawSpec": "1.6.0",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "1.6.0"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/proxy-addr"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.6.0.tgz",
|
||||
"_shasum": "e3fa357b773da619f26e95f049d055c72796f86b",
|
||||
"_spec": "ipaddr.js@1.6.0",
|
||||
"_where": "/home/wn/workspace-node/homepage/node_modules/proxy-addr",
|
||||
"author": {
|
||||
"name": "whitequark",
|
||||
"email": "whitequark@whitequark.org"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/whitequark/ipaddr.js/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"dependencies": {},
|
||||
"deprecated": false,
|
||||
"description": "A library for manipulating IPv4 and IPv6 addresses in JavaScript.",
|
||||
"devDependencies": {
|
||||
"coffee-script": "~1.12.6",
|
||||
"nodeunit": ">=0.8.2 <0.8.7",
|
||||
"uglify-js": "~3.0.19"
|
||||
},
|
||||
"directories": {
|
||||
"lib": "./lib"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 0.10"
|
||||
},
|
||||
"homepage": "https://github.com/whitequark/ipaddr.js#readme",
|
||||
"keywords": [
|
||||
"ip",
|
||||
"ipv4",
|
||||
"ipv6"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "./lib/ipaddr.js",
|
||||
"name": "ipaddr.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/whitequark/ipaddr.js.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "cake build test"
|
||||
},
|
||||
"types": "./lib/ipaddr.js.d.ts",
|
||||
"version": "1.6.0"
|
||||
}
|
||||
554
node_modules/ipaddr.js/src/ipaddr.coffee
generated
vendored
Normal file
554
node_modules/ipaddr.js/src/ipaddr.coffee
generated
vendored
Normal file
@ -0,0 +1,554 @@
|
||||
# Define the main object
|
||||
ipaddr = {}
|
||||
|
||||
root = this
|
||||
|
||||
# Export for both the CommonJS and browser-like environment
|
||||
if module? && module.exports
|
||||
module.exports = ipaddr
|
||||
else
|
||||
root['ipaddr'] = ipaddr
|
||||
|
||||
# A generic CIDR (Classless Inter-Domain Routing) RFC1518 range matcher.
|
||||
matchCIDR = (first, second, partSize, cidrBits) ->
|
||||
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
|
||||
shift = 0 if shift < 0
|
||||
|
||||
if first[part] >> shift != second[part] >> shift
|
||||
return false
|
||||
|
||||
cidrBits -= partSize
|
||||
part += 1
|
||||
|
||||
return true
|
||||
|
||||
# An utility function to ease named range matching. See examples below.
|
||||
# rangeList can contain both IPv4 and IPv6 subnet entries and will not throw errors
|
||||
# on matching IPv4 addresses to IPv6 ranges or vice versa.
|
||||
ipaddr.subnetMatch = (address, rangeList, defaultName='unicast') ->
|
||||
for rangeName, rangeSubnets of rangeList
|
||||
# ECMA5 Array.isArray isn't available everywhere
|
||||
if rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)
|
||||
rangeSubnets = [ rangeSubnets ]
|
||||
|
||||
for subnet in rangeSubnets
|
||||
if address.kind() == subnet[0].kind()
|
||||
if address.match.apply(address, subnet)
|
||||
return rangeName
|
||||
|
||||
return defaultName
|
||||
|
||||
# An IPv4 address (RFC791).
|
||||
class ipaddr.IPv4
|
||||
# Constructs a new IPv4 address from an array of four octets
|
||||
# in network order (MSB first)
|
||||
# Verifies the input.
|
||||
constructor: (octets) ->
|
||||
if octets.length != 4
|
||||
throw new Error "ipaddr: ipv4 octet count should be 4"
|
||||
|
||||
for octet in octets
|
||||
if !(0 <= octet <= 255)
|
||||
throw new Error "ipaddr: ipv4 octet should fit in 8 bits"
|
||||
|
||||
@octets = octets
|
||||
|
||||
# The 'kind' method exists on both IPv4 and IPv6 classes.
|
||||
kind: ->
|
||||
return 'ipv4'
|
||||
|
||||
# Returns the address in convenient, decimal-dotted format.
|
||||
toString: ->
|
||||
return @octets.join "."
|
||||
|
||||
# Symmetrical method strictly for aligning with the IPv6 methods.
|
||||
toNormalizedString: ->
|
||||
return this.toString()
|
||||
|
||||
# Returns an array of byte-sized values in network order (MSB first)
|
||||
toByteArray: ->
|
||||
return @octets.slice(0) # octets.clone
|
||||
|
||||
# Checks if this address matches other one within given CIDR range.
|
||||
match: (other, cidrRange) ->
|
||||
if cidrRange == undefined
|
||||
[other, cidrRange] = other
|
||||
|
||||
if other.kind() != 'ipv4'
|
||||
throw new Error "ipaddr: cannot match ipv4 address with non-ipv4 one"
|
||||
|
||||
return matchCIDR(this.octets, other.octets, 8, cidrRange)
|
||||
|
||||
# Special IPv4 address ranges.
|
||||
# See also https://en.wikipedia.org/wiki/Reserved_IP_addresses
|
||||
SpecialRanges:
|
||||
unspecified: [
|
||||
[ new IPv4([0, 0, 0, 0]), 8 ]
|
||||
]
|
||||
broadcast: [
|
||||
[ new IPv4([255, 255, 255, 255]), 32 ]
|
||||
]
|
||||
multicast: [ # RFC3171
|
||||
[ new IPv4([224, 0, 0, 0]), 4 ]
|
||||
]
|
||||
linkLocal: [ # RFC3927
|
||||
[ new IPv4([169, 254, 0, 0]), 16 ]
|
||||
]
|
||||
loopback: [ # RFC5735
|
||||
[ new IPv4([127, 0, 0, 0]), 8 ]
|
||||
]
|
||||
carrierGradeNat: [ # RFC6598
|
||||
[ new IPv4([100, 64, 0, 0]), 10 ]
|
||||
]
|
||||
private: [ # RFC1918
|
||||
[ new IPv4([10, 0, 0, 0]), 8 ]
|
||||
[ new IPv4([172, 16, 0, 0]), 12 ]
|
||||
[ new IPv4([192, 168, 0, 0]), 16 ]
|
||||
]
|
||||
reserved: [ # Reserved and testing-only ranges; RFCs 5735, 5737, 2544, 1700
|
||||
[ 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 ]
|
||||
]
|
||||
|
||||
# Checks if the address corresponds to one of the special ranges.
|
||||
range: ->
|
||||
return ipaddr.subnetMatch(this, @SpecialRanges)
|
||||
|
||||
# Convrets this IPv4 address to an IPv4-mapped IPv6 address.
|
||||
toIPv4MappedAddress: ->
|
||||
return ipaddr.IPv6.parse "::ffff:#{@toString()}"
|
||||
|
||||
# returns a number of leading ones in IPv4 address, making sure that
|
||||
# the rest is a solid sequence of 0's (valid netmask)
|
||||
# returns either the CIDR length or null if mask is not valid
|
||||
prefixLengthFromSubnetMask: ->
|
||||
# number of zeroes in octet
|
||||
zerotable =
|
||||
0: 8
|
||||
128: 7
|
||||
192: 6
|
||||
224: 5
|
||||
240: 4
|
||||
248: 3
|
||||
252: 2
|
||||
254: 1
|
||||
255: 0
|
||||
|
||||
cidr = 0
|
||||
# non-zero encountered stop scanning for zeroes
|
||||
stop = false
|
||||
for i in [3..0] by -1
|
||||
octet = @octets[i]
|
||||
if octet of zerotable
|
||||
zeros = zerotable[octet]
|
||||
if stop and zeros != 0
|
||||
return null
|
||||
unless zeros == 8
|
||||
stop = true
|
||||
cidr += zeros
|
||||
else
|
||||
return null
|
||||
return 32 - cidr
|
||||
|
||||
# A list of regular expressions that match arbitrary IPv4 addresses,
|
||||
# for which a number of weird notations exist.
|
||||
# Note that an address like 0010.0xa5.1.1 is considered legal.
|
||||
ipv4Part = "(0?\\d+|0x[a-f0-9]+)"
|
||||
ipv4Regexes =
|
||||
fourOctet: new RegExp "^#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}$", 'i'
|
||||
longValue: new RegExp "^#{ipv4Part}$", 'i'
|
||||
|
||||
# Classful variants (like a.b, where a is an octet, and b is a 24-bit
|
||||
# value representing last three octets; this corresponds to a class C
|
||||
# address) are omitted due to classless nature of modern Internet.
|
||||
ipaddr.IPv4.parser = (string) ->
|
||||
parseIntAuto = (string) ->
|
||||
if string[0] == "0" && string[1] != "x"
|
||||
parseInt(string, 8)
|
||||
else
|
||||
parseInt(string)
|
||||
|
||||
# parseInt recognizes all that octal & hexadecimal weirdness for us
|
||||
if match = string.match(ipv4Regexes.fourOctet)
|
||||
return (parseIntAuto(part) for part in match[1..5])
|
||||
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 ((value >> shift) & 0xff for shift in [0..24] by 8).reverse()
|
||||
else
|
||||
return null
|
||||
|
||||
# An IPv6 address (RFC2460)
|
||||
class ipaddr.IPv6
|
||||
# Constructs an IPv6 address from an array of eight 16-bit parts
|
||||
# or sixteen 8-bit parts in network order (MSB first).
|
||||
# Throws an error if the input is invalid.
|
||||
constructor: (parts, zoneId) ->
|
||||
if parts.length == 16
|
||||
@parts = []
|
||||
for i in [0..14] by 2
|
||||
@parts.push((parts[i] << 8) | parts[i + 1])
|
||||
else if parts.length == 8
|
||||
@parts = parts
|
||||
else
|
||||
throw new Error "ipaddr: ipv6 part count should be 8 or 16"
|
||||
|
||||
for part in @parts
|
||||
if !(0 <= part <= 0xffff)
|
||||
throw new Error "ipaddr: ipv6 part should fit in 16 bits"
|
||||
|
||||
if zoneId
|
||||
@zoneId = zoneId
|
||||
|
||||
# The 'kind' method exists on both IPv4 and IPv6 classes.
|
||||
kind: ->
|
||||
return 'ipv6'
|
||||
|
||||
# Returns the address in compact, human-readable format like
|
||||
# 2001:db8:8:66::1
|
||||
toString: ->
|
||||
# Replace the first sequence of 1 or more '0' parts with '::'
|
||||
return @toNormalizedString().replace( /((^|:)(0(:|$))+)/, '::' )
|
||||
|
||||
# Returns an array of byte-sized values in network order (MSB first)
|
||||
toByteArray: ->
|
||||
bytes = []
|
||||
for part in @parts
|
||||
bytes.push(part >> 8)
|
||||
bytes.push(part & 0xff)
|
||||
|
||||
return bytes
|
||||
|
||||
# Returns the address in expanded format with all zeroes included, like
|
||||
# 2001:db8:8:66:0:0:0:1
|
||||
toNormalizedString: ->
|
||||
addr = (part.toString(16) for part in @parts).join ":"
|
||||
|
||||
suffix = ''
|
||||
if @zoneId
|
||||
suffix = '%' + @zoneId
|
||||
|
||||
return addr + suffix
|
||||
|
||||
# Checks if this address matches other one within given CIDR range.
|
||||
match: (other, cidrRange) ->
|
||||
if cidrRange == undefined
|
||||
[other, cidrRange] = other
|
||||
|
||||
if other.kind() != 'ipv6'
|
||||
throw new Error "ipaddr: cannot match ipv6 address with non-ipv6 one"
|
||||
|
||||
return matchCIDR(this.parts, other.parts, 16, cidrRange)
|
||||
|
||||
# Special IPv6 ranges
|
||||
SpecialRanges:
|
||||
unspecified: [ new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128 ] # RFC4291, here and after
|
||||
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 ] # RFC6145
|
||||
rfc6052: [ new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96 ] # RFC6052
|
||||
'6to4': [ new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16 ] # RFC3056
|
||||
teredo: [ new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32 ] # RFC6052, RFC6146
|
||||
reserved: [
|
||||
[ new IPv6([ 0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32 ] # RFC4291
|
||||
]
|
||||
|
||||
# Checks if the address corresponds to one of the special ranges.
|
||||
range: ->
|
||||
return ipaddr.subnetMatch(this, @SpecialRanges)
|
||||
|
||||
# Checks if this address is an IPv4-mapped IPv6 address.
|
||||
isIPv4MappedAddress: ->
|
||||
return @range() == 'ipv4Mapped'
|
||||
|
||||
# Converts this address to IPv4 address if it is an IPv4-mapped IPv6 address.
|
||||
# Throws an error otherwise.
|
||||
toIPv4Address: ->
|
||||
unless @isIPv4MappedAddress()
|
||||
throw new Error "ipaddr: trying to convert a generic ipv6 address to ipv4"
|
||||
|
||||
[high, low] = @parts[-2..-1]
|
||||
|
||||
return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff])
|
||||
|
||||
# returns a number of leading ones in IPv6 address, making sure that
|
||||
# the rest is a solid sequence of 0's (valid netmask)
|
||||
# returns either the CIDR length or null if mask is not valid
|
||||
prefixLengthFromSubnetMask: ->
|
||||
# number of zeroes in octet
|
||||
zerotable =
|
||||
0 : 16
|
||||
32768: 15
|
||||
49152: 14
|
||||
57344: 13
|
||||
61440: 12
|
||||
63488: 11
|
||||
64512: 10
|
||||
65024: 9
|
||||
65280: 8
|
||||
65408: 7
|
||||
65472: 6
|
||||
65504: 5
|
||||
65520: 4
|
||||
65528: 3
|
||||
65532: 2
|
||||
65534: 1
|
||||
65535: 0
|
||||
|
||||
cidr = 0
|
||||
# non-zero encountered stop scanning for zeroes
|
||||
stop = false
|
||||
for i in [7..0] by -1
|
||||
part = @parts[i]
|
||||
if part of zerotable
|
||||
zeros = zerotable[part]
|
||||
if stop and zeros != 0
|
||||
return null
|
||||
unless zeros == 16
|
||||
stop = true
|
||||
cidr += zeros
|
||||
else
|
||||
return null
|
||||
return 128 - cidr
|
||||
|
||||
# IPv6-matching regular expressions.
|
||||
# For IPv6, the task is simpler: it is enough to match the colon-delimited
|
||||
# hexadecimal IPv6 and a transitional variant with dotted-decimal IPv4 at
|
||||
# the end.
|
||||
ipv6Part = "(?:[0-9a-f]+::?)+"
|
||||
zoneIndex = "%[0-9a-z]{1,}"
|
||||
ipv6Regexes =
|
||||
zoneIndex: new RegExp zoneIndex, 'i'
|
||||
native: new RegExp "^(::)?(#{ipv6Part})?([0-9a-f]+)?(::)?(#{zoneIndex})?$", 'i'
|
||||
transitional: new RegExp "^((?:#{ipv6Part})|(?:::)(?:#{ipv6Part})?)" +
|
||||
"#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}" +
|
||||
"(#{zoneIndex})?$", 'i'
|
||||
|
||||
# Expand :: in an IPv6 address or address part consisting of `parts` groups.
|
||||
expandIPv6 = (string, parts) ->
|
||||
# More than one '::' means invalid adddress
|
||||
if string.indexOf('::') != string.lastIndexOf('::')
|
||||
return null
|
||||
|
||||
# Remove zone index and save it for later
|
||||
zoneId = (string.match(ipv6Regexes['zoneIndex']) || [])[0]
|
||||
if zoneId
|
||||
zoneId = zoneId.substring(1)
|
||||
string = string.replace(/%.+$/, '')
|
||||
|
||||
# How many parts do we already have?
|
||||
colonCount = 0
|
||||
lastColon = -1
|
||||
while (lastColon = string.indexOf(':', lastColon + 1)) >= 0
|
||||
colonCount++
|
||||
|
||||
# 0::0 is two parts more than ::
|
||||
colonCount-- if string.substr(0, 2) == '::'
|
||||
colonCount-- if string.substr(-2, 2) == '::'
|
||||
|
||||
# The following loop would hang if colonCount > parts
|
||||
if colonCount > parts
|
||||
return null
|
||||
|
||||
# replacement = ':' + '0:' * (parts - colonCount)
|
||||
replacementCount = parts - colonCount
|
||||
replacement = ':'
|
||||
while replacementCount--
|
||||
replacement += '0:'
|
||||
|
||||
# Insert the missing zeroes
|
||||
string = string.replace('::', replacement)
|
||||
|
||||
# Trim any garbage which may be hanging around if :: was at the edge in
|
||||
# the source string
|
||||
string = string[1..-1] if string[0] == ':'
|
||||
string = string[0..-2] if string[string.length-1] == ':'
|
||||
|
||||
parts = (parseInt(part, 16) for part in string.split(":"))
|
||||
return { parts: parts, zoneId: zoneId }
|
||||
|
||||
# Parse an IPv6 address.
|
||||
ipaddr.IPv6.parser = (string) ->
|
||||
if ipv6Regexes['native'].test(string)
|
||||
return expandIPv6(string, 8)
|
||||
|
||||
else if match = string.match(ipv6Regexes['transitional'])
|
||||
zoneId = match[6] || ''
|
||||
addr = expandIPv6(match[1][0..-2] + zoneId, 6)
|
||||
if addr.parts
|
||||
octets = [parseInt(match[2]), parseInt(match[3]),
|
||||
parseInt(match[4]), parseInt(match[5])]
|
||||
for octet in octets
|
||||
if !(0 <= octet <= 255)
|
||||
return null
|
||||
|
||||
addr.parts.push(octets[0] << 8 | octets[1])
|
||||
addr.parts.push(octets[2] << 8 | octets[3])
|
||||
return { parts: addr.parts, zoneId: addr.zoneId }
|
||||
|
||||
return null
|
||||
|
||||
# Checks if a given string is formatted like IPv4/IPv6 address.
|
||||
ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = (string) ->
|
||||
return @parser(string) != null
|
||||
|
||||
# Checks if a given string is a valid IPv4/IPv6 address.
|
||||
ipaddr.IPv4.isValid = (string) ->
|
||||
try
|
||||
new this(@parser(string))
|
||||
return true
|
||||
catch e
|
||||
return false
|
||||
|
||||
ipaddr.IPv4.isValidFourPartDecimal = (string) ->
|
||||
if ipaddr.IPv4.isValid(string) and string.match(/^\d+(\.\d+){3}$/)
|
||||
return true
|
||||
else
|
||||
return false
|
||||
|
||||
ipaddr.IPv6.isValid = (string) ->
|
||||
# Since IPv6.isValid is always called first, this shortcut
|
||||
# provides a substantial performance gain.
|
||||
if typeof string == "string" and string.indexOf(":") == -1
|
||||
return false
|
||||
|
||||
try
|
||||
addr = @parser(string)
|
||||
new this(addr.parts, addr.zoneId)
|
||||
return true
|
||||
catch e
|
||||
return false
|
||||
|
||||
# Tries to parse and validate a string with IPv4/IPv6 address.
|
||||
# Throws an error if it fails.
|
||||
ipaddr.IPv4.parse = (string) ->
|
||||
parts = @parser(string)
|
||||
if parts == null
|
||||
throw new Error "ipaddr: string is not formatted like ip address"
|
||||
|
||||
return new this(parts)
|
||||
|
||||
ipaddr.IPv6.parse = (string) ->
|
||||
addr = @parser(string)
|
||||
if addr.parts == null
|
||||
throw new Error "ipaddr: string is not formatted like ip address"
|
||||
|
||||
return new this(addr.parts, addr.zoneId)
|
||||
|
||||
ipaddr.IPv4.parseCIDR = (string) ->
|
||||
if match = string.match(/^(.+)\/(\d+)$/)
|
||||
maskLength = parseInt(match[2])
|
||||
if maskLength >= 0 and maskLength <= 32
|
||||
return [@parse(match[1]), maskLength]
|
||||
|
||||
throw new Error "ipaddr: string is not formatted like an IPv4 CIDR range"
|
||||
|
||||
# A utility function to return subnet mask in IPv4 format given the prefix length
|
||||
ipaddr.IPv4.subnetMaskFromPrefixLength = (prefix) ->
|
||||
prefix = parseInt(prefix)
|
||||
if prefix < 0 or prefix > 32
|
||||
throw new Error('ipaddr: invalid IPv4 prefix length')
|
||||
octets = [0, 0, 0, 0]
|
||||
j = 0
|
||||
filledOctetCount = Math.floor(prefix / 8)
|
||||
while j < filledOctetCount
|
||||
octets[j] = 255
|
||||
j++
|
||||
if filledOctetCount < 4
|
||||
octets[filledOctetCount] = Math.pow(2, (prefix % 8)) - 1 << 8 - (prefix % 8)
|
||||
new @(octets)
|
||||
|
||||
# A utility function to return broadcast address given the IPv4 interface and prefix length in CIDR notation
|
||||
ipaddr.IPv4.broadcastAddressFromCIDR = (string) ->
|
||||
try
|
||||
cidr = @parseCIDR(string)
|
||||
ipInterfaceOctets = cidr[0].toByteArray()
|
||||
subnetMaskOctets = @subnetMaskFromPrefixLength(cidr[1]).toByteArray()
|
||||
octets = []
|
||||
i = 0
|
||||
while i < 4
|
||||
# Broadcast address is bitwise OR between ip interface and inverted mask
|
||||
octets.push parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255
|
||||
i++
|
||||
return new @(octets)
|
||||
catch error
|
||||
throw new Error('ipaddr: the address does not have IPv4 CIDR format')
|
||||
return
|
||||
|
||||
# A utility function to return network address given the IPv4 interface and prefix length in CIDR notation
|
||||
ipaddr.IPv4.networkAddressFromCIDR = (string) ->
|
||||
try
|
||||
cidr = @parseCIDR(string)
|
||||
ipInterfaceOctets = cidr[0].toByteArray()
|
||||
subnetMaskOctets = @subnetMaskFromPrefixLength(cidr[1]).toByteArray()
|
||||
octets = []
|
||||
i = 0
|
||||
while i < 4
|
||||
# Network address is bitwise AND between ip interface and mask
|
||||
octets.push parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10)
|
||||
i++
|
||||
return new @(octets)
|
||||
catch error
|
||||
throw new Error('ipaddr: the address does not have IPv4 CIDR format')
|
||||
return
|
||||
|
||||
ipaddr.IPv6.parseCIDR = (string) ->
|
||||
if match = string.match(/^(.+)\/(\d+)$/)
|
||||
maskLength = parseInt(match[2])
|
||||
if maskLength >= 0 and maskLength <= 128
|
||||
return [@parse(match[1]), maskLength]
|
||||
|
||||
throw new Error "ipaddr: string is not formatted like an IPv6 CIDR range"
|
||||
|
||||
# Checks if the address is valid IP address
|
||||
ipaddr.isValid = (string) ->
|
||||
return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string)
|
||||
|
||||
# Try to parse an address and throw an error if it is impossible
|
||||
ipaddr.parse = (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 = (string) ->
|
||||
try
|
||||
return ipaddr.IPv6.parseCIDR(string)
|
||||
catch e
|
||||
try
|
||||
return ipaddr.IPv4.parseCIDR(string)
|
||||
catch e
|
||||
throw new Error "ipaddr: the address has neither IPv6 nor IPv4 CIDR format"
|
||||
|
||||
# Try to parse an array in network order (MSB first) for IPv4 and IPv6
|
||||
ipaddr.fromByteArray = (bytes) ->
|
||||
length = bytes.length
|
||||
if length == 4
|
||||
return new ipaddr.IPv4(bytes)
|
||||
else if length == 16
|
||||
return new ipaddr.IPv6(bytes)
|
||||
else
|
||||
throw new Error "ipaddr: the binary input is neither an IPv6 nor IPv4 address"
|
||||
|
||||
# Parse an address and return plain IPv4 address if it is an IPv4-mapped address
|
||||
ipaddr.process = (string) ->
|
||||
addr = @parse(string)
|
||||
if addr.kind() == 'ipv6' && addr.isIPv4MappedAddress()
|
||||
return addr.toIPv4Address()
|
||||
else
|
||||
return addr
|
||||
491
node_modules/ipaddr.js/test/ipaddr.test.coffee
generated
vendored
Normal file
491
node_modules/ipaddr.js/test/ipaddr.test.coffee
generated
vendored
Normal file
@ -0,0 +1,491 @@
|
||||
ipaddr = require '../lib/ipaddr'
|
||||
|
||||
module.exports =
|
||||
'should define main classes': (test) ->
|
||||
test.ok(ipaddr.IPv4?, 'defines IPv4 class')
|
||||
test.ok(ipaddr.IPv6?, 'defines IPv6 class')
|
||||
test.done()
|
||||
|
||||
'can construct IPv4 from octets': (test) ->
|
||||
test.doesNotThrow ->
|
||||
new ipaddr.IPv4([192, 168, 1, 2])
|
||||
test.done()
|
||||
|
||||
'refuses to construct invalid IPv4': (test) ->
|
||||
test.throws ->
|
||||
new ipaddr.IPv4([300, 1, 2, 3])
|
||||
test.throws ->
|
||||
new ipaddr.IPv4([8, 8, 8])
|
||||
test.done()
|
||||
|
||||
'converts IPv4 to string correctly': (test) ->
|
||||
addr = new ipaddr.IPv4([192, 168, 1, 1])
|
||||
test.equal(addr.toString(), '192.168.1.1')
|
||||
test.equal(addr.toNormalizedString(), '192.168.1.1')
|
||||
test.done()
|
||||
|
||||
'returns correct kind for IPv4': (test) ->
|
||||
addr = new ipaddr.IPv4([1, 2, 3, 4])
|
||||
test.equal(addr.kind(), 'ipv4')
|
||||
test.done()
|
||||
|
||||
'allows to access IPv4 octets': (test) ->
|
||||
addr = new ipaddr.IPv4([42, 0, 0, 0])
|
||||
test.equal(addr.octets[0], 42)
|
||||
test.done()
|
||||
|
||||
'checks IPv4 address format': (test) ->
|
||||
test.equal(ipaddr.IPv4.isIPv4('192.168.007.0xa'), true)
|
||||
test.equal(ipaddr.IPv4.isIPv4('1024.0.0.1'), true)
|
||||
test.equal(ipaddr.IPv4.isIPv4('8.0xa.wtf.6'), false)
|
||||
test.done()
|
||||
|
||||
'validates IPv4 addresses': (test) ->
|
||||
test.equal(ipaddr.IPv4.isValid('192.168.007.0xa'), true)
|
||||
test.equal(ipaddr.IPv4.isValid('1024.0.0.1'), false)
|
||||
test.equal(ipaddr.IPv4.isValid('8.0xa.wtf.6'), false)
|
||||
test.done()
|
||||
|
||||
'parses IPv4 in several weird formats': (test) ->
|
||||
test.deepEqual(ipaddr.IPv4.parse('192.168.1.1').octets, [192, 168, 1, 1])
|
||||
test.deepEqual(ipaddr.IPv4.parse('0xc0.168.1.1').octets, [192, 168, 1, 1])
|
||||
test.deepEqual(ipaddr.IPv4.parse('192.0250.1.1').octets, [192, 168, 1, 1])
|
||||
test.deepEqual(ipaddr.IPv4.parse('0xc0a80101').octets, [192, 168, 1, 1])
|
||||
test.deepEqual(ipaddr.IPv4.parse('030052000401').octets, [192, 168, 1, 1])
|
||||
test.deepEqual(ipaddr.IPv4.parse('3232235777').octets, [192, 168, 1, 1])
|
||||
test.done()
|
||||
|
||||
'barfs at invalid IPv4': (test) ->
|
||||
test.throws ->
|
||||
ipaddr.IPv4.parse('10.0.0.wtf')
|
||||
test.done()
|
||||
|
||||
'matches IPv4 CIDR correctly': (test) ->
|
||||
addr = new ipaddr.IPv4([10, 5, 0, 1])
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('0.0.0.0'), 0), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('11.0.0.0'), 8), false)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('10.0.0.0'), 8), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('10.0.0.1'), 8), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('10.0.0.10'), 8), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('10.5.5.0'), 16), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('10.4.5.0'), 16), false)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('10.4.5.0'), 15), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parse('10.5.0.2'), 32), false)
|
||||
test.equal(addr.match(addr, 32), true)
|
||||
test.done()
|
||||
|
||||
'parses IPv4 CIDR correctly': (test) ->
|
||||
addr = new ipaddr.IPv4([10, 5, 0, 1])
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('0.0.0.0/0')), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('11.0.0.0/8')), false)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.0.0.0/8')), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.0.0.1/8')), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.0.0.10/8')), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.5.5.0/16')), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.4.5.0/16')), false)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.4.5.0/15')), true)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.5.0.2/32')), false)
|
||||
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.5.0.1/32')), true)
|
||||
test.throws ->
|
||||
ipaddr.IPv4.parseCIDR('10.5.0.1')
|
||||
test.throws ->
|
||||
ipaddr.IPv4.parseCIDR('0.0.0.0/-1')
|
||||
test.throws ->
|
||||
ipaddr.IPv4.parseCIDR('0.0.0.0/33')
|
||||
test.done()
|
||||
|
||||
'detects reserved IPv4 networks': (test) ->
|
||||
test.equal(ipaddr.IPv4.parse('0.0.0.0').range(), 'unspecified')
|
||||
test.equal(ipaddr.IPv4.parse('0.1.0.0').range(), 'unspecified')
|
||||
test.equal(ipaddr.IPv4.parse('10.1.0.1').range(), 'private')
|
||||
test.equal(ipaddr.IPv4.parse('100.64.0.0').range(), 'carrierGradeNat')
|
||||
test.equal(ipaddr.IPv4.parse('100.127.255.255').range(), 'carrierGradeNat')
|
||||
test.equal(ipaddr.IPv4.parse('192.168.2.1').range(), 'private')
|
||||
test.equal(ipaddr.IPv4.parse('224.100.0.1').range(), 'multicast')
|
||||
test.equal(ipaddr.IPv4.parse('169.254.15.0').range(), 'linkLocal')
|
||||
test.equal(ipaddr.IPv4.parse('127.1.1.1').range(), 'loopback')
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.255').range(), 'broadcast')
|
||||
test.equal(ipaddr.IPv4.parse('240.1.2.3').range(), 'reserved')
|
||||
test.equal(ipaddr.IPv4.parse('8.8.8.8').range(), 'unicast')
|
||||
test.done()
|
||||
|
||||
'checks the conventional IPv4 address format': (test) ->
|
||||
test.equal(ipaddr.IPv4.isValidFourPartDecimal('192.168.1.1'), true)
|
||||
test.equal(ipaddr.IPv4.isValidFourPartDecimal('0xc0.168.1.1'), false)
|
||||
test.done()
|
||||
|
||||
'can construct IPv6 from 16bit parts': (test) ->
|
||||
test.doesNotThrow ->
|
||||
new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
|
||||
test.done()
|
||||
|
||||
'can construct IPv6 from 8bit parts': (test) ->
|
||||
test.doesNotThrow ->
|
||||
new ipaddr.IPv6([0x20, 0x01, 0xd, 0xb8, 0xf5, 0x3a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
|
||||
test.deepEqual(new ipaddr.IPv6([0x20, 0x01, 0xd, 0xb8, 0xf5, 0x3a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]),
|
||||
new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1]))
|
||||
test.done()
|
||||
|
||||
'refuses to construct invalid IPv6': (test) ->
|
||||
test.throws ->
|
||||
new ipaddr.IPv6([0xfffff, 0, 0, 0, 0, 0, 0, 1])
|
||||
test.throws ->
|
||||
new ipaddr.IPv6([0xfffff, 0, 0, 0, 0, 0, 1])
|
||||
test.throws ->
|
||||
new ipaddr.IPv6([0xffff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
|
||||
test.done()
|
||||
|
||||
'converts IPv6 to string correctly': (test) ->
|
||||
addr = new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
|
||||
test.equal(addr.toNormalizedString(), '2001:db8:f53a:0:0:0:0:1')
|
||||
test.equal(addr.toString(), '2001:db8:f53a::1')
|
||||
test.equal(new ipaddr.IPv6([0, 0, 0, 0, 0, 0, 0, 0]).toString(), '::')
|
||||
test.equal(new ipaddr.IPv6([0, 0, 0, 0, 0, 0, 0, 1]).toString(), '::1')
|
||||
test.equal(new ipaddr.IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]).toString(), '2001:db8::')
|
||||
test.equal(new ipaddr.IPv6([0, 0xff, 0, 0, 0, 0, 0, 0]).toString(), '::ff:0:0:0:0:0:0')
|
||||
test.equal(new ipaddr.IPv6([0, 0, 0, 0, 0, 0, 0xff, 0]).toString(), '::ff:0')
|
||||
test.equal(new ipaddr.IPv6([0, 0, 0xff, 0, 0, 0, 0, 0]).toString(), '::ff:0:0:0:0:0')
|
||||
test.equal(new ipaddr.IPv6([0, 0, 0, 0, 0, 0xff, 0, 0]).toString(), '::ff:0:0')
|
||||
test.equal(new ipaddr.IPv6([0x2001, 0xdb8, 0xff, 0xabc, 0xdef, 0x123b, 0x456c, 0x78d]).toString(), '2001:db8:ff:abc:def:123b:456c:78d')
|
||||
test.equal(new ipaddr.IPv6([0x2001, 0xdb8, 0xff, 0xabc, 0, 0x123b, 0x456c, 0x78d]).toString(), '2001:db8:ff:abc::123b:456c:78d')
|
||||
test.equal(new ipaddr.IPv6([0x2001, 0xdb8, 0xff, 0xabc, 0, 0, 0x456c, 0x78d]).toString(), '2001:db8:ff:abc::456c:78d')
|
||||
test.done()
|
||||
|
||||
'returns IPv6 zoneIndex': (test) ->
|
||||
addr = new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1], 'utun0')
|
||||
test.equal(addr.toNormalizedString(), '2001:db8:f53a:0:0:0:0:1%utun0')
|
||||
test.equal(addr.toString(), '2001:db8:f53a::1%utun0')
|
||||
|
||||
test.equal(
|
||||
ipaddr.parse('2001:db8:f53a::1%2').toString(),
|
||||
'2001:db8:f53a::1%2'
|
||||
)
|
||||
test.equal(
|
||||
ipaddr.parse('2001:db8:f53a::1%WAT').toString(),
|
||||
'2001:db8:f53a::1%WAT'
|
||||
)
|
||||
test.equal(
|
||||
ipaddr.parse('2001:db8:f53a::1%sUp').toString(),
|
||||
'2001:db8:f53a::1%sUp'
|
||||
)
|
||||
|
||||
test.done()
|
||||
|
||||
'returns IPv6 zoneIndex for IPv4-mapped IPv6 addresses': (test) ->
|
||||
addr = ipaddr.parse('::ffff:192.168.1.1%eth0')
|
||||
test.equal(addr.toNormalizedString(), '0:0:0:0:0:ffff:c0a8:101%eth0')
|
||||
test.equal(addr.toString(), '::ffff:c0a8:101%eth0')
|
||||
|
||||
test.equal(
|
||||
ipaddr.parse('::ffff:192.168.1.1%2').toString(),
|
||||
'::ffff:c0a8:101%2'
|
||||
)
|
||||
test.equal(
|
||||
ipaddr.parse('::ffff:192.168.1.1%WAT').toString(),
|
||||
'::ffff:c0a8:101%WAT'
|
||||
)
|
||||
test.equal(
|
||||
ipaddr.parse('::ffff:192.168.1.1%sUp').toString(),
|
||||
'::ffff:c0a8:101%sUp'
|
||||
)
|
||||
|
||||
test.done()
|
||||
|
||||
'returns correct kind for IPv6': (test) ->
|
||||
addr = new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
|
||||
test.equal(addr.kind(), 'ipv6')
|
||||
test.done()
|
||||
|
||||
'allows to access IPv6 address parts': (test) ->
|
||||
addr = new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 42, 0, 1])
|
||||
test.equal(addr.parts[5], 42)
|
||||
test.done()
|
||||
|
||||
'checks IPv6 address format': (test) ->
|
||||
test.equal(ipaddr.IPv6.isIPv6('2001:db8:F53A::1'), true)
|
||||
test.equal(ipaddr.IPv6.isIPv6('200001::1'), true)
|
||||
test.equal(ipaddr.IPv6.isIPv6('::ffff:192.168.1.1'), true)
|
||||
test.equal(ipaddr.IPv6.isIPv6('::ffff:192.168.1.1%z'), true)
|
||||
test.equal(ipaddr.IPv6.isIPv6('::ffff:300.168.1.1'), false)
|
||||
test.equal(ipaddr.IPv6.isIPv6('::ffff:300.168.1.1:0'), false)
|
||||
test.equal(ipaddr.IPv6.isIPv6('fe80::wtf'), false)
|
||||
test.equal(ipaddr.IPv6.isIPv6('fe80::%'), false)
|
||||
test.done()
|
||||
|
||||
'validates IPv6 addresses': (test) ->
|
||||
test.equal(ipaddr.IPv6.isValid('2001:db8:F53A::1'), true)
|
||||
test.equal(ipaddr.IPv6.isValid('200001::1'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('::ffff:192.168.1.1'), true)
|
||||
test.equal(ipaddr.IPv6.isValid('::ffff:192.168.1.1%z'), true)
|
||||
test.equal(ipaddr.IPv6.isValid('::ffff:300.168.1.1'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('::ffff:300.168.1.1:0'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('::ffff:222.1.41.9000'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('2001:db8::F53A::1'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('fe80::wtf'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('fe80::%'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('2002::2:'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('::%z'), true)
|
||||
|
||||
test.equal(ipaddr.IPv6.isValid(undefined), false)
|
||||
test.done()
|
||||
|
||||
'parses IPv6 in different formats': (test) ->
|
||||
test.deepEqual(ipaddr.IPv6.parse('2001:db8:F53A:0:0:0:0:1').parts, [0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
|
||||
test.deepEqual(ipaddr.IPv6.parse('fe80::10').parts, [0xfe80, 0, 0, 0, 0, 0, 0, 0x10])
|
||||
test.deepEqual(ipaddr.IPv6.parse('2001:db8:F53A::').parts, [0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 0])
|
||||
test.deepEqual(ipaddr.IPv6.parse('::1').parts, [0, 0, 0, 0, 0, 0, 0, 1])
|
||||
test.deepEqual(ipaddr.IPv6.parse('::').parts, [0, 0, 0, 0, 0, 0, 0, 0])
|
||||
test.deepEqual(ipaddr.IPv6.parse('::%z').parts, [0, 0, 0, 0, 0, 0, 0, 0])
|
||||
test.deepEqual(ipaddr.IPv6.parse('::%z').zoneId, 'z')
|
||||
test.done()
|
||||
|
||||
'barfs at invalid IPv6': (test) ->
|
||||
test.throws ->
|
||||
ipaddr.IPv6.parse('fe80::0::1')
|
||||
test.done()
|
||||
|
||||
'matches IPv6 CIDR correctly': (test) ->
|
||||
addr = ipaddr.IPv6.parse('2001:db8:f53a::1')
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('::'), 0), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f53a::1:1'), 64), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f53b::1:1'), 48), false)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f531::1:1'), 44), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f500::1'), 40), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f500::1%z'), 40), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db9:f500::1'), 40), false)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db9:f500::1'), 40), false)
|
||||
test.equal(addr.match(ipaddr.IPv6.parse('2001:db9:f500::1%z'), 40), false)
|
||||
test.equal(addr.match(addr, 128), true)
|
||||
test.done()
|
||||
|
||||
'parses IPv6 CIDR correctly': (test) ->
|
||||
addr = ipaddr.IPv6.parse('2001:db8:f53a::1')
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('::/0')), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f53a::1:1/64')), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f53b::1:1/48')), false)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f531::1:1/44')), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f500::1/40')), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f500::1%z/40')), true)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db9:f500::1/40')), false)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db9:f500::1%z/40')), false)
|
||||
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f53a::1/128')), true)
|
||||
test.throws ->
|
||||
ipaddr.IPv6.parseCIDR('2001:db8:f53a::1')
|
||||
test.throws ->
|
||||
ipaddr.IPv6.parseCIDR('2001:db8:f53a::1/-1')
|
||||
test.throws ->
|
||||
ipaddr.IPv6.parseCIDR('2001:db8:f53a::1/129')
|
||||
test.done()
|
||||
|
||||
'converts between IPv4-mapped IPv6 addresses and IPv4 addresses': (test) ->
|
||||
addr = ipaddr.IPv4.parse('77.88.21.11')
|
||||
mapped = addr.toIPv4MappedAddress()
|
||||
test.deepEqual(mapped.parts, [0, 0, 0, 0, 0, 0xffff, 0x4d58, 0x150b])
|
||||
test.deepEqual(mapped.toIPv4Address().octets, addr.octets)
|
||||
test.done()
|
||||
|
||||
'refuses to convert non-IPv4-mapped IPv6 address to IPv4 address': (test) ->
|
||||
test.throws ->
|
||||
ipaddr.IPv6.parse('2001:db8::1').toIPv4Address()
|
||||
test.done()
|
||||
|
||||
'detects reserved IPv6 networks': (test) ->
|
||||
test.equal(ipaddr.IPv6.parse('::').range(), 'unspecified')
|
||||
test.equal(ipaddr.IPv6.parse('fe80::1234:5678:abcd:0123').range(), 'linkLocal')
|
||||
test.equal(ipaddr.IPv6.parse('ff00::1234').range(), 'multicast')
|
||||
test.equal(ipaddr.IPv6.parse('::1').range(), 'loopback')
|
||||
test.equal(ipaddr.IPv6.parse('fc00::').range(), 'uniqueLocal')
|
||||
test.equal(ipaddr.IPv6.parse('::ffff:192.168.1.10').range(), 'ipv4Mapped')
|
||||
test.equal(ipaddr.IPv6.parse('::ffff:0:192.168.1.10').range(), 'rfc6145')
|
||||
test.equal(ipaddr.IPv6.parse('64:ff9b::1234').range(), 'rfc6052')
|
||||
test.equal(ipaddr.IPv6.parse('2002:1f63:45e8::1').range(), '6to4')
|
||||
test.equal(ipaddr.IPv6.parse('2001::4242').range(), 'teredo')
|
||||
test.equal(ipaddr.IPv6.parse('2001:db8::3210').range(), 'reserved')
|
||||
test.equal(ipaddr.IPv6.parse('2001:470:8:66::1').range(), 'unicast')
|
||||
test.equal(ipaddr.IPv6.parse('2001:470:8:66::1%z').range(), 'unicast')
|
||||
test.done()
|
||||
|
||||
'is able to determine IP address type': (test) ->
|
||||
test.equal(ipaddr.parse('8.8.8.8').kind(), 'ipv4')
|
||||
test.equal(ipaddr.parse('2001:db8:3312::1').kind(), 'ipv6')
|
||||
test.equal(ipaddr.parse('2001:db8:3312::1%z').kind(), 'ipv6')
|
||||
test.done()
|
||||
|
||||
'throws an error if tried to parse an invalid address': (test) ->
|
||||
test.throws ->
|
||||
ipaddr.parse('::some.nonsense')
|
||||
test.done()
|
||||
|
||||
'correctly processes IPv4-mapped addresses': (test) ->
|
||||
test.equal(ipaddr.process('8.8.8.8').kind(), 'ipv4')
|
||||
test.equal(ipaddr.process('2001:db8:3312::1').kind(), 'ipv6')
|
||||
test.equal(ipaddr.process('::ffff:192.168.1.1').kind(), 'ipv4')
|
||||
test.equal(ipaddr.process('::ffff:192.168.1.1%z').kind(), 'ipv4')
|
||||
test.done()
|
||||
|
||||
'correctly converts IPv6 and IPv4 addresses to byte arrays': (test) ->
|
||||
test.deepEqual(ipaddr.parse('1.2.3.4').toByteArray(),
|
||||
[0x1, 0x2, 0x3, 0x4]);
|
||||
# Fuck yeah. The first byte of Google's IPv6 address is 42. 42!
|
||||
test.deepEqual(ipaddr.parse('2a00:1450:8007::68').toByteArray(),
|
||||
[42, 0x00, 0x14, 0x50, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68 ])
|
||||
test.deepEqual(ipaddr.parse('2a00:1450:8007::68%z').toByteArray(),
|
||||
[42, 0x00, 0x14, 0x50, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68 ])
|
||||
|
||||
test.done()
|
||||
|
||||
'correctly parses 1 as an IPv4 address': (test) ->
|
||||
test.equal(ipaddr.IPv6.isValid('1'), false)
|
||||
test.equal(ipaddr.IPv4.isValid('1'), true)
|
||||
test.deepEqual(new ipaddr.IPv4([0, 0, 0, 1]), ipaddr.parse('1'))
|
||||
test.done()
|
||||
|
||||
'correctly detects IPv4 and IPv6 CIDR addresses': (test) ->
|
||||
test.deepEqual([ipaddr.IPv6.parse('fc00::'), 64],
|
||||
ipaddr.parseCIDR('fc00::/64'))
|
||||
test.deepEqual([ipaddr.IPv4.parse('1.2.3.4'), 5],
|
||||
ipaddr.parseCIDR('1.2.3.4/5'))
|
||||
test.done()
|
||||
|
||||
'does not consider a very large or very small number a valid IP address': (test) ->
|
||||
test.equal(ipaddr.isValid('4999999999'), false)
|
||||
test.equal(ipaddr.isValid('-1'), false)
|
||||
test.done()
|
||||
|
||||
'does not hang on ::8:8:8:8:8:8:8:8:8': (test) ->
|
||||
test.equal(ipaddr.IPv6.isValid('::8:8:8:8:8:8:8:8:8'), false)
|
||||
test.equal(ipaddr.IPv6.isValid('::8:8:8:8:8:8:8:8:8%z'), false)
|
||||
test.done()
|
||||
|
||||
'subnetMatch does not fail on empty range': (test) ->
|
||||
ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {}, false)
|
||||
ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {subnet: []}, false)
|
||||
test.done()
|
||||
|
||||
'subnetMatch returns default subnet on empty range': (test) ->
|
||||
test.equal(ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {}, false), false)
|
||||
test.equal(ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {subnet: []}, false), false)
|
||||
test.done()
|
||||
|
||||
'subnetMatch does not fail on IPv4 when looking for IPv6': (test) ->
|
||||
rangelist = {subnet6: ipaddr.parseCIDR('fe80::/64')}
|
||||
test.equal(ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), rangelist, false), false)
|
||||
test.done()
|
||||
|
||||
'subnetMatch does not fail on IPv6 when looking for IPv4': (test) ->
|
||||
rangelist = {subnet4: ipaddr.parseCIDR('1.2.3.0/24')}
|
||||
test.equal(ipaddr.subnetMatch(new ipaddr.IPv6([0xfe80, 0, 0, 0, 0, 0, 0, 1]), rangelist, false), false)
|
||||
test.done()
|
||||
|
||||
'subnetMatch can use a hybrid IPv4/IPv6 range list': (test) ->
|
||||
rangelist = {dual64: [ipaddr.parseCIDR('1.2.4.0/24'), ipaddr.parseCIDR('2001:1:2:3::/64')]}
|
||||
test.equal(ipaddr.subnetMatch(new ipaddr.IPv4([1,2,4,1]), rangelist, false), 'dual64')
|
||||
test.equal(ipaddr.subnetMatch(new ipaddr.IPv6([0x2001, 1, 2, 3, 0, 0, 0, 1]), rangelist, false), 'dual64')
|
||||
test.done()
|
||||
|
||||
'is able to determine IP address type from byte array input': (test) ->
|
||||
test.equal(ipaddr.fromByteArray([0x7f, 0, 0, 1]).kind(), 'ipv4')
|
||||
test.equal(ipaddr.fromByteArray([0x20, 0x01, 0xd, 0xb8, 0xf5, 0x3a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]).kind(), 'ipv6')
|
||||
test.throws ->
|
||||
ipaddr.fromByteArray([1])
|
||||
test.done()
|
||||
|
||||
'prefixLengthFromSubnetMask returns proper CIDR notation for standard IPv4 masks': (test) ->
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.255').prefixLengthFromSubnetMask(), 32)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.254').prefixLengthFromSubnetMask(), 31)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.252').prefixLengthFromSubnetMask(), 30)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.248').prefixLengthFromSubnetMask(), 29)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.240').prefixLengthFromSubnetMask(), 28)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.224').prefixLengthFromSubnetMask(), 27)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.192').prefixLengthFromSubnetMask(), 26)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.128').prefixLengthFromSubnetMask(), 25)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.255.0').prefixLengthFromSubnetMask(), 24)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.254.0').prefixLengthFromSubnetMask(), 23)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.252.0').prefixLengthFromSubnetMask(), 22)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.248.0').prefixLengthFromSubnetMask(), 21)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.240.0').prefixLengthFromSubnetMask(), 20)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.224.0').prefixLengthFromSubnetMask(), 19)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.192.0').prefixLengthFromSubnetMask(), 18)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.128.0').prefixLengthFromSubnetMask(), 17)
|
||||
test.equal(ipaddr.IPv4.parse('255.255.0.0').prefixLengthFromSubnetMask(), 16)
|
||||
test.equal(ipaddr.IPv4.parse('255.254.0.0').prefixLengthFromSubnetMask(), 15)
|
||||
test.equal(ipaddr.IPv4.parse('255.252.0.0').prefixLengthFromSubnetMask(), 14)
|
||||
test.equal(ipaddr.IPv4.parse('255.248.0.0').prefixLengthFromSubnetMask(), 13)
|
||||
test.equal(ipaddr.IPv4.parse('255.240.0.0').prefixLengthFromSubnetMask(), 12)
|
||||
test.equal(ipaddr.IPv4.parse('255.224.0.0').prefixLengthFromSubnetMask(), 11)
|
||||
test.equal(ipaddr.IPv4.parse('255.192.0.0').prefixLengthFromSubnetMask(), 10)
|
||||
test.equal(ipaddr.IPv4.parse('255.128.0.0').prefixLengthFromSubnetMask(), 9)
|
||||
test.equal(ipaddr.IPv4.parse('255.0.0.0').prefixLengthFromSubnetMask(), 8)
|
||||
test.equal(ipaddr.IPv4.parse('254.0.0.0').prefixLengthFromSubnetMask(), 7)
|
||||
test.equal(ipaddr.IPv4.parse('252.0.0.0').prefixLengthFromSubnetMask(), 6)
|
||||
test.equal(ipaddr.IPv4.parse('248.0.0.0').prefixLengthFromSubnetMask(), 5)
|
||||
test.equal(ipaddr.IPv4.parse('240.0.0.0').prefixLengthFromSubnetMask(), 4)
|
||||
test.equal(ipaddr.IPv4.parse('224.0.0.0').prefixLengthFromSubnetMask(), 3)
|
||||
test.equal(ipaddr.IPv4.parse('192.0.0.0').prefixLengthFromSubnetMask(), 2)
|
||||
test.equal(ipaddr.IPv4.parse('128.0.0.0').prefixLengthFromSubnetMask(), 1)
|
||||
test.equal(ipaddr.IPv4.parse('0.0.0.0').prefixLengthFromSubnetMask(), 0)
|
||||
# negative cases
|
||||
test.equal(ipaddr.IPv4.parse('192.168.255.0').prefixLengthFromSubnetMask(), null)
|
||||
test.equal(ipaddr.IPv4.parse('255.0.255.0').prefixLengthFromSubnetMask(), null)
|
||||
test.done()
|
||||
|
||||
'prefixLengthFromSubnetMask returns proper CIDR notation for standard IPv6 masks': (test) ->
|
||||
test.equal(ipaddr.IPv6.parse('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff').prefixLengthFromSubnetMask(), 128)
|
||||
test.equal(ipaddr.IPv6.parse('ffff:ffff:ffff:ffff::').prefixLengthFromSubnetMask(), 64)
|
||||
test.equal(ipaddr.IPv6.parse('ffff:ffff:ffff:ff80::').prefixLengthFromSubnetMask(), 57)
|
||||
test.equal(ipaddr.IPv6.parse('ffff:ffff:ffff::').prefixLengthFromSubnetMask(), 48)
|
||||
test.equal(ipaddr.IPv6.parse('ffff:ffff:ffff::%z').prefixLengthFromSubnetMask(), 48)
|
||||
test.equal(ipaddr.IPv6.parse('::').prefixLengthFromSubnetMask(), 0)
|
||||
test.equal(ipaddr.IPv6.parse('::%z').prefixLengthFromSubnetMask(), 0)
|
||||
# negative cases
|
||||
test.equal(ipaddr.IPv6.parse('2001:db8::').prefixLengthFromSubnetMask(), null)
|
||||
test.equal(ipaddr.IPv6.parse('ffff:0:0:ffff::').prefixLengthFromSubnetMask(), null)
|
||||
test.equal(ipaddr.IPv6.parse('ffff:0:0:ffff::%z').prefixLengthFromSubnetMask(), null)
|
||||
test.done()
|
||||
|
||||
'subnetMaskFromPrefixLength returns correct IPv4 subnet mask given prefix length': (test) ->
|
||||
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(0), "0.0.0.0");
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(1), "128.0.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(2), "192.0.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(3), "224.0.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(4), "240.0.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(5), "248.0.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(6), "252.0.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(7), "254.0.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(8), "255.0.0.0");
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(9), "255.128.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(10), "255.192.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(11), "255.224.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(12), "255.240.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(13), "255.248.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(14), "255.252.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(15), "255.254.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(16), "255.255.0.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(17), "255.255.128.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(18), "255.255.192.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(19), "255.255.224.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(20), "255.255.240.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(21), "255.255.248.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(22), "255.255.252.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(23), "255.255.254.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(24), "255.255.255.0")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(25), "255.255.255.128")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(26), "255.255.255.192")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(27), "255.255.255.224")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(28), "255.255.255.240")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(29), "255.255.255.248")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(30), "255.255.255.252")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(31), "255.255.255.254")
|
||||
test.equal(ipaddr.IPv4.subnetMaskFromPrefixLength(32), "255.255.255.255")
|
||||
test.done()
|
||||
|
||||
'broadcastAddressFromCIDR returns correct IPv4 broadcast address': (test) ->
|
||||
test.equal(ipaddr.IPv4.broadcastAddressFromCIDR("172.0.0.1/24"), "172.0.0.255")
|
||||
test.equal(ipaddr.IPv4.broadcastAddressFromCIDR("172.0.0.1/26"), "172.0.0.63")
|
||||
test.done()
|
||||
|
||||
'networkAddressFromCIDR returns correct IPv4 network address': (test) ->
|
||||
test.equal(ipaddr.IPv4.networkAddressFromCIDR("172.0.0.1/24"), "172.0.0.0")
|
||||
test.equal(ipaddr.IPv4.networkAddressFromCIDR("172.0.0.1/5"), "168.0.0.0")
|
||||
test.done()
|
||||
Reference in New Issue
Block a user