dns: stop using deprecated ares_query

avivkeller · marco-ippolito · commit 22e0d17097fa · 2025-01-24T22:17:39.000+01:00
PR-URL: #55430 Refs: #52464 Reviewed-By: Luigi Pinca <luigipinca@gmail.com> Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
@@ -829,62 +829,62 @@ void ChannelWrap::EnsureServers() {
 }
 
 int AnyTraits::Send(QueryWrap<AnyTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_any);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_ANY);
   return ARES_SUCCESS;
 }
 
 int ATraits::Send(QueryWrap<ATraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_a);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_A);
   return ARES_SUCCESS;
 }
 
 int AaaaTraits::Send(QueryWrap<AaaaTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_aaaa);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_AAAA);
   return ARES_SUCCESS;
 }
 
 int CaaTraits::Send(QueryWrap<CaaTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, T_CAA);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_CAA);
   return ARES_SUCCESS;
 }
 
 int CnameTraits::Send(QueryWrap<CnameTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_cname);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_CNAME);
   return ARES_SUCCESS;
 }
 
 int MxTraits::Send(QueryWrap<MxTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_mx);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_MX);
   return ARES_SUCCESS;
 }
 
 int NsTraits::Send(QueryWrap<NsTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_ns);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_NS);
   return ARES_SUCCESS;
 }
 
 int TxtTraits::Send(QueryWrap<TxtTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_txt);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_TXT);
   return ARES_SUCCESS;
 }
 
 int SrvTraits::Send(QueryWrap<SrvTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_srv);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_SRV);
   return ARES_SUCCESS;
 }
 
 int PtrTraits::Send(QueryWrap<PtrTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_ptr);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_PTR);
   return ARES_SUCCESS;
 }
 
 int NaptrTraits::Send(QueryWrap<NaptrTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_naptr);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_NAPTR);
   return ARES_SUCCESS;
 }
 
 int SoaTraits::Send(QueryWrap<SoaTraits>* wrap, const char* name) {
-  wrap->AresQuery(name, ns_c_in, ns_t_soa);
+  wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_SOA);
   return ARES_SUCCESS;
 }
 
diff --git a/src/cares_wrap.h b/src/cares_wrap.h
@@ -246,18 +246,20 @@ class QueryWrap final : public AsyncWrap {
     return Traits::Send(this, name);
   }
 
-  void AresQuery(const char* name, int dnsclass, int type) {
+  void AresQuery(const char* name,
+                 ares_dns_class_t dnsclass,
+                 ares_dns_rec_type_t type) {
     channel_->EnsureServers();
     TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(
       TRACING_CATEGORY_NODE2(dns, native), trace_name_, this,
       "name", TRACE_STR_COPY(name));
-    ares_query(
-        channel_->cares_channel(),
-        name,
-        dnsclass,
-        type,
-        Callback,
-        MakeCallbackPointer());
+    ares_query_dnsrec(channel_->cares_channel(),
+                      name,
+                      dnsclass,
+                      type,
+                      Callback,
+                      MakeCallbackPointer(),
+                      nullptr);
   }
 
   void ParseError(int status) {
@@ -304,19 +306,20 @@ class QueryWrap final : public AsyncWrap {
     return wrap;
   }
 
-  static void Callback(
-      void* arg,
-      int status,
-      int timeouts,
-      unsigned char* answer_buf,
-      int answer_len) {
+  static void Callback(void* arg,
+                       ares_status_t status,
+                       size_t timeouts,
+                       const ares_dns_record_t* dnsrec) {
     QueryWrap<Traits>* wrap = FromCallbackPointer(arg);
     if (wrap == nullptr) return;
 
     unsigned char* buf_copy = nullptr;
+    size_t answer_len = 0;
     if (status == ARES_SUCCESS) {
-      buf_copy = node::Malloc<unsigned char>(answer_len);
-      memcpy(buf_copy, answer_buf, answer_len);
+      // No need to explicitly call ares_free_string here,
+      // as it is a wrapper around free, which is already
+      // invoked when MallocedBuffer is destructed.
+      ares_dns_write(dnsrec, &buf_copy, &answer_len);
     }
 
     wrap->response_data_ = std::make_unique<ResponseData>();

Original file line number	Diff line number	Diff line change
`@@ -829,62 +829,62 @@ void ChannelWrap::EnsureServers() {`
`829`	`829`	`}`
`830`	`830`
`831`	`831`	`int AnyTraits::Send(QueryWrap<AnyTraits>* wrap, const char* name) {`
`832`		`- wrap->AresQuery(name, ns_c_in, ns_t_any);`
	`832`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_ANY);`
`833`	`833`	`return ARES_SUCCESS;`
`834`	`834`	`}`
`835`	`835`
`836`	`836`	`int ATraits::Send(QueryWrap<ATraits>* wrap, const char* name) {`
`837`		`- wrap->AresQuery(name, ns_c_in, ns_t_a);`
	`837`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_A);`
`838`	`838`	`return ARES_SUCCESS;`
`839`	`839`	`}`
`840`	`840`
`841`	`841`	`int AaaaTraits::Send(QueryWrap<AaaaTraits>* wrap, const char* name) {`
`842`		`- wrap->AresQuery(name, ns_c_in, ns_t_aaaa);`
	`842`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_AAAA);`
`843`	`843`	`return ARES_SUCCESS;`
`844`	`844`	`}`
`845`	`845`
`846`	`846`	`int CaaTraits::Send(QueryWrap<CaaTraits>* wrap, const char* name) {`
`847`		`- wrap->AresQuery(name, ns_c_in, T_CAA);`
	`847`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_CAA);`
`848`	`848`	`return ARES_SUCCESS;`
`849`	`849`	`}`
`850`	`850`
`851`	`851`	`int CnameTraits::Send(QueryWrap<CnameTraits>* wrap, const char* name) {`
`852`		`- wrap->AresQuery(name, ns_c_in, ns_t_cname);`
	`852`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_CNAME);`
`853`	`853`	`return ARES_SUCCESS;`
`854`	`854`	`}`
`855`	`855`
`856`	`856`	`int MxTraits::Send(QueryWrap<MxTraits>* wrap, const char* name) {`
`857`		`- wrap->AresQuery(name, ns_c_in, ns_t_mx);`
	`857`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_MX);`
`858`	`858`	`return ARES_SUCCESS;`
`859`	`859`	`}`
`860`	`860`
`861`	`861`	`int NsTraits::Send(QueryWrap<NsTraits>* wrap, const char* name) {`
`862`		`- wrap->AresQuery(name, ns_c_in, ns_t_ns);`
	`862`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_NS);`
`863`	`863`	`return ARES_SUCCESS;`
`864`	`864`	`}`
`865`	`865`
`866`	`866`	`int TxtTraits::Send(QueryWrap<TxtTraits>* wrap, const char* name) {`
`867`		`- wrap->AresQuery(name, ns_c_in, ns_t_txt);`
	`867`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_TXT);`
`868`	`868`	`return ARES_SUCCESS;`
`869`	`869`	`}`
`870`	`870`
`871`	`871`	`int SrvTraits::Send(QueryWrap<SrvTraits>* wrap, const char* name) {`
`872`		`- wrap->AresQuery(name, ns_c_in, ns_t_srv);`
	`872`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_SRV);`
`873`	`873`	`return ARES_SUCCESS;`
`874`	`874`	`}`
`875`	`875`
`876`	`876`	`int PtrTraits::Send(QueryWrap<PtrTraits>* wrap, const char* name) {`
`877`		`- wrap->AresQuery(name, ns_c_in, ns_t_ptr);`
	`877`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_PTR);`
`878`	`878`	`return ARES_SUCCESS;`
`879`	`879`	`}`
`880`	`880`
`881`	`881`	`int NaptrTraits::Send(QueryWrap<NaptrTraits>* wrap, const char* name) {`
`882`		`- wrap->AresQuery(name, ns_c_in, ns_t_naptr);`
	`882`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_NAPTR);`
`883`	`883`	`return ARES_SUCCESS;`
`884`	`884`	`}`
`885`	`885`
`886`	`886`	`int SoaTraits::Send(QueryWrap<SoaTraits>* wrap, const char* name) {`
`887`		`- wrap->AresQuery(name, ns_c_in, ns_t_soa);`
	`887`	`+ wrap->AresQuery(name, ARES_CLASS_IN, ARES_REC_TYPE_SOA);`
`888`	`888`	`return ARES_SUCCESS;`
`889`	`889`	`}`
`890`	`890`