src: use macros to reduce code duplication is cares_wrap

PR-URL: #57937
Reviewed-By: Yagiz Nizipli <[email protected]>

Author: jasnell

src/README.md

@@ -474,7 +474,7 @@ void Initialize(Local<Object> target,
   SetProtoMethod(isolate, channel_wrap, "queryA", Query<QueryAWrap>);
   // ...
   SetProtoMethod(isolate, channel_wrap, "querySoa", Query<QuerySoaWrap>);
-  SetProtoMethod(isolate, channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
+  SetProtoMethod(isolate, channel_wrap, "getHostByAddr", Query<QueryReverseWrap>);
 
   SetProtoMethodNoSideEffect(isolate, channel_wrap, "getServers", GetServers);
 

src/cares_wrap.cc

@@ -1612,7 +1612,7 @@ Maybe<int> SoaTraits::Parse(QuerySoaWrap* wrap,
   return Just<int>(ARES_SUCCESS);
 }
 
-int ReverseTraits::Send(GetHostByAddrWrap* wrap, const char* name) {
+int ReverseTraits::Send(QueryReverseWrap* wrap, const char* name) {
   int length, family;
   char address_buffer[sizeof(struct in6_addr)];
 
@@ -1631,17 +1631,16 @@ int ReverseTraits::Send(GetHostByAddrWrap* wrap, const char* name) {
       "name", TRACE_STR_COPY(name),
       "family", family == AF_INET ? "ipv4" : "ipv6");
 
-  ares_gethostbyaddr(
-      wrap->channel()->cares_channel(),
-      address_buffer,
-      length,
-      family,
-      GetHostByAddrWrap::Callback,
-      wrap->MakeCallbackPointer());
+  ares_gethostbyaddr(wrap->channel()->cares_channel(),
+                     address_buffer,
+                     length,
+                     family,
+                     QueryReverseWrap::Callback,
+                     wrap->MakeCallbackPointer());
   return ARES_SUCCESS;
 }
 
-Maybe<int> ReverseTraits::Parse(GetHostByAddrWrap* wrap,
+Maybe<int> ReverseTraits::Parse(QueryReverseWrap* wrap,
                                 const std::unique_ptr<ResponseData>& response) {
   if (!response->is_host) [[unlikely]] {
     return Just<int>(ARES_EBADRESP);
@@ -2220,21 +2219,10 @@ void Initialize(Local<Object> target,
       ChannelWrap::kInternalFieldCount);
   channel_wrap->Inherit(AsyncWrap::GetConstructorTemplate(env));
 
-  SetProtoMethod(isolate, channel_wrap, "queryAny", Query<QueryAnyWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryA", Query<QueryAWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryAaaa", Query<QueryAaaaWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryCaa", Query<QueryCaaWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryCname", Query<QueryCnameWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryMx", Query<QueryMxWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryNs", Query<QueryNsWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryTlsa", Query<QueryTlsaWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryTxt", Query<QueryTxtWrap>);
-  SetProtoMethod(isolate, channel_wrap, "querySrv", Query<QuerySrvWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryPtr", Query<QueryPtrWrap>);
-  SetProtoMethod(isolate, channel_wrap, "queryNaptr", Query<QueryNaptrWrap>);
-  SetProtoMethod(isolate, channel_wrap, "querySoa", Query<QuerySoaWrap>);
-  SetProtoMethod(
-      isolate, channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
+#define V(Name, _, JS)                                                         \
+  SetProtoMethod(isolate, channel_wrap, #JS, Query<Query##Name##Wrap>);
+  QUERY_TYPES(V)
+#undef V
 
   SetProtoMethodNoSideEffect(isolate, channel_wrap, "getServers", GetServers);
   SetProtoMethod(isolate, channel_wrap, "setServers", SetServers);
@@ -2252,20 +2240,9 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(StrError);
   registry->Register(ChannelWrap::New);
 
-  registry->Register(Query<QueryAnyWrap>);
-  registry->Register(Query<QueryAWrap>);
-  registry->Register(Query<QueryAaaaWrap>);
-  registry->Register(Query<QueryCaaWrap>);
-  registry->Register(Query<QueryCnameWrap>);
-  registry->Register(Query<QueryMxWrap>);
-  registry->Register(Query<QueryNsWrap>);
-  registry->Register(Query<QueryTlsaWrap>);
-  registry->Register(Query<QueryTxtWrap>);
-  registry->Register(Query<QuerySrvWrap>);
-  registry->Register(Query<QueryPtrWrap>);
-  registry->Register(Query<QueryNaptrWrap>);
-  registry->Register(Query<QuerySoaWrap>);
-  registry->Register(Query<GetHostByAddrWrap>);
+#define V(Name, _, __) registry->Register(Query<Query##Name##Wrap>);
+  QUERY_TYPES(V)
+#undef V
 
   registry->Register(GetServers);
   registry->Register(SetServers);

src/cares_wrap.h

@@ -406,119 +406,38 @@ class QueryWrap final : public AsyncWrap {
   QueryWrap<Traits>** callback_ptr_ = nullptr;
 };
 
-struct AnyTraits final {
-  static constexpr const char* name = "resolveAny";
-  static int Send(QueryWrap<AnyTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<AnyTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct ATraits final {
-  static constexpr const char* name = "resolve4";
-  static int Send(QueryWrap<ATraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<ATraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct AaaaTraits final {
-  static constexpr const char* name = "resolve6";
-  static int Send(QueryWrap<AaaaTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<AaaaTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct CaaTraits final {
-  static constexpr const char* name = "resolveCaa";
-  static int Send(QueryWrap<CaaTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<CaaTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct CnameTraits final {
-  static constexpr const char* name = "resolveCname";
-  static int Send(QueryWrap<CnameTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<CnameTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct MxTraits final {
-  static constexpr const char* name = "resolveMx";
-  static int Send(QueryWrap<MxTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<MxTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct NsTraits final {
-  static constexpr const char* name = "resolveNs";
-  static int Send(QueryWrap<NsTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<NsTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct TlsaTraits final {
-  static constexpr const char* name = "resolveTlsa";
-  static int Send(QueryWrap<TlsaTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<TlsaTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct TxtTraits final {
-  static constexpr const char* name = "resolveTxt";
-  static int Send(QueryWrap<TxtTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<TxtTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct SrvTraits final {
-  static constexpr const char* name = "resolveSrv";
-  static int Send(QueryWrap<SrvTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<SrvTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct PtrTraits final {
-  static constexpr const char* name = "resolvePtr";
-  static int Send(QueryWrap<PtrTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<PtrTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct NaptrTraits final {
-  static constexpr const char* name = "resolveNaptr";
-  static int Send(QueryWrap<NaptrTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<NaptrTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct SoaTraits final {
-  static constexpr const char* name = "resolveSoa";
-  static int Send(QueryWrap<SoaTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<SoaTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-struct ReverseTraits final {
-  static constexpr const char* name = "reverse";
-  static int Send(QueryWrap<ReverseTraits>* wrap, const char* name);
-  static v8::Maybe<int> Parse(QueryWrap<ReverseTraits>* wrap,
-                              const std::unique_ptr<ResponseData>& response);
-};
-
-using QueryAnyWrap = QueryWrap<AnyTraits>;
-using QueryAWrap = QueryWrap<ATraits>;
-using QueryAaaaWrap = QueryWrap<AaaaTraits>;
-using QueryCaaWrap = QueryWrap<CaaTraits>;
-using QueryCnameWrap = QueryWrap<CnameTraits>;
-using QueryMxWrap = QueryWrap<MxTraits>;
-using QueryNsWrap = QueryWrap<NsTraits>;
-using QueryTlsaWrap = QueryWrap<TlsaTraits>;
-using QueryTxtWrap = QueryWrap<TxtTraits>;
-using QuerySrvWrap = QueryWrap<SrvTraits>;
-using QueryPtrWrap = QueryWrap<PtrTraits>;
-using QueryNaptrWrap = QueryWrap<NaptrTraits>;
-using QuerySoaWrap = QueryWrap<SoaTraits>;
-using GetHostByAddrWrap = QueryWrap<ReverseTraits>;
-
+#define QUERY_TYPES(V)                                                         \
+  V(Reverse, reverse, getHostByAddr)                                           \
+  V(A, resolve4, queryA)                                                       \
+  V(Any, resolveAny, queryAny)                                                 \
+  V(Aaaa, resolve6, queryAaaa)                                                 \
+  V(Caa, resolveCaa, queryCaa)                                                 \
+  V(Cname, resolveCname, queryCname)                                           \
+  V(Mx, resolveMx, queryMx)                                                    \
+  V(Naptr, resolveNaptr, queryNaptr)                                           \
+  V(Ns, resolveNs, queryNs)                                                    \
+  V(Ptr, resolvePtr, queryPtr)                                                 \
+  V(Srv, resolveSrv, querySrv)                                                 \
+  V(Soa, resolveSoa, querySoa)                                                 \
+  V(Tlsa, resolveTlsa, queryTlsa)                                              \
+  V(Txt, resolveTxt, queryTxt)
+
+// All query type handlers share the same basic structure, so we can simplify
+// the code a bit by using a macro to define that structure.
+#define TYPE_TRAITS(Name, label)                                               \
+  struct Name##Traits final {                                                  \
+    static constexpr const char* name = #label;                                \
+    static int Send(QueryWrap<Name##Traits>* wrap, const char* name);          \
+    static v8::Maybe<int> Parse(                                               \
+        QueryWrap<Name##Traits>* wrap,                                         \
+        const std::unique_ptr<ResponseData>& response);                        \
+  };                                                                           \
+  using Query##Name##Wrap = QueryWrap<Name##Traits>;
+
+#define V(NAME, LABEL, _) TYPE_TRAITS(NAME, LABEL)
+QUERY_TYPES(V)
+#undef V
+#undef TYPE_TRAITS
 }  // namespace cares_wrap
 }  // namespace node