Upload Kmake

lib/internal/dns/callback_resolver.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const {
+  ArrayPrototypeMap,
+  ObjectDefineProperty,
+  ReflectApply,
+  Symbol,
+} = primordials;
+
+const {
+  DNSException,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+  },
+} = require('internal/errors');
+
+const {
+  createResolverClass,
+} = require('internal/dns/utils');
+
+const {
+  validateFunction,
+  validateString,
+} = require('internal/validators');
+
+const {
+  QueryReqWrap,
+} = internalBinding('cares_wrap');
+
+const {
+  hasObserver,
+  startPerf,
+  stopPerf,
+} = require('internal/perf/observe');
+
+const kPerfHooksDnsLookupResolveContext = Symbol('kPerfHooksDnsLookupResolveContext');
+
+function onresolve(err, result, ttls) {
+  if (ttls && this.ttl)
+    result = ArrayPrototypeMap(
+      result, (address, index) => ({ address, ttl: ttls[index] }));
+
+  if (err)
+    this.callback(new DNSException(err, this.bindingName, this.hostname));
+  else {
+    this.callback(null, result);
+    if (this[kPerfHooksDnsLookupResolveContext] && hasObserver('dns')) {
+      stopPerf(this, kPerfHooksDnsLookupResolveContext, { detail: { result } });
+    }
+  }
+}
+
+function resolver(bindingName) {
+  function query(name, /* options, */ callback) {
+    let options;
+    if (arguments.length > 2) {
+      options = callback;
+      callback = arguments[2];
+    }
+
+    validateString(name, 'name');
+    validateFunction(callback, 'callback');
+
+    const req = new QueryReqWrap();
+    req.bindingName = bindingName;
+    req.callback = callback;
+    req.hostname = name;
+    req.oncomplete = onresolve;
+    req.ttl = !!(options?.ttl);
+    const err = this._handle[bindingName](req, name);
+    if (err) throw new DNSException(err, bindingName, name);
+    if (hasObserver('dns')) {
+      startPerf(req, kPerfHooksDnsLookupResolveContext, {
+        type: 'dns',
+        name: bindingName,
+        detail: {
+          host: name,
+          ttl: req.ttl,
+        },
+      });
+    }
+    return req;
+  }
+  ObjectDefineProperty(query, 'name', { __proto__: null, value: bindingName });
+  return query;
+}
+
+// This is the callback-based resolver. There is another similar
+// resolver in dns/promises.js with resolve methods that are based
+// on promises instead.
+const { Resolver, resolveMap } = createResolverClass(resolver);
+Resolver.prototype.resolve = resolve;
+
+function resolve(hostname, rrtype, callback) {
+  let resolver;
+  if (typeof rrtype === 'string') {
+    resolver = resolveMap[rrtype];
+  } else if (typeof rrtype === 'function') {
+    resolver = resolveMap.A;
+    callback = rrtype;
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('rrtype', 'string', rrtype);
+  }
+
+  if (typeof resolver === 'function') {
+    return ReflectApply(resolver, this, [hostname, callback]);
+  }
+  throw new ERR_INVALID_ARG_VALUE('rrtype', rrtype);
+}
+
+module.exports = {
+  Resolver,
+};

lib/internal/dns/promises.js

