Source: net/hostlist.js

  1. /*!
  2.  * hostlist.js - address management 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 path = require('path');
  11. const fs = require('bfile');
  12. const IP = require('binet');
  13. const dns = require('bdns');
  14. const Logger = require('blgr');
  15. const murmur3 = require('bcrypto/lib/murmur3');
  16. const List = require('blst');
  17. const {randomRange} = require('bcrypto/lib/random');
  18. const util = require('../utils/util');
  19. const Network = require('../protocol/network');
  20. const NetAddress = require('./netaddress');
  21. const common = require('./common');
  22. const seeds = require('./seeds');
  23. const {inspectSymbol} = require('../utils');
  25. /*
  26.  * Constants
  27.  */
  29. const POOL32 = Buffer.allocUnsafe(32);
  31. /**
  32.  * Host List
  33.  * @alias module:net.HostList
  34.  */
  36. class HostList {
  37.   /**
  38.    * Create a host list.
  39.    * @constructor
  40.    * @param {Object} options
  41.    */
  43.   constructor(options) {
  44.     this.options = new HostListOptions(options);
  45.     this.network = this.options.network;
  46.     this.logger = this.options.logger.context('hostlist');
  47.     this.address = this.options.address;
  48.     this.resolve = this.options.resolve;
  50.     this.dnsSeeds = [];
  51.     this.dnsNodes = [];
  53.     this.map = new Map();
  54.     this.fresh = [];
  55.     this.totalFresh = 0;
  56.     this.used = [];
  57.     this.totalUsed = 0;
  58.     this.nodes = [];
  59.     this.local = new Map();
  60.     this.banned = new Map();
  62.     this.timer = null;
  63.     this.needsFlush = false;
  64.     this.flushing = false;
  66.     this.init();
  67.   }
  69.   /**
  70.    * Initialize list.
  71.    * @private
  72.    */
  74.   init() {
  75.     const options = this.options;
  76.     const scores = HostList.scores;
  78.     for (let i = 0; i < options.maxBuckets; i++)
  79.       this.fresh.push(new Map());
  81.     for (let i = 0; i < options.maxBuckets; i++)
  82.       this.used.push(new List());
  84.     this.setSeeds(options.seeds);
  85.     this.setNodes(options.nodes);
  87.     this.pushLocal(this.address, scores.MANUAL);
  88.     this.addLocal(options.host, options.port, scores.BIND);
  90.     const hosts = IP.getPublic();
  91.     const port = this.address.port;
  93.     for (const host of hosts)
  94.       this.addLocal(host, port, scores.IF);
  95.   }
  97.   /**
  98.    * Open hostlist and read hosts file.
  99.    * @method
  100.    * @returns {Promise}
  101.    */
  103.   async open() {
  104.     try {
  105.       await this.loadFile();
  106.     } catch (e) {
  107.       this.logger.warning('Hosts deserialization failed.');
  108.       this.logger.error(e);
  109.     }
  111.     if (this.size() === 0)
  112.       this.injectSeeds();
  114.     await this.discoverNodes();
  116.     this.start();
  117.   }
  119.   /**
  120.    * Close hostlist.
  121.    * @method
  122.    * @returns {Promise}
  123.    */
  125.   async close() {
  126.     this.stop();
  127.     await this.flush();
  128.     this.reset();
  129.   }
  131.   /**
  132.    * Start flush interval.
  133.    */
  135.   start() {
  136.     if (this.options.memory)
  137.       return;
  139.     if (!this.options.filename)
  140.       return;
  142.     assert(this.timer == null);
  143.     this.timer = setInterval(() => this.flush(), this.options.flushInterval);
  144.   }
  146.   /**
  147.    * Stop flush interval.
  148.    */
  150.   stop() {
  151.     if (this.options.memory)
  152.       return;
  154.     if (!this.options.filename)
  155.       return;
  157.     assert(this.timer != null);
  158.     clearInterval(this.timer);
  159.     this.timer = null;
  160.   }
  162.   /**
  163.    * Read and initialize from hosts file.
  164.    * @method
  165.    * @returns {Promise}
  166.    */
  168.   injectSeeds() {
  169.     const nodes = seeds.get(this.network.type);
  171.     for (const node of nodes) {
  172.       const addr = NetAddress.fromHostname(node, this.network);
  174.       if (!addr.isRoutable())
  175.         continue;
  177.       if (!this.options.onion && addr.isOnion())
  178.         continue;
  180.       if (addr.port === 0)
  181.         continue;
  183.       this.add(addr);
  184.     }
  185.   }
  187.   /**
  188.    * Read and initialize from hosts file.
  189.    * @method
  190.    * @returns {Promise}
  191.    */
  193.   async loadFile() {
  194.     const filename = this.options.filename;
  196.     if (fs.unsupported)
  197.       return;
  199.     if (this.options.memory)
  200.       return;
  202.     if (!filename)
  203.       return;
  205.     let data;
  206.     try {
  207.       data = await fs.readFile(filename, 'utf8');
  208.     } catch (e) {
  209.       if (e.code === 'ENOENT')
  210.         return;
  211.       throw e;
  212.     }
  214.     const json = JSON.parse(data);
  216.     this.fromJSON(json);
  217.   }
  219.   /**
  220.    * Flush addrs to hosts file.
  221.    * @method
  222.    * @returns {Promise}
  223.    */
  225.   async flush() {
  226.     const filename = this.options.filename;
  228.     if (fs.unsupported)
  229.       return;
  231.     if (this.options.memory)
  232.       return;
  234.     if (!filename)
  235.       return;
  237.     if (!this.needsFlush)
  238.       return;
  240.     if (this.flushing)
  241.       return;
  243.     this.needsFlush = false;
  245.     this.logger.debug('Writing hosts to %s.', filename);
  247.     const json = this.toJSON();
  248.     const data = JSON.stringify(json);
  250.     this.flushing = true;
  252.     try {
  253.       await fs.writeFile(filename, data, 'utf8');
  254.     } catch (e) {
  255.       this.logger.warning('Writing hosts failed.');
  256.       this.logger.error(e);
  257.     }
  259.     this.flushing = false;
  260.   }
  262.   /**
  263.    * Get list size.
  264.    * @returns {Number}
  265.    */
  267.   size() {
  268.     return this.totalFresh + this.totalUsed;
  269.   }
  271.   /**
  272.    * Test whether the host list is full.
  273.    * @returns {Boolean}
  274.    */
  276.   isFull() {
  277.     const max = this.options.maxBuckets * this.options.maxEntries;
  278.     return this.size() >= max;
  279.   }
  281.   /**
  282.    * Reset host list.
  283.    */
  285.   reset() {
  286.     this.map.clear();
  288.     for (const bucket of this.fresh)
  289.       bucket.clear();
  291.     for (const bucket of this.used)
  292.       bucket.reset();
  294.     this.totalFresh = 0;
  295.     this.totalUsed = 0;
  297.     this.nodes.length = 0;
  298.   }
  300.   /**
  301.    * Mark a peer as banned.
  302.    * @param {String} host
  303.    */
  305.   ban(host) {
  306.     this.banned.set(host, util.now());
  307.   }
  309.   /**
  310.    * Unban host.
  311.    * @param {String} host
  312.    */
  314.   unban(host) {
  315.     this.banned.delete(host);
  316.   }
  318.   /**
  319.    * Clear banned hosts.
  320.    */
  322.   clearBanned() {
  323.     this.banned.clear();
  324.   }
  326.   /**
  327.    * Test whether the host is banned.
  328.    * @param {String} host
  329.    * @returns {Boolean}
  330.    */
  332.   isBanned(host) {
  333.     const time = this.banned.get(host);
  335.     if (time == null)
  336.       return false;
  338.     if (util.now() > time + this.options.banTime) {
  339.       this.banned.delete(host);
  340.       return false;
  341.     }
  343.     return true;
  344.   }
  346.   /**
  347.    * Allocate a new host.
  348.    * @returns {HostEntry}
  349.    */
  351.   getHost() {
  352.     let buckets = null;
  354.     if (this.totalFresh > 0)
  355.       buckets = this.fresh;
  357.     if (this.totalUsed > 0) {
  358.       if (this.totalFresh === 0 || random(2) === 0)
  359.         buckets = this.used;
  360.     }
  362.     if (!buckets)
  363.       return null;
  365.     const now = this.network.now();
  367.     let factor = 1;
  369.     for (;;) {
  370.       const i = random(buckets.length);
  371.       const bucket = buckets[i];
  373.       if (bucket.size === 0)
  374.         continue;
  376.       let index = random(bucket.size);
  377.       let entry;
  379.       if (buckets === this.used) {
  380.         entry = bucket.head;
  381.         while (index--)
  382.           entry = entry.next;
  383.       } else {
  384.         for (entry of bucket.values()) {
  385.           if (index === 0)
  386.             break;
  387.           index -= 1;
  388.         }
  389.       }
  391.       const num = random(1 << 30);
  393.       if (num < factor * entry.chance(now) * (1 << 30))
  394.         return entry;
  396.       factor *= 1.2;
  397.     }
  398.   }
  400.   /**
  401.    * Get fresh bucket for host.
  402.    * @private
  403.    * @param {HostEntry} entry
  404.    * @returns {Map}
  405.    */
  407.   freshBucket(entry) {
  408.     const addr = entry.addr;
  409.     const src = entry.src;
  410.     const data = concat32(addr.raw, src.raw);
  411.     const hash = murmur3.sum(data, 0xfba4c795);
  412.     const index = hash % this.fresh.length;
  413.     return this.fresh[index];
  414.   }
  416.   /**
  417.    * Get used bucket for host.
  418.    * @private
  419.    * @param {HostEntry} entry
  420.    * @returns {List}
  421.    */
  423.   usedBucket(entry) {
  424.     const addr = entry.addr;
  425.     const hash = murmur3.sum(addr.raw, 0xfba4c795);
  426.     const index = hash % this.used.length;
  427.     return this.used[index];
  428.   }
  430.   /**
  431.    * Add host to host list.
  432.    * @param {NetAddress} addr
  433.    * @param {NetAddress?} src
  434.    * @returns {Boolean}
  435.    */
  437.   add(addr, src) {
  438.     assert(addr.port !== 0);
  440.     let entry = this.map.get(addr.hostname);
  442.     if (entry) {
  443.       let penalty = 2 * 60 * 60;
  444.       let interval = 24 * 60 * 60;
  446.       // No source means we're inserting
  447.       // this ourselves. No penalty.
  448.       if (!src)
  449.         penalty = 0;
  451.       // Update services.
  452.       entry.addr.services |= addr.services;
  453.       entry.addr.services >>>= 0;
  455.       // Online?
  456.       const now = this.network.now();
  457.       if (now - addr.time < 24 * 60 * 60)
  458.         interval = 60 * 60;
  460.       // Periodically update time.
  461.       if (entry.addr.time < addr.time - interval - penalty) {
  462.         entry.addr.time = addr.time;
  463.         this.needsFlush = true;
  464.       }
  466.       // Do not update if no new
  467.       // information is present.
  468.       if (entry.addr.time && addr.time <= entry.addr.time)
  469.         return false;
  471.       // Do not update if the entry was
  472.       // already in the "used" table.
  473.       if (entry.used)
  474.         return false;
  476.       assert(entry.refCount > 0);
  478.       // Do not update if the max
  479.       // reference count is reached.
  480.       if (entry.refCount === HostList.MAX_REFS)
  481.         return false;
  483.       assert(entry.refCount < HostList.MAX_REFS);
  485.       // Stochastic test: previous refCount
  486.       // N: 2^N times harder to increase it.
  487.       let factor = 1;
  488.       for (let i = 0; i < entry.refCount; i++)
  489.         factor *= 2;
  491.       if (random(factor) !== 0)
  492.         return false;
  493.     } else {
  494.       if (this.isFull())
  495.         return false;
  497.       if (!src)
  498.         src = this.address;
  500.       entry = new HostEntry(addr, src);
  502.       this.totalFresh += 1;
  503.     }
  505.     const bucket = this.freshBucket(entry);
  507.     if (bucket.has(entry.key()))
  508.       return false;
  510.     if (bucket.size >= this.options.maxEntries)
  511.       this.evictFresh(bucket);
  513.     bucket.set(entry.key(), entry);
  514.     entry.refCount += 1;
  516.     this.map.set(entry.key(), entry);
  517.     this.needsFlush = true;
  519.     return true;
  520.   }
  522.   /**
  523.    * Evict a host from fresh bucket.
  524.    * @param {Map} bucket
  525.    */
  527.   evictFresh(bucket) {
  528.     let old = null;
  530.     for (const entry of bucket.values()) {
  531.       if (this.isStale(entry)) {
  532.         bucket.delete(entry.key());
  534.         if (--entry.refCount === 0) {
  535.           this.map.delete(entry.key());
  536.           this.totalFresh -= 1;
  537.         }
  539.         continue;
  540.       }
  542.       if (!old) {
  543.         old = entry;
  544.         continue;
  545.       }
  547.       if (entry.addr.time < old.addr.time)
  548.         old = entry;
  549.     }
  551.     if (!old)
  552.       return;
  554.     bucket.delete(old.key());
  556.     if (--old.refCount === 0) {
  557.       this.map.delete(old.key());
  558.       this.totalFresh -= 1;
  559.     }
  560.   }
  562.   /**
  563.    * Test whether a host is evictable.
  564.    * @param {HostEntry} entry
  565.    * @returns {Boolean}
  566.    */
  568.   isStale(entry) {
  569.     const now = this.network.now();
  571.     if (entry.lastAttempt && entry.lastAttempt >= now - 60)
  572.       return false;
  574.     if (entry.addr.time > now + 10 * 60)
  575.       return true;
  577.     if (entry.addr.time === 0)
  578.       return true;
  580.     if (now - entry.addr.time > HostList.HORIZON_DAYS * 24 * 60 * 60)
  581.       return true;
  583.     if (entry.lastSuccess === 0 && entry.attempts >= HostList.RETRIES)
  584.       return true;
  586.     if (now - entry.lastSuccess > HostList.MIN_FAIL_DAYS * 24 * 60 * 60) {
  587.       if (entry.attempts >= HostList.MAX_FAILURES)
  588.         return true;
  589.     }
  591.     return false;
  592.   }
  594.   /**
  595.    * Remove host from host list.
  596.    * @param {String} hostname
  597.    * @returns {NetAddress}
  598.    */
  600.   remove(hostname) {
  601.     const entry = this.map.get(hostname);
  603.     if (!entry)
  604.       return null;
  606.     if (entry.used) {
  607.       let head = entry;
  609.       assert(entry.refCount === 0);
  611.       while (head.prev)
  612.         head = head.prev;
  614.       for (const bucket of this.used) {
  615.         if (bucket.head === head) {
  616.           bucket.remove(entry);
  617.           this.totalUsed -= 1;
  618.           head = null;
  619.           break;
  620.         }
  621.       }
  623.       assert(!head);
  624.     } else {
  625.       for (const bucket of this.fresh) {
  626.         if (bucket.delete(entry.key()))
  627.           entry.refCount -= 1;
  628.       }
  630.       this.totalFresh -= 1;
  631.       assert(entry.refCount === 0);
  632.     }
  634.     this.map.delete(entry.key());
  636.     return entry.addr;
  637.   }
  639.   /**
  640.    * Mark host as failed.
  641.    * @param {String} hostname
  642.    */
  644.   markAttempt(hostname) {
  645.     const entry = this.map.get(hostname);
  646.     const now = this.network.now();
  648.     if (!entry)
  649.       return;
  651.     entry.attempts += 1;
  652.     entry.lastAttempt = now;
  653.   }
  655.   /**
  656.    * Mark host as successfully connected.
  657.    * @param {String} hostname
  658.    */
  660.   markSuccess(hostname) {
  661.     const entry = this.map.get(hostname);
  662.     const now = this.network.now();
  664.     if (!entry)
  665.       return;
  667.     if (now - entry.addr.time > 20 * 60)
  668.       entry.addr.time = now;
  669.   }
  671.   /**
  672.    * Mark host as successfully ack'd.
  673.    * @param {String} hostname
  674.    * @param {Number} services
  675.    */
  677.   markAck(hostname, services) {
  678.     const entry = this.map.get(hostname);
  680.     if (!entry)
  681.       return;
  683.     const now = this.network.now();
  685.     entry.addr.services |= services;
  686.     entry.addr.services >>>= 0;
  688.     entry.lastSuccess = now;
  689.     entry.lastAttempt = now;
  690.     entry.attempts = 0;
  692.     if (entry.used)
  693.       return;
  695.     assert(entry.refCount > 0);
  697.     // Remove from fresh.
  698.     let old = null;
  699.     for (const bucket of this.fresh) {
  700.       if (bucket.delete(entry.key())) {
  701.         entry.refCount -= 1;
  702.         old = bucket;
  703.       }
  704.     }
  706.     assert(old);
  707.     assert(entry.refCount === 0);
  708.     this.totalFresh -= 1;
  710.     // Find room in used bucket.
  711.     const bucket = this.usedBucket(entry);
  713.     if (bucket.size < this.options.maxEntries) {
  714.       entry.used = true;
  715.       bucket.push(entry);
  716.       this.totalUsed += 1;
  717.       return;
  718.     }
  720.     // No room. Evict.
  721.     const evicted = this.evictUsed(bucket);
  723.     let fresh = this.freshBucket(evicted);
  725.     // Move to entry's old bucket if no room.
  726.     if (fresh.size >= this.options.maxEntries)
  727.       fresh = old;
  729.     // Swap to evicted's used bucket.
  730.     entry.used = true;
  731.     bucket.replace(evicted, entry);
  733.     // Move evicted to fresh bucket.
  734.     evicted.used = false;
  735.     fresh.set(evicted.key(), evicted);
  736.     assert(evicted.refCount === 0);
  737.     evicted.refCount += 1;
  738.     this.totalFresh += 1;
  739.   }
  741.   /**
  742.    * Pick used for eviction.
  743.    * @param {List} bucket
  744.    */
  746.   evictUsed(bucket) {
  747.     let old = bucket.head;
  749.     for (let entry = bucket.head; entry; entry = entry.next) {
  750.       if (entry.addr.time < old.addr.time)
  751.         old = entry;
  752.     }
  754.     return old;
  755.   }
  757.   /**
  758.    * Convert address list to array.
  759.    * @returns {NetAddress[]}
  760.    */
  762.   toArray() {
  763.     const out = [];
  765.     for (const entry of this.map.values())
  766.       out.push(entry.addr);
  768.     assert.strictEqual(out.length, this.size());
  770.     return out;
  771.   }
  773.   /**
  774.    * Add a preferred seed.
  775.    * @param {String} host
  776.    */
  778.   addSeed(host) {
  779.     const ip = IP.fromHostname(host, this.network.port);
  781.     if (ip.type === IP.types.DNS) {
  782.       // Defer for resolution.
  783.       this.dnsSeeds.push(ip);
  784.       return null;
  785.     }
  787.     const addr = NetAddress.fromHost(ip.host, ip.port, this.network);
  789.     this.add(addr);
  791.     return addr;
  792.   }
  794.   /**
  795.    * Add a priority node.
  796.    * @param {String} host
  797.    * @returns {NetAddress}
  798.    */
  800.   addNode(host) {
  801.     const ip = IP.fromHostname(host, this.network.port);
  803.     if (ip.type === IP.types.DNS) {
  804.       // Defer for resolution.
  805.       this.dnsNodes.push(ip);
  806.       return null;
  807.     }
  809.     const addr = NetAddress.fromHost(ip.host, ip.port, this.network);
  811.     this.nodes.push(addr);
  812.     this.add(addr);
  814.     return addr;
  815.   }
  817.   /**
  818.    * Remove a priority node.
  819.    * @param {String} host
  820.    * @returns {Boolean}
  821.    */
  823.   removeNode(host) {
  824.     const addr = IP.fromHostname(host, this.network.port);
  826.     for (let i = 0; i < this.nodes.length; i++) {
  827.       const node = this.nodes[i];
  829.       if (node.host !== addr.host)
  830.         continue;
  832.       if (node.port !== addr.port)
  833.         continue;
  835.       this.nodes.splice(i, 1);
  837.       return true;
  838.     }
  840.     return false;
  841.   }
  843.   /**
  844.    * Set initial seeds.
  845.    * @param {String[]} seeds
  846.    */
  848.   setSeeds(seeds) {
  849.     this.dnsSeeds.length = 0;
  851.     for (const host of seeds)
  852.       this.addSeed(host);
  853.   }
  855.   /**
  856.    * Set priority nodes.
  857.    * @param {String[]} nodes
  858.    */
  860.   setNodes(nodes) {
  861.     this.dnsNodes.length = 0;
  862.     this.nodes.length = 0;
  864.     for (const host of nodes)
  865.       this.addNode(host);
  866.   }
  868.   /**
  869.    * Add a local address.
  870.    * @param {String} host
  871.    * @param {Number} port
  872.    * @param {Number} score
  873.    * @returns {Boolean}
  874.    */
  876.   addLocal(host, port, score) {
  877.     const addr = NetAddress.fromHost(host, port, this.network);
  878.     addr.services = this.options.services;
  879.     return this.pushLocal(addr, score);
  880.   }
  882.   /**
  883.    * Add a local address.
  884.    * @param {NetAddress} addr
  885.    * @param {Number} score
  886.    * @returns {Boolean}
  887.    */
  889.   pushLocal(addr, score) {
  890.     if (!addr.isRoutable())
  891.       return false;
  893.     if (this.local.has(addr.hostname))
  894.       return false;
  896.     const local = new LocalAddress(addr, score);
  898.     this.local.set(addr.hostname, local);
  900.     return true;
  901.   }
  903.   /**
  904.    * Get local address based on reachability.
  905.    * @param {NetAddress?} src
  906.    * @returns {NetAddress}
  907.    */
  909.   getLocal(src) {
  910.     let bestReach = -1;
  911.     let bestScore = -1;
  912.     let bestDest = null;
  914.     if (!src)
  915.       src = this.address;
  917.     if (this.local.size === 0)
  918.       return null;
  920.     for (const dest of this.local.values()) {
  921.       const reach = src.getReachability(dest.addr);
  923.       if (reach < bestReach)
  924.         continue;
  926.       if (reach > bestReach || dest.score > bestScore) {
  927.         bestReach = reach;
  928.         bestScore = dest.score;
  929.         bestDest = dest.addr;
  930.       }
  931.     }
  933.     bestDest.time = this.network.now();
  935.     return bestDest;
  936.   }
  938.   /**
  939.    * Mark local address as seen during a handshake.
  940.    * @param {NetAddress} addr
  941.    * @returns {Boolean}
  942.    */
  944.   markLocal(addr) {
  945.     const local = this.local.get(addr.hostname);
  947.     if (!local)
  948.       return false;
  950.     local.score += 1;
  952.     return true;
  953.   }
  955.   /**
  956.    * Discover hosts from seeds.
  957.    * @method
  958.    * @returns {Promise}
  959.    */
  961.   async discoverSeeds() {
  962.     const jobs = [];
  964.     for (const seed of this.dnsSeeds)
  965.       jobs.push(this.populateSeed(seed));
  967.     return Promise.all(jobs);
  968.   }
  970.   /**
  971.    * Discover hosts from nodes.
  972.    * @method
  973.    * @returns {Promise}
  974.    */
  976.   async discoverNodes() {
  977.     const jobs = [];
  979.     for (const node of this.dnsNodes)
  980.       jobs.push(this.populateNode(node));
  982.     return Promise.all(jobs);
  983.   }
  985.   /**
  986.    * Lookup node's domain.
  987.    * @method
  988.    * @param {Object} addr
  989.    * @returns {Promise}
  990.    */
  992.   async populateNode(addr) {
  993.     const addrs = await this.populate(addr);
  995.     if (addrs.length === 0)
  996.       return;
  998.     this.nodes.push(addrs[0]);
  999.     this.add(addrs[0]);
  1000.   }
  1002.   /**
  1003.    * Populate from seed.
  1004.    * @method
  1005.    * @param {Object} seed
  1006.    * @returns {Promise}
  1007.    */
  1009.   async populateSeed(seed) {
  1010.     const addrs = await this.populate(seed);
  1012.     for (const addr of addrs)
  1013.       this.add(addr);
  1014.   }
  1016.   /**
  1017.    * Lookup hosts from dns host.
  1018.    * @method
  1019.    * @param {Object} target
  1020.    * @returns {Promise}
  1021.    */
  1023.   async populate(target) {
  1024.     const addrs = [];
  1026.     assert(target.type === IP.types.DNS, 'Resolved host passed.');
  1028.     this.logger.info('Resolving host: %s.', target.host);
  1030.     let hosts;
  1031.     try {
  1032.       hosts = await this.resolve(target.host);
  1033.     } catch (e) {
  1034.       this.logger.error(e);
  1035.       return addrs;
  1036.     }
  1038.     for (const host of hosts) {
  1039.       const addr = NetAddress.fromHost(host, target.port, this.network);
  1040.       addrs.push(addr);
  1041.     }
  1043.     return addrs;
  1044.   }
  1046.   /**
  1047.    * Convert host list to json-friendly object.
  1048.    * @returns {Object}
  1049.    */
  1051.   toJSON() {
  1052.     const addrs = [];
  1053.     const fresh = [];
  1054.     const used = [];
  1056.     for (const entry of this.map.values())
  1057.       addrs.push(entry.toJSON());
  1059.     for (const bucket of this.fresh) {
  1060.       const keys = [];
  1061.       for (const key of bucket.keys())
  1062.         keys.push(key);
  1063.       fresh.push(keys);
  1064.     }
  1066.     for (const bucket of this.used) {
  1067.       const keys = [];
  1068.       for (let entry = bucket.head; entry; entry = entry.next)
  1069.         keys.push(entry.key());
  1070.       used.push(keys);
  1071.     }
  1073.     return {
  1074.       version: HostList.VERSION,
  1075.       network: this.network.type,
  1076.       addrs: addrs,
  1077.       fresh: fresh,
  1078.       used: used
  1079.     };
  1080.   }
  1082.   /**
  1083.    * Inject properties from json object.
  1084.    * @private
  1085.    * @param {Object} json
  1086.    * @returns {HostList}
  1087.    */
  1089.   fromJSON(json) {
  1090.     const sources = new Map();
  1091.     const map = new Map();
  1092.     const fresh = [];
  1093.     const used = [];
  1095.     let totalFresh = 0;
  1096.     let totalUsed = 0;
  1098.     assert(json && typeof json === 'object');
  1100.     assert(!json.network || json.network === this.network.type,
  1101.       'Network mistmatch.');
  1103.     assert(json.version === HostList.VERSION,
  1104.       'Bad address serialization version.');
  1106.     assert(Array.isArray(json.addrs));
  1108.     for (const addr of json.addrs) {
  1109.       const entry = HostEntry.fromJSON(addr, this.network);
  1111.       let src = sources.get(entry.src.hostname);
  1113.       // Save some memory.
  1114.       if (!src) {
  1115.         src = entry.src;
  1116.         sources.set(src.hostname, src);
  1117.       }
  1119.       entry.src = src;
  1121.       map.set(entry.key(), entry);
  1122.     }
  1124.     assert(Array.isArray(json.fresh));
  1125.     assert(json.fresh.length <= this.options.maxBuckets,
  1126.       'Buckets mismatch.');
  1128.     for (const keys of json.fresh) {
  1129.       const bucket = new Map();
  1131.       for (const key of keys) {
  1132.         const entry = map.get(key);
  1133.         assert(entry);
  1134.         if (entry.refCount === 0)
  1135.           totalFresh += 1;
  1136.         entry.refCount += 1;
  1137.         bucket.set(key, entry);
  1138.       }
  1140.       assert(bucket.size <= this.options.maxEntries,
  1141.         'Bucket size mismatch.');
  1143.       fresh.push(bucket);
  1144.     }
  1146.     assert(fresh.length === this.fresh.length,
  1147.       'Buckets mismatch.');
  1149.     assert(Array.isArray(json.used));
  1150.     assert(json.used.length <= this.options.maxBuckets,
  1151.       'Buckets mismatch.');
  1153.     for (const keys of json.used) {
  1154.       const bucket = new List();
  1156.       for (const key of keys) {
  1157.         const entry = map.get(key);
  1158.         assert(entry);
  1159.         assert(entry.refCount === 0);
  1160.         assert(!entry.used);
  1161.         entry.used = true;
  1162.         totalUsed += 1;
  1163.         bucket.push(entry);
  1164.       }
  1166.       assert(bucket.size <= this.options.maxEntries,
  1167.         'Bucket size mismatch.');
  1169.       used.push(bucket);
  1170.     }
  1172.     assert(used.length === this.used.length,
  1173.       'Buckets mismatch.');
  1175.     for (const entry of map.values())
  1176.       assert(entry.used || entry.refCount > 0);
  1178.     this.map = map;
  1179.     this.fresh = fresh;
  1180.     this.totalFresh = totalFresh;
  1181.     this.used = used;
  1182.     this.totalUsed = totalUsed;
  1184.     return this;
  1185.   }
  1187.   /**
  1188.    * Instantiate host list from json object.
  1189.    * @param {Object} options
  1190.    * @param {Object} json
  1191.    * @returns {HostList}
  1192.    */
  1194.   static fromJSON(options, json) {
  1195.     return new this(options).fromJSON(json);
  1196.   }
  1197. }
  1199. /**
  1200.  * Number of days before considering
  1201.  * an address stale.
  1202.  * @const {Number}
  1203.  * @default
  1204.  */
  1206. HostList.HORIZON_DAYS = 30;
  1208. /**
  1209.  * Number of retries (without success)
  1210.  * before considering an address stale.
  1211.  * @const {Number}
  1212.  * @default
  1213.  */
  1215. HostList.RETRIES = 3;
  1217. /**
  1218.  * Number of days after reaching
  1219.  * MAX_FAILURES to consider an
  1220.  * address stale.
  1221.  * @const {Number}
  1222.  * @default
  1223.  */
  1225. HostList.MIN_FAIL_DAYS = 7;
  1227. /**
  1228.  * Maximum number of failures
  1229.  * allowed before considering
  1230.  * an address stale.
  1231.  * @const {Number}
  1232.  * @default
  1233.  */
  1235. HostList.MAX_FAILURES = 10;
  1237. /**
  1238.  * Maximum number of references
  1239.  * in fresh buckets.
  1240.  * @const {Number}
  1241.  * @default
  1242.  */
  1244. HostList.MAX_REFS = 8;
  1246. /**
  1247.  * Serialization version.
  1248.  * @const {Number}
  1249.  * @default
  1250.  */
  1252. HostList.VERSION = 0;
  1254. /**
  1255.  * Local address scores.
  1256.  * @enum {Number}
  1257.  * @default
  1258.  */
  1260. HostList.scores = {
  1261.   NONE: 0,
  1262.   IF: 1,
  1263.   BIND: 2,
  1264.   UPNP: 3,
  1265.   DNS: 3,
  1266.   MANUAL: 4,
  1267.   MAX: 5
  1268. };
  1270. /**
  1271.  * Host Entry
  1272.  * @alias module:net.HostEntry
  1273.  */
  1275. class HostEntry {
  1276.   /**
  1277.    * Create a host entry.
  1278.    * @constructor
  1279.    * @param {NetAddress} addr
  1280.    * @param {NetAddress} src
  1281.    */
  1283.   constructor(addr, src) {
  1284.     this.addr = addr || new NetAddress();
  1285.     this.src = src || new NetAddress();
  1286.     this.prev = null;
  1287.     this.next = null;
  1288.     this.used = false;
  1289.     this.refCount = 0;
  1290.     this.attempts = 0;
  1291.     this.lastSuccess = 0;
  1292.     this.lastAttempt = 0;
  1294.     if (addr)
  1295.       this.fromOptions(addr, src);
  1296.   }
  1298.   /**
  1299.    * Inject properties from options.
  1300.    * @private
  1301.    * @param {NetAddress} addr
  1302.    * @param {NetAddress} src
  1303.    * @returns {HostEntry}
  1304.    */
  1306.   fromOptions(addr, src) {
  1307.     assert(addr instanceof NetAddress);
  1308.     assert(src instanceof NetAddress);
  1309.     this.addr = addr;
  1310.     this.src = src;
  1311.     return this;
  1312.   }
  1314.   /**
  1315.    * Instantiate host entry from options.
  1316.    * @param {NetAddress} addr
  1317.    * @param {NetAddress} src
  1318.    * @returns {HostEntry}
  1319.    */
  1321.   static fromOptions(addr, src) {
  1322.     return new this().fromOptions(addr, src);
  1323.   }
  1325.   /**
  1326.    * Get key suitable for a hash table (hostname).
  1327.    * @returns {String}
  1328.    */
  1330.   key() {
  1331.     return this.addr.hostname;
  1332.   }
  1334.   /**
  1335.    * Get host priority.
  1336.    * @param {Number} now
  1337.    * @returns {Number}
  1338.    */
  1340.   chance(now) {
  1341.     let c = 1;
  1343.     if (now - this.lastAttempt < 60 * 10)
  1344.       c *= 0.01;
  1346.     c *= Math.pow(0.66, Math.min(this.attempts, 8));
  1348.     return c;
  1349.   }
  1351.   /**
  1352.    * Inspect host address.
  1353.    * @returns {Object}
  1354.    */
  1356.   [inspectSymbol]() {
  1357.     return {
  1358.       addr: this.addr,
  1359.       src: this.src,
  1360.       used: this.used,
  1361.       refCount: this.refCount,
  1362.       attempts: this.attempts,
  1363.       lastSuccess: util.date(this.lastSuccess),
  1364.       lastAttempt: util.date(this.lastAttempt)
  1365.     };
  1366.   }
  1368.   /**
  1369.    * Convert host entry to json-friendly object.
  1370.    * @returns {Object}
  1371.    */
  1373.   toJSON() {
  1374.     return {
  1375.       addr: this.addr.hostname,
  1376.       src: this.src.hostname,
  1377.       services: this.addr.services.toString(2),
  1378.       time: this.addr.time,
  1379.       attempts: this.attempts,
  1380.       lastSuccess: this.lastSuccess,
  1381.       lastAttempt: this.lastAttempt
  1382.     };
  1383.   }
  1385.   /**
  1386.    * Inject properties from json object.
  1387.    * @private
  1388.    * @param {Object} json
  1389.    * @param {Network} network
  1390.    * @returns {HostEntry}
  1391.    */
  1393.   fromJSON(json, network) {
  1394.     assert(json && typeof json === 'object');
  1395.     assert(typeof json.addr === 'string');
  1396.     assert(typeof json.src === 'string');
  1398.     this.addr.fromHostname(json.addr, network);
  1400.     if (json.services != null) {
  1401.       assert(typeof json.services === 'string');
  1402.       assert(json.services.length > 0);
  1403.       assert(json.services.length <= 32);
  1404.       const services = parseInt(json.services, 2);
  1405.       assert((services >>> 0) === services);
  1406.       this.addr.services = services;
  1407.     }
  1409.     if (json.time != null) {
  1410.       assert(Number.isSafeInteger(json.time));
  1411.       assert(json.time >= 0);
  1412.       this.addr.time = json.time;
  1413.     }
  1415.     if (json.src != null) {
  1416.       assert(typeof json.src === 'string');
  1417.       this.src.fromHostname(json.src, network);
  1418.     }
  1420.     if (json.attempts != null) {
  1421.       assert((json.attempts >>> 0) === json.attempts);
  1422.       this.attempts = json.attempts;
  1423.     }
  1425.     if (json.lastSuccess != null) {
  1426.       assert(Number.isSafeInteger(json.lastSuccess));
  1427.       assert(json.lastSuccess >= 0);
  1428.       this.lastSuccess = json.lastSuccess;
  1429.     }
  1431.     if (json.lastAttempt != null) {
  1432.       assert(Number.isSafeInteger(json.lastAttempt));
  1433.       assert(json.lastAttempt >= 0);
  1434.       this.lastAttempt = json.lastAttempt;
  1435.     }
  1437.     return this;
  1438.   }
  1440.   /**
  1441.    * Instantiate host entry from json object.
  1442.    * @param {Object} json
  1443.    * @param {Network} network
  1444.    * @returns {HostEntry}
  1445.    */
  1447.   static fromJSON(json, network) {
  1448.     return new this().fromJSON(json, network);
  1449.   }
  1450. }
  1452. /**
  1453.  * Local Address
  1454.  * @alias module:net.LocalAddress
  1455.  */
  1457. class LocalAddress {
  1458.   /**
  1459.    * Create a local address.
  1460.    * @constructor
  1461.    * @param {NetAddress} addr
  1462.    * @param {Number?} score
  1463.    */
  1465.   constructor(addr, score) {
  1466.     this.addr = addr;
  1467.     this.score = score || 0;
  1468.   }
  1469. }
  1471. /**
  1472.  * Host List Options
  1473.  * @alias module:net.HostListOptions
  1474.  */
  1476. class HostListOptions {
  1477.   /**
  1478.    * Create host list options.
  1479.    * @constructor
  1480.    * @param {Object?} options
  1481.    */
  1483.   constructor(options) {
  1484.     this.network = Network.primary;
  1485.     this.logger = Logger.global;
  1486.     this.resolve = dns.lookup;
  1487.     this.host = '0.0.0.0';
  1488.     this.port = this.network.port;
  1489.     this.services = common.LOCAL_SERVICES;
  1490.     this.onion = false;
  1491.     this.banTime = common.BAN_TIME;
  1493.     this.address = new NetAddress();
  1494.     this.address.services = this.services;
  1495.     this.address.time = this.network.now();
  1497.     this.seeds = this.network.seeds;
  1498.     this.nodes = [];
  1500.     this.maxBuckets = 20;
  1501.     this.maxEntries = 50;
  1503.     this.prefix = null;
  1504.     this.filename = null;
  1505.     this.memory = true;
  1506.     this.flushInterval = 120000;
  1508.     if (options)
  1509.       this.fromOptions(options);
  1510.   }
  1512.   /**
  1513.    * Inject properties from options.
  1514.    * @private
  1515.    * @param {Object} options
  1516.    */
  1518.   fromOptions(options) {
  1519.     assert(options, 'Options are required.');
  1521.     if (options.network != null) {
  1522.       this.network = Network.get(options.network);
  1523.       this.seeds = this.network.seeds;
  1524.       this.address.port = this.network.port;
  1525.       this.port = this.network.port;
  1526.     }
  1528.     if (options.logger != null) {
  1529.       assert(typeof options.logger === 'object');
  1530.       this.logger = options.logger;
  1531.     }
  1533.     if (options.resolve != null) {
  1534.       assert(typeof options.resolve === 'function');
  1535.       this.resolve = options.resolve;
  1536.     }
  1538.     if (options.banTime != null) {
  1539.       assert(options.banTime >= 0);
  1540.       this.banTime = options.banTime;
  1541.     }
  1543.     if (options.seeds) {
  1544.       assert(Array.isArray(options.seeds));
  1545.       this.seeds = options.seeds;
  1546.     }
  1548.     if (options.nodes) {
  1549.       assert(Array.isArray(options.nodes));
  1550.       this.nodes = options.nodes;
  1551.     }
  1553.     if (options.host != null) {
  1554.       assert(typeof options.host === 'string');
  1555.       const raw = IP.toBuffer(options.host);
  1556.       this.host = IP.toString(raw);
  1557.       if (IP.isRoutable(raw))
  1558.         this.address.setHost(this.host);
  1559.     }
  1561.     if (options.port != null) {
  1562.       assert(typeof options.port === 'number');
  1563.       assert(options.port > 0 && options.port <= 0xffff);
  1564.       this.port = options.port;
  1565.       this.address.setPort(this.port);
  1566.     }
  1568.     if (options.publicHost != null) {
  1569.       assert(typeof options.publicHost === 'string');
  1570.       this.address.setHost(options.publicHost);
  1571.     }
  1573.     if (options.publicPort != null) {
  1574.       assert(typeof options.publicPort === 'number');
  1575.       assert(options.publicPort > 0 && options.publicPort <= 0xffff);
  1576.       this.address.setPort(options.publicPort);
  1577.     }
  1579.     if (options.services != null) {
  1580.       assert(typeof options.services === 'number');
  1581.       this.services = options.services;
  1582.     }
  1584.     if (options.onion != null) {
  1585.       assert(typeof options.onion === 'boolean');
  1586.       this.onion = options.onion;
  1587.     }
  1589.     if (options.maxBuckets != null) {
  1590.       assert(typeof options.maxBuckets === 'number');
  1591.       this.maxBuckets = options.maxBuckets;
  1592.     }
  1594.     if (options.maxEntries != null) {
  1595.       assert(typeof options.maxEntries === 'number');
  1596.       this.maxEntries = options.maxEntries;
  1597.     }
  1599.     if (options.memory != null) {
  1600.       assert(typeof options.memory === 'boolean');
  1601.       this.memory = options.memory;
  1602.     }
  1604.     if (options.prefix != null) {
  1605.       assert(typeof options.prefix === 'string');
  1606.       this.prefix = options.prefix;
  1607.       this.filename = path.join(this.prefix, 'hosts.json');
  1608.     }
  1610.     if (options.filename != null) {
  1611.       assert(typeof options.filename === 'string');
  1612.       this.filename = options.filename;
  1613.     }
  1615.     if (options.flushInterval != null) {
  1616.       assert(options.flushInterval >= 0);
  1617.       this.flushInterval = options.flushInterval;
  1618.     }
  1620.     this.address.time = this.network.now();
  1621.     this.address.services = this.services;
  1623.     return this;
  1624.   }
  1625. }
  1627. /*
  1628.  * Helpers
  1629.  */
  1631. function concat32(left, right) {
  1632.   const data = POOL32;
  1633.   left.copy(data, 0);
  1634.   right.copy(data, 32);
  1635.   return data;
  1636. }
  1638. function random(max) {
  1639.   return randomRange(0, max);
  1640. }
  1642. /*
  1643.  * Expose
  1644.  */
  1646. module.exports = HostList;