// 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.

#include "cares_wrap.h"

#include "ada.h"

#include "async_wrap-inl.h"

#include "base_object-inl.h"

#include "env-inl.h"

#include "memory_tracker-inl.h"

#include "nbytes.h"

#include "node.h"

#include "node_errors.h"

#include "node_external_reference.h"

#include "req_wrap-inl.h"

#include "util-inl.h"

#include "uv.h"

#include "v8.h"

#include <cerrno>

#include <cstring>

#include <memory>

#include <vector>

#include <unordered_set>

#ifndef T_TLSA

#define T_TLSA 52 /* TLSA certificate association */

#endif

#ifndef T_CAA

# define T_CAA 257 /* Certification Authority Authorization */

#endif

// OpenBSD does not define these

#ifndef AI_ALL

# define AI_ALL 0

#endif

#ifndef AI_V4MAPPED

# define AI_V4MAPPED 0

#endif

namespace node {

namespace cares_wrap {

using v8::Array;

using v8::ArrayBuffer;

using v8::Context;

using v8::DictionaryTemplate;

using v8::EscapableHandleScope;

using v8::Exception;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::HandleScope;

using v8::Int32;

using v8::Integer;

using v8::Isolate;

using v8::Just;

using v8::JustVoid;

using v8::Local;

using v8::LocalVector;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Nothing;

using v8::Null;

using v8::Object;

using v8::String;

using v8::Uint32;

using v8::Undefined;

using v8::Value;

namespace {

Mutex ares_library_mutex;

inline uint16_t cares_get_16bit(const unsigned char* p) {

return static_cast<uint32_t>(p[0] << 8U) | (static_cast<uint32_t>(p[1]));

}

void ares_poll_cb(uv_poll_t* watcher, int status, int events) {

NodeAresTask* task = ContainerOf(&NodeAresTask::poll_watcher, watcher);

ChannelWrap* channel = task->channel;

/* Reset the idle timer */

uv_timer_again(channel->timer_handle());

if (status < 0) {

/* An error happened. Just pretend that the socket is both readable and */

/* writable. */

ares_process_fd(channel->cares_channel(), task->sock, task->sock);

return;

}

/* Process DNS responses */

ares_process_fd(channel->cares_channel(),

events & UV_READABLE ? task->sock : ARES_SOCKET_BAD,

events & UV_WRITABLE ? task->sock : ARES_SOCKET_BAD);

}

void ares_poll_close_cb(uv_poll_t* watcher) {

std::unique_ptr<NodeAresTask> free_me(

ContainerOf(&NodeAresTask::poll_watcher, watcher));

}

/* Callback from ares when socket operation is started */

void ares_sockstate_cb(void* data, ares_socket_t sock, int read, int write) {

ChannelWrap* channel = static_cast<ChannelWrap*>(data);

NodeAresTask* task;

NodeAresTask lookup_task;

lookup_task.sock = sock;

auto it = channel->task_list()->find(&lookup_task);

task = (it == channel->task_list()->end()) ? nullptr : *it;

if (read || write) {

if (!task) {

/* New socket */

channel->StartTimer();

task = NodeAresTask::Create(channel, sock);

if (task == nullptr) {

/* This should never happen unless we're out of memory or something */

/* is seriously wrong. The socket won't be polled, but the query will */

/* eventually time out. */

return;

}

channel->task_list()->insert(task);

}

/* This should never fail. If it fails anyway, the query will eventually */

/* time out. */

uv_poll_start(&task->poll_watcher,

(read ? UV_READABLE : 0) | (write ? UV_WRITABLE : 0),

ares_poll_cb);

} else {

if (task != nullptr) {

channel->task_list()->erase(it);

channel->env()->CloseHandle(&task->poll_watcher, ares_poll_close_cb);

}

if (channel->task_list()->empty()) {

channel->CloseTimer();

}

}

}

MaybeLocal<Array> HostentToNames(Environment* env, struct hostent* host) {

EscapableHandleScope scope(env->isolate());

LocalVector<Value> names(env->isolate());

for (uint32_t i = 0; host->h_aliases[i] != nullptr; ++i) {

names.emplace_back(OneByteString(env->isolate(), host->h_aliases[i]));

}

return scope.Escape(Array::New(env->isolate(), names.data(), names.size()));

}

MaybeLocal<Array> HostentToNames(Environment* env,

struct hostent* host,

Local<Array> names) {

size_t offset = names->Length();

for (uint32_t i = 0; host->h_aliases[i] != nullptr; ++i) {

if (names

->Set(env->context(),

i + offset,

OneByteString(env->isolate(), host->h_aliases[i]))

.IsNothing()) {

return {};

}

}

return names;

}

template <typename T>

Local<Array> AddrTTLToArray(

Environment* env,

const T* addrttls,

size_t naddrttls) {

MaybeStackBuffer<Local<Value>, 8> ttls(naddrttls);

for (size_t i = 0; i < naddrttls; i++) {

ttls[i] = Integer::NewFromUnsigned(env->isolate(), addrttls[i].ttl);

}

return Array::New(env->isolate(), ttls.out(), naddrttls);

}

Maybe<int> ParseGeneralReply(Environment* env,

const unsigned char* buf,

int len,

int* type,

Local<Array> ret,

void* addrttls = nullptr,

int* naddrttls = nullptr) {

HandleScope handle_scope(env->isolate());

hostent* host;

int status;

switch (*type) {

case ns_t_a:

case ns_t_cname:

case ns_t_cname_or_a:

status = ares_parse_a_reply(buf,

len,

&host,

static_cast<ares_addrttl*>(addrttls),

naddrttls);

break;

case ns_t_aaaa:

status = ares_parse_aaaa_reply(buf,

len,

&host,

static_cast<ares_addr6ttl*>(addrttls),

naddrttls);

break;

case ns_t_ns:

status = ares_parse_ns_reply(buf, len, &host);

break;

case ns_t_ptr:

status = ares_parse_ptr_reply(buf, len, nullptr, 0, AF_INET, &host);

break;

default:

UNREACHABLE("Bad NS type");

}

if (status != ARES_SUCCESS) return Just<int>(status);

CHECK_NOT_NULL(host);

HostEntPointer ptr(host);

/* If it's `CNAME`, return the CNAME value;

* And if it's `CNAME_OR_A` and it has value in `h_name` and `h_aliases[0]`,

* we consider it's a CNAME record, otherwise we consider it's an A record. */

if ((*type == ns_t_cname_or_a && ptr->h_name && ptr->h_aliases[0]) ||

*type == ns_t_cname) {

// A cname lookup always returns a single record but we follow the

// common API here.

*type = ns_t_cname;

if (ret->Set(env->context(),

ret->Length(),

OneByteString(env->isolate(), ptr->h_name))

.IsNothing()) {

return Nothing<int>();

}

return Just<int>(ARES_SUCCESS);

}

if (*type == ns_t_cname_or_a)

*type = ns_t_a;

if (*type == ns_t_ns) {

if (HostentToNames(env, ptr.get(), ret).IsEmpty()) {

return Nothing<int>();

}

} else if (*type == ns_t_ptr) {

uint32_t offset = ret->Length();

for (uint32_t i = 0; ptr->h_aliases[i] != nullptr; i++) {

auto alias = OneByteString(env->isolate(), ptr->h_aliases[i]);

if (ret->Set(env->context(), i + offset, alias).IsNothing()) {

return Nothing<int>();

}

}

} else {

uint32_t offset = ret->Length();

char ip[INET6_ADDRSTRLEN];

for (uint32_t i = 0; ptr->h_addr_list[i] != nullptr; ++i) {

uv_inet_ntop(ptr->h_addrtype, ptr->h_addr_list[i], ip, sizeof(ip));

auto address = OneByteString(env->isolate(), ip);

if (ret->Set(env->context(), i + offset, address).IsNothing()) {

return Nothing<int>();

}

}

}

return Just<int>(ARES_SUCCESS);

}

Maybe<int> ParseMxReply(Environment* env,

const unsigned char* buf,

int len,

Local<Array> ret,

bool need_type = false) {

HandleScope handle_scope(env->isolate());

auto tmpl = env->mx_record_template();

if (tmpl.IsEmpty()) {

static constexpr std::string_view names[] = {

"exchange",

"priority",

"type",

};

tmpl = DictionaryTemplate::New(env->isolate(), names);

env->set_mx_record_template(tmpl);

}

struct ares_mx_reply* mx_start;

int status = ares_parse_mx_reply(buf, len, &mx_start);

if (status != ARES_SUCCESS) return Just<int>(status);

DeleteFnPtr<void, ares_free_data> free_me(mx_start);

uint32_t offset = ret->Length();

ares_mx_reply* current = mx_start;

MaybeLocal<Value> values[] = {

Undefined(env->isolate()), // exchange

Undefined(env->isolate()), // priority

Undefined(env->isolate()), // type

};

for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {

values[0] = OneByteString(env->isolate(), current->host);

values[1] = Integer::New(env->isolate(), current->priority);

values[2] = env->dns_mx_string();

Local<Value> record;

if (!NewDictionaryInstance(env->context(), tmpl, values).ToLocal(&record) ||

ret->Set(env->context(), i + offset, record).IsNothing()) {

return Nothing<int>();

}

}

return Just<int>(ARES_SUCCESS);

}

Maybe<int> ParseCaaReply(Environment* env,

const unsigned char* buf,

int len,

Local<Array> ret,

bool need_type = false) {

HandleScope handle_scope(env->isolate());

auto tmpl = env->caa_record_template();

if (tmpl.IsEmpty()) {

static constexpr std::string_view names[] = {

"critical",

"type",

};

tmpl = DictionaryTemplate::New(env->isolate(), names);

env->set_caa_record_template(tmpl);

}

struct ares_caa_reply* caa_start;

int status = ares_parse_caa_reply(buf, len, &caa_start);

if (status != ARES_SUCCESS) return Just<int>(status);

DeleteFnPtr<void, ares_free_data> free_me(caa_start);

MaybeLocal<Value> values[] = {

Undefined(env->isolate()), // critical

Undefined(env->isolate()), // type

};

uint32_t offset = ret->Length();

ares_caa_reply* current = caa_start;

for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {

values[0] = Integer::New(env->isolate(), current->critical);

values[1] = env->dns_caa_string();

Local<Object> caa_record;

if (!NewDictionaryInstance(env->context(), tmpl, values)

.ToLocal(&caa_record)) {

return Nothing<int>();

}

// This additional property is not part of the template as it is

// variable based on the record.

if (caa_record

->Set(env->context(),

OneByteString(env->isolate(), current->property),

OneByteString(env->isolate(), current->value))

.IsNothing()) {

return Nothing<int>();

}

if (ret->Set(env->context(), i + offset, caa_record).IsNothing()) {

return Nothing<int>();

}

}

return Just<int>(ARES_SUCCESS);

}

Maybe<int> ParseTlsaReply(Environment* env,

unsigned char* buf,

int len,

Local<Array> ret) {

EscapableHandleScope handle_scope(env->isolate());

auto tmpl = env->tlsa_record_template();

if (tmpl.IsEmpty()) {

static constexpr std::string_view names[] = {

"certUsage",

"selector",

"match",

"data",

};

tmpl = DictionaryTemplate::New(env->isolate(), names);

env->set_tlsa_record_template(tmpl);

}

ares_dns_record_t* dnsrec = nullptr;

int status = ares_dns_parse(buf, len, 0, &dnsrec);

if (status != ARES_SUCCESS) {

ares_dns_record_destroy(dnsrec);

return Just<int>(status);

}

DeleteFnPtr<ares_dns_record_t, ares_dns_record_destroy> free_me(dnsrec);

uint32_t offset = ret->Length();

size_t rr_count = ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER);

MaybeLocal<Value> values[] = {

Undefined(env->isolate()), // certUsage

Undefined(env->isolate()), // selector

Undefined(env->isolate()), // match

Undefined(env->isolate()), // data

};

for (size_t i = 0; i < rr_count; i++) {

const ares_dns_rr_t* rr =

ares_dns_record_rr_get(dnsrec, ARES_SECTION_ANSWER, i);

if (ares_dns_rr_get_type(rr) != ARES_REC_TYPE_TLSA) continue;

unsigned char certusage = ares_dns_rr_get_u8(rr, ARES_RR_TLSA_CERT_USAGE);

unsigned char selector = ares_dns_rr_get_u8(rr, ARES_RR_TLSA_SELECTOR);

unsigned char match = ares_dns_rr_get_u8(rr, ARES_RR_TLSA_MATCH);

size_t data_len;

const unsigned char* data =

ares_dns_rr_get_bin(rr, ARES_RR_TLSA_DATA, &data_len);

if (!data || data_len == 0) continue;

Local<ArrayBuffer> data_ab = ArrayBuffer::New(env->isolate(), data_len);

memcpy(data_ab->Data(), data, data_len);

values[0] = Integer::NewFromUnsigned(env->isolate(), certusage);

values[1] = Integer::NewFromUnsigned(env->isolate(), selector);

values[2] = Integer::NewFromUnsigned(env->isolate(), match);

values[3] = data_ab;

Local<Object> tlsa_rec;

if (!NewDictionaryInstance(env->context(), tmpl, values)

.ToLocal(&tlsa_rec) ||

ret->Set(env->context(), offset + i, tlsa_rec).IsNothing()) {

return Nothing<int>();

}

}

return Just<int>(ARES_SUCCESS);

}

Maybe<int> ParseTxtReply(Environment* env,

const unsigned char* buf,

int len,

Local<Array> ret,

bool need_type = false) {

HandleScope handle_scope(env->isolate());

auto tmpl = env->txt_record_template();

if (tmpl.IsEmpty()) {

static constexpr std::string_view names[] = {

"entries",

"type",

};

tmpl = DictionaryTemplate::New(env->isolate(), names);

env->set_txt_record_template(tmpl);

}

struct ares_txt_ext* txt_out;

int status = ares_parse_txt_reply_ext(buf, len, &txt_out);

if (status != ARES_SUCCESS) return Just<int>(status);

DeleteFnPtr<void, ares_free_data> free_me(txt_out);

Local<Array> txt_chunk;

LocalVector<Value> chunks(env->isolate());

struct ares_txt_ext* current = txt_out;

uint32_t i = 0;

uint32_t offset = ret->Length();

MaybeLocal<Value> values[] = {

Undefined(env->isolate()), // entries

Undefined(env->isolate()), // type

};

for (; current != nullptr; current = current->next) {

Local<String> txt =

OneByteString(env->isolate(), current->txt, current->length);

// New record found - write out the current chunk

if (current->record_start) {

if (!chunks.empty()) {

auto txt_chunk =

Array::New(env->isolate(), chunks.data(), chunks.size());

chunks.clear();

if (need_type) {

values[0] = txt_chunk;

values[1] = env->dns_txt_string();

Local<Object> elem;

if (!NewDictionaryInstance(env->context(), tmpl, values)

.ToLocal(&elem) ||

ret->Set(env->context(), offset + i++, elem).IsNothing()) {

return Nothing<int>();

}

} else if (ret->Set(env->context(), offset + i++, txt_chunk)

.IsNothing()) {

return Nothing<int>();

}

}

txt_chunk = Array::New(env->isolate());

}

chunks.push_back(txt);

}

// Push last chunk if it isn't empty

if (!chunks.empty()) {

txt_chunk = Array::New(env->isolate(), chunks.data(), chunks.size());

if (need_type) {

values[0] = txt_chunk;

values[1] = env->dns_txt_string();

Local<Object> elem;

if (!NewDictionaryInstance(env->context(), tmpl, values).ToLocal(&elem) ||

ret->Set(env->context(), offset + i, elem).IsNothing()) {

return Nothing<int>();

}

} else if (ret->Set(env->context(), offset + i, txt_chunk).IsNothing()) {

return Nothing<int>();

}

}

return Just<int>(ARES_SUCCESS);

}

Maybe<int> ParseSrvReply(Environment* env,

const unsigned char* buf,

int len,

Local<Array> ret,

bool need_type = false) {

HandleScope handle_scope(env->isolate());

auto tmpl = env->srv_record_template();

if (tmpl.IsEmpty()) {

static constexpr std::string_view names[] = {

"name",

"port",

"priority",

"weight",

"type",

};

tmpl = DictionaryTemplate::New(env->isolate(), names);

env->set_srv_record_template(tmpl);

}

struct ares_srv_reply* srv_start;

int status = ares_parse_srv_reply(buf, len, &srv_start);

if (status != ARES_SUCCESS) return Just<int>(status);

DeleteFnPtr<void, ares_free_data> free_me(srv_start);

MaybeLocal<Value> values[] = {

Undefined(env->isolate()), // name

Undefined(env->isolate()), // port

Undefined(env->isolate()), // priority

Undefined(env->isolate()), // weight

Undefined(env->isolate()), // type

};

ares_srv_reply* current = srv_start;

int offset = ret->Length();

for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {

values[0] = OneByteString(env->isolate(), current->host);

values[1] = Integer::New(env->isolate(), current->port);

values[2] = Integer::New(env->isolate(), current->priority);

values[3] = Integer::New(env->isolate(), current->weight);

values[4] = env->dns_srv_string();

Local<Object> srv_record;

if (!NewDictionaryInstance(env->context(), tmpl, values)

.ToLocal(&srv_record) ||

ret->Set(env->context(), i + offset, srv_record).IsNothing()) {

return Nothing<int>();

}

}

return Just<int>(ARES_SUCCESS);

}

Maybe<int> ParseNaptrReply(Environment* env,

const unsigned char* buf,

int len,

Local<Array> ret,

bool need_type = false) {

HandleScope handle_scope(env->isolate());

auto tmpl = env->naptr_record_template();

if (tmpl.IsEmpty()) {

static constexpr std::string_view names[] = {

"flags",

"service",

"regexp",

"replacement",

"order",

"preference",

"type",

};

tmpl = DictionaryTemplate::New(env->isolate(), names);

env->set_naptr_record_template(tmpl);

}

ares_naptr_reply* naptr_start;

int status = ares_parse_naptr_reply(buf, len, &naptr_start);

if (status != ARES_SUCCESS) return Just<int>(status);

DeleteFnPtr<void, ares_free_data> free_me(naptr_start);

MaybeLocal<Value> values[] = {

Undefined(env->isolate()), // flags

Undefined(env->isolate()), // service

Undefined(env->isolate()), // regexp

Undefined(env->isolate()), // replacement

Undefined(env->isolate()), // order

Undefined(env->isolate()), // preference

Undefined(env->isolate()), // type

};

ares_naptr_reply* current = naptr_start;

int offset = ret->Length();

for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {

values[0] = OneByteString(env->isolate(), current->flags);

values[1] = OneByteString(env->isolate(), current->service);

values[2] = OneByteString(env->isolate(), current->regexp);

values[3] = OneByteString(env->isolate(), current->replacement);

values[4] = Integer::New(env->isolate(), current->order);

values[5] = Integer::New(env->isolate(), current->preference);

if (need_type) {

values[6] = env->dns_naptr_string();

}

Local<Object> naptr_record;

if (!NewDictionaryInstance(env->context(), tmpl, values)

.ToLocal(&naptr_record) ||

ret->Set(env->context(), i + offset, naptr_record).IsNothing()) {

return Nothing<int>();

}

}

return Just<int>(ARES_SUCCESS);

}

Local<DictionaryTemplate> getSoaRecordTemplate(Environment* env) {

auto tmpl = env->soa_record_template();

if (tmpl.IsEmpty()) {

static constexpr std::string_view names[] = {

"nsname",

"hostmaster",

"serial",

"refresh",

"retry",

"expire",

"minttl",

"type",

};

tmpl = DictionaryTemplate::New(env->isolate(), names);

env->set_soa_record_template(tmpl);

}

return tmpl;

}

Maybe<int> ParseSoaReply(Environment* env,

unsigned char* buf,

int len,

Local<Object>* ret) {

EscapableHandleScope handle_scope(env->isolate());

auto tmpl = getSoaRecordTemplate(env);

// Manage memory using standardard smart pointer std::unique_tr

struct AresDeleter {

void operator()(char* ptr) const noexcept { ares_free_string(ptr); }

};

using ares_unique_ptr = std::unique_ptr<char[], AresDeleter>;

// Can't use ares_parse_soa_reply() here which can only parse single record

const unsigned int ancount = cares_get_16bit(buf + 6);

unsigned char* ptr = buf + NS_HFIXEDSZ;

char* name_temp = nullptr;

long temp_len; // NOLINT(runtime/int)

int status = ares_expand_name(ptr, buf, len, &name_temp, &temp_len);

if (status != ARES_SUCCESS) {

// returns EBADRESP in case of invalid input

return Just<int>(status == ARES_EBADNAME ? ARES_EBADRESP : status);

}

const ares_unique_ptr name(name_temp);

if (ptr + temp_len + NS_QFIXEDSZ > buf + len) {

return Just<int>(ARES_EBADRESP);

}

ptr += temp_len + NS_QFIXEDSZ;

MaybeLocal<Value> values[] = {

Undefined(env->isolate()), // nsname

Undefined(env->isolate()), // hostmaster

Undefined(env->isolate()), // serial

Undefined(env->isolate()), // refresh

Undefined(env->isolate()), // retry

Undefined(env->isolate()), // expire

Undefined(env->isolate()), // minttl

Undefined(env->isolate()), // type

};

for (unsigned int i = 0; i < ancount; i++) {

char* rr_name_temp = nullptr;

long rr_temp_len; // NOLINT(runtime/int)

int status2 = ares_expand_name(ptr, buf, len, &rr_name_temp, &rr_temp_len);

if (status2 != ARES_SUCCESS)

return Just<int>(status2 == ARES_EBADNAME ? ARES_EBADRESP : status2);

const ares_unique_ptr rr_name(rr_name_temp);

ptr += rr_temp_len;

if (ptr + NS_RRFIXEDSZ > buf + len) {

return Just<int>(ARES_EBADRESP);

}

const int rr_type = cares_get_16bit(ptr);

const int rr_len = cares_get_16bit(ptr + 8);

ptr += NS_RRFIXEDSZ;

// only need SOA

if (rr_type == ns_t_soa) {

char* nsname_temp = nullptr;

long nsname_temp_len; // NOLINT(runtime/int)

int status3 = ares_expand_name(ptr, buf, len,

&nsname_temp,

&nsname_temp_len);

if (status3 != ARES_SUCCESS) {

return Just<int>(status3 == ARES_EBADNAME ? ARES_EBADRESP : status3);

}

const ares_unique_ptr nsname(nsname_temp);

ptr += nsname_temp_len;

char* hostmaster_temp = nullptr;

long hostmaster_temp_len; // NOLINT(runtime/int)

int status4 = ares_expand_name(ptr, buf, len,

&hostmaster_temp,

&hostmaster_temp_len);

if (status4 != ARES_SUCCESS) {

return Just<int>(status4 == ARES_EBADNAME ? ARES_EBADRESP : status4);

}

const ares_unique_ptr hostmaster(hostmaster_temp);

ptr += hostmaster_temp_len;

if (ptr + 5 * 4 > buf + len) {

return Just<int>(ARES_EBADRESP);

}

const unsigned int serial = nbytes::ReadUint32BE(ptr + 0 * 4);

const unsigned int refresh = nbytes::ReadUint32BE(ptr + 1 * 4);

const unsigned int retry = nbytes::ReadUint32BE(ptr + 2 * 4);

const unsigned int expire = nbytes::ReadUint32BE(ptr + 3 * 4);

const unsigned int minttl = nbytes::ReadUint32BE(ptr + 4 * 4);

values[0] = OneByteString(env->isolate(), nsname.get());

values[1] = OneByteString(env->isolate(), hostmaster.get());

values[2] = Integer::NewFromUnsigned(env->isolate(), serial);

values[3] = Integer::New(env->isolate(), refresh);

values[4] = Integer::New(env->isolate(), retry);

values[5] = Integer::New(env->isolate(), expire);

values[6] = Integer::NewFromUnsigned(env->isolate(), minttl);

values[7] = env->dns_soa_string();

Local<Object> soa_record;

if (!NewDictionaryInstance(env->context(), tmpl, values)

.ToLocal(&soa_record)) {

return Nothing<int>();

}

*ret = handle_scope.Escape(soa_record);

break;

}

ptr += rr_len;

}

return Just<int>(ARES_SUCCESS);

}

} // anonymous namespace

ChannelWrap::ChannelWrap(Environment* env,

Local<Object> object,

int timeout,

int tries,

int max_timeout)

: AsyncWrap(env, object, PROVIDER_DNSCHANNEL),

timeout_(timeout),

tries_(tries),

max_timeout_(max_timeout) {

MakeWeak();

Setup();

}

void ChannelWrap::MemoryInfo(MemoryTracker* tracker) const {

if (timer_handle_ != nullptr)

tracker->TrackField("timer_handle", *timer_handle_);

tracker->TrackField("task_list", task_list_, "NodeAresTask::List");

}

void ChannelWrap::New(const FunctionCallbackInfo<Value>& args) {

CHECK(args.IsConstructCall());

CHECK_EQ(args.Length(), 3);

CHECK(args[0]->IsInt32());

CHECK(args[1]->IsInt32());

CHECK(args[2]->IsInt32());

const int timeout = args[0].As<Int32>()->Value();

const int tries = args[1].As<Int32>()->Value();

const int max_timeout = args[2].As<Int32>()->Value();

Environment* env = Environment::GetCurrent(args);

new ChannelWrap(env, args.This(), timeout, tries, max_timeout);

}

GetAddrInfoReqWrap::GetAddrInfoReqWrap(Environment* env,

Local<Object> req_wrap_obj,

uint8_t order)

: ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_GETADDRINFOREQWRAP),

