pax_global_header00006660000000000000000000000064123571762510014523gustar00rootroot0000000000000052 comment=69c0a0b59249ee1ca6d00fc487bbd3c693800da4 ipaddr.js-0.1.3/000077500000000000000000000000001235717625100134025ustar00rootroot00000000000000ipaddr.js-0.1.3/.gitignore000066400000000000000000000000231235717625100153650ustar00rootroot00000000000000.idea node_modules ipaddr.js-0.1.3/Cakefile000066400000000000000000000011601235717625100150260ustar00rootroot00000000000000fs = 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' 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) -> result = UglifyJS.minify('lib/ipaddr.js') fs.writeFileSync('ipaddr.min.js', result.code) ipaddr.js-0.1.3/LICENSE000066400000000000000000000020721235717625100144100ustar00rootroot00000000000000Copyright (C) 2011 Peter Zotov 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.ipaddr.js-0.1.3/README.md000066400000000000000000000126061235717625100146660ustar00rootroot00000000000000# ipaddr.js — an IPv6 and IPv4 address manipulation library 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` ## 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 couterparts 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 ``` 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 both IPv6 and 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'); // => "he.net" ``` 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, , 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. [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] ``` #### 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] ``` ipaddr.js-0.1.3/ipaddr.min.js000066400000000000000000000132571235717625100157750ustar00rootroot00000000000000(function(){var t,r,n,e,i,o,a,s;r={},s=this,"undefined"!=typeof module&&null!==module&&module.exports?module.exports=r:s.ipaddr=r,a=function(t,r,n,e){var i,o;if(t.length!==r.length)throw new Error("ipaddr: cannot match CIDR for objects with different lengths");for(i=0;e>0;){if(o=n-e,0>o&&(o=0),t[i]>>o!==r[i]>>o)return!1;e-=n,i+=1}return!0},r.subnetMatch=function(t,r,n){var e,i,o,a,s;null==n&&(n="unicast");for(e in r)for(i=r[e],"[object Array]"!==toString.call(i[0])&&(i=[i]),a=0,s=i.length;s>a;a++)if(o=i[a],t.match.apply(t,o))return e;return n},r.IPv4=function(){function t(t){var r,n,e;if(4!==t.length)throw new Error("ipaddr: ipv4 octet count should be 4");for(n=0,e=t.length;e>n;n++)if(r=t[n],!(r>=0&&255>=r))throw new Error("ipaddr: ipv4 octet is a byte");this.octets=t}return t.prototype.kind=function(){return"ipv4"},t.prototype.toString=function(){return this.octets.join(".")},t.prototype.toByteArray=function(){return this.octets.slice(0)},t.prototype.match=function(t,r){if("ipv4"!==t.kind())throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");return a(this.octets,t.octets,8,r)},t.prototype.SpecialRanges={broadcast:[[new t([255,255,255,255]),32]],multicast:[[new t([224,0,0,0]),4]],linkLocal:[[new t([169,254,0,0]),16]],loopback:[[new t([127,0,0,0]),8]],"private":[[new t([10,0,0,0]),8],[new t([172,16,0,0]),12],[new t([192,168,0,0]),16]],reserved:[[new t([192,0,0,0]),24],[new t([192,0,2,0]),24],[new t([192,88,99,0]),24],[new t([198,51,100,0]),24],[new t([203,0,113,0]),24],[new t([240,0,0,0]),4]]},t.prototype.range=function(){return r.subnetMatch(this,this.SpecialRanges)},t.prototype.toIPv4MappedAddress=function(){return r.IPv6.parse("::ffff:"+this.toString())},t}(),n="(0?\\d+|0x[a-f0-9]+)",e={fourOctet:new RegExp("^"+n+"\\."+n+"\\."+n+"\\."+n+"$","i"),longValue:new RegExp("^"+n+"$","i")},r.IPv4.parser=function(t){var r,n,i,o,a;return n=function(t){return"0"===t[0]&&"x"!==t[1]?parseInt(t,8):parseInt(t)},(r=t.match(e.fourOctet))?function(){var t,e,o,a;for(o=r.slice(1,6),a=[],t=0,e=o.length;e>t;t++)i=o[t],a.push(n(i));return a}():(r=t.match(e.longValue))?(a=n(r[1]),function(){var t,r;for(r=[],o=t=0;24>=t;o=t+=8)r.push(a>>o&255);return r}().reverse()):null},r.IPv6=function(){function t(t){var r,n,e;if(8!==t.length)throw new Error("ipaddr: ipv6 part count should be 8");for(n=0,e=t.length;e>n;n++)if(r=t[n],!(r>=0&&65535>=r))throw new Error("ipaddr: ipv6 part should fit to two octets");this.parts=t}return t.prototype.kind=function(){return"ipv6"},t.prototype.toString=function(){var t,r,n,e,i,o,a;for(i=function(){var t,n,e,i;for(e=this.parts,i=[],t=0,n=e.length;n>t;t++)r=e[t],i.push(r.toString(16));return i}.call(this),t=[],n=function(r){return t.push(r)},e=0,o=0,a=i.length;a>o;o++)switch(r=i[o],e){case 0:"0"===r?n(""):n(r),e=1;break;case 1:"0"===r?e=2:n(r);break;case 2:"0"!==r&&(n(""),n(r),e=3);break;case 3:n(r)}return 2===e&&(n(""),n("")),t.join(":")},t.prototype.toByteArray=function(){var t,r,n,e,i;for(t=[],i=this.parts,n=0,e=i.length;e>n;n++)r=i[n],t.push(r>>8),t.push(255&r);return t},t.prototype.toNormalizedString=function(){var t;return function(){var r,n,e,i;for(e=this.parts,i=[],r=0,n=e.length;n>r;r++)t=e[r],i.push(t.toString(16));return i}.call(this).join(":")},t.prototype.match=function(t,r){if("ipv6"!==t.kind())throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");return a(this.parts,t.parts,16,r)},t.prototype.SpecialRanges={unspecified:[new t([0,0,0,0,0,0,0,0]),128],linkLocal:[new t([65152,0,0,0,0,0,0,0]),10],multicast:[new t([65280,0,0,0,0,0,0,0]),8],loopback:[new t([0,0,0,0,0,0,0,1]),128],uniqueLocal:[new t([64512,0,0,0,0,0,0,0]),7],ipv4Mapped:[new t([0,0,0,0,0,65535,0,0]),96],rfc6145:[new t([0,0,0,0,65535,0,0,0]),96],rfc6052:[new t([100,65435,0,0,0,0,0,0]),96],"6to4":[new t([8194,0,0,0,0,0,0,0]),16],teredo:[new t([8193,0,0,0,0,0,0,0]),32],reserved:[[new t([8193,3512,0,0,0,0,0,0]),32]]},t.prototype.range=function(){return r.subnetMatch(this,this.SpecialRanges)},t.prototype.isIPv4MappedAddress=function(){return"ipv4Mapped"===this.range()},t.prototype.toIPv4Address=function(){var t,n,e;if(!this.isIPv4MappedAddress())throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4");return e=this.parts.slice(-2),t=e[0],n=e[1],new r.IPv4([t>>8,255&t,n>>8,255&n])},t}(),i="(?:[0-9a-f]+::?)+",o={"native":new RegExp("^(::)?("+i+")?([0-9a-f]+)?(::)?$","i"),transitional:new RegExp("^((?:"+i+")|(?:::)(?:"+i+")?)"+(""+n+"\\."+n+"\\."+n+"\\."+n+"$"),"i")},t=function(t,r){var n,e,i,o,a;if(t.indexOf("::")!==t.lastIndexOf("::"))return null;for(n=0,e=-1;(e=t.indexOf(":",e+1))>=0;)n++;for(":"===t[0]&&n--,":"===t[t.length-1]&&n--,a=r-n,o=":";a--;)o+="0:";return t=t.replace("::",o),":"===t[0]&&(t=t.slice(1)),":"===t[t.length-1]&&(t=t.slice(0,-1)),function(){var r,n,e,o;for(e=t.split(":"),o=[],r=0,n=e.length;n>r;r++)i=e[r],o.push(parseInt(i,16));return o}()},r.IPv6.parser=function(r){var n,e;return r.match(o["native"])?t(r,8):(n=r.match(o.transitional))&&(e=t(n[1].slice(0,-1),6))?(e.push(parseInt(n[2])<<8|parseInt(n[3])),e.push(parseInt(n[4])<<8|parseInt(n[5])),e):null},r.IPv4.isIPv4=r.IPv6.isIPv6=function(t){return null!==this.parser(t)},r.IPv4.isValid=r.IPv6.isValid=function(t){var r;try{return new this(this.parser(t)),!0}catch(n){return r=n,!1}},r.IPv4.parse=r.IPv6.parse=function(t){var r;if(r=this.parser(t),null===r)throw new Error("ipaddr: string is not formatted like ip address");return new this(r)},r.isValid=function(t){return r.IPv6.isValid(t)||r.IPv4.isValid(t)},r.parse=function(t){if(r.IPv6.isIPv6(t))return r.IPv6.parse(t);if(r.IPv4.isIPv4(t))return r.IPv4.parse(t);throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format")},r.process=function(t){var r;return r=this.parse(t),"ipv6"===r.kind()&&r.isIPv4MappedAddress()?r.toIPv4Address():r}}).call(this);ipaddr.js-0.1.3/lib/000077500000000000000000000000001235717625100141505ustar00rootroot00000000000000ipaddr.js-0.1.3/lib/ipaddr.js000066400000000000000000000267161235717625100157650ustar00rootroot00000000000000(function() { var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root; ipaddr = {}; root = this; if ((typeof module !== "undefined" && module !== null) && module.exports) { module.exports = ipaddr; } else { root['ipaddr'] = ipaddr; } matchCIDR = function(first, second, partSize, cidrBits) { var part, shift; if (first.length !== second.length) { throw new Error("ipaddr: cannot match CIDR for objects with different lengths"); } part = 0; while (cidrBits > 0) { shift = partSize - cidrBits; if (shift < 0) { shift = 0; } if (first[part] >> shift !== second[part] >> shift) { return false; } cidrBits -= partSize; part += 1; } return true; }; ipaddr.subnetMatch = function(address, rangeList, defaultName) { var rangeName, rangeSubnets, subnet, _i, _len; if (defaultName == null) { defaultName = 'unicast'; } for (rangeName in rangeList) { rangeSubnets = rangeList[rangeName]; if (toString.call(rangeSubnets[0]) !== '[object Array]') { rangeSubnets = [rangeSubnets]; } for (_i = 0, _len = rangeSubnets.length; _i < _len; _i++) { subnet = rangeSubnets[_i]; if (address.match.apply(address, subnet)) { return rangeName; } } } return defaultName; }; ipaddr.IPv4 = (function() { function IPv4(octets) { var octet, _i, _len; if (octets.length !== 4) { throw new Error("ipaddr: ipv4 octet count should be 4"); } for (_i = 0, _len = octets.length; _i < _len; _i++) { octet = octets[_i]; if (!((0 <= octet && octet <= 255))) { throw new Error("ipaddr: ipv4 octet is a byte"); } } this.octets = octets; } IPv4.prototype.kind = function() { return 'ipv4'; }; IPv4.prototype.toString = function() { return this.octets.join("."); }; IPv4.prototype.toByteArray = function() { return this.octets.slice(0); }; IPv4.prototype.match = function(other, cidrRange) { 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 = { broadcast: [[new IPv4([255, 255, 255, 255]), 32]], multicast: [[new IPv4([224, 0, 0, 0]), 4]], linkLocal: [[new IPv4([169, 254, 0, 0]), 16]], loopback: [[new IPv4([127, 0, 0, 0]), 8]], "private": [[new IPv4([10, 0, 0, 0]), 8], [new IPv4([172, 16, 0, 0]), 12], [new IPv4([192, 168, 0, 0]), 16]], reserved: [[new IPv4([192, 0, 0, 0]), 24], [new IPv4([192, 0, 2, 0]), 24], [new IPv4([192, 88, 99, 0]), 24], [new IPv4([198, 51, 100, 0]), 24], [new IPv4([203, 0, 113, 0]), 24], [new IPv4([240, 0, 0, 0]), 4]] }; IPv4.prototype.range = function() { return ipaddr.subnetMatch(this, this.SpecialRanges); }; IPv4.prototype.toIPv4MappedAddress = function() { return ipaddr.IPv6.parse("::ffff:" + (this.toString())); }; return IPv4; })(); ipv4Part = "(0?\\d+|0x[a-f0-9]+)"; ipv4Regexes = { fourOctet: new RegExp("^" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$", 'i'), longValue: new RegExp("^" + ipv4Part + "$", 'i') }; ipaddr.IPv4.parser = function(string) { var match, parseIntAuto, part, shift, value; parseIntAuto = function(string) { if (string[0] === "0" && string[1] !== "x") { return parseInt(string, 8); } else { return parseInt(string); } }; if (match = string.match(ipv4Regexes.fourOctet)) { return (function() { var _i, _len, _ref, _results; _ref = match.slice(1, 6); _results = []; for (_i = 0, _len = _ref.length; _i < _len; _i++) { part = _ref[_i]; _results.push(parseIntAuto(part)); } return _results; })(); } else if (match = string.match(ipv4Regexes.longValue)) { value = parseIntAuto(match[1]); return ((function() { var _i, _results; _results = []; for (shift = _i = 0; _i <= 24; shift = _i += 8) { _results.push((value >> shift) & 0xff); } return _results; })()).reverse(); } else { return null; } }; ipaddr.IPv6 = (function() { function IPv6(parts) { var part, _i, _len; if (parts.length !== 8) { throw new Error("ipaddr: ipv6 part count should be 8"); } for (_i = 0, _len = parts.length; _i < _len; _i++) { part = parts[_i]; if (!((0 <= part && part <= 0xffff))) { throw new Error("ipaddr: ipv6 part should fit to two octets"); } } this.parts = parts; } IPv6.prototype.kind = function() { return 'ipv6'; }; IPv6.prototype.toString = function() { var compactStringParts, part, pushPart, state, stringParts, _i, _len; stringParts = (function() { var _i, _len, _ref, _results; _ref = this.parts; _results = []; for (_i = 0, _len = _ref.length; _i < _len; _i++) { part = _ref[_i]; _results.push(part.toString(16)); } return _results; }).call(this); compactStringParts = []; pushPart = function(part) { return compactStringParts.push(part); }; state = 0; for (_i = 0, _len = stringParts.length; _i < _len; _i++) { part = stringParts[_i]; switch (state) { case 0: if (part === '0') { pushPart(''); } else { pushPart(part); } state = 1; break; case 1: if (part === '0') { state = 2; } else { pushPart(part); } break; case 2: if (part !== '0') { pushPart(''); pushPart(part); state = 3; } break; case 3: pushPart(part); } } if (state === 2) { pushPart(''); pushPart(''); } return compactStringParts.join(":"); }; IPv6.prototype.toByteArray = function() { var bytes, part, _i, _len, _ref; bytes = []; _ref = this.parts; for (_i = 0, _len = _ref.length; _i < _len; _i++) { part = _ref[_i]; bytes.push(part >> 8); bytes.push(part & 0xff); } return bytes; }; IPv6.prototype.toNormalizedString = function() { var part; return ((function() { var _i, _len, _ref, _results; _ref = this.parts; _results = []; for (_i = 0, _len = _ref.length; _i < _len; _i++) { part = _ref[_i]; _results.push(part.toString(16)); } return _results; }).call(this)).join(":"); }; IPv6.prototype.match = function(other, cidrRange) { if (other.kind() !== 'ipv6') { throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one"); } return matchCIDR(this.parts, other.parts, 16, cidrRange); }; IPv6.prototype.SpecialRanges = { unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128], linkLocal: [new IPv6([0xfe80, 0, 0, 0, 0, 0, 0, 0]), 10], multicast: [new IPv6([0xff00, 0, 0, 0, 0, 0, 0, 0]), 8], loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128], uniqueLocal: [new IPv6([0xfc00, 0, 0, 0, 0, 0, 0, 0]), 7], ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 0xffff, 0, 0]), 96], rfc6145: [new IPv6([0, 0, 0, 0, 0xffff, 0, 0, 0]), 96], rfc6052: [new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96], '6to4': [new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16], teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32], reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]] }; IPv6.prototype.range = function() { return ipaddr.subnetMatch(this, this.SpecialRanges); }; IPv6.prototype.isIPv4MappedAddress = function() { return this.range() === 'ipv4Mapped'; }; IPv6.prototype.toIPv4Address = function() { var high, low, _ref; if (!this.isIPv4MappedAddress()) { throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4"); } _ref = this.parts.slice(-2), high = _ref[0], low = _ref[1]; return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff]); }; return IPv6; })(); ipv6Part = "(?:[0-9a-f]+::?)+"; ipv6Regexes = { "native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?$", 'i'), transitional: new RegExp(("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)") + ("" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$"), 'i') }; expandIPv6 = function(string, parts) { var colonCount, lastColon, part, replacement, replacementCount; if (string.indexOf('::') !== string.lastIndexOf('::')) { return null; } colonCount = 0; lastColon = -1; while ((lastColon = string.indexOf(':', lastColon + 1)) >= 0) { colonCount++; } if (string[0] === ':') { colonCount--; } if (string[string.length - 1] === ':') { colonCount--; } replacementCount = parts - colonCount; replacement = ':'; while (replacementCount--) { replacement += '0:'; } string = string.replace('::', replacement); if (string[0] === ':') { string = string.slice(1); } if (string[string.length - 1] === ':') { string = string.slice(0, -1); } return (function() { var _i, _len, _ref, _results; _ref = string.split(":"); _results = []; for (_i = 0, _len = _ref.length; _i < _len; _i++) { part = _ref[_i]; _results.push(parseInt(part, 16)); } return _results; })(); }; ipaddr.IPv6.parser = function(string) { var match, parts; if (string.match(ipv6Regexes['native'])) { return expandIPv6(string, 8); } else if (match = string.match(ipv6Regexes['transitional'])) { parts = expandIPv6(match[1].slice(0, -1), 6); if (parts) { parts.push(parseInt(match[2]) << 8 | parseInt(match[3])); parts.push(parseInt(match[4]) << 8 | parseInt(match[5])); return parts; } } return null; }; ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = function(string) { return this.parser(string) !== null; }; ipaddr.IPv4.isValid = ipaddr.IPv6.isValid = function(string) { var e; try { new this(this.parser(string)); return true; } catch (_error) { e = _error; return false; } }; ipaddr.IPv4.parse = ipaddr.IPv6.parse = function(string) { var parts; parts = this.parser(string); if (parts === null) { throw new Error("ipaddr: string is not formatted like ip address"); } return new this(parts); }; ipaddr.isValid = function(string) { return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string); }; ipaddr.parse = function(string) { if (ipaddr.IPv6.isIPv6(string)) { return ipaddr.IPv6.parse(string); } else if (ipaddr.IPv4.isIPv4(string)) { return ipaddr.IPv4.parse(string); } else { throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format"); } }; ipaddr.process = function(string) { var addr; addr = this.parse(string); if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) { return addr.toIPv4Address(); } else { return addr; } }; }).call(this); ipaddr.js-0.1.3/package.json000066400000000000000000000010731235717625100156710ustar00rootroot00000000000000{ "name": "ipaddr.js", "description": "A library for manipulating IPv4 and IPv6 addresses in JavaScript.", "version": "0.1.3", "author": "Peter Zotov ", "directories": { "lib": "./lib" }, "dependencies": {}, "devDependencies": { "coffee-script": "~1.6", "nodeunit": "~0.5.3", "uglify-js": "latest" }, "scripts": { "test": "cake build test" }, "keywords": ["ip", "ipv4", "ipv6"], "repository": "git://github.com/whitequark/ipaddr.js", "main": "./lib/ipaddr", "engines": { "node": ">= 0.2.5" } } ipaddr.js-0.1.3/src/000077500000000000000000000000001235717625100141715ustar00rootroot00000000000000ipaddr.js-0.1.3/src/ipaddr.coffee000066400000000000000000000256031235717625100166130ustar00rootroot00000000000000# 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 toString.call(rangeSubnets[0]) != '[object 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. # 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 is a byte" @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 toByteArray: -> return @octets.slice(0) # octets.clone # Checks if this address matches other one within given CIDR range. match: (other, cidrRange) -> 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. SpecialRanges: 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 ] ] 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()}" # 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]) 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. # Throws an error if the input is invalid. constructor: (parts) -> if parts.length != 8 throw new Error "ipaddr: ipv6 part count should be 8" for part in parts if !(0 <= part <= 0xffff) throw new Error "ipaddr: ipv6 part should fit to two octets" @parts = parts # 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 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 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[0] == ':' colonCount-- if string[string.length-1] == ':' # 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 parts.push(parseInt(match[2]) << 8 | parseInt(match[3])) parts.push(parseInt(match[4]) << 8 | parseInt(match[5])) 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 = ipaddr.IPv6.isValid = (string) -> 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) # 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.isIPv6(string) return ipaddr.IPv6.parse(string) else if ipaddr.IPv4.isIPv4(string) return ipaddr.IPv4.parse(string) else throw new Error "ipaddr: the address has neither IPv6 nor IPv4 format" # 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 ipaddr.js-0.1.3/test/000077500000000000000000000000001235717625100143615ustar00rootroot00000000000000ipaddr.js-0.1.3/test/ipaddr.test.coffee000066400000000000000000000222621235717625100177570ustar00rootroot00000000000000ipaddr = 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() 'detects reserved IPv4 networks': (test) -> test.equal(ipaddr.IPv4.parse('10.1.0.1').range(), 'private') 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() 'can construct IPv6 from parts': (test) -> test.doesNotThrow -> 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.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'), true) 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('2001:db8::F53A::1'), false) test.equal(ipaddr.IPv6.isValid('fe80::wtf'), 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() '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()