DNS

[Stable: 2 - Stable]

Stable: 2 Stability: 2 - Stable

Code source: lib/dns.js

Le module node:dns permet la résolution de noms. Par exemple, utilisez-le pour rechercher les adresses IP des noms d'hôte.

Bien qu'il porte le nom de Domain Name System (DNS), il n'utilise pas toujours le protocole DNS pour les recherches. dns.lookup() utilise les fonctions du système d'exploitation pour effectuer la résolution de noms. Il n'est peut-être pas nécessaire d'effectuer une communication réseau. Pour effectuer la résolution de noms de la même manière que les autres applications sur le même système, utilisez dns.lookup().

ESM

import dns from 'node:dns';

dns.lookup('example.org', (err, address, family) => {
  console.log('address: %j family: IPv%s', address, family);
});
// address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6

CJS

const dns = require('node:dns');

dns.lookup('example.org', (err, address, family) => {
  console.log('address: %j family: IPv%s', address, family);
});
// address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6

Toutes les autres fonctions du module node:dns se connectent à un serveur DNS réel pour effectuer la résolution de noms. Elles utiliseront toujours le réseau pour effectuer des requêtes DNS. Ces fonctions n'utilisent pas le même ensemble de fichiers de configuration que dns.lookup() (par exemple, /etc/hosts). Utilisez ces fonctions pour toujours effectuer des requêtes DNS, en contournant les autres mécanismes de résolution de noms.

ESM

import dns from 'node:dns';

dns.resolve4('archive.org', (err, addresses) => {
  if (err) throw err;

  console.log(`addresses: ${JSON.stringify(addresses)}`);

  addresses.forEach((a) => {
    dns.reverse(a, (err, hostnames) => {
      if (err) {
        throw err;
      }
      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
    });
  });
});

CJS

const dns = require('node:dns');

dns.resolve4('archive.org', (err, addresses) => {
  if (err) throw err;

  console.log(`addresses: ${JSON.stringify(addresses)}`);

  addresses.forEach((a) => {
    dns.reverse(a, (err, hostnames) => {
      if (err) {
        throw err;
      }
      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
    });
  });
});

Voir la section Considérations d'implémentation pour plus d'informations.

Classe : dns.Resolver

Ajoutée dans : v8.3.0

Un résolveur indépendant pour les requêtes DNS.

La création d'un nouveau résolveur utilise les paramètres du serveur par défaut. La définition des serveurs utilisés pour un résolveur à l'aide de resolver.setServers() n'affecte pas les autres résolveurs :

ESM

import { Resolver } from 'node:dns';
const resolver = new Resolver();
resolver.setServers(['4.4.4.4']);

// Cette requête utilisera le serveur à l'adresse 4.4.4.4, indépendamment des paramètres globaux.
resolver.resolve4('example.org', (err, addresses) => {
  // ...
});

CJS

const { Resolver } = require('node:dns');
const resolver = new Resolver();
resolver.setServers(['4.4.4.4']);

// Cette requête utilisera le serveur à l'adresse 4.4.4.4, indépendamment des paramètres globaux.
resolver.resolve4('example.org', (err, addresses) => {
  // ...
});

Les méthodes suivantes du module node:dns sont disponibles :

• resolver.getServers()
• resolver.resolve()
• resolver.resolve4()
• resolver.resolve6()
• resolver.resolveAny()
• resolver.resolveCaa()
• resolver.resolveCname()
• resolver.resolveMx()
• resolver.resolveNaptr()
• resolver.resolveNs()
• resolver.resolvePtr()
• resolver.resolveSoa()
• resolver.resolveSrv()
• resolver.resolveTxt()
• resolver.reverse()
• resolver.setServers()

Resolver([options])

[Historique]

Version	Modifications
v16.7.0, v14.18.0	L'objet options accepte désormais une option tries.
v12.18.3	Le constructeur accepte désormais un objet options. La seule option prise en charge est timeout.
v8.3.0	Ajoutée dans : v8.3.0

Crée un nouveau résolveur.

• options <Object>
  • timeout <number> Délai d'expiration de la requête en millisecondes, ou -1 pour utiliser le délai d'expiration par défaut.
  • tries <number> Le nombre de tentatives que le résolveur tentera de contacter chaque serveur de noms avant d'abandonner. Par défaut : 4

resolver.cancel()

Ajouté dans : v8.3.0

Annule toutes les requêtes DNS en attente effectuées par ce résolveur. Les rappels correspondants seront appelés avec une erreur avec le code ECANCELLED.

resolver.setLocalAddress([ipv4][, ipv6])

Ajouté dans : v15.1.0, v14.17.0

• ipv4 <string> Une représentation sous forme de chaîne d’une adresse IPv4. Par défaut : '0.0.0.0'
• ipv6 <string> Une représentation sous forme de chaîne d’une adresse IPv6. Par défaut : '::0'

L’instance du résolveur enverra ses requêtes à partir de l’adresse IP spécifiée. Cela permet aux programmes de spécifier les interfaces sortantes lorsqu’ils sont utilisés sur des systèmes multi-hébergés.

Si une adresse v4 ou v6 n’est pas spécifiée, elle est définie sur la valeur par défaut et le système d’exploitation choisira automatiquement une adresse locale.

Le résolveur utilisera l’adresse locale v4 lors de la formulation de requêtes aux serveurs DNS IPv4, et l’adresse locale v6 lors de la formulation de requêtes aux serveurs DNS IPv6. Le rrtype des requêtes de résolution n’a aucun impact sur l’adresse locale utilisée.

dns.getServers()

Ajouté dans : v0.11.3

• Retourne : <string[]>

Retourne un tableau de chaînes d’adresses IP, formatées conformément à la RFC 5952, qui sont actuellement configurées pour la résolution DNS. Une chaîne inclura une section de port si un port personnalisé est utilisé.

[
  '8.8.8.8',
  '2001:4860:4860::8888',
  '8.8.8.8:1053',
  '[2001:4860:4860::8888]:1053',
]