order_(order) {}

GetNameInfoReqWrap::GetNameInfoReqWrap(

Environment* env,

Local<Object> req_wrap_obj)

: ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_GETNAMEINFOREQWRAP) {}

/* This is called once per second by loop->timer. It is used to constantly */

/* call back into c-ares for possibly processing timeouts. */

void ChannelWrap::AresTimeout(uv_timer_t* handle) {

ChannelWrap* channel = static_cast<ChannelWrap*>(handle->data);

CHECK_EQ(channel->timer_handle(), handle);

ares_process_fd(channel->cares_channel(), ARES_SOCKET_BAD, ARES_SOCKET_BAD);

}

void NodeAresTask::MemoryInfo(MemoryTracker* tracker) const {

tracker->TrackField("channel", channel);

}

/* Allocates and returns a new NodeAresTask */

NodeAresTask* NodeAresTask::Create(ChannelWrap* channel, ares_socket_t sock) {

auto task = new NodeAresTask();

task->channel = channel;

task->sock = sock;

if (uv_poll_init_socket(channel->env()->event_loop(),

&task->poll_watcher, sock) < 0) {

/* This should never happen. */

delete task;

return nullptr;

}

return task;

}

void ChannelWrap::Setup() {

struct ares_options options;

memset(&options, 0, sizeof(options));

options.flags = ARES_FLAG_NOCHECKRESP;

options.sock_state_cb = ares_sockstate_cb;

options.sock_state_cb_data = this;

options.timeout = timeout_;

options.tries = tries_;

options.qcache_max_ttl = 0;

int r;

if (!library_inited_) {

Mutex::ScopedLock lock(ares_library_mutex);

// Multiple calls to ares_library_init() increase a reference counter,

// so this is a no-op except for the first call to it.

r = ares_library_init(ARES_LIB_INIT_ALL);

if (r != ARES_SUCCESS)

return env()->ThrowError(ToErrorCodeString(r));

}

/* We do the call to ares_init_option for caller. */

int optmask = ARES_OPT_FLAGS | ARES_OPT_TIMEOUTMS | ARES_OPT_SOCK_STATE_CB |

ARES_OPT_TRIES | ARES_OPT_QUERY_CACHE;

if (max_timeout_ > 0) {

options.maxtimeout = max_timeout_;

optmask |= ARES_OPT_MAXTIMEOUTMS;

}

r = ares_init_options(&channel_, &options, optmask);

if (r != ARES_SUCCESS) {

Mutex::ScopedLock lock(ares_library_mutex);

ares_library_cleanup();

return env()->ThrowError(ToErrorCodeString(r));

}

library_inited_ = true;

}

