OSSForks/node
1
0
Fork 0
mirror of https://github.com/zebrajr/node.git synced 2025-12-06 12:20:27 +01:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity

src: use macros to reduce code duplication is cares_wrap

Browse Source 
PR-URL: https://github.com/nodejs/node/pull/57937
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
This commit is contained in:
James M Snell 2025-04-19 15:41:26 -07:00
parent f114dbee9d
commit 49bb0ae8c6
3 changed files with 46 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/README.md
View File

@ -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);

53
src/cares_wrap.cc
View File

@ -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);

141
src/cares_wrap.h
View File

@ -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);
};
#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)
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>;
// 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