1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-23 07:44:48 -05:00
denoland-deno/ext/node/polyfills/internal/dns/promises.ts
2024-01-01 19:58:21 +00:00

514 lines
13 KiB
TypeScript

// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// TODO(petamoriken): enable prefer-primordials for node polyfills
// deno-lint-ignore-file prefer-primordials
import {
validateBoolean,
validateNumber,
validateOneOf,
validateString,
} from "ext:deno_node/internal/validators.mjs";
import { isIP } from "ext:deno_node/internal/net.ts";
import {
emitInvalidHostnameWarning,
getDefaultResolver,
getDefaultVerbatim,
isFamily,
isLookupOptions,
Resolver as CallbackResolver,
validateHints,
} from "ext:deno_node/internal/dns/utils.ts";
import type {
LookupAddress,
LookupAllOptions,
LookupOneOptions,
LookupOptions,
Records,
ResolveOptions,
ResolveWithTtlOptions,
} from "ext:deno_node/internal/dns/utils.ts";
import {
dnsException,
ERR_INVALID_ARG_TYPE,
ERR_INVALID_ARG_VALUE,
} from "ext:deno_node/internal/errors.ts";
import {
ChannelWrapQuery,
getaddrinfo,
GetAddrInfoReqWrap,
QueryReqWrap,
} from "ext:deno_node/internal_binding/cares_wrap.ts";
import { toASCII } from "node:punycode";
function onlookup(
this: GetAddrInfoReqWrap,
err: number | null,
addresses: string[],
) {
if (err) {
this.reject(dnsException(err, "getaddrinfo", this.hostname));
return;
}
const family = this.family || isIP(addresses[0]);
this.resolve({ address: addresses[0], family });
}
function onlookupall(
this: GetAddrInfoReqWrap,
err: number | null,
addresses: string[],
) {
if (err) {
this.reject(dnsException(err, "getaddrinfo", this.hostname));
return;
}
const family = this.family;
const parsedAddresses = [];
for (let i = 0; i < addresses.length; i++) {
const address = addresses[i];
parsedAddresses[i] = {
address,
family: family ? family : isIP(address),
};
}
this.resolve(parsedAddresses);
}
function createLookupPromise(
family: number,
hostname: string,
all: boolean,
hints: number,
verbatim: boolean,
): Promise<void | LookupAddress | LookupAddress[]> {
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;
const err = getaddrinfo(req, toASCII(hostname), family, hints, verbatim);
if (err) {
reject(dnsException(err, "getaddrinfo", hostname));
}
});
}
const validFamilies = [0, 4, 6];
export function lookup(
hostname: string,
family: number,
): Promise<void | LookupAddress | LookupAddress[]>;
export function lookup(
hostname: string,
options: LookupOneOptions,
): Promise<void | LookupAddress | LookupAddress[]>;
export function lookup(
hostname: string,
options: LookupAllOptions,
): Promise<void | LookupAddress | LookupAddress[]>;
export function lookup(
hostname: string,
options: LookupOptions,
): Promise<void | LookupAddress | LookupAddress[]>;
export function lookup(
hostname: string,
options: unknown,
): Promise<void | LookupAddress | LookupAddress[]> {
let hints = 0;
let family = 0;
let all = false;
let verbatim = getDefaultVerbatim();
// Parse arguments
if (hostname) {
validateString(hostname, "hostname");
}
if (isFamily(options)) {
validateOneOf(options, "family", validFamilies);
family = options;
} else if (!isLookupOptions(options)) {
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");
verbatim = options.verbatim;
}
}
return createLookupPromise(family, hostname, all, hints, verbatim);
}
function onresolve(
this: QueryReqWrap,
err: number,
records: Records,
ttls?: number[],
) {
if (err) {
this.reject(dnsException(err, this.bindingName, this.hostname));
return;
}
const parsedRecords = ttls && this.ttl
? (records as string[]).map((address: string, index: number) => ({
address,
ttl: ttls[index],
}))
: records;
this.resolve(parsedRecords);
}
function createResolverPromise(
resolver: Resolver,
bindingName: keyof ChannelWrapQuery,
hostname: string,
ttl: boolean,
) {
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, toASCII(hostname));
if (err) {
reject(dnsException(err, bindingName, hostname));
}
});
}
function resolver(bindingName: keyof ChannelWrapQuery) {
function query(
this: Resolver,
name: string,
options?: unknown,
) {
validateString(name, "name");
const ttl = !!(options && (options as ResolveOptions).ttl);
return createResolverPromise(this, bindingName, name, ttl);
}
Object.defineProperty(query, "name", { value: bindingName });
return query;
}
const resolveMap = Object.create(null);
class Resolver extends CallbackResolver {
// deno-lint-ignore no-explicit-any
[resolveMethod: string]: any;
}
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.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");
Resolver.prototype.resolve = _resolve;
function _resolve(
this: Resolver,
hostname: string,
rrtype?: string,
) {
let resolver;
if (typeof hostname !== "string") {
throw new ERR_INVALID_ARG_TYPE("name", "string", hostname);
}
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 Reflect.apply(resolver, this, [hostname]);
}
// The Node implementation uses `bindDefaultResolver` to set the follow methods
// on `module.exports` bound to the current `defaultResolver`. We don't have
// the same ability in ESM but can simulate this (at some cost) by explicitly
// exporting these methods which dynamically bind to the default resolver when
// called.
export function getServers(): string[] {
return Resolver.prototype.getServers.bind(getDefaultResolver())();
}
export function resolveAny(
hostname: string,
) {
return Resolver.prototype.resolveAny.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolve4(
hostname: string,
): Promise<void>;
export function resolve4(
hostname: string,
options: ResolveWithTtlOptions,
): Promise<void>;
export function resolve4(
hostname: string,
options: ResolveOptions,
): Promise<void>;
export function resolve4(hostname: string, options?: unknown) {
return Resolver.prototype.resolve4.bind(getDefaultResolver() as Resolver)(
hostname,
options,
);
}
export function resolve6(hostname: string): Promise<void>;
export function resolve6(
hostname: string,
options: ResolveWithTtlOptions,
): Promise<void>;
export function resolve6(
hostname: string,
options: ResolveOptions,
): Promise<void>;
export function resolve6(hostname: string, options?: unknown) {
return Resolver.prototype.resolve6.bind(getDefaultResolver() as Resolver)(
hostname,
options,
);
}
export function resolveCaa(
hostname: string,
) {
return Resolver.prototype.resolveCaa.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolveCname(
hostname: string,
) {
return Resolver.prototype.resolveCname.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolveMx(
hostname: string,
) {
return Resolver.prototype.resolveMx.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolveNs(hostname: string) {
return Resolver.prototype.resolveNs.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolveTxt(hostname: string) {
return Resolver.prototype.resolveTxt.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolveSrv(hostname: string) {
return Resolver.prototype.resolveSrv.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolvePtr(hostname: string) {
return Resolver.prototype.resolvePtr.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolveNaptr(hostname: string) {
return Resolver.prototype.resolveNaptr.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function resolveSoa(hostname: string) {
return Resolver.prototype.resolveSoa.bind(getDefaultResolver() as Resolver)(
hostname,
);
}
export function reverse(ip: string) {
return Resolver.prototype.reverse.bind(getDefaultResolver() as Resolver)(
ip,
);
}
export function resolve(
hostname: string,
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "A",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "AAAA",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "ANY",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "CNAME",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "MX",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "NAPTR",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "NS",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "PTR",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "SOA",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "SRV",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: "TXT",
): Promise<void>;
export function resolve(
hostname: string,
rrtype: string,
): Promise<void>;
export function resolve(hostname: string, rrtype?: string) {
return Resolver.prototype.resolve.bind(getDefaultResolver() as Resolver)(
hostname,
rrtype,
);
}
export { Resolver };
export default {
lookup,
Resolver,
getServers,
resolveAny,
resolve4,
resolve6,
resolveCaa,
resolveCname,
resolveMx,
resolveNs,
resolveTxt,
resolveSrv,
resolvePtr,
resolveNaptr,
resolveSoa,
resolve,
reverse,
};