| 1 | 'use strict';
|
|---|
| 2 |
|
|---|
| 3 | var ip = exports;
|
|---|
| 4 | var Buffer = require('buffer').Buffer;
|
|---|
| 5 | var os = require('os');
|
|---|
| 6 |
|
|---|
| 7 | ip.toBuffer = function(ip, buff, offset) {
|
|---|
| 8 | offset = ~~offset;
|
|---|
| 9 |
|
|---|
| 10 | var result;
|
|---|
| 11 |
|
|---|
| 12 | if (this.isV4Format(ip)) {
|
|---|
| 13 | result = buff || new Buffer(offset + 4);
|
|---|
| 14 | ip.split(/\./g).map(function(byte) {
|
|---|
| 15 | result[offset++] = parseInt(byte, 10) & 0xff;
|
|---|
| 16 | });
|
|---|
| 17 | } else if (this.isV6Format(ip)) {
|
|---|
| 18 | var sections = ip.split(':', 8);
|
|---|
| 19 |
|
|---|
| 20 | var i;
|
|---|
| 21 | for (i = 0; i < sections.length; i++) {
|
|---|
| 22 | var isv4 = this.isV4Format(sections[i]);
|
|---|
| 23 | var v4Buffer;
|
|---|
| 24 |
|
|---|
| 25 | if (isv4) {
|
|---|
| 26 | v4Buffer = this.toBuffer(sections[i]);
|
|---|
| 27 | sections[i] = v4Buffer.slice(0, 2).toString('hex');
|
|---|
| 28 | }
|
|---|
| 29 |
|
|---|
| 30 | if (v4Buffer && ++i < 8) {
|
|---|
| 31 | sections.splice(i, 0, v4Buffer.slice(2, 4).toString('hex'));
|
|---|
| 32 | }
|
|---|
| 33 | }
|
|---|
| 34 |
|
|---|
| 35 | if (sections[0] === '') {
|
|---|
| 36 | while (sections.length < 8) sections.unshift('0');
|
|---|
| 37 | } else if (sections[sections.length - 1] === '') {
|
|---|
| 38 | while (sections.length < 8) sections.push('0');
|
|---|
| 39 | } else if (sections.length < 8) {
|
|---|
| 40 | for (i = 0; i < sections.length && sections[i] !== ''; i++);
|
|---|
| 41 | var argv = [ i, 1 ];
|
|---|
| 42 | for (i = 9 - sections.length; i > 0; i--) {
|
|---|
| 43 | argv.push('0');
|
|---|
| 44 | }
|
|---|
| 45 | sections.splice.apply(sections, argv);
|
|---|
| 46 | }
|
|---|
| 47 |
|
|---|
| 48 | result = buff || new Buffer(offset + 16);
|
|---|
| 49 | for (i = 0; i < sections.length; i++) {
|
|---|
| 50 | var word = parseInt(sections[i], 16);
|
|---|
| 51 | result[offset++] = (word >> 8) & 0xff;
|
|---|
| 52 | result[offset++] = word & 0xff;
|
|---|
| 53 | }
|
|---|
| 54 | }
|
|---|
| 55 |
|
|---|
| 56 | if (!result) {
|
|---|
| 57 | throw Error('Invalid ip address: ' + ip);
|
|---|
| 58 | }
|
|---|
| 59 |
|
|---|
| 60 | return result;
|
|---|
| 61 | };
|
|---|
| 62 |
|
|---|
| 63 | ip.toString = function(buff, offset, length) {
|
|---|
| 64 | offset = ~~offset;
|
|---|
| 65 | length = length || (buff.length - offset);
|
|---|
| 66 |
|
|---|
| 67 | var result = [];
|
|---|
| 68 | if (length === 4) {
|
|---|
| 69 | // IPv4
|
|---|
| 70 | for (var i = 0; i < length; i++) {
|
|---|
| 71 | result.push(buff[offset + i]);
|
|---|
| 72 | }
|
|---|
| 73 | result = result.join('.');
|
|---|
| 74 | } else if (length === 16) {
|
|---|
| 75 | // IPv6
|
|---|
| 76 | for (var i = 0; i < length; i += 2) {
|
|---|
| 77 | result.push(buff.readUInt16BE(offset + i).toString(16));
|
|---|
| 78 | }
|
|---|
| 79 | result = result.join(':');
|
|---|
| 80 | result = result.replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3');
|
|---|
| 81 | result = result.replace(/:{3,4}/, '::');
|
|---|
| 82 | }
|
|---|
| 83 |
|
|---|
| 84 | return result;
|
|---|
| 85 | };
|
|---|
| 86 |
|
|---|
| 87 | var ipv4Regex = /^(\d{1,3}\.){3,3}\d{1,3}$/;
|
|---|
| 88 | var ipv6Regex =
|
|---|
| 89 | /^(::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?$/i;
|
|---|
| 90 |
|
|---|
| 91 | ip.isV4Format = function(ip) {
|
|---|
| 92 | return ipv4Regex.test(ip);
|
|---|
| 93 | };
|
|---|
| 94 |
|
|---|
| 95 | ip.isV6Format = function(ip) {
|
|---|
| 96 | return ipv6Regex.test(ip);
|
|---|
| 97 | };
|
|---|
| 98 | function _normalizeFamily(family) {
|
|---|
| 99 | return family ? family.toLowerCase() : 'ipv4';
|
|---|
| 100 | }
|
|---|
| 101 |
|
|---|
| 102 | ip.fromPrefixLen = function(prefixlen, family) {
|
|---|
| 103 | if (prefixlen > 32) {
|
|---|
| 104 | family = 'ipv6';
|
|---|
| 105 | } else {
|
|---|
| 106 | family = _normalizeFamily(family);
|
|---|
| 107 | }
|
|---|
| 108 |
|
|---|
| 109 | var len = 4;
|
|---|
| 110 | if (family === 'ipv6') {
|
|---|
| 111 | len = 16;
|
|---|
| 112 | }
|
|---|
| 113 | var buff = new Buffer(len);
|
|---|
| 114 |
|
|---|
| 115 | for (var i = 0, n = buff.length; i < n; ++i) {
|
|---|
| 116 | var bits = 8;
|
|---|
| 117 | if (prefixlen < 8) {
|
|---|
| 118 | bits = prefixlen;
|
|---|
| 119 | }
|
|---|
| 120 | prefixlen -= bits;
|
|---|
| 121 |
|
|---|
| 122 | buff[i] = ~(0xff >> bits) & 0xff;
|
|---|
| 123 | }
|
|---|
| 124 |
|
|---|
| 125 | return ip.toString(buff);
|
|---|
| 126 | };
|
|---|
| 127 |
|
|---|
| 128 | ip.mask = function(addr, mask) {
|
|---|
| 129 | addr = ip.toBuffer(addr);
|
|---|
| 130 | mask = ip.toBuffer(mask);
|
|---|
| 131 |
|
|---|
| 132 | var result = new Buffer(Math.max(addr.length, mask.length));
|
|---|
| 133 |
|
|---|
| 134 | var i = 0;
|
|---|
| 135 | // Same protocol - do bitwise and
|
|---|
| 136 | if (addr.length === mask.length) {
|
|---|
| 137 | for (i = 0; i < addr.length; i++) {
|
|---|
| 138 | result[i] = addr[i] & mask[i];
|
|---|
| 139 | }
|
|---|
| 140 | } else if (mask.length === 4) {
|
|---|
| 141 | // IPv6 address and IPv4 mask
|
|---|
| 142 | // (Mask low bits)
|
|---|
| 143 | for (i = 0; i < mask.length; i++) {
|
|---|
| 144 | result[i] = addr[addr.length - 4 + i] & mask[i];
|
|---|
| 145 | }
|
|---|
| 146 | } else {
|
|---|
| 147 | // IPv6 mask and IPv4 addr
|
|---|
| 148 | for (var i = 0; i < result.length - 6; i++) {
|
|---|
| 149 | result[i] = 0;
|
|---|
| 150 | }
|
|---|
| 151 |
|
|---|
| 152 | // ::ffff:ipv4
|
|---|
| 153 | result[10] = 0xff;
|
|---|
| 154 | result[11] = 0xff;
|
|---|
| 155 | for (i = 0; i < addr.length; i++) {
|
|---|
| 156 | result[i + 12] = addr[i] & mask[i + 12];
|
|---|
| 157 | }
|
|---|
| 158 | i = i + 12;
|
|---|
| 159 | }
|
|---|
| 160 | for (; i < result.length; i++)
|
|---|
| 161 | result[i] = 0;
|
|---|
| 162 |
|
|---|
| 163 | return ip.toString(result);
|
|---|
| 164 | };
|
|---|
| 165 |
|
|---|
| 166 | ip.cidr = function(cidrString) {
|
|---|
| 167 | var cidrParts = cidrString.split('/');
|
|---|
| 168 |
|
|---|
| 169 | var addr = cidrParts[0];
|
|---|
| 170 | if (cidrParts.length !== 2)
|
|---|
| 171 | throw new Error('invalid CIDR subnet: ' + addr);
|
|---|
| 172 |
|
|---|
| 173 | var mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
|
|---|
| 174 |
|
|---|
| 175 | return ip.mask(addr, mask);
|
|---|
| 176 | };
|
|---|
| 177 |
|
|---|
| 178 | ip.subnet = function(addr, mask) {
|
|---|
| 179 | var networkAddress = ip.toLong(ip.mask(addr, mask));
|
|---|
| 180 |
|
|---|
| 181 | // Calculate the mask's length.
|
|---|
| 182 | var maskBuffer = ip.toBuffer(mask);
|
|---|
| 183 | var maskLength = 0;
|
|---|
| 184 |
|
|---|
| 185 | for (var i = 0; i < maskBuffer.length; i++) {
|
|---|
| 186 | if (maskBuffer[i] === 0xff) {
|
|---|
| 187 | maskLength += 8;
|
|---|
| 188 | } else {
|
|---|
| 189 | var octet = maskBuffer[i] & 0xff;
|
|---|
| 190 | while (octet) {
|
|---|
| 191 | octet = (octet << 1) & 0xff;
|
|---|
| 192 | maskLength++;
|
|---|
| 193 | }
|
|---|
| 194 | }
|
|---|
| 195 | }
|
|---|
| 196 |
|
|---|
| 197 | var numberOfAddresses = Math.pow(2, 32 - maskLength);
|
|---|
| 198 |
|
|---|
| 199 | return {
|
|---|
| 200 | networkAddress: ip.fromLong(networkAddress),
|
|---|
| 201 | firstAddress: numberOfAddresses <= 2 ?
|
|---|
| 202 | ip.fromLong(networkAddress) :
|
|---|
| 203 | ip.fromLong(networkAddress + 1),
|
|---|
| 204 | lastAddress: numberOfAddresses <= 2 ?
|
|---|
| 205 | ip.fromLong(networkAddress + numberOfAddresses - 1) :
|
|---|
| 206 | ip.fromLong(networkAddress + numberOfAddresses - 2),
|
|---|
| 207 | broadcastAddress: ip.fromLong(networkAddress + numberOfAddresses - 1),
|
|---|
| 208 | subnetMask: mask,
|
|---|
| 209 | subnetMaskLength: maskLength,
|
|---|
| 210 | numHosts: numberOfAddresses <= 2 ?
|
|---|
| 211 | numberOfAddresses : numberOfAddresses - 2,
|
|---|
| 212 | length: numberOfAddresses,
|
|---|
| 213 | contains: function(other) {
|
|---|
| 214 | return networkAddress === ip.toLong(ip.mask(other, mask));
|
|---|
| 215 | }
|
|---|
| 216 | };
|
|---|
| 217 | };
|
|---|
| 218 |
|
|---|
| 219 | ip.cidrSubnet = function(cidrString) {
|
|---|
| 220 | var cidrParts = cidrString.split('/');
|
|---|
| 221 |
|
|---|
| 222 | var addr = cidrParts[0];
|
|---|
| 223 | if (cidrParts.length !== 2)
|
|---|
| 224 | throw new Error('invalid CIDR subnet: ' + addr);
|
|---|
| 225 |
|
|---|
| 226 | var mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
|
|---|
| 227 |
|
|---|
| 228 | return ip.subnet(addr, mask);
|
|---|
| 229 | };
|
|---|
| 230 |
|
|---|
| 231 | ip.not = function(addr) {
|
|---|
| 232 | var buff = ip.toBuffer(addr);
|
|---|
| 233 | for (var i = 0; i < buff.length; i++) {
|
|---|
| 234 | buff[i] = 0xff ^ buff[i];
|
|---|
| 235 | }
|
|---|
| 236 | return ip.toString(buff);
|
|---|
| 237 | };
|
|---|
| 238 |
|
|---|
| 239 | ip.or = function(a, b) {
|
|---|
| 240 | a = ip.toBuffer(a);
|
|---|
| 241 | b = ip.toBuffer(b);
|
|---|
| 242 |
|
|---|
| 243 | // same protocol
|
|---|
| 244 | if (a.length === b.length) {
|
|---|
| 245 | for (var i = 0; i < a.length; ++i) {
|
|---|
| 246 | a[i] |= b[i];
|
|---|
| 247 | }
|
|---|
| 248 | return ip.toString(a);
|
|---|
| 249 |
|
|---|
| 250 | // mixed protocols
|
|---|
| 251 | } else {
|
|---|
| 252 | var buff = a;
|
|---|
| 253 | var other = b;
|
|---|
| 254 | if (b.length > a.length) {
|
|---|
| 255 | buff = b;
|
|---|
| 256 | other = a;
|
|---|
| 257 | }
|
|---|
| 258 |
|
|---|
| 259 | var offset = buff.length - other.length;
|
|---|
| 260 | for (var i = offset; i < buff.length; ++i) {
|
|---|
| 261 | buff[i] |= other[i - offset];
|
|---|
| 262 | }
|
|---|
| 263 |
|
|---|
| 264 | return ip.toString(buff);
|
|---|
| 265 | }
|
|---|
| 266 | };
|
|---|
| 267 |
|
|---|
| 268 | ip.isEqual = function(a, b) {
|
|---|
| 269 | a = ip.toBuffer(a);
|
|---|
| 270 | b = ip.toBuffer(b);
|
|---|
| 271 |
|
|---|
| 272 | // Same protocol
|
|---|
| 273 | if (a.length === b.length) {
|
|---|
| 274 | for (var i = 0; i < a.length; i++) {
|
|---|
| 275 | if (a[i] !== b[i]) return false;
|
|---|
| 276 | }
|
|---|
| 277 | return true;
|
|---|
| 278 | }
|
|---|
| 279 |
|
|---|
| 280 | // Swap
|
|---|
| 281 | if (b.length === 4) {
|
|---|
| 282 | var t = b;
|
|---|
| 283 | b = a;
|
|---|
| 284 | a = t;
|
|---|
| 285 | }
|
|---|
| 286 |
|
|---|
| 287 | // a - IPv4, b - IPv6
|
|---|
| 288 | for (var i = 0; i < 10; i++) {
|
|---|
| 289 | if (b[i] !== 0) return false;
|
|---|
| 290 | }
|
|---|
| 291 |
|
|---|
| 292 | var word = b.readUInt16BE(10);
|
|---|
| 293 | if (word !== 0 && word !== 0xffff) return false;
|
|---|
| 294 |
|
|---|
| 295 | for (var i = 0; i < 4; i++) {
|
|---|
| 296 | if (a[i] !== b[i + 12]) return false;
|
|---|
| 297 | }
|
|---|
| 298 |
|
|---|
| 299 | return true;
|
|---|
| 300 | };
|
|---|
| 301 |
|
|---|
| 302 | ip.isPrivate = function(addr) {
|
|---|
| 303 | return /^(::f{4}:)?10\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i
|
|---|
| 304 | .test(addr) ||
|
|---|
| 305 | /^(::f{4}:)?192\.168\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
|
|---|
| 306 | /^(::f{4}:)?172\.(1[6-9]|2\d|30|31)\.([0-9]{1,3})\.([0-9]{1,3})$/i
|
|---|
| 307 | .test(addr) ||
|
|---|
| 308 | /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
|
|---|
| 309 | /^(::f{4}:)?169\.254\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
|
|---|
| 310 | /^f[cd][0-9a-f]{2}:/i.test(addr) ||
|
|---|
| 311 | /^fe80:/i.test(addr) ||
|
|---|
| 312 | /^::1$/.test(addr) ||
|
|---|
| 313 | /^::$/.test(addr);
|
|---|
| 314 | };
|
|---|
| 315 |
|
|---|
| 316 | ip.isPublic = function(addr) {
|
|---|
| 317 | return !ip.isPrivate(addr);
|
|---|
| 318 | };
|
|---|
| 319 |
|
|---|
| 320 | ip.isLoopback = function(addr) {
|
|---|
| 321 | return /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/
|
|---|
| 322 | .test(addr) ||
|
|---|
| 323 | /^fe80::1$/.test(addr) ||
|
|---|
| 324 | /^::1$/.test(addr) ||
|
|---|
| 325 | /^::$/.test(addr);
|
|---|
| 326 | };
|
|---|
| 327 |
|
|---|
| 328 | ip.loopback = function(family) {
|
|---|
| 329 | //
|
|---|
| 330 | // Default to `ipv4`
|
|---|
| 331 | //
|
|---|
| 332 | family = _normalizeFamily(family);
|
|---|
| 333 |
|
|---|
| 334 | if (family !== 'ipv4' && family !== 'ipv6') {
|
|---|
| 335 | throw new Error('family must be ipv4 or ipv6');
|
|---|
| 336 | }
|
|---|
| 337 |
|
|---|
| 338 | return family === 'ipv4' ? '127.0.0.1' : 'fe80::1';
|
|---|
| 339 | };
|
|---|
| 340 |
|
|---|
| 341 | //
|
|---|
| 342 | // ### function address (name, family)
|
|---|
| 343 | // #### @name {string|'public'|'private'} **Optional** Name or security
|
|---|
| 344 | // of the network interface.
|
|---|
| 345 | // #### @family {ipv4|ipv6} **Optional** IP family of the address (defaults
|
|---|
| 346 | // to ipv4).
|
|---|
| 347 | //
|
|---|
| 348 | // Returns the address for the network interface on the current system with
|
|---|
| 349 | // the specified `name`:
|
|---|
| 350 | // * String: First `family` address of the interface.
|
|---|
| 351 | // If not found see `undefined`.
|
|---|
| 352 | // * 'public': the first public ip address of family.
|
|---|
| 353 | // * 'private': the first private ip address of family.
|
|---|
| 354 | // * undefined: First address with `ipv4` or loopback address `127.0.0.1`.
|
|---|
| 355 | //
|
|---|
| 356 | ip.address = function(name, family) {
|
|---|
| 357 | var interfaces = os.networkInterfaces();
|
|---|
| 358 | var all;
|
|---|
| 359 |
|
|---|
| 360 | //
|
|---|
| 361 | // Default to `ipv4`
|
|---|
| 362 | //
|
|---|
| 363 | family = _normalizeFamily(family);
|
|---|
| 364 |
|
|---|
| 365 | //
|
|---|
| 366 | // If a specific network interface has been named,
|
|---|
| 367 | // return the address.
|
|---|
| 368 | //
|
|---|
| 369 | if (name && name !== 'private' && name !== 'public') {
|
|---|
| 370 | var res = interfaces[name].filter(function(details) {
|
|---|
| 371 | var itemFamily = details.family.toLowerCase();
|
|---|
| 372 | return itemFamily === family;
|
|---|
| 373 | });
|
|---|
| 374 | if (res.length === 0)
|
|---|
| 375 | return undefined;
|
|---|
| 376 | return res[0].address;
|
|---|
| 377 | }
|
|---|
| 378 |
|
|---|
| 379 | var all = Object.keys(interfaces).map(function (nic) {
|
|---|
| 380 | //
|
|---|
| 381 | // Note: name will only be `public` or `private`
|
|---|
| 382 | // when this is called.
|
|---|
| 383 | //
|
|---|
| 384 | var addresses = interfaces[nic].filter(function (details) {
|
|---|
| 385 | details.family = details.family.toLowerCase();
|
|---|
| 386 | if (details.family !== family || ip.isLoopback(details.address)) {
|
|---|
| 387 | return false;
|
|---|
| 388 | } else if (!name) {
|
|---|
| 389 | return true;
|
|---|
| 390 | }
|
|---|
| 391 |
|
|---|
| 392 | return name === 'public' ? ip.isPrivate(details.address) :
|
|---|
| 393 | ip.isPublic(details.address);
|
|---|
| 394 | });
|
|---|
| 395 |
|
|---|
| 396 | return addresses.length ? addresses[0].address : undefined;
|
|---|
| 397 | }).filter(Boolean);
|
|---|
| 398 |
|
|---|
| 399 | return !all.length ? ip.loopback(family) : all[0];
|
|---|
| 400 | };
|
|---|
| 401 |
|
|---|
| 402 | ip.toLong = function(ip) {
|
|---|
| 403 | var ipl = 0;
|
|---|
| 404 | ip.split('.').forEach(function(octet) {
|
|---|
| 405 | ipl <<= 8;
|
|---|
| 406 | ipl += parseInt(octet);
|
|---|
| 407 | });
|
|---|
| 408 | return(ipl >>> 0);
|
|---|
| 409 | };
|
|---|
| 410 |
|
|---|
| 411 | ip.fromLong = function(ipl) {
|
|---|
| 412 | return ((ipl >>> 24) + '.' +
|
|---|
| 413 | (ipl >> 16 & 255) + '.' +
|
|---|
| 414 | (ipl >> 8 & 255) + '.' +
|
|---|
| 415 | (ipl & 255) );
|
|---|
| 416 | };
|
|---|