void ChannelWrap::StartTimer() {

if (timer_handle_ == nullptr) {

timer_handle_ = new uv_timer_t();

timer_handle_->data = static_cast<void*>(this);

uv_timer_init(env()->event_loop(), timer_handle_);

} else if (uv_is_active(reinterpret_cast<uv_handle_t*>(timer_handle_))) {

return;

}

int timeout = timeout_;

if (timeout <= 0 || timeout > 1000) timeout = 1000;

uv_timer_start(timer_handle_, AresTimeout, timeout, timeout);

}

void ChannelWrap::CloseTimer() {

if (timer_handle_ == nullptr)

return;

env()->CloseHandle(timer_handle_, [](uv_timer_t* handle) { delete handle; });

timer_handle_ = nullptr;

}

ChannelWrap::~ChannelWrap() {

ares_destroy(channel_);

if (library_inited_) {

Mutex::ScopedLock lock(ares_library_mutex);

// This decreases the reference counter increased by ares_library_init().

ares_library_cleanup();

}

CloseTimer();

}

void ChannelWrap::ModifyActivityQueryCount(int count) {

active_query_count_ += count;

CHECK_GE(active_query_count_, 0);

}

/**

* This function is to check whether current servers are fallback servers

* when cares initialized.

*

* The fallback servers of cares is [ "127.0.0.1" ] with no user additional

* setting.

*/

void ChannelWrap::EnsureServers() {

/* if last query is OK or servers are set by user self, do not check */

if (query_last_ok_ || !is_servers_default_) {

return;

}

ares_addr_port_node* servers = nullptr;

ares_get_servers_ports(channel_, &servers);

/* if no server, ignore */

if (servers == nullptr) return;

/* if multi-servers, mark as non-default and ignore */

if (servers->next != nullptr) {

ares_free_data(servers);

is_servers_default_ = false;

return;

}

/* Check if the only server is a loopback address (IPv4 127.0.0.1 or IPv6

* ::1). Newer c-ares versions may set tcp_port/udp_port to 53 instead of 0,

* so we no longer check port values. */

bool is_loopback = false;

if (servers[0].family == AF_INET) {