@@ -0,0 +1,411 @@
+'use strict';
+const {
+  ArrayPrototypeMap,
+  ObjectDefineProperty,
+  Promise,
+  ReflectApply,
+  Symbol,
+} = primordials;
+
+const {
+  bindDefaultResolver,
+  createResolverClass,
+  validateHints,
+  emitInvalidHostnameWarning,
+  errorCodes: dnsErrorCodes,
+  getDefaultResultOrder,
+  setDefaultResultOrder,
+  setDefaultResolver,
+  validDnsOrders,
+  validFamilies,
+} = require('internal/dns/utils');
+
+const {
+  NODATA,
+  FORMERR,
+  SERVFAIL,
+  NOTFOUND,
+  NOTIMP,
+  REFUSED,
+  BADQUERY,
+  BADNAME,
+  BADFAMILY,
+  BADRESP,
+  CONNREFUSED,
+  TIMEOUT,
+  EOF,
+  FILE,
+  NOMEM,
+  DESTRUCTION,
+  BADSTR,
+  BADFLAGS,
+  NONAME,
+  BADHINTS,
+  NOTINITIALIZED,
+  LOADIPHLPAPI,
+  ADDRGETNETWORKPARAMS,
+  CANCELLED,
+} = dnsErrorCodes;
+const {
+  DNSException,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+    ERR_MISSING_ARGS,
+  },
+} = require('internal/errors');
+const { isIP } = require('internal/net');
+const {
+  getaddrinfo,
+  getnameinfo,
+  GetAddrInfoReqWrap,
+  GetNameInfoReqWrap,
+  QueryReqWrap,
+  DNS_ORDER_VERBATIM,
+  DNS_ORDER_IPV4_FIRST,
+  DNS_ORDER_IPV6_FIRST,
+} = internalBinding('cares_wrap');
+const {
+  validateBoolean,
+  validateNumber,
+  validateOneOf,
+  validatePort,
+  validateString,
+} = require('internal/validators');
+
+const kPerfHooksDnsLookupContext = Symbol('kPerfHooksDnsLookupContext');
+const kPerfHooksDnsLookupServiceContext = Symbol('kPerfHooksDnsLookupServiceContext');
+const kPerfHooksDnsLookupResolveContext = Symbol('kPerfHooksDnsLookupResolveContext');
+
+const {
+  hasObserver,
+  startPerf,
+  stopPerf,
+} = require('internal/perf/observe');
+
+function onlookup(err, addresses) {
+  if (err) {
+    this.reject(new DNSException(err, 'getaddrinfo', this.hostname));
+    return;
+  }
+
+  const family = this.family || isIP(addresses[0]);
+  this.resolve({ address: addresses[0], family });
+  if (this[kPerfHooksDnsLookupContext] && hasObserver('dns')) {
+    stopPerf(this, kPerfHooksDnsLookupContext, { detail: { addresses } });
+  }
+}
+
+function onlookupall(err, addresses) {
+  if (err) {
+    this.reject(new DNSException(err, 'getaddrinfo', this.hostname));
+    return;
+  }
+
+  const family = this.family;
+
+  for (let i = 0; i < addresses.length; i++) {
+    const address = addresses[i];
+
+    addresses[i] = {
+      address,
+      family: family || isIP(addresses[i]),
+    };
+  }
+
+  this.resolve(addresses);
+  if (this[kPerfHooksDnsLookupContext] && hasObserver('dns')) {
+    stopPerf(this, kPerfHooksDnsLookupContext, { detail: { addresses } });
+  }
+}
+
+/**
+ * Creates a promise that resolves with the IP address of the given hostname.
+ * @param {0 | 4 | 6} family - The IP address family (4 or 6, or 0 for both).
+ * @param {string} hostname - The hostname to resolve.
+ * @param {boolean} all - Whether to resolve with all IP addresses for the hostname.
+ * @param {number} hints - One or more supported getaddrinfo flags (supply multiple via
+ * bitwise OR).
+ * @param {number} dnsOrder - How to sort results. Must be `ipv4first`, `ipv6first` or `verbatim`.
+ * @returns {Promise<DNSLookupResult | DNSLookupResult[]>} The IP address(es) of the hostname.
+ * @typedef {object} DNSLookupResult
+ * @property {string} address - The IP address.
+ * @property {0 | 4 | 6} family - The IP address type. 4 for IPv4 or 6 for IPv6, or 0 (for both).
+ */
+function createLookupPromise(family, hostname, all, hints, dnsOrder) {
+  return new Promise((resolve, reject) => {
+    if (!hostname) {
+      emitInvalidHostnameWarning(hostname);
+      resolve(all ? [] : { address: null, family: family === 6 ? 6 : 4 });
+      return;
+    }
+
+    const matchedFamily = isIP(hostname);
+
+    if (matchedFamily !== 0) {
+      const result = { address: hostname, family: matchedFamily };
+      resolve(all ? [result] : result);
+      return;
+    }
+
+    const req = new GetAddrInfoReqWrap();
+
+    req.family = family;
+    req.hostname = hostname;
+    req.oncomplete = all ? onlookupall : onlookup;
+    req.resolve = resolve;
+    req.reject = reject;
+
+    let order = DNS_ORDER_VERBATIM;
+
+    if (dnsOrder === 'ipv4first') {
+      order = DNS_ORDER_IPV4_FIRST;
+    } else if (dnsOrder === 'ipv6first') {
+      order = DNS_ORDER_IPV6_FIRST;
+    }
+
+    const err = getaddrinfo(req, hostname, family, hints, order);
+
+    if (err) {
+      reject(new DNSException(err, 'getaddrinfo', hostname));
+    } else if (hasObserver('dns')) {
+      const detail = {
+        hostname,
+        family,
+        hints,
+        verbatim: order === DNS_ORDER_VERBATIM,
+        order: dnsOrder,
+      };
+      startPerf(req, kPerfHooksDnsLookupContext, { type: 'dns', name: 'lookup', detail });
+    }
+  });
+}
+
+/**
+ * Get the IP address for a given hostname.
+ * @param {string} hostname - The hostname to resolve (ex. 'nodejs.org').
+ * @param {object} [options] - Optional settings.
+ * @param {boolean} [options.all=false] - Whether to return all or just the first resolved address.
+ * @param {0 | 4 | 6} [options.family=0] - The record family. Must be 4, 6, or 0 (for both).
+ * @param {number} [options.hints] - One or more supported getaddrinfo flags (supply multiple via
+ * bitwise OR).
+ * @param {string} [options.order='verbatim'] - Return results in same order DNS resolved them;
+ * Must be `ipv4first`, `ipv6first` or `verbatim`.
+ * New code should supply `verbatim`.
+ */
+function lookup(hostname, options) {
+  let hints = 0;
+  let family = 0;
+  let all = false;
+  let dnsOrder = getDefaultResultOrder();
+
+  // Parse arguments
+  if (hostname) {
+    validateString(hostname, 'hostname');
+  }
+
+  if (typeof options === 'number') {
+    validateOneOf(options, 'family', validFamilies);
+    family = options;
+  } else if (options !== undefined && typeof options !== 'object') {
+    throw new ERR_INVALID_ARG_TYPE('options', ['integer', 'object'], options);
+  } else {
+    if (options?.hints != null) {
+      validateNumber(options.hints, 'options.hints');
+      hints = options.hints >>> 0;
+      validateHints(hints);
+    }
+    if (options?.family != null) {
+      validateOneOf(options.family, 'options.family', validFamilies);
+      family = options.family;
+    }
+    if (options?.all != null) {
+      validateBoolean(options.all, 'options.all');
+      all = options.all;
+    }
+    if (options?.verbatim != null) {
+      validateBoolean(options.verbatim, 'options.verbatim');
+      dnsOrder = options.verbatim ? 'verbatim' : 'ipv4first';
+    }
+    if (options?.order != null) {
+      validateOneOf(options.order, 'options.order', validDnsOrders);
+      dnsOrder = options.order;
+    }
+  }
+
+  return createLookupPromise(family, hostname, all, hints, dnsOrder);
+}
+
+
+function onlookupservice(err, hostname, service) {
+  if (err) {
+    this.reject(new DNSException(err, 'getnameinfo', this.host));
+    return;
+  }
+
+  this.resolve({ hostname, service });
+  if (this[kPerfHooksDnsLookupServiceContext] && hasObserver('dns')) {
+    stopPerf(this, kPerfHooksDnsLookupServiceContext, { detail: { hostname, service } });
+  }
+}
+
+function createLookupServicePromise(hostname, port) {
+  return new Promise((resolve, reject) => {
+    const req = new GetNameInfoReqWrap();
+
+    req.hostname = hostname;
+    req.port = port;
+    req.oncomplete = onlookupservice;
+    req.resolve = resolve;
+    req.reject = reject;
+
+    const err = getnameinfo(req, hostname, port);
+
+    if (err)
+      reject(new DNSException(err, 'getnameinfo', hostname));
+    else if (hasObserver('dns')) {
+      startPerf(req, kPerfHooksDnsLookupServiceContext, {
+        type: 'dns',
+        name: 'lookupService',
+        detail: {
+          host: hostname,
+          port,
+        },
+      });
+    }
+  });
+}
+
+function lookupService(address, port) {
+  if (arguments.length !== 2)
+    throw new ERR_MISSING_ARGS('address', 'port');
+
+  if (isIP(address) === 0)
+    throw new ERR_INVALID_ARG_VALUE('address', address);
+
+  validatePort(port);
+
+  return createLookupServicePromise(address, +port);
+}
+
+
+function onresolve(err, result, ttls) {
+  if (err) {
+    this.reject(new DNSException(err, this.bindingName, this.hostname));
+    return;
+  }
+
+  if (ttls && this.ttl)
+    result = ArrayPrototypeMap(
+      result, (address, index) => ({ address, ttl: ttls[index] }));
+
+  this.resolve(result);
+  if (this[kPerfHooksDnsLookupResolveContext] && hasObserver('dns')) {
+    stopPerf(this, kPerfHooksDnsLookupResolveContext, { detail: { result } });
+  }
+}
+
+function createResolverPromise(resolver, bindingName, hostname, ttl) {
+  return new Promise((resolve, reject) => {
+    const req = new QueryReqWrap();
+
+    req.bindingName = bindingName;
+    req.hostname = hostname;
+    req.oncomplete = onresolve;
+    req.resolve = resolve;
+    req.reject = reject;
+    req.ttl = ttl;
+
+    const err = resolver._handle[bindingName](req, hostname);
+
+    if (err)
+      reject(new DNSException(err, bindingName, hostname));
+    else if (hasObserver('dns')) {
+      startPerf(req, kPerfHooksDnsLookupResolveContext, {
+        type: 'dns',
+        name: bindingName,
+        detail: {
+          host: hostname,
+          ttl,
+        },
+      });
+    }
+  });
+}
+
+function resolver(bindingName) {
+  function query(name, options) {
+    validateString(name, 'name');
+
+    const ttl = !!(options?.ttl);
+    return createResolverPromise(this, bindingName, name, ttl);
+  }
+
+  ObjectDefineProperty(query, 'name', { __proto__: null, value: bindingName });
+  return query;
+}
+
+function resolve(hostname, rrtype) {
+  let resolver;
+
+  if (rrtype !== undefined) {
+    validateString(rrtype, 'rrtype');
+
+    resolver = resolveMap[rrtype];
+
+    if (typeof resolver !== 'function')
+      throw new ERR_INVALID_ARG_VALUE('rrtype', rrtype);
+  } else {
+    resolver = resolveMap.A;
+  }
+
+  return ReflectApply(resolver, this, [hostname]);
+}
+
+// Promise-based resolver.
+const { Resolver, resolveMap } = createResolverClass(resolver);
+Resolver.prototype.resolve = resolve;
+
+function defaultResolverSetServers(servers) {
+  const resolver = new Resolver();
+
+  resolver.setServers(servers);
+  setDefaultResolver(resolver);
+  bindDefaultResolver(module.exports, Resolver.prototype);
+}
+
+module.exports = {
+  lookup,
+  lookupService,
+  Resolver,
+  getDefaultResultOrder,
+  setDefaultResultOrder,
+  setServers: defaultResolverSetServers,
+
+  // ERROR CODES
+  NODATA,
+  FORMERR,
+  SERVFAIL,
+  NOTFOUND,
+  NOTIMP,
+  REFUSED,
+  BADQUERY,
+  BADNAME,
+  BADFAMILY,
+  BADRESP,
+  CONNREFUSED,
+  TIMEOUT,
+  EOF,
+  FILE,
+  NOMEM,
+  DESTRUCTION,
+  BADSTR,
+  BADFLAGS,
+  NONAME,
+  BADHINTS,
+  NOTINITIALIZED,
+  LOADIPHLPAPI,
+  ADDRGETNETWORKPARAMS,
+  CANCELLED,
+};
+bindDefaultResolver(module.exports, Resolver.prototype);

lib/internal/dns/utils.js

@@ -0,0 +1,363 @@
+'use strict';
+
+const {
+  ArrayPrototypeForEach,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  FunctionPrototypeBind,
+  NumberParseInt,
+  RegExpPrototypeExec,
+  RegExpPrototypeSymbolReplace,
+  Symbol,
+} = primordials;
+
+const {
+  codes: {
+    ERR_DNS_SET_SERVERS_FAILED,
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_IP_ADDRESS,
+  },
+} = require('internal/errors');
+const { isIP } = require('internal/net');
+const { getOptionValue } = require('internal/options');
+const {
+  validateArray,
+  validateInt32,
+  validateOneOf,
+  validateString,
+} = require('internal/validators');
+let binding;
+function lazyBinding() {
+  binding ??= internalBinding('cares_wrap');
+  return binding;
+}
+const IANA_DNS_PORT = 53;
+const IPv6RE = /^\[([^[\]]*)\]/;
+const addrSplitRE = /(^.+?)(?::(\d+))?$/;
+
+const {
+  namespace: {
+    addSerializeCallback,
+    addDeserializeCallback,
+    isBuildingSnapshot,
+  },
+} = require('internal/v8/startup_snapshot');
+
+function validateTimeout(options) {
+  const { timeout = -1 } = { ...options };
+  validateInt32(timeout, 'options.timeout', -1);
+  return timeout;
+}
+
+function validateTries(options) {
+  const { tries = 4 } = { ...options };
+  validateInt32(tries, 'options.tries', 1);
+  return tries;
+}
+
+const kSerializeResolver = Symbol('dns:resolver:serialize');
+const kDeserializeResolver = Symbol('dns:resolver:deserialize');
+const kSnapshotStates = Symbol('dns:resolver:config');
+const kInitializeHandle = Symbol('dns:resolver:initializeHandle');
+const kSetServersInternal = Symbol('dns:resolver:setServers');
+
+// Resolver instances correspond 1:1 to c-ares channels.
+
+class ResolverBase {
+  constructor(options = undefined) {
+    const timeout = validateTimeout(options);
+    const tries = validateTries(options);
+    // If we are building snapshot, save the states of the resolver along
+    // the way.
+    if (isBuildingSnapshot()) {
+      this[kSnapshotStates] = { timeout, tries };
+    }
+    this[kInitializeHandle](timeout, tries);
+  }
+
+  [kInitializeHandle](timeout, tries) {
+    const { ChannelWrap } = lazyBinding();
+    this._handle = new ChannelWrap(timeout, tries);
+  }
+
+  cancel() {
+    this._handle.cancel();
+  }
+
+  getServers() {
+    return ArrayPrototypeMap(this._handle.getServers() || [], (val) => {
+      if (!val[1] || val[1] === IANA_DNS_PORT)
+        return val[0];
+
+      const host = isIP(val[0]) === 6 ? `[${val[0]}]` : val[0];
+      return `${host}:${val[1]}`;
+    });
+  }
+
+  setServers(servers) {
+    validateArray(servers, 'servers');
+
+    // Cache the original servers because in the event of an error while
+    // setting the servers, c-ares won't have any servers available for
+    // resolution.
+    const newSet = [];
+    ArrayPrototypeForEach(servers, (serv, index) => {
+      validateString(serv, `servers[${index}]`);
+      let ipVersion = isIP(serv);
+
+      if (ipVersion !== 0)
+        return ArrayPrototypePush(newSet, [ipVersion, serv, IANA_DNS_PORT]);
+
+      const match = RegExpPrototypeExec(IPv6RE, serv);
+
+      // Check for an IPv6 in brackets.
+      if (match) {
+        ipVersion = isIP(match[1]);
+
+        if (ipVersion !== 0) {
+          const port = NumberParseInt(
+            RegExpPrototypeSymbolReplace(addrSplitRE, serv, '$2')) || IANA_DNS_PORT;
+          return ArrayPrototypePush(newSet, [ipVersion, match[1], port]);
+        }
+      }
+
+      // addr::port
+      const addrSplitMatch = RegExpPrototypeExec(addrSplitRE, serv);
+
+      if (addrSplitMatch) {
+        const hostIP = addrSplitMatch[1];
+        const port = addrSplitMatch[2] || IANA_DNS_PORT;
+
+        ipVersion = isIP(hostIP);
+
+        if (ipVersion !== 0) {
+          return ArrayPrototypePush(
+            newSet, [ipVersion, hostIP, NumberParseInt(port)]);
+        }
+      }
+
+      throw new ERR_INVALID_IP_ADDRESS(serv);
+    });
+
+    this[kSetServersInternal](newSet, servers);
+  }
+
+  [kSetServersInternal](newSet, servers) {
+    const orig = ArrayPrototypeMap(this._handle.getServers() || [], (val) => {
+      val.unshift(isIP(val[0]));
+      return val;
+    });
+    const errorNumber = this._handle.setServers(newSet);
+
+    if (errorNumber !== 0) {
+      // Reset the servers to the old servers, because ares probably unset them.
+      this._handle.setServers(orig);
+      const { strerror } = lazyBinding();
+      const err = strerror(errorNumber);
+      throw new ERR_DNS_SET_SERVERS_FAILED(err, servers);
+    }
+
+    if (isBuildingSnapshot()) {
+      this[kSnapshotStates].servers = newSet;
+    }
+  }
+
+
+  setLocalAddress(ipv4, ipv6) {
+    validateString(ipv4, 'ipv4');
+
+    if (ipv6 !== undefined) {
+      validateString(ipv6, 'ipv6');
+    }
+
+    this._handle.setLocalAddress(ipv4, ipv6);
+
+    if (isBuildingSnapshot()) {
+      this[kSnapshotStates].localAddress = { ipv4, ipv6 };
+    }
+  }
+
+  // TODO(joyeecheung): consider exposing this if custom DNS resolvers
+  // end up being useful for snapshot users.
+  [kSerializeResolver]() {
+    this._handle = null;  // We'll restore it during deserialization.
+    addDeserializeCallback(function deserializeResolver(resolver) {
+      resolver[kDeserializeResolver]();
+    }, this);
+  }
+
+  [kDeserializeResolver]() {
+    const { timeout, tries, localAddress, servers } = this[kSnapshotStates];
+    this[kInitializeHandle](timeout, tries);
+    if (localAddress) {
+      const { ipv4, ipv6 } = localAddress;
+      this._handle.setLocalAddress(ipv4, ipv6);
+    }
+    if (servers) {
+      this[kSetServersInternal](servers, servers);
+    }
+  }
+}
+
+let defaultResolver;
+let dnsOrder;
+const validDnsOrders = ['verbatim', 'ipv4first', 'ipv6first'];
+const validFamilies = [0, 4, 6];
+
+function initializeDns() {
+  const orderFromCLI = getOptionValue('--dns-result-order');
+  if (!orderFromCLI) {
+    dnsOrder ??= 'verbatim';
+  } else {
+    // Allow the deserialized application to override order from CLI.
+    validateOneOf(orderFromCLI, '--dns-result-order', validDnsOrders);
+    dnsOrder = orderFromCLI;
+  }
+
+  if (!isBuildingSnapshot()) {
+    return;
+  }
+
+  addSerializeCallback(() => {
+    defaultResolver?.[kSerializeResolver]();
+  });
+}
+
+const resolverKeys = [
+  'getServers',
+  'resolve',
+  'resolve4',
+  'resolve6',
+  'resolveAny',
+  'resolveCaa',
+  'resolveCname',
+  'resolveMx',
+  'resolveNaptr',
+  'resolveNs',
+  'resolvePtr',
+  'resolveSoa',
+  'resolveSrv',
+  'resolveTlsa',
+  'resolveTxt',
+  'reverse',
+];
+
+function getDefaultResolver() {
+  // We do this here instead of pre-execution so that the default resolver is
+  // only ever created when the user loads any dns module.
+  if (defaultResolver === undefined) {
+    defaultResolver = new ResolverBase();
+  }
+  return defaultResolver;
+}
+
+function setDefaultResolver(resolver) {
+  defaultResolver = resolver;
+}
+
+function bindDefaultResolver(target, source) {
+  const defaultResolver = getDefaultResolver();
+  ArrayPrototypeForEach(resolverKeys, (key) => {
+    target[key] = FunctionPrototypeBind(source[key], defaultResolver);
+  });
+}
+
+function validateHints(hints) {
+  const { AI_ADDRCONFIG, AI_ALL, AI_V4MAPPED } = lazyBinding();
+  if ((hints & ~(AI_ADDRCONFIG | AI_ALL | AI_V4MAPPED)) !== 0) {
+    throw new ERR_INVALID_ARG_VALUE('hints', hints);
+  }
+}
+
+let invalidHostnameWarningEmitted = false;
+function emitInvalidHostnameWarning(hostname) {
+  if (!invalidHostnameWarningEmitted) {
+    process.emitWarning(
+      `The provided hostname "${hostname}" is not a valid ` +
+      'hostname, and is supported in the dns module solely for compatibility.',
+      'DeprecationWarning',
+      'DEP0118',
+    );
+    invalidHostnameWarningEmitted = true;
+  }
+}
+
+function setDefaultResultOrder(value) {
+  validateOneOf(value, 'dnsOrder', validDnsOrders);
+  dnsOrder = value;
+}
+
+function getDefaultResultOrder() {
+  return dnsOrder;
+}
+
+function createResolverClass(resolver) {
+  const resolveMap = { __proto__: null };
+
+  class Resolver extends ResolverBase {}
+
+  Resolver.prototype.resolveAny = resolveMap.ANY = resolver('queryAny');
+  Resolver.prototype.resolve4 = resolveMap.A = resolver('queryA');
+  Resolver.prototype.resolve6 = resolveMap.AAAA = resolver('queryAaaa');
+  Resolver.prototype.resolveCaa = resolveMap.CAA = resolver('queryCaa');
+  Resolver.prototype.resolveCname = resolveMap.CNAME = resolver('queryCname');
+  Resolver.prototype.resolveMx = resolveMap.MX = resolver('queryMx');
+  Resolver.prototype.resolveNs = resolveMap.NS = resolver('queryNs');
+  Resolver.prototype.resolveTlsa = resolveMap.TLSA = resolver('queryTlsa');
+  Resolver.prototype.resolveTxt = resolveMap.TXT = resolver('queryTxt');
+  Resolver.prototype.resolveSrv = resolveMap.SRV = resolver('querySrv');
+  Resolver.prototype.resolvePtr = resolveMap.PTR = resolver('queryPtr');
+  Resolver.prototype.resolveNaptr = resolveMap.NAPTR = resolver('queryNaptr');
+  Resolver.prototype.resolveSoa = resolveMap.SOA = resolver('querySoa');
+  Resolver.prototype.reverse = resolver('getHostByAddr');
+
+  return {
+    resolveMap,
+    Resolver,
+  };
+}
+
+// ERROR CODES
+const errorCodes = {
+  NODATA: 'ENODATA',
+  FORMERR: 'EFORMERR',
+  SERVFAIL: 'ESERVFAIL',
+  NOTFOUND: 'ENOTFOUND',
+  NOTIMP: 'ENOTIMP',
+  REFUSED: 'EREFUSED',
+  BADQUERY: 'EBADQUERY',
+  BADNAME: 'EBADNAME',
+  BADFAMILY: 'EBADFAMILY',
+  BADRESP: 'EBADRESP',
+  CONNREFUSED: 'ECONNREFUSED',
+  TIMEOUT: 'ETIMEOUT',
+  EOF: 'EOF',
+  FILE: 'EFILE',
+  NOMEM: 'ENOMEM',
+  DESTRUCTION: 'EDESTRUCTION',
+  BADSTR: 'EBADSTR',
+  BADFLAGS: 'EBADFLAGS',
+  NONAME: 'ENONAME',
+  BADHINTS: 'EBADHINTS',
+  NOTINITIALIZED: 'ENOTINITIALIZED',
+  LOADIPHLPAPI: 'ELOADIPHLPAPI',
+  ADDRGETNETWORKPARAMS: 'EADDRGETNETWORKPARAMS',
+  CANCELLED: 'ECANCELLED',
+};
+
+module.exports = {
+  bindDefaultResolver,
+  getDefaultResolver,
+  setDefaultResolver,
+  validateHints,
+  validateTimeout,
+  validateTries,
+  emitInvalidHostnameWarning,
+  getDefaultResultOrder,
+  setDefaultResultOrder,
+  errorCodes,
+  createResolverClass,
+  initializeDns,
+  validDnsOrders,
+  validFamilies,
+};