dergeorg/SmartShopper
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Firebase Update

Browse Source
This commit is contained in:
Lukas Nowy
2018-12-22 23:30:39 +01:00
parent befb44764d
commit acffe619b3
11523 changed files with 1614327 additions and 930246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
express-server/node_modules/ipaddr.js/.npmignore generated vendored
View File

@ -1,2 +0,0 @@
.idea
node_modules

10
express-server/node_modules/ipaddr.js/.travis.yml generated vendored
View File

@ -1,10 +0,0 @@
language: node_js
node_js:
- "0.10"
- "0.11"
- "0.12"
- "4.0"
- "4.1"
- "4.2"
- "5"

18
express-server/node_modules/ipaddr.js/Cakefile generated vendored
View File

@ -1,18 +0,0 @@
fs = require 'fs'
CoffeeScript = require 'coffee-script'
nodeunit = require 'nodeunit'
UglifyJS = require 'uglify-js'
task 'build', 'build the JavaScript files from CoffeeScript source', build = (cb) ->
source = fs.readFileSync 'src/ipaddr.coffee', 'utf-8'
fs.writeFileSync 'lib/ipaddr.js', CoffeeScript.compile source.toString()
invoke 'test'
invoke 'compress'
task 'test', 'run the bundled tests', (cb) ->
nodeunit.reporters.default.run ['test']
task 'compress', 'uglify the resulting javascript', (cb) ->
source = fs.readFileSync 'lib/ipaddr.js', 'utf-8'
fs.writeFileSync('ipaddr.min.js', UglifyJS.minify(source).code)

19
express-server/node_modules/ipaddr.js/LICENSE generated vendored
View File

@ -1,19 +0,0 @@
Copyright (C) 2011 Peter Zotov <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.

20
express-server/node_modules/ipaddr.js/README.md generated vendored
View File

@ -43,7 +43,7 @@ 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 couterparts
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
@ -97,8 +97,7 @@ in the source: [IPv6 ranges] and [IPv4 ranges]. Some common ones include `"unica
(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 both
IPv6 and IPv4 addresses, and accepts a name-to-subnet map as the range list. For example:
`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 = {
@ -108,7 +107,7 @@ var rangeList = {
[ ipaddr.parse('2001:5c0::'), 32 ] // freenet6
]
};
ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown'); // => "he.net"
ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown'); // => "tunnelProviders"
```
The addresses can be converted to their byte representation with `toByteArray()`.
@ -155,6 +154,13 @@ 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.
@ -177,11 +183,11 @@ 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"
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.
`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"
```

29
express-server/node_modules/ipaddr.js/bower.json generated vendored
View File

@ -1,29 +0,0 @@
{
"name": "ipaddr.js",
"version": "1.4.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"
]
}

2
express-server/node_modules/ipaddr.js/ipaddr.min.js generated vendored
View File

File diff suppressed because one or more lines are too long

232
express-server/node_modules/ipaddr.js/lib/ipaddr.js generated vendored
View File

@ -1,5 +1,5 @@
(function() {
var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root;
var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root, zoneIndex;
ipaddr = {};
@ -43,8 +43,10 @@
}
for (k = 0, len = rangeSubnets.length; k < len; k++) {
subnet = rangeSubnets[k];
if (address.match.apply(address, subnet)) {
return rangeName;
if (address.kind() === subnet[0].kind()) {
if (address.match.apply(address, subnet)) {
return rangeName;
}
}
}
}
@ -74,6 +76,10 @@
return this.octets.join(".");
};
IPv4.prototype.toNormalizedString = function() {
return this.toString();
};
IPv4.prototype.toByteArray = function() {
return this.octets.slice(0);
};
@ -191,7 +197,7 @@
};
ipaddr.IPv6 = (function() {
function IPv6(parts) {
function IPv6(parts, zoneId) {
var i, k, l, len, part, ref;
if (parts.length === 16) {
this.parts = [];
@ -210,6 +216,9 @@
throw new Error("ipaddr: ipv6 part should fit in 16 bits");
}
}
if (zoneId) {
this.zoneId = zoneId;
}
}
IPv6.prototype.kind = function() {
@ -217,56 +226,7 @@
};
IPv6.prototype.toString = function() {
var compactStringParts, k, len, part, pushPart, state, stringParts;
stringParts = (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);
compactStringParts = [];
pushPart = function(part) {
return compactStringParts.push(part);
};
state = 0;
for (k = 0, len = stringParts.length; k < len; k++) {
part = stringParts[k];
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(":");
return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, '::');
};
IPv6.prototype.toByteArray = function() {
@ -282,8 +242,8 @@
};
IPv6.prototype.toNormalizedString = function() {
var part;
return ((function() {
var addr, part, suffix;
addr = ((function() {
var k, len, ref, results;
ref = this.parts;
results = [];
@ -293,6 +253,11 @@
}
return results;
}).call(this)).join(":");
suffix = '';
if (this.zoneId) {
suffix = '%' + this.zoneId;
}
return addr + suffix;
};
IPv6.prototype.match = function(other, cidrRange) {
@ -337,22 +302,71 @@
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 = {
"native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?$", 'i'),
transitional: new RegExp(("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)") + (ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$"), 'i')
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;
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) {
@ -379,7 +393,7 @@
if (string[string.length - 1] === ':') {
string = string.slice(0, -1);
}
return (function() {
parts = (function() {
var k, len, ref, results;
ref = string.split(":");
results = [];
@ -389,15 +403,20 @@
}
return results;
})();
return {
parts: parts,
zoneId: zoneId
};
};
ipaddr.IPv6.parser = function(string) {
var k, len, match, octet, octets, parts;
if (string.match(ipv6Regexes['native'])) {
var addr, k, len, match, octet, octets, zoneId;
if (ipv6Regexes['native'].test(string)) {
return expandIPv6(string, 8);
} else if (match = string.match(ipv6Regexes['transitional'])) {
parts = expandIPv6(match[1].slice(0, -1), 6);
if (parts) {
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];
@ -405,9 +424,12 @@
return null;
}
}
parts.push(octets[0] << 8 | octets[1]);
parts.push(octets[2] << 8 | octets[3]);
return parts;
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;
@ -429,7 +451,7 @@
};
ipaddr.IPv4.isValidFourPartDecimal = function(string) {
if (ipaddr.IPv4.isValid(string) && string.match(/^\d+(\.\d+){3}$/)) {
if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
return true;
} else {
return false;
@ -437,12 +459,13 @@
};
ipaddr.IPv6.isValid = function(string) {
var e;
var addr, e;
if (typeof string === "string" && string.indexOf(":") === -1) {
return false;
}
try {
new this(this.parser(string));
addr = this.parser(string);
new this(addr.parts, addr.zoneId);
return true;
} catch (error1) {
e = error1;
@ -450,7 +473,7 @@
}
};
ipaddr.IPv4.parse = ipaddr.IPv6.parse = function(string) {
ipaddr.IPv4.parse = function(string) {
var parts;
parts = this.parser(string);
if (parts === null) {
@ -459,44 +482,64 @@
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;
var maskLength, match, parsed;
if (match = string.match(/^(.+)\/(\d+)$/)) {
maskLength = parseInt(match[2]);
if (maskLength >= 0 && maskLength <= 32) {
return [this.parse(match[1]), maskLength];
parsed = [this.parse(match[1]), maskLength];
Object.defineProperty(parsed, 'toString', {
value: function() {
return this.join('/');
}
});
return parsed;
}
}
throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range");
};
ipaddr.IPv4.subnetMaskFromPrefixLength = function(prefix) {
var j, octets;
var filledOctetCount, j, octets;
prefix = parseInt(prefix);
if (prefix < 0 || prefix > 32) {
throw new Error('ipaddr: invalid prefix length');
throw new Error('ipaddr: invalid IPv4 prefix length');
}
octets = Array(4).fill(0);
octets = [0, 0, 0, 0];
j = 0;
while (j < Math.floor(prefix / 8)) {
filledOctetCount = Math.floor(prefix / 8);
while (j < filledOctetCount) {
octets[j] = 255;
j++;
}
octets[Math.floor(prefix / 8)] = Math.pow(2, prefix % 8) - 1 << 8 - (prefix % 8);
return new ipaddr.IPv4(octets);
if (filledOctetCount < 4) {
octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - (prefix % 8);
}
return new this(octets);
};
ipaddr.IPv4.broadcastAddressFromCIDR = function(string) {
var error, i, ipInterface, octets, subnetMask;
var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets;
try {
ipInterface = ipaddr.IPv4.parseCIDR(string)[0];
subnetMask = this.subnetMaskFromPrefixLength([ipaddr.IPv4.parseCIDR(string)[1]]);
cidr = this.parseCIDR(string);
ipInterfaceOctets = cidr[0].toByteArray();
subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
octets = [];
i = 0;
while (i < 4) {
octets.push(parseInt(ipInterface.octets[i], 10) | parseInt(subnetMask.octets[i], 10) ^ 255);
octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
i++;
}
return new ipaddr.IPv4(octets);
return new this(octets);
} catch (error1) {
error = error1;
throw new Error('ipaddr: the address does not have IPv4 CIDR format');
@ -504,17 +547,18 @@
};
ipaddr.IPv4.networkAddressFromCIDR = function(string) {
var error, i, ipInterface, octets, subnetMask;
var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets;
try {
ipInterface = ipaddr.IPv4.parseCIDR(string)[0];
subnetMask = this.subnetMaskFromPrefixLength([ipaddr.IPv4.parseCIDR(string)[1]]);
cidr = this.parseCIDR(string);
ipInterfaceOctets = cidr[0].toByteArray();
subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
octets = [];
i = 0;
while (i < 4) {
octets.push(parseInt(ipInterface.octets[i], 10) & parseInt(subnetMask.octets[i], 10));
octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
i++;
}
return new ipaddr.IPv4(octets);
return new this(octets);
} catch (error1) {
error = error1;
throw new Error('ipaddr: the address does not have IPv4 CIDR format');
@ -522,11 +566,17 @@
};
ipaddr.IPv6.parseCIDR = function(string) {
var maskLength, match;
var maskLength, match, parsed;
if (match = string.match(/^(.+)\/(\d+)$/)) {
maskLength = parseInt(match[2]);
if (maskLength >= 0 && maskLength <= 128) {
return [this.parse(match[1]), maskLength];
parsed = [this.parse(match[1]), maskLength];
Object.defineProperty(parsed, 'toString', {
value: function() {
return this.join('/');
}
});
return parsed;
}
}
throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");

29
express-server/node_modules/ipaddr.js/package.json generated vendored
View File

@ -1,27 +1,27 @@
{
"_from": "ipaddr.js@1.4.0",
"_id": "ipaddr.js@1.4.0",
"_from": "ipaddr.js@1.8.0",
"_id": "ipaddr.js@1.8.0",
"_inBundle": false,
"_integrity": "sha1-KWrKh4qCGBbluF0KKFqZvP9FgvA=",
"_integrity": "sha1-6qM9bd16zo9/b+DJygRA5wZzix4=",
"_location": "/ipaddr.js",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "ipaddr.js@1.4.0",
"raw": "ipaddr.js@1.8.0",
"name": "ipaddr.js",
"escapedName": "ipaddr.js",
"rawSpec": "1.4.0",
"rawSpec": "1.8.0",
"saveSpec": null,
"fetchSpec": "1.4.0"
"fetchSpec": "1.8.0"
},
"_requiredBy": [
"/proxy-addr"
],
"_resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.4.0.tgz",
"_shasum": "296aca878a821816e5b85d0a285a99bcff4582f0",
"_spec": "ipaddr.js@1.4.0",
"_where": "D:\\5CHITM\\Diplomarbeit\\smart-shopper\\express-server\\node_modules\\proxy-addr",
"_resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.8.0.tgz",
"_shasum": "eaa33d6ddd7ace8f7f6fe0c9ca0440e706738b1e",
"_spec": "ipaddr.js@1.8.0",
"_where": "D:\\Desktop\\smartshopperNodeReworkFirebase\\node_modules\\proxy-addr",
"author": {
"name": "whitequark",
"email": "whitequark@whitequark.org"
@ -44,6 +44,10 @@
"engines": {
"node": ">= 0.10"
},
"files": [
"lib/",
"ipaddr.min.js"
],
"homepage": "https://github.com/whitequark/ipaddr.js#readme",
"keywords": [
"ip",
@ -51,7 +55,7 @@
"ipv6"
],
"license": "MIT",
"main": "./lib/ipaddr",
"main": "./lib/ipaddr.js",
"name": "ipaddr.js",
"repository": {
"type": "git",
@ -60,5 +64,6 @@
"scripts": {
"test": "cake build test"
},
"version": "1.4.0"
"types": "./lib/ipaddr.js.d.ts",
"version": "1.8.0"
}

504
express-server/node_modules/ipaddr.js/src/ipaddr.coffee generated vendored
View File

@ -1,504 +0,0 @@
# 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.
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
return rangeName if address.match.apply(address, subnet)
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 "."
# 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) ->
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"
# 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: ->
stringParts = (part.toString(16) for part in @parts)
compactStringParts = []
pushPart = (part) -> compactStringParts.push part
state = 0
for part in stringParts
switch state
when 0
if part == '0'
pushPart('')
else
pushPart(part)
state = 1
when 1
if part == '0'
state = 2
else
pushPart(part)
when 2
unless part == '0'
pushPart('')
pushPart(part)
state = 3
when 3
pushPart(part)
if state == 2
pushPart('')
pushPart('')
return compactStringParts.join ":"
# 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: ->
return (part.toString(16) for part in @parts).join ":"
# 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])
# 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]+::?)+"
ipv6Regexes =
native: new RegExp "^(::)?(#{ipv6Part})?([0-9a-f]+)?(::)?$", 'i'
transitional: new RegExp "^((?:#{ipv6Part})|(?:::)(?:#{ipv6Part})?)" +
"#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}$", '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
# 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] == ':'
return (parseInt(part, 16) for part in string.split(":"))
# Parse an IPv6 address.
ipaddr.IPv6.parser = (string) ->
if string.match(ipv6Regexes['native'])
return expandIPv6(string, 8)
else if match = string.match(ipv6Regexes['transitional'])
parts = expandIPv6(match[1][0..-2], 6)
if parts
octets = [parseInt(match[2]), parseInt(match[3]),
parseInt(match[4]), parseInt(match[5])]
for octet in octets
if !(0 <= octet <= 255)
return null
parts.push(octets[0] << 8 | octets[1])
parts.push(octets[2] << 8 | octets[3])
return parts
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
new this(@parser(string))
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 = ipaddr.IPv6.parse = (string) ->
parts = @parser(string)
if parts == null
throw new Error "ipaddr: string is not formatted like ip address"
return new this(parts)
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) ->
if prefix < 0 or prefix > 32
throw new Error('ipaddr: invalid prefix length')
octets = Array(4).fill(0)
j = 0
while j < Math.floor(prefix / 8)
octets[j] = 255
j++
octets[Math.floor(prefix / 8)] = Math.pow(2, (prefix % 8)) - 1 << 8 - (prefix % 8)
new (ipaddr.IPv4)(octets)
# A utility function to return broadcast address given the IPv4 interface and prefix length in CIDR notation
ipaddr.IPv4.broadcastAddressFromCIDR = (string) ->
try
ipInterface = ipaddr.IPv4.parseCIDR(string)[0]
subnetMask = @subnetMaskFromPrefixLength([ ipaddr.IPv4.parseCIDR(string)[1] ])
octets = []
i = 0
while i < 4
# Broadcast address is bitwise OR between ip interface and inverted mask
octets.push parseInt(ipInterface.octets[i], 10) | parseInt(subnetMask.octets[i], 10) ^ 255
i++
return new (ipaddr.IPv4)(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
ipInterface = ipaddr.IPv4.parseCIDR(string)[0]
subnetMask = @subnetMaskFromPrefixLength([ ipaddr.IPv4.parseCIDR(string)[1] ])
octets = []
i = 0
while i < 4
# Network address is bitwise AND between ip interface and mask
octets.push parseInt(ipInterface.octets[i], 10) & parseInt(subnetMask.octets[i], 10)
i++
return new (ipaddr.IPv4)(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

391
express-server/node_modules/ipaddr.js/test/ipaddr.test.coffee generated vendored
View File

@ -1,391 +0,0 @@
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.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, 1]).toString(), '::1')
test.equal(new ipaddr.IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]).toString(), '2001:db8::')
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: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.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: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('2002::2:'), false)
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.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:db9:f500::1'), 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:db9:f500::1/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.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.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.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.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.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()
'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()
'subnetMaskFromPrefixLength returns correct 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.done()
'broadcastAddressFromCIDR returns correct 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 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()