dns.lookup(hostname[, options], callback)

[Historique]

Version	Modifications
v22.1.0, v20.13.0	L’option verbatim est désormais obsolète au profit de la nouvelle option order.
v18.4.0	Pour la compatibilité avec node:net, lors du passage d’un objet d’option, l’option family peut être la chaîne 'IPv4' ou la chaîne 'IPv6'.
v18.0.0	Le passage d’un rappel non valide à l’argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v17.0.0	Les options verbatim sont désormais définies par défaut sur true.
v8.5.0	L’option verbatim est désormais prise en charge.
v1.2.0	L’option all est désormais prise en charge.
v0.1.90	Ajouté dans : v0.1.90

• hostname <string>

• options <integer> | <Object>

  • family <integer> | <string> La famille d’enregistrements. Doit être 4, 6 ou 0. Pour des raisons de compatibilité descendante, 'IPv4' et 'IPv6' sont interprétés respectivement comme 4 et 6. La valeur 0 indique qu’une adresse IPv4 ou IPv6 est retournée. Si la valeur 0 est utilisée avec { all: true } (voir ci-dessous), soit une adresse IPv4, soit une adresse IPv6, soit les deux sont retournées, selon le résolveur DNS du système. Par défaut : 0.
  • hints <number> Un ou plusieurs indicateurs getaddrinfo pris en charge. Plusieurs indicateurs peuvent être transmis en appliquant un OR bit à bit à leurs valeurs.
  • all <boolean> Lorsque la valeur est true, le rappel retourne toutes les adresses résolues dans un tableau. Sinon, retourne une seule adresse. Par défaut : false.
  • order <string> Lorsque la valeur est verbatim, les adresses résolues sont retournées non triées. Lorsque la valeur est ipv4first, les adresses résolues sont triées en plaçant les adresses IPv4 avant les adresses IPv6. Lorsque la valeur est ipv6first, les adresses résolues sont triées en plaçant les adresses IPv6 avant les adresses IPv4. Par défaut : verbatim (les adresses ne sont pas réorganisées). La valeur par défaut est configurable à l’aide de dns.setDefaultResultOrder() ou --dns-result-order.
  • verbatim <boolean> Lorsque la valeur est true, le rappel reçoit les adresses IPv4 et IPv6 dans l’ordre dans lequel le résolveur DNS les a retournées. Lorsque la valeur est false, les adresses IPv4 sont placées avant les adresses IPv6. Cette option sera obsolète au profit de order. Lorsque les deux sont spécifiés, order a une priorité plus élevée. Le nouveau code ne doit utiliser que order. Par défaut : true (les adresses ne sont pas réorganisées). La valeur par défaut est configurable à l’aide de dns.setDefaultResultOrder() ou --dns-result-order.

• callback <Function>

  • err <Error>
  • address <string> Représentation sous forme de chaîne d’une adresse IPv4 ou IPv6.
  • family <integer> 4 ou 6, désignant la famille de address, ou 0 si l’adresse n’est pas une adresse IPv4 ou IPv6. 0 est un indicateur probable d’un bogue dans le service de résolution de nom utilisé par le système d’exploitation.

Résout un nom d’hôte (par exemple 'nodejs.org') dans le premier enregistrement A (IPv4) ou AAAA (IPv6) trouvé. Toutes les propriétés option sont facultatives. Si options est un entier, il doit être 4 ou 6 : si options n’est pas fourni, alors les adresses IPv4 ou IPv6, ou les deux, sont retournées si elles sont trouvées.

Avec l’option all définie sur true, les arguments de callback passent à (err, addresses), avec addresses étant un tableau d’objets avec les propriétés address et family.

En cas d’erreur, err est un objet Error, où err.code est le code d’erreur. Gardez à l’esprit que err.code sera défini sur 'ENOTFOUND' non seulement lorsque le nom d’hôte n’existe pas, mais également lorsque la recherche échoue d’autres manières, comme l’absence de descripteurs de fichiers disponibles.

dns.lookup() n’a pas nécessairement de lien avec le protocole DNS. L’implémentation utilise une fonctionnalité du système d’exploitation qui peut associer des noms à des adresses et vice versa. Cette implémentation peut avoir des conséquences subtiles mais importantes sur le comportement de tout programme Node.js. Veuillez prendre le temps de consulter la section Considérations sur l’implémentation avant d’utiliser dns.lookup().

Exemple d’utilisation :

ESM

import dns from 'node:dns';
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
};
dns.lookup('example.org', options, (err, address, family) =>
  console.log('address: %j family: IPv%s', address, family));
// address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6

// When options.all is true, the result will be an Array.
options.all = true;
dns.lookup('example.org', options, (err, addresses) =>
  console.log('addresses: %j', addresses));
// addresses: [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]

CJS

const dns = require('node:dns');
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
};
dns.lookup('example.org', options, (err, address, family) =>
  console.log('address: %j family: IPv%s', address, family));
// address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6

// When options.all is true, the result will be an Array.
options.all = true;
dns.lookup('example.org', options, (err, addresses) =>
  console.log('addresses: %j', addresses));
// addresses: [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]

Si cette méthode est invoquée comme sa version util.promisify()ée, et que all n’est pas défini sur true, elle retourne une Promise pour un Object avec les propriétés address et family.

Indicateurs getaddrinfo pris en charge

[Historique]

Version	Modifications
v13.13.0, v12.17.0	Ajout de la prise en charge de l'indicateur dns.ALL.

Les indicateurs suivants peuvent être transmis en tant qu'indications à dns.lookup().

• dns.ADDRCONFIG : Limite les types d'adresses renvoyés aux types d'adresses non-boucle locale configurées sur le système. Par exemple, les adresses IPv4 ne sont renvoyées que si le système actuel a au moins une adresse IPv4 configurée.
• dns.V4MAPPED : Si la famille IPv6 a été spécifiée, mais qu'aucune adresse IPv6 n'a été trouvée, renvoie les adresses IPv6 mappées IPv4. Elle n'est pas prise en charge sur certains systèmes d'exploitation (par exemple FreeBSD 10.1).
• dns.ALL : Si dns.V4MAPPED est spécifié, renvoie les adresses IPv6 résolues ainsi que les adresses IPv6 mappées IPv4.

dns.lookupService(address, port, callback)

[Historique]

Version	Modifications
v18.0.0	La transmission d'un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.11.14	Ajoutée dans : v0.11.14

• address <string>
• port <number>
• callback <Function>
  • err <Error>
  • hostname <string> par ex. example.com
  • service <string> par ex. http

Résout l' address et le port donnés en un nom d'hôte et un service à l'aide de l'implémentation getnameinfo sous-jacente du système d'exploitation.

Si address n'est pas une adresse IP valide, une TypeError sera levée. Le port sera converti en nombre. S'il ne s'agit pas d'un port légal, une TypeError sera levée.

En cas d'erreur, err est un objet Error, où err.code est le code d'erreur.

ESM

import dns from 'node:dns';
dns.lookupService('127.0.0.1', 22, (err, hostname, service) => {
  console.log(hostname, service);
  // Prints: localhost ssh
});

CJS

const dns = require('node:dns');
dns.lookupService('127.0.0.1', 22, (err, hostname, service) => {
  console.log(hostname, service);
  // Prints: localhost ssh
});

Si cette méthode est invoquée comme sa version util.promisify()ed, elle renvoie une Promise pour un Object avec les propriétés hostname et service.

dns.resolve(hostname[, rrtype], callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string> Nom d'hôte à résoudre.
• rrtype <string> Type d'enregistrement de ressource. Par défaut : 'A'.
• callback <Function>
  • err <Error>
  • records <string[]> | <Object[]> | <Object>

Utilise le protocole DNS pour résoudre un nom d'hôte (par exemple, 'nodejs.org') en un tableau d'enregistrements de ressources. La fonction callback a les arguments (err, records). En cas de succès, records sera un tableau d'enregistrements de ressources. Le type et la structure des résultats individuels varient en fonction de rrtype:

rrtype	records contient	Type de résultat	Méthode abrégée
'A'	Adresses IPv4 (par défaut)	<string>	dns.resolve4()
'AAAA'	Adresses IPv6	<string>	dns.resolve6()
'ANY'	n'importe quel enregistrement	<Object>	dns.resolveAny()
'CAA'	Enregistrements d'autorisation CA	<Object>	dns.resolveCaa()
'CNAME'	Enregistrements de nom canonique	<string>	dns.resolveCname()
'MX'	Enregistrements d'échange de courrier	<Object>	dns.resolveMx()
'NAPTR'	Enregistrements de pointeur d'autorité de nom	<Object>	dns.resolveNaptr()
'NS'	Enregistrements de serveur de noms	<string>	dns.resolveNs()
'PTR'	Enregistrements de pointeur	<string>	dns.resolvePtr()
'SOA'	Enregistrements de début d'autorité	<Object>	dns.resolveSoa()
'SRV'	Enregistrements de service	<Object>	dns.resolveSrv()
'TXT'	Enregistrements de texte	<string[]>	dns.resolveTxt()

En cas d'erreur, err est un objet Error, où err.code est l'un des codes d'erreur DNS.

dns.resolve4(hostname[, options], callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v7.2.0	Cette méthode prend désormais en charge le passage d'options, en particulier options.ttl.
v0.1.16	Ajouté dans : v0.1.16

• hostname <string> Nom d'hôte à résoudre.

• options <Object>

  • ttl <boolean> Récupère la valeur Time-To-Live (TTL) de chaque enregistrement. Lorsque true, le callback reçoit un tableau d'objets { address: '1.2.3.4', ttl: 60 } plutôt qu'un tableau de chaînes, avec le TTL exprimé en secondes.

• callback <Function>

  • err <Error>
  • addresses <string[]> | <Object[]>

Utilise le protocole DNS pour résoudre une adresse IPv4 (enregistrements A) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'adresses IPv4 (par ex. ['74.125.79.104', '74.125.79.105', '74.125.79.106']).

dns.resolve6(hostname[, options], callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v7.2.0	Cette méthode prend désormais en charge le passage d'options, en particulier options.ttl.
v0.1.16	Ajouté dans : v0.1.16

• hostname <string> Nom d'hôte à résoudre.

• options <Object>

  • ttl <boolean> Récupère la valeur Time-To-Live (TTL) de chaque enregistrement. Lorsque true, le callback reçoit un tableau d'objets { address: '0:1:2:3:4:5:6:7', ttl: 60 } plutôt qu'un tableau de chaînes, avec le TTL exprimé en secondes.

• callback <Function>

  • err <Error>
  • addresses <string[]> | <Object[]>

Utilise le protocole DNS pour résoudre les adresses IPv6 (enregistrements AAAA) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'adresses IPv6.

dns.resolveAny(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.

• hostname <string>
• callback <Function>
  • err <Error>
  • ret <Object[]>

Utilise le protocole DNS pour résoudre tous les enregistrements (également appelés requête ANY ou *). L'argument ret passé à la fonction callback sera un tableau contenant divers types d'enregistrements. Chaque objet possède une propriété type qui indique le type de l'enregistrement actuel. Et en fonction du type, des propriétés supplémentaires seront présentes sur l'objet :

Type	Propriétés
'A'	address / ttl
'AAAA'	address / ttl
'CNAME'	value
'MX'	Voir dns.resolveMx()
'NAPTR'	Voir dns.resolveNaptr()
'NS'	value
'PTR'	value
'SOA'	Voir dns.resolveSoa()
'SRV'	Voir dns.resolveSrv()
'TXT'	Ce type d'enregistrement contient une propriété de tableau appelée entries qui fait référence à dns.resolveTxt(), par exemple { entries: ['...'], type: 'TXT' }
Voici un exemple de l'objet ret passé au callback :

[ { type: 'A', address: '127.0.0.1', ttl: 299 },
  { type: 'CNAME', value: 'example.com' },
  { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
  { type: 'NS', value: 'ns1.example.com' },
  { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
  { type: 'SOA',
    nsname: 'ns1.example.com',
    hostmaster: 'admin.example.com',
    serial: 156696742,
    refresh: 900,
    retry: 900,
    expire: 1800,
    minttl: 60 } ]

Les opérateurs de serveurs DNS peuvent choisir de ne pas répondre aux requêtes ANY. Il peut être préférable d'appeler des méthodes individuelles telles que dns.resolve4(), dns.resolveMx(), et ainsi de suite. Pour plus de détails, voir RFC 8482.

dns.resolveCname(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.3.2	Ajouté dans : v0.3.2

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <string[]>

Utilise le protocole DNS pour résoudre les enregistrements CNAME pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'enregistrements de nom canonique disponibles pour le hostname (par exemple, ['bar.example.com']).

dns.resolveCaa(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v15.0.0, v14.17.0	Ajouté dans : v15.0.0, v14.17.0

• hostname <string>
• callback <Function>
  • err <Error>
  • records <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements CAA pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'enregistrements d'autorisation d'autorité de certification disponibles pour le hostname (par exemple, [{critical: 0, iodef: 'mailto:[email protected]'}, {critical: 128, issue: 'pki.example.com'}]).

dns.resolveMx(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements d'échange de courrier (MX records) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'objets contenant à la fois une propriété priority et exchange (par exemple [{priority: 10, exchange: 'mx.example.com'}, ...]).

dns.resolveNaptr(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Passer un callback invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.9.12	Ajouté dans : v0.9.12

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements basés sur des expressions régulières (NAPTR records) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'objets avec les propriétés suivantes :

• flags
• service
• regexp
• replacement
• order
• preference

{
  flags: 's',
  service: 'SIP+D2U',
  regexp: '',
  replacement: '_sip._udp.example.com',
  order: 30,
  preference: 100
}

dns.resolveNs(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Transmettre un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.90	Ajouté dans : v0.1.90

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <string[]>

Utilise le protocole DNS pour résoudre les enregistrements de serveur de noms (enregistrements NS) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'enregistrements de serveur de noms disponibles pour hostname (par exemple, ['ns1.example.com', 'ns2.example.com']).

dns.resolvePtr(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Transmettre un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v6.0.0	Ajouté dans : v6.0.0

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <string[]>

Utilise le protocole DNS pour résoudre les enregistrements de pointeur (PTR) pour le hostname. L'argument addresses passé à la fonction callback sera un tableau de chaînes de caractères contenant les enregistrements de réponse.

dns.resolveSoa(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Transmettre un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.11.10	Ajouté dans : v0.11.10

• hostname <string>
• callback <Function>
  • err <Error>
  • address <Object>

Utilise le protocole DNS pour résoudre un enregistrement de début d'autorité (enregistrement SOA) pour le hostname. L'argument address passé à la fonction callback sera un objet avec les propriétés suivantes :

• nsname
• hostmaster
• serial
• refresh
• retry
• expire
• minttl

{
  nsname: 'ns.example.com',
  hostmaster: 'root.example.com',
  serial: 2013101809,
  refresh: 10000,
  retry: 2400,
  expire: 604800,
  minttl: 3600
}

dns.resolveSrv(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Transmettre un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements de service (enregistrements SRV) pour le hostname. L'argument addresses transmis à la fonction callback sera un tableau d'objets avec les propriétés suivantes :

• priority
• weight
• port
• name

{
  priority: 10,
  weight: 5,
  port: 21223,
  name: 'service.example.com'
}

dns.resolveTxt(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Transmettre un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string>
• callback <Function>
  • err <Error>
  • records <string[][]>

Utilise le protocole DNS pour résoudre les requêtes de texte (enregistrements TXT) pour le hostname. L'argument records transmis à la fonction callback est un tableau bidimensionnel des enregistrements de texte disponibles pour hostname (par exemple, [ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]). Chaque sous-tableau contient des blocs TXT d'un enregistrement. Selon le cas d'utilisation, ceux-ci peuvent être regroupés ou traités séparément.

dns.reverse(ip, callback)

Ajoutée dans : v0.1.16

• ip <string>
• callback <Function>
  • err <Error>
  • hostnames <string[]>

Effectue une requête DNS inverse qui résout une adresse IPv4 ou IPv6 en un tableau de noms d'hôte.

En cas d'erreur, err est un objet Error, où err.code est l'un des codes d'erreur DNS.

dns.setDefaultResultOrder(order)

[Historique]

Version	Modifications
v22.1.0, v20.13.0	La valeur ipv6first est désormais prise en charge.
v17.0.0	Valeur par défaut modifiée en verbatim.
v16.4.0, v14.18.0	Ajoutée dans : v16.4.0, v14.18.0

• order <string> doit être 'ipv4first', 'ipv6first' ou 'verbatim'.

Définissez la valeur par défaut de order dans dns.lookup() et dnsPromises.lookup(). La valeur peut être :

• ipv4first : définit la valeur par défaut de order sur ipv4first.
• ipv6first : définit la valeur par défaut de order sur ipv6first.
• verbatim : définit la valeur par défaut de order sur verbatim.

La valeur par défaut est verbatim et dns.setDefaultResultOrder() a une priorité plus élevée que --dns-result-order. Lorsque vous utilisez des threads de worker, dns.setDefaultResultOrder() à partir du thread principal n'affectera pas les ordres DNS par défaut dans les workers.

dns.getDefaultResultOrder()

[Historique]

Version	Modifications
v22.1.0, v20.13.0	La valeur ipv6first est désormais prise en charge.
v20.1.0, v18.17.0	Ajoutée dans : v20.1.0, v18.17.0

Obtenez la valeur par défaut pour order dans dns.lookup() et dnsPromises.lookup(). La valeur peut être :

• ipv4first : pour order qui est par défaut ipv4first.
• ipv6first : pour order qui est par défaut ipv6first.
• verbatim : pour order qui est par défaut verbatim.

dns.setServers(servers)

Ajoutée dans : v0.11.3

• servers <string[]> tableau d'adresses formatées RFC 5952

Définit l'adresse IP et le port des serveurs à utiliser lors de la résolution DNS. L'argument servers est un tableau d'adresses formatées RFC 5952. Si le port est le port DNS par défaut IANA (53), il peut être omis.

dns.setServers([
  '8.8.8.8',
  '[2001:4860:4860::8888]',
  '8.8.8.8:1053',
  '[2001:4860:4860::8888]:1053',
]);

Une erreur sera levée si une adresse invalide est fournie.

La méthode dns.setServers() ne doit pas être appelée lorsqu'une requête DNS est en cours.

La méthode dns.setServers() affecte uniquement dns.resolve(), dns.resolve*() et dns.reverse() (et spécifiquement pas dns.lookup()).

Cette méthode fonctionne de la même manière que resolve.conf. Autrement dit, si la tentative de résolution avec le premier serveur fourni entraîne une erreur NOTFOUND, la méthode resolve() ne tentera pas de résoudre avec les serveurs suivants fournis. Les serveurs DNS de secours ne seront utilisés que si les précédents expirent ou entraînent une autre erreur.

API DNS promises

[Historique]

Version	Modifications
v15.0.0	Exposée en tant que require('dns/promises').
v11.14.0, v10.17.0	Cette API n'est plus expérimentale.
v10.6.0	Ajoutée dans : v10.6.0

L'API dns.promises fournit un ensemble alternatif de méthodes DNS asynchrones qui renvoient des objets Promise plutôt que d'utiliser des rappels. L'API est accessible via require('node:dns').promises ou require('node:dns/promises').

Class: dnsPromises.Resolver

Ajoutée dans : v10.6.0

Un résolveur indépendant pour les requêtes DNS.

La création d'un nouveau résolveur utilise les paramètres de serveur par défaut. La configuration des serveurs utilisés pour un résolveur à l'aide de resolver.setServers() n'affecte pas les autres résolveurs :

ESM

import { Resolver } from 'node:dns/promises';
const resolver = new Resolver();
resolver.setServers(['4.4.4.4']);

// Cette requête utilisera le serveur à 4.4.4.4, indépendamment des paramètres globaux.
const addresses = await resolver.resolve4('example.org');

CJS

const { Resolver } = require('node:dns').promises;
const resolver = new Resolver();
resolver.setServers(['4.4.4.4']);

// Cette requête utilisera le serveur à 4.4.4.4, indépendamment des paramètres globaux.
resolver.resolve4('example.org').then((addresses) => {
  // ...
});

// Alternativement, le même code peut être écrit en utilisant le style async-await.
(async function() {
  const addresses = await resolver.resolve4('example.org');
})();

Les méthodes suivantes de l'API dnsPromises sont disponibles :

• resolver.getServers()
• resolver.resolve()
• resolver.resolve4()
• resolver.resolve6()
• resolver.resolveAny()
• resolver.resolveCaa()
• resolver.resolveCname()
• resolver.resolveMx()
• resolver.resolveNaptr()
• resolver.resolveNs()
• resolver.resolvePtr()
• resolver.resolveSoa()
• resolver.resolveSrv()
• resolver.resolveTxt()
• resolver.reverse()
• resolver.setServers()

resolver.cancel()

Ajouté dans : v15.3.0, v14.17.0

Annule toutes les requêtes DNS en attente effectuées par ce résolveur. Les promesses correspondantes seront rejetées avec une erreur avec le code ECANCELLED.

dnsPromises.getServers()

Ajouté dans : v10.6.0

• Retourne : <string[]>

Retourne un tableau de chaînes d’adresses IP, formatées selon RFC 5952, qui sont actuellement configurées pour la résolution DNS. Une chaîne inclura une section de port si un port personnalisé est utilisé.

[
  '8.8.8.8',
  '2001:4860:4860::8888',
  '8.8.8.8:1053',
  '[2001:4860:4860::8888]:1053',
]

dnsPromises.lookup(hostname[, options])

[Historique]

Version	Modifications
v22.1.0, v20.13.0	L'option verbatim est maintenant obsolète en faveur de la nouvelle option order.
v10.6.0	Ajouté dans : v10.6.0

• hostname <string>
• options <integer> | <Object>
  • family <integer> La famille d’enregistrements. Doit être 4, 6 ou 0. La valeur 0 indique qu’une adresse IPv4 ou IPv6 est retournée. Si la valeur 0 est utilisée avec { all: true } (voir ci-dessous), une ou les deux adresses IPv4 et IPv6 sont retournées, selon le résolveur DNS du système. Par défaut : 0.
  • hints <number> Un ou plusieurs indicateurs getaddrinfo pris en charge. Plusieurs indicateurs peuvent être transmis en effectuant un OR bit à bit de leurs valeurs.
  • all <boolean> Lorsque true, la Promise est résolue avec toutes les adresses dans un tableau. Sinon, retourne une seule adresse. Par défaut : false.
  • order <string> Lorsque verbatim, la Promise est résolue avec les adresses IPv4 et IPv6 dans l’ordre dans lequel le résolveur DNS les a retournées. Lorsque ipv4first, les adresses IPv4 sont placées avant les adresses IPv6. Lorsque ipv6first, les adresses IPv6 sont placées avant les adresses IPv4. Par défaut : verbatim (les adresses ne sont pas réorganisées). La valeur par défaut est configurable à l’aide de dns.setDefaultResultOrder() ou --dns-result-order. Le nouveau code doit utiliser { order: 'verbatim' }.
  • verbatim <boolean> Lorsque true, la Promise est résolue avec les adresses IPv4 et IPv6 dans l’ordre dans lequel le résolveur DNS les a retournées. Lorsque false, les adresses IPv4 sont placées avant les adresses IPv6. Cette option sera obsolète en faveur de order. Lorsque les deux sont spécifiés, order a une priorité plus élevée. Le nouveau code ne doit utiliser que order. Par défaut : actuellement false (les adresses sont réorganisées), mais cela devrait changer dans un avenir pas trop lointain. La valeur par défaut est configurable à l’aide de dns.setDefaultResultOrder() ou --dns-result-order.

Résout un nom d’hôte (par exemple, 'nodejs.org') dans le premier enregistrement A (IPv4) ou AAAA (IPv6) trouvé. Toutes les propriétés option sont facultatives. Si options est un entier, il doit être 4 ou 6 - si options n’est pas fourni, alors les adresses IPv4 ou IPv6, ou les deux, sont retournées si elles sont trouvées.

Avec l’option all définie sur true, la Promise est résolue avec addresses étant un tableau d’objets avec les propriétés address et family.

En cas d’erreur, la Promise est rejetée avec un objet Error, où err.code est le code d’erreur. Gardez à l’esprit que err.code sera défini sur 'ENOTFOUND' non seulement lorsque le nom d’hôte n’existe pas, mais aussi lorsque la recherche échoue d’autres manières, comme l’absence de descripteurs de fichiers disponibles.

dnsPromises.lookup() n’a pas nécessairement quoi que ce soit à voir avec le protocole DNS. L’implémentation utilise une fonctionnalité du système d’exploitation qui peut associer des noms à des adresses et vice versa. Cette implémentation peut avoir des conséquences subtiles mais importantes sur le comportement de tout programme Node.js. Veuillez prendre le temps de consulter la section Considérations relatives à l’implémentation avant d’utiliser dnsPromises.lookup().

Exemple d’utilisation :

ESM

import dns from 'node:dns';
const dnsPromises = dns.promises;
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
};

await dnsPromises.lookup('example.org', options).then((result) => {
  console.log('address: %j family: IPv%s', result.address, result.family);
  // address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6
});

// When options.all is true, the result will be an Array.
options.all = true;
await dnsPromises.lookup('example.org', options).then((result) => {
  console.log('addresses: %j', result);
  // addresses: [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]
});

CJS

const dns = require('node:dns');
const dnsPromises = dns.promises;
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
};

dnsPromises.lookup('example.org', options).then((result) => {
  console.log('address: %j family: IPv%s', result.address, result.family);
  // address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6
});

// When options.all is true, the result will be an Array.
options.all = true;
dnsPromises.lookup('example.org', options).then((result) => {
  console.log('addresses: %j', result);
  // addresses: [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]
});

dnsPromises.lookupService(address, port)

Ajoutée dans : v10.6.0

• address <string>
• port <number>

Résout l'adresse et le port donnés en un nom d'hôte et un service en utilisant l'implémentation getnameinfo sous-jacente du système d'exploitation.

Si address n'est pas une adresse IP valide, une erreur TypeError sera émise. Le port sera forcé en un nombre. S'il ne s'agit pas d'un port légal, une TypeError sera émise.

En cas d'erreur, la Promise est rejetée avec un objet Error, où err.code est le code d'erreur.

ESM

import dnsPromises from 'node:dns/promises';
const result = await dnsPromises.lookupService('127.0.0.1', 22);

console.log(result.hostname, result.service); // Affiche : localhost ssh

CJS

const dnsPromises = require('node:dns').promises;
dnsPromises.lookupService('127.0.0.1', 22).then((result) => {
  console.log(result.hostname, result.service);
  // Affiche : localhost ssh
});

dnsPromises.resolve(hostname[, rrtype])

Ajoutée dans : v10.6.0

• hostname <string> Nom d'hôte à résoudre.
• rrtype <string> Type d'enregistrement de ressource. Par défaut : 'A'.

Utilise le protocole DNS pour résoudre un nom d'hôte (par exemple 'nodejs.org') en un tableau d'enregistrements de ressource. En cas de succès, la Promise est résolue avec un tableau d'enregistrements de ressource. Le type et la structure des résultats individuels varient en fonction de rrtype :

rrtype	records contient	Type de résultat	Méthode raccourcie
'A'	Adresses IPv4 (par défaut)	<string>	dnsPromises.resolve4()
'AAAA'	Adresses IPv6	<string>	dnsPromises.resolve6()
'ANY'	tous les enregistrements	<Object>	dnsPromises.resolveAny()
'CAA'	enregistrements d'autorisation CA	<Object>	dnsPromises.resolveCaa()
'CNAME'	enregistrements de nom canonique	<string>	dnsPromises.resolveCname()
'MX'	enregistrements d'échange de courrier	<Object>	dnsPromises.resolveMx()
'NAPTR'	enregistrements de pointeur d'autorité de nom	<Object>	dnsPromises.resolveNaptr()
'NS'	enregistrements de serveur de noms	<string>	dnsPromises.resolveNs()
'PTR'	enregistrements de pointeur	<string>	dnsPromises.resolvePtr()
'SOA'	enregistrements de début d'autorité	<Object>	dnsPromises.resolveSoa()
'SRV'	enregistrements de service	<Object>	dnsPromises.resolveSrv()
'TXT'	enregistrements texte	<string[]>	dnsPromises.resolveTxt()

En cas d'erreur, la Promise est rejetée avec un objet Error, où err.code est l'un des codes d'erreur DNS.

dnsPromises.resolve4(hostname[, options])

Ajouté dans : v10.6.0

• hostname <string> Nom d'hôte à résoudre.
• options <Object>
  • ttl <boolean> Récupérer la valeur de la durée de vie (TTL) de chaque enregistrement. Lorsque true, la Promise est résolue avec un tableau d'objets { address: '1.2.3.4', ttl: 60 } plutôt qu'un tableau de chaînes, avec le TTL exprimé en secondes.

Utilise le protocole DNS pour résoudre les adresses IPv4 (enregistrements A) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'adresses IPv4 (par exemple ['74.125.79.104', '74.125.79.105', '74.125.79.106']).

dnsPromises.resolve6(hostname[, options])

Ajouté dans : v10.6.0

• hostname <string> Nom d'hôte à résoudre.
• options <Object>
  • ttl <boolean> Récupérer la valeur de la durée de vie (TTL) de chaque enregistrement. Lorsque true, la Promise est résolue avec un tableau d'objets { address: '0:1:2:3:4:5:6:7', ttl: 60 } plutôt qu'un tableau de chaînes, avec le TTL exprimé en secondes.

Utilise le protocole DNS pour résoudre les adresses IPv6 (enregistrements AAAA) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'adresses IPv6.

dnsPromises.resolveAny(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre tous les enregistrements (également appelés requête ANY ou *). En cas de succès, la Promise est résolue avec un tableau contenant différents types d'enregistrements. Chaque objet a une propriété type qui indique le type de l'enregistrement actuel. Et selon le type, des propriétés supplémentaires seront présentes sur l'objet :

Type	Propriétés
'A'	address / ttl
'AAAA'	address / ttl
'CNAME'	value
'MX'	Voir dnsPromises.resolveMx()
'NAPTR'	Voir dnsPromises.resolveNaptr()
'NS'	value
'PTR'	value
'SOA'	Voir dnsPromises.resolveSoa()
'SRV'	Voir dnsPromises.resolveSrv()
'TXT'	Ce type d'enregistrement contient une propriété de tableau appelée entries qui fait référence à dnsPromises.resolveTxt(), par exemple { entries: ['...'], type: 'TXT' }
Voici un exemple de l'objet de résultat :

[ { type: 'A', address: '127.0.0.1', ttl: 299 },
  { type: 'CNAME', value: 'example.com' },
  { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
  { type: 'NS', value: 'ns1.example.com' },
  { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
  { type: 'SOA',
    nsname: 'ns1.example.com',
    hostmaster: 'admin.example.com',
    serial: 156696742,
    refresh: 900,
    retry: 900,
    expire: 1800,
    minttl: 60 } ]

dnsPromises.resolveCaa(hostname)

Ajouté dans : v15.0.0, v14.17.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements CAA pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'objets contenant les enregistrements d'autorisation d'autorité de certification disponibles pour le hostname (par exemple [{critical: 0, iodef: 'mailto:[email protected]'},{critical: 128, issue: 'pki.example.com'}]).

dnsPromises.resolveCname(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements CNAME pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'enregistrements de noms canoniques disponibles pour le hostname (par exemple ['bar.example.com']).

dnsPromises.resolveMx(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements d'échange de courrier (MX records) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'objets contenant à la fois une propriété priority et exchange (par exemple [{priority: 10, exchange: 'mx.example.com'}, ...]).

dnsPromises.resolveNaptr(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements basés sur des expressions régulières (enregistrements NAPTR) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'objets ayant les propriétés suivantes :

• flags
• service
• regexp
• replacement
• order
• preference

{
  flags: 's',
  service: 'SIP+D2U',
  regexp: '',
  replacement: '_sip._udp.example.com',
  order: 30,
  preference: 100
}

dnsPromises.resolveNs(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements de serveur de noms (enregistrements NS) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'enregistrements de serveur de noms disponibles pour hostname (par exemple ['ns1.example.com', 'ns2.example.com']).

dnsPromises.resolvePtr(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements de pointeur (enregistrements PTR) pour le hostname. En cas de succès, la Promise est résolue avec un tableau de chaînes contenant les enregistrements de réponse.

dnsPromises.resolveSoa(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre un enregistrement de début d’autorité (enregistrement SOA) pour le hostname. En cas de succès, la Promise est résolue avec un objet ayant les propriétés suivantes :

• nsname
• hostmaster
• serial
• refresh
• retry
• expire
• minttl

{
  nsname: 'ns.example.com',
  hostmaster: 'root.example.com',
  serial: 2013101809,
  refresh: 10000,
  retry: 2400,
  expire: 604800,
  minttl: 3600
}

dnsPromises.resolveSrv(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements de service (enregistrements SRV) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d’objets ayant les propriétés suivantes :

• priority
• weight
• port
• name

{
  priority: 10,
  weight: 5,
  port: 21223,
  name: 'service.example.com'
}

dnsPromises.resolveTxt(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les requêtes de texte (enregistrements TXT) pour le hostname. En cas de succès, la Promise est résolue avec un tableau bidimensionnel des enregistrements de texte disponibles pour hostname (par exemple [ [ 'v=spf1 ip4:0.0.0.0 ', '~all' ] ]). Chaque sous-tableau contient des blocs TXT d’un enregistrement. Selon le cas d’utilisation, ceux-ci peuvent être soit regroupés, soit traités séparément.

dnsPromises.reverse(ip)

Ajouté dans: v10.6.0

• ip <string>

Effectue une requête DNS inverse qui résout une adresse IPv4 ou IPv6 en un tableau de noms d'hôte.

En cas d'erreur, la Promise est rejetée avec un objet Error, où err.code est l'un des codes d'erreur DNS.

dnsPromises.setDefaultResultOrder(order)

[Historique]

Version	Modifications
v22.1.0, v20.13.0	La valeur ipv6first est maintenant prise en charge.
v17.0.0	La valeur par défaut est passée à verbatim.
v16.4.0, v14.18.0	Ajouté dans : v16.4.0, v14.18.0

• order <string> doit être 'ipv4first', 'ipv6first' ou 'verbatim'.

Définit la valeur par défaut de order dans dns.lookup() et dnsPromises.lookup(). La valeur peut être :

• ipv4first : définit la valeur par défaut de order sur ipv4first.
• ipv6first : définit la valeur par défaut de order sur ipv6first.
• verbatim : définit la valeur par défaut de order sur verbatim.

La valeur par défaut est verbatim et dnsPromises.setDefaultResultOrder() a une priorité plus élevée que --dns-result-order. Lors de l'utilisation de threads worker, dnsPromises.setDefaultResultOrder() du thread principal n'affectera pas les ordres DNS par défaut dans les workers.

dnsPromises.getDefaultResultOrder()

Ajouté dans : v20.1.0, v18.17.0

Obtenir la valeur de dnsOrder.

dnsPromises.setServers(servers)

Ajouté dans: v10.6.0

• servers <string[]> tableau d'adresses formatées RFC 5952

Définit l'adresse IP et le port des serveurs à utiliser lors de l'exécution de la résolution DNS. L'argument servers est un tableau d'adresses formatées RFC 5952. Si le port est le port DNS par défaut de l'IANA (53), il peut être omis.

dnsPromises.setServers([
  '8.8.8.8',
  '[2001:4860:4860::8888]',
  '8.8.8.8:1053',
  '[2001:4860:4860::8888]:1053',
]);

Une erreur sera levée si une adresse invalide est fournie.

La méthode dnsPromises.setServers() ne doit pas être appelée pendant qu'une requête DNS est en cours.

Cette méthode fonctionne un peu comme resolve.conf. C'est-à-dire que si la tentative de résolution avec le premier serveur fourni entraîne une erreur NOTFOUND, la méthode resolve() ne tentera pas de résoudre avec les serveurs suivants fournis. Les serveurs DNS de secours ne seront utilisés que si les serveurs précédents expirent ou entraînent une autre erreur.

Codes d'erreur

Chaque requête DNS peut renvoyer l'un des codes d'erreur suivants :

• dns.NODATA: Le serveur DNS a renvoyé une réponse sans données.
• dns.FORMERR: Le serveur DNS indique que la requête est mal formatée.
• dns.SERVFAIL: Le serveur DNS a renvoyé une erreur générale.
• dns.NOTFOUND: Nom de domaine introuvable.
• dns.NOTIMP: Le serveur DNS n'implémente pas l'opération demandée.
• dns.REFUSED: Le serveur DNS a refusé la requête.
• dns.BADQUERY: Requête DNS mal formatée.
• dns.BADNAME: Nom d'hôte mal formaté.
• dns.BADFAMILY: Famille d'adresses non prise en charge.
• dns.BADRESP: Réponse DNS mal formatée.
• dns.CONNREFUSED: Impossible de contacter les serveurs DNS.
• dns.TIMEOUT: Délai d'attente lors de la communication avec les serveurs DNS.
• dns.EOF: Fin de fichier.
• dns.FILE: Erreur de lecture du fichier.
• dns.NOMEM: Mémoire insuffisante.
• dns.DESTRUCTION: Canal en cours de destruction.
• dns.BADSTR: Chaîne mal formatée.
• dns.BADFLAGS: Indicateurs illégaux spécifiés.
• dns.NONAME: Le nom d'hôte donné n'est pas numérique.
• dns.BADHINTS: Indicateurs d'hints illégaux spécifiés.
• dns.NOTINITIALIZED: L'initialisation de la bibliothèque c-ares n'a pas encore été effectuée.
• dns.LOADIPHLPAPI: Erreur lors du chargement de iphlpapi.dll.
• dns.ADDRGETNETWORKPARAMS: Impossible de trouver la fonction GetNetworkParams.
• dns.CANCELLED: Requête DNS annulée.

L'API dnsPromises exporte également les codes d'erreur ci-dessus, par exemple dnsPromises.NODATA.

Considérations relatives à l'implémentation

Bien que dns.lookup() et les différentes fonctions dns.resolve*()/dns.reverse() aient le même objectif d'associer un nom de réseau à une adresse réseau (ou inversement), leur comportement est très différent. Ces différences peuvent avoir des conséquences subtiles mais importantes sur le comportement des programmes Node.js.

dns.lookup()

En coulisses, dns.lookup() utilise les mêmes ressources du système d'exploitation que la plupart des autres programmes. Par exemple, dns.lookup() résoudra presque toujours un nom donné de la même manière que la commande ping. Sur la plupart des systèmes d'exploitation de type POSIX, le comportement de la fonction dns.lookup() peut être modifié en modifiant les paramètres dans nsswitch.conf(5) et/ou resolv.conf(5), mais la modification de ces fichiers modifiera le comportement de tous les autres programmes exécutés sur le même système d'exploitation.

Bien que l'appel à dns.lookup() soit asynchrone du point de vue de JavaScript, il est implémenté comme un appel synchrone à getaddrinfo(3) qui s'exécute sur le pool de threads de libuv. Cela peut avoir des implications négatives surprenantes en termes de performances pour certaines applications, consultez la documentation UV_THREADPOOL_SIZE pour plus d'informations.

Diverses API réseau appelleront dns.lookup() en interne pour résoudre les noms d'hôtes. Si cela pose problème, envisagez de résoudre le nom d'hôte en une adresse à l'aide de dns.resolve() et d'utiliser l'adresse au lieu d'un nom d'hôte. De plus, certaines API réseau (telles que socket.connect() et dgram.createSocket()) permettent de remplacer le résolveur par défaut, dns.lookup().

dns.resolve(), dns.resolve*(), et dns.reverse()

Ces fonctions sont implémentées de manière assez différente de dns.lookup(). Elles n'utilisent pas getaddrinfo(3) et elles effectuent toujours une requête DNS sur le réseau. Cette communication réseau est toujours effectuée de manière asynchrone et n'utilise pas le pool de threads de libuv.

Par conséquent, ces fonctions ne peuvent pas avoir le même impact négatif sur les autres traitements qui se déroulent sur le pool de threads de libuv que dns.lookup() peut avoir.

Elles n'utilisent pas le même ensemble de fichiers de configuration que dns.lookup(). Par exemple, elles n'utilisent pas la configuration de /etc/hosts.