Source: net/netaddress.js

  1. /*!
  2.  * netaddress.js - network address object for bcoin
  3.  * Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
  4.  * https://github.com/bcoin-org/bcoin
  5.  */
  7. 'use strict';
  9. const assert = require('bsert');
  10. const bio = require('bufio');
  11. const IP = require('binet');
  12. const Network = require('../protocol/network');
  13. const util = require('../utils/util');
  14. const common = require('./common');
  15. const {inspectSymbol} = require('../utils');
  17. /**
  18.  * Net Address
  19.  * Represents a network address.
  20.  * @alias module:net.NetAddress
  21.  * @property {Host} host
  22.  * @property {Number} port
  23.  * @property {Number} services
  24.  * @property {Number} time
  25.  */
  27. class NetAddress {
  28.   /**
  29.    * Create a network address.
  30.    * @constructor
  31.    * @param {Object} options
  32.    * @param {Number?} options.time - Timestamp.
  33.    * @param {Number?} options.services - Service bits.
  34.    * @param {String?} options.host - IP address (IPv6 or IPv4).
  35.    * @param {Number?} options.port - Port.
  36.    */
  38.   constructor(options) {
  39.     this.host = '0.0.0.0';
  40.     this.port = 0;
  41.     this.services = 0;
  42.     this.time = 0;
  43.     this.hostname = '0.0.0.0:0';
  44.     this.raw = IP.ZERO_IP;
  46.     if (options)
  47.       this.fromOptions(options);
  48.   }
  50.   /**
  51.    * Inject properties from options object.
  52.    * @private
  53.    * @param {Object} options
  54.    */
  56.   fromOptions(options) {
  57.     assert(typeof options.host === 'string');
  58.     assert(typeof options.port === 'number');
  60.     this.raw = IP.toBuffer(options.host);
  61.     this.host = IP.toString(this.raw);
  62.     this.port = options.port;
  64.     if (options.services) {
  65.       assert(typeof options.services === 'number');
  66.       this.services = options.services;
  67.     }
  69.     if (options.time) {
  70.       assert(typeof options.time === 'number');
  71.       this.time = options.time;
  72.     }
  74.     this.hostname = IP.toHostname(this.host, this.port);
  76.     return this;
  77.   }
  79.   /**
  80.    * Instantiate network address from options.
  81.    * @param {Object} options
  82.    * @returns {NetAddress}
  83.    */
  85.   static fromOptions(options) {
  86.     return new this().fromOptions(options);
  87.   }
  89.   /**
  90.    * Test whether required services are available.
  91.    * @param {Number} services
  92.    * @returns {Boolean}
  93.    */
  95.   hasServices(services) {
  96.     return (this.services & services) === services;
  97.   }
  99.   /**
  100.    * Test whether the address is IPv4.
  101.    * @returns {Boolean}
  102.    */
  104.   isIPv4() {
  105.     return IP.isIPv4(this.raw);
  106.   }
  108.   /**
  109.    * Test whether the address is IPv6.
  110.    * @returns {Boolean}
  111.    */
  113.   isIPv6() {
  114.     return IP.isIPv6(this.raw);
  115.   }
  117.   /**
  118.    * Test whether the host is null.
  119.    * @returns {Boolean}
  120.    */
  122.   isNull() {
  123.     return IP.isNull(this.raw);
  124.   }
  126.   /**
  127.    * Test whether the host is a local address.
  128.    * @returns {Boolean}
  129.    */
  131.   isLocal() {
  132.     return IP.isLocal(this.raw);
  133.   }
  135.   /**
  136.    * Test whether the host is valid.
  137.    * @returns {Boolean}
  138.    */
  140.   isValid() {
  141.     return IP.isValid(this.raw);
  142.   }
  144.   /**
  145.    * Test whether the host is routable.
  146.    * @returns {Boolean}
  147.    */
  149.   isRoutable() {
  150.     return IP.isRoutable(this.raw);
  151.   }
  153.   /**
  154.    * Test whether the host is an onion address.
  155.    * @returns {Boolean}
  156.    */
  158.   isOnion() {
  159.     return IP.isOnion(this.raw);
  160.   }
  162.   /**
  163.    * Compare against another network address.
  164.    * @returns {Boolean}
  165.    */
  167.   equal(addr) {
  168.     return this.compare(addr) === 0;
  169.   }
  171.   /**
  172.    * Compare against another network address.
  173.    * @returns {Number}
  174.    */
  176.   compare(addr) {
  177.     const cmp = this.raw.compare(addr.raw);
  179.     if (cmp !== 0)
  180.       return cmp;
  182.     return this.port - addr.port;
  183.   }
  185.   /**
  186.    * Get reachable score to destination.
  187.    * @param {NetAddress} dest
  188.    * @returns {Number}
  189.    */
  191.   getReachability(dest) {
  192.     return IP.getReachability(this.raw, dest.raw);
  193.   }
  195.   /**
  196.    * Set null host.
  197.    */
  199.   setNull() {
  200.     this.raw = IP.ZERO_IP;
  201.     this.host = '0.0.0.0';
  202.     this.hostname = IP.toHostname(this.host, this.port);
  203.   }
  205.   /**
  206.    * Set host.
  207.    * @param {String} host
  208.    */
  210.   setHost(host) {
  211.     this.raw = IP.toBuffer(host);
  212.     this.host = IP.toString(this.raw);
  213.     this.hostname = IP.toHostname(this.host, this.port);
  214.   }
  216.   /**
  217.    * Set port.
  218.    * @param {Number} port
  219.    */
  221.   setPort(port) {
  222.     assert(port >= 0 && port <= 0xffff);
  223.     this.port = port;
  224.     this.hostname = IP.toHostname(this.host, port);
  225.   }
  227.   /**
  228.    * Inject properties from host, port, and network.
  229.    * @private
  230.    * @param {String} host
  231.    * @param {Number} port
  232.    * @param {(Network|NetworkType)?} network
  233.    */
  235.   fromHost(host, port, network) {
  236.     network = Network.get(network);
  238.     assert(port >= 0 && port <= 0xffff);
  240.     this.raw = IP.toBuffer(host);
  241.     this.host = IP.toString(this.raw);
  242.     this.port = port;
  243.     this.services = NetAddress.DEFAULT_SERVICES;
  244.     this.time = network.now();
  246.     this.hostname = IP.toHostname(this.host, this.port);
  248.     return this;
  249.   }
  251.   /**
  252.    * Instantiate a network address
  253.    * from a host and port.
  254.    * @param {String} host
  255.    * @param {Number} port
  256.    * @param {(Network|NetworkType)?} network
  257.    * @returns {NetAddress}
  258.    */
  260.   static fromHost(host, port, network) {
  261.     return new this().fromHost(host, port, network);
  262.   }
  264.   /**
  265.    * Inject properties from hostname and network.
  266.    * @private
  267.    * @param {String} hostname
  268.    * @param {(Network|NetworkType)?} network
  269.    */
  271.   fromHostname(hostname, network) {
  272.     network = Network.get(network);
  274.     const addr = IP.fromHostname(hostname, network.port);
  276.     return this.fromHost(addr.host, addr.port, network);
  277.   }
  279.   /**
  280.    * Instantiate a network address
  281.    * from a hostname (i.e. 127.0.0.1:8333).
  282.    * @param {String} hostname
  283.    * @param {(Network|NetworkType)?} network
  284.    * @returns {NetAddress}
  285.    */
  287.   static fromHostname(hostname, network) {
  288.     return new this().fromHostname(hostname, network);
  289.   }
  291.   /**
  292.    * Inject properties from socket.
  293.    * @private
  294.    * @param {net.Socket} socket
  295.    */
  297.   fromSocket(socket, network) {
  298.     const host = socket.remoteAddress;
  299.     const port = socket.remotePort;
  300.     assert(typeof host === 'string');
  301.     assert(typeof port === 'number');
  302.     return this.fromHost(IP.normalize(host), port, network);
  303.   }
  305.   /**
  306.    * Instantiate a network address
  307.    * from a socket.
  308.    * @param {net.Socket} socket
  309.    * @returns {NetAddress}
  310.    */
  312.   static fromSocket(hostname, network) {
  313.     return new this().fromSocket(hostname, network);
  314.   }
  316.   /**
  317.    * Inject properties from buffer reader.
  318.    * @private
  319.    * @param {BufferReader} br
  320.    * @param {Boolean?} full - Include timestamp.
  321.    */
  323.   fromReader(br, full) {
  324.     this.time = full ? br.readU32() : 0;
  325.     this.services = br.readU32();
  327.     // Note: hi service bits
  328.     // are currently unused.
  329.     br.readU32();
  331.     this.raw = br.readBytes(16);
  332.     this.host = IP.toString(this.raw);
  333.     this.port = br.readU16BE();
  334.     this.hostname = IP.toHostname(this.host, this.port);
  336.     return this;
  337.   }
  339.   /**
  340.    * Inject properties from serialized data.
  341.    * @private
  342.    * @param {Buffer} data
  343.    * @param {Boolean?} full - Include timestamp.
  344.    */
  346.   fromRaw(data, full) {
  347.     return this.fromReader(bio.read(data), full);
  348.   }
  350.   /**
  351.    * Insantiate a network address from buffer reader.
  352.    * @param {BufferReader} br
  353.    * @param {Boolean?} full - Include timestamp.
  354.    * @returns {NetAddress}
  355.    */
  357.   static fromReader(br, full) {
  358.     return new this().fromReader(br, full);
  359.   }
  361.   /**
  362.    * Insantiate a network address from serialized data.
  363.    * @param {Buffer} data
  364.    * @param {Boolean?} full - Include timestamp.
  365.    * @returns {NetAddress}
  366.    */
  368.   static fromRaw(data, full) {
  369.     return new this().fromRaw(data, full);
  370.   }
  372.   /**
  373.    * Write network address to a buffer writer.
  374.    * @param {BufferWriter} bw
  375.    * @param {Boolean?} full - Include timestamp.
  376.    * @returns {Buffer}
  377.    */
  379.   toWriter(bw, full) {
  380.     if (full)
  381.       bw.writeU32(this.time);
  383.     bw.writeU32(this.services);
  384.     bw.writeU32(0);
  385.     bw.writeBytes(this.raw);
  386.     bw.writeU16BE(this.port);
  388.     return bw;
  389.   }
  391.   /**
  392.    * Calculate serialization size of address.
  393.    * @returns {Number}
  394.    */
  396.   getSize(full) {
  397.     return 26 + (full ? 4 : 0);
  398.   }
  400.   /**
  401.    * Serialize network address.
  402.    * @param {Boolean?} full - Include timestamp.
  403.    * @returns {Buffer}
  404.    */
  406.   toRaw(full) {
  407.     const size = this.getSize(full);
  408.     return this.toWriter(bio.write(size), full).render();
  409.   }
  411.   /**
  412.    * Convert net address to json-friendly object.
  413.    * @returns {Object}
  414.    */
  416.   toJSON() {
  417.     return {
  418.       host: this.host,
  419.       port: this.port,
  420.       services: this.services,
  421.       time: this.time
  422.     };
  423.   }
  425.   /**
  426.    * Inject properties from json object.
  427.    * @private
  428.    * @param {Object} json
  429.    * @returns {NetAddress}
  430.    */
  432.   fromJSON(json) {
  433.     assert((json.port & 0xffff) === json.port);
  434.     assert((json.services >>> 0) === json.services);
  435.     assert((json.time >>> 0) === json.time);
  436.     this.raw = IP.toBuffer(json.host);
  437.     this.host = json.host;
  438.     this.port = json.port;
  439.     this.services = json.services;
  440.     this.time = json.time;
  441.     this.hostname = IP.toHostname(this.host, this.port);
  442.     return this;
  443.   }
  445.   /**
  446.    * Instantiate net address from json object.
  447.    * @param {Object} json
  448.    * @returns {NetAddress}
  449.    */
  451.   static fromJSON(json) {
  452.     return new this().fromJSON(json);
  453.   }
  455.   /**
  456.    * Inspect the network address.
  457.    * @returns {Object}
  458.    */
  460.   [inspectSymbol]() {
  461.     return '<NetAddress:'
  462.       + ` hostname=${this.hostname}`
  463.       + ` services=${this.services.toString(2)}`
  464.       + ` date=${util.date(this.time)}`
  465.       + '>';
  466.   }
  467. }
  469. /**
  470.  * Default services for
  471.  * unknown outbound peers.
  472.  * @const {Number}
  473.  * @default
  474.  */
  476. NetAddress.DEFAULT_SERVICES = 0
  477.   | common.services.NETWORK
  478.   | common.services.WITNESS
  479.   | common.services.BLOOM;
  481. /*
  482.  * Expose
  483.  */
  485. module.exports = NetAddress;