Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/nodejs/src/cares_wrap.h
$ cat -n /usr/include/nodejs/src/cares_wrap.h 1 #ifndef SRC_CARES_WRAP_H_ 2 #define SRC_CARES_WRAP_H_ 3 4 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS 5 6 #define CARES_STATICLIB 7 8 #include "async_wrap.h" 9 #include "base_object.h" 10 #include "env.h" 11 #include "memory_tracker.h" 12 #include "node.h" 13 #include "node_internals.h" 14 #include "util.h" 15 16 #include "ares.h" 17 #include "v8.h" 18 #include "uv.h" 19 20 #include <unordered_set> 21 22 #ifdef __POSIX__ 23 # include <netdb.h> 24 #endif // __POSIX__ 25 26 #if defined(__ANDROID__) || \ 27 defined(__MINGW32__) || \ 28 defined(__OpenBSD__) || \ 29 defined(_MSC_VER) 30 # include <nameser.h> 31 #else 32 # include <arpa/nameser.h> 33 #endif 34 35 36 namespace node { 37 namespace cares_wrap { 38 39 constexpr int ns_t_cname_or_a = -1; 40 constexpr int DNS_ESETSRVPENDING = -1000; 41 42 class ChannelWrap; 43 44 inline void safe_free_hostent(struct hostent* host); 45 46 using HostEntPointer = DeleteFnPtr<hostent, ares_free_hostent>; 47 using SafeHostEntPointer = DeleteFnPtr<hostent, safe_free_hostent>; 48 49 inline const char* ToErrorCodeString(int status) { 50 switch (status) { 51 #define V(code) case ARES_##code: return #code; 52 V(EADDRGETNETWORKPARAMS) 53 V(EBADFAMILY) 54 V(EBADFLAGS) 55 V(EBADHINTS) 56 V(EBADNAME) 57 V(EBADQUERY) 58 V(EBADRESP) 59 V(EBADSTR) 60 V(ECANCELLED) 61 V(ECONNREFUSED) 62 V(EDESTRUCTION) 63 V(EFILE) 64 V(EFORMERR) 65 V(ELOADIPHLPAPI) 66 V(ENODATA) 67 V(ENOMEM) 68 V(ENONAME) 69 V(ENOTFOUND) 70 V(ENOTIMP) 71 V(ENOTINITIALIZED) 72 V(EOF) 73 V(EREFUSED) 74 V(ESERVFAIL) 75 V(ETIMEOUT) 76 #undef V 77 } 78 79 return "UNKNOWN_ARES_ERROR"; 80 } 81 82 inline void cares_wrap_hostent_cpy( 83 struct hostent* dest, 84 const struct hostent* src) { 85 dest->h_addr_list = nullptr; 86 dest->h_addrtype = 0; 87 dest->h_aliases = nullptr; 88 dest->h_length = 0; 89 dest->h_name = nullptr; 90 91 /* copy `h_name` */ 92 size_t name_size = strlen(src->h_name) + 1; 93 dest->h_name = node::Malloc<char>(name_size); 94 memcpy(dest->h_name, src->h_name, name_size); 95 96 /* copy `h_aliases` */ 97 size_t alias_count; 98 for (alias_count = 0; 99 src->h_aliases[alias_count] != nullptr; 100 alias_count++) { 101 } 102 103 dest->h_aliases = node::Malloc<char*>(alias_count + 1); 104 for (size_t i = 0; i < alias_count; i++) { 105 const size_t cur_alias_size = strlen(src->h_aliases[i]) + 1; 106 dest->h_aliases[i] = node::Malloc(cur_alias_size); 107 memcpy(dest->h_aliases[i], src->h_aliases[i], cur_alias_size); 108 } 109 dest->h_aliases[alias_count] = nullptr; 110 111 /* copy `h_addr_list` */ 112 size_t list_count; 113 for (list_count = 0; 114 src->h_addr_list[list_count] != nullptr; 115 list_count++) { 116 } 117 118 dest->h_addr_list = node::Malloc<char*>(list_count + 1); 119 for (size_t i = 0; i < list_count; i++) { 120 dest->h_addr_list[i] = node::Malloc(src->h_length); 121 memcpy(dest->h_addr_list[i], src->h_addr_list[i], src->h_length); 122 } 123 dest->h_addr_list[list_count] = nullptr; 124 125 /* work after work */ 126 dest->h_length = src->h_length; 127 dest->h_addrtype = src->h_addrtype; 128 } 129 130 131 struct NodeAresTask final : public MemoryRetainer { 132 ChannelWrap* channel; 133 ares_socket_t sock; 134 uv_poll_t poll_watcher; 135 136 inline void MemoryInfo(MemoryTracker* trakcer) const override; 137 SET_MEMORY_INFO_NAME(NodeAresTask) 138 SET_SELF_SIZE(NodeAresTask) 139 140 struct Hash { 141 inline size_t operator()(NodeAresTask* a) const { 142 return std::hash<ares_socket_t>()(a->sock); 143 } 144 }; 145 146 struct Equal { 147 inline bool operator()(NodeAresTask* a, NodeAresTask* b) const { 148 return a->sock == b->sock; 149 } 150 }; 151 152 static NodeAresTask* Create(ChannelWrap* channel, ares_socket_t sock); 153 154 using List = std::unordered_set<NodeAresTask*, Hash, Equal>; 155 }; 156 157 class ChannelWrap final : public AsyncWrap { 158 public: 159 ChannelWrap( 160 Environment* env, 161 v8::Local<v8::Object> object, 162 int timeout, 163 int tries); 164 ~ChannelWrap() override; 165 166 static void New(const v8::FunctionCallbackInfo<v8::Value>& args); 167 168 void Setup(); 169 void EnsureServers(); 170 void StartTimer(); 171 void CloseTimer(); 172 173 void ModifyActivityQueryCount(int count); 174 175 inline uv_timer_t* timer_handle() { return timer_handle_; } 176 inline ares_channel cares_channel() { return channel_; } 177 inline void set_query_last_ok(bool ok) { query_last_ok_ = ok; } 178 inline void set_is_servers_default(bool is_default) { 179 is_servers_default_ = is_default; 180 } 181 inline int active_query_count() { return active_query_count_; } 182 inline NodeAresTask::List* task_list() { return &task_list_; } 183 184 void MemoryInfo(MemoryTracker* tracker) const override; 185 SET_MEMORY_INFO_NAME(ChannelWrap) 186 SET_SELF_SIZE(ChannelWrap) 187 188 static void AresTimeout(uv_timer_t* handle); 189 190 private: 191 uv_timer_t* timer_handle_ = nullptr; 192 ares_channel channel_ = nullptr; 193 bool query_last_ok_ = true; 194 bool is_servers_default_ = true; 195 bool library_inited_ = false; 196 int timeout_; 197 int tries_; 198 int active_query_count_ = 0; 199 NodeAresTask::List task_list_; 200 }; 201 202 class GetAddrInfoReqWrap final : public ReqWrap<uv_getaddrinfo_t> { 203 public: 204 GetAddrInfoReqWrap(Environment* env, 205 v8::Local<v8::Object> req_wrap_obj, 206 bool verbatim); 207 208 SET_NO_MEMORY_INFO() 209 SET_MEMORY_INFO_NAME(GetAddrInfoReqWrap) 210 SET_SELF_SIZE(GetAddrInfoReqWrap) 211 212 bool verbatim() const { return verbatim_; } 213 214 private: 215 const bool verbatim_; 216 }; 217 218 class GetNameInfoReqWrap final : public ReqWrap<uv_getnameinfo_t> { 219 public: 220 GetNameInfoReqWrap(Environment* env, v8::Local<v8::Object> req_wrap_obj); 221 222 SET_NO_MEMORY_INFO() 223 SET_MEMORY_INFO_NAME(GetNameInfoReqWrap) 224 SET_SELF_SIZE(GetNameInfoReqWrap) 225 }; 226 227 struct ResponseData final { 228 int status; 229 bool is_host; 230 SafeHostEntPointer host; 231 MallocedBuffer<unsigned char> buf; 232 }; 233 234 template <typename Traits> 235 class QueryWrap final : public AsyncWrap { 236 public: 237 QueryWrap(ChannelWrap* channel, v8::Local<v8::Object> req_wrap_obj) 238 : AsyncWrap(channel->env(), req_wrap_obj, AsyncWrap::PROVIDER_QUERYWRAP), 239 channel_(channel), 240 trace_name_(Traits::name) {} 241 242 ~QueryWrap() { 243 CHECK_EQ(false, persistent().IsEmpty()); 244 245 // Let Callback() know that this object no longer exists. 246 if (callback_ptr_ != nullptr) 247 *callback_ptr_ = nullptr; 248 } 249 250 int Send(const char* name) { 251 return Traits::Send(this, name); 252 } 253 254 void AresQuery(const char* name, int dnsclass, int type) { 255 channel_->EnsureServers(); 256 TRACE_EVENT_NESTABLE_ASYNC_BEGIN1( 257 TRACING_CATEGORY_NODE2(dns, native), trace_name_, this, 258 "name", TRACE_STR_COPY(name)); 259 ares_query( 260 channel_->cares_channel(), 261 name, 262 dnsclass, 263 type, 264 Callback, 265 MakeCallbackPointer()); 266 } 267 268 void ParseError(int status) { 269 CHECK_NE(status, ARES_SUCCESS); 270 v8::HandleScope handle_scope(env()->isolate()); 271 v8::Context::Scope context_scope(env()->context()); 272 const char* code = ToErrorCodeString(status); 273 v8::Local<v8::Value> arg = OneByteString(env()->isolate(), code); 274 TRACE_EVENT_NESTABLE_ASYNC_END1( 275 TRACING_CATEGORY_NODE2(dns, native), trace_name_, this, 276 "error", status); 277 MakeCallback(env()->oncomplete_string(), 1, &arg); 278 } 279 280 const BaseObjectPtr<ChannelWrap>& channel() const { return channel_; } 281 282 void AfterResponse() { 283 CHECK(response_data_); 284 285 int status = response_data_->status; 286 287 if (status != ARES_SUCCESS) 288 return ParseError(status); 289 290 status = Traits::Parse(this, response_data_); 291 292 if (status != ARES_SUCCESS) 293 ParseError(status); 294 } 295 296 void* MakeCallbackPointer() { 297 CHECK_NULL(callback_ptr_); 298 callback_ptr_ = new QueryWrap<Traits>*(this); 299 return callback_ptr_; 300 } 301 302 static QueryWrap<Traits>* FromCallbackPointer(void* arg) { 303 std::unique_ptr<QueryWrap<Traits>*> wrap_ptr { 304 static_cast<QueryWrap<Traits>**>(arg) 305 }; 306 QueryWrap<Traits>* wrap = *wrap_ptr.get(); 307 if (wrap == nullptr) return nullptr; 308 wrap->callback_ptr_ = nullptr; 309 return wrap; 310 } 311 312 static void Callback( 313 void* arg, 314 int status, 315 int timeouts, 316 unsigned char* answer_buf, 317 int answer_len) { 318 QueryWrap<Traits>* wrap = FromCallbackPointer(arg); 319 if (wrap == nullptr) return; 320 321 unsigned char* buf_copy = nullptr; 322 if (status == ARES_SUCCESS) { 323 buf_copy = node::Malloc<unsigned char>(answer_len); 324 memcpy(buf_copy, answer_buf, answer_len); 325 } 326 327 wrap->response_data_ = std::make_unique<ResponseData>(); 328 ResponseData* data = wrap->response_data_.get(); 329 data->status = status; 330 data->is_host = false; 331 data->buf = MallocedBuffer<unsigned char>(buf_copy, answer_len); 332 333 wrap->QueueResponseCallback(status); 334 } 335 336 static void Callback( 337 void* arg, 338 int status, 339 int timeouts, 340 struct hostent* host) { 341 QueryWrap<Traits>* wrap = FromCallbackPointer(arg); 342 if (wrap == nullptr) return; 343 344 struct hostent* host_copy = nullptr; 345 if (status == ARES_SUCCESS) { 346 host_copy = node::Malloc<hostent>(1); 347 cares_wrap_hostent_cpy(host_copy, host); 348 } 349 350 wrap->response_data_ = std::make_unique<ResponseData>(); 351 ResponseData* data = wrap->response_data_.get(); 352 data->status = status; 353 data->host.reset(host_copy); 354 data->is_host = true; 355 356 wrap->QueueResponseCallback(status); 357 } 358 359 void QueueResponseCallback(int status) { 360 BaseObjectPtr<QueryWrap<Traits>> strong_ref{this}; 361 env()->SetImmediate([this, strong_ref](Environment*) { 362 AfterResponse(); 363 364 // Delete once strong_ref goes out of scope. 365 Detach(); 366 }); 367 368 channel_->set_query_last_ok(status != ARES_ECONNREFUSED); 369 channel_->ModifyActivityQueryCount(-1); 370 } 371 372 void CallOnComplete( 373 v8::Local<v8::Value> answer, 374 v8::Local<v8::Value> extra = v8::Local<v8::Value>()) { 375 v8::HandleScope handle_scope(env()->isolate()); 376 v8::Context::Scope context_scope(env()->context()); 377 v8::Local<v8::Value> argv[] = { 378 v8::Integer::New(env()->isolate(), 0), 379 answer, 380 extra 381 }; 382 const int argc = arraysize(argv) - extra.IsEmpty(); 383 TRACE_EVENT_NESTABLE_ASYNC_END0( 384 TRACING_CATEGORY_NODE2(dns, native), trace_name_, this); 385 386 MakeCallback(env()->oncomplete_string(), argc, argv); 387 } 388 389 void MemoryInfo(MemoryTracker* tracker) const override { 390 tracker->TrackField("channel", channel_); 391 if (response_data_) { 392 tracker->TrackFieldWithSize("response", response_data_->buf.size); 393 } 394 } 395 396 SET_MEMORY_INFO_NAME(QueryWrap) 397 SET_SELF_SIZE(QueryWrap<Traits>) 398 399 private: 400 BaseObjectPtr<ChannelWrap> channel_; 401 402 std::unique_ptr<ResponseData> response_data_; 403 const char* trace_name_; 404 // Pointer to pointer to 'this' that can be reset from the destructor, 405 // in order to let Callback() know that 'this' no longer exists. 406 QueryWrap<Traits>** callback_ptr_ = nullptr; 407 }; 408 409 struct AnyTraits final { 410 static constexpr const char* name = "resolveAny"; 411 static int Send(QueryWrap<AnyTraits>* wrap, const char* name); 412 static int Parse( 413 QueryWrap<AnyTraits>* wrap, 414 const std::unique_ptr<ResponseData>& response); 415 }; 416 417 struct ATraits final { 418 static constexpr const char* name = "resolve4"; 419 static int Send(QueryWrap<ATraits>* wrap, const char* name); 420 static int Parse( 421 QueryWrap<ATraits>* wrap, 422 const std::unique_ptr<ResponseData>& response); 423 }; 424 425 struct AaaaTraits final { 426 static constexpr const char* name = "resolve6"; 427 static int Send(QueryWrap<AaaaTraits>* wrap, const char* name); 428 static int Parse( 429 QueryWrap<AaaaTraits>* wrap, 430 const std::unique_ptr<ResponseData>& response); 431 }; 432 433 struct CaaTraits final { 434 static constexpr const char* name = "resolveCaa"; 435 static int Send(QueryWrap<CaaTraits>* wrap, const char* name); 436 static int Parse( 437 QueryWrap<CaaTraits>* wrap, 438 const std::unique_ptr<ResponseData>& response); 439 }; 440 441 struct CnameTraits final { 442 static constexpr const char* name = "resolveCname"; 443 static int Send(QueryWrap<CnameTraits>* wrap, const char* name); 444 static int Parse( 445 QueryWrap<CnameTraits>* wrap, 446 const std::unique_ptr<ResponseData>& response); 447 }; 448 449 struct MxTraits final { 450 static constexpr const char* name = "resolveMx"; 451 static int Send(QueryWrap<MxTraits>* wrap, const char* name); 452 static int Parse( 453 QueryWrap<MxTraits>* wrap, 454 const std::unique_ptr<ResponseData>& response); 455 }; 456 457 struct NsTraits final { 458 static constexpr const char* name = "resolveNs"; 459 static int Send(QueryWrap<NsTraits>* wrap, const char* name); 460 static int Parse( 461 QueryWrap<NsTraits>* wrap, 462 const std::unique_ptr<ResponseData>& response); 463 }; 464 465 struct TxtTraits final { 466 static constexpr const char* name = "resolveTxt"; 467 static int Send(QueryWrap<TxtTraits>* wrap, const char* name); 468 static int Parse( 469 QueryWrap<TxtTraits>* wrap, 470 const std::unique_ptr<ResponseData>& response); 471 }; 472 473 struct SrvTraits final { 474 static constexpr const char* name = "resolveSrv"; 475 static int Send(QueryWrap<SrvTraits>* wrap, const char* name); 476 static int Parse( 477 QueryWrap<SrvTraits>* wrap, 478 const std::unique_ptr<ResponseData>& response); 479 }; 480 481 struct PtrTraits final { 482 static constexpr const char* name = "resolvePtr"; 483 static int Send(QueryWrap<PtrTraits>* wrap, const char* name); 484 static int Parse( 485 QueryWrap<PtrTraits>* wrap, 486 const std::unique_ptr<ResponseData>& response); 487 }; 488 489 struct NaptrTraits final { 490 static constexpr const char* name = "resolveNaptr"; 491 static int Send(QueryWrap<NaptrTraits>* wrap, const char* name); 492 static int Parse( 493 QueryWrap<NaptrTraits>* wrap, 494 const std::unique_ptr<ResponseData>& response); 495 }; 496 497 struct SoaTraits final { 498 static constexpr const char* name = "resolveSoa"; 499 static int Send(QueryWrap<SoaTraits>* wrap, const char* name); 500 static int Parse( 501 QueryWrap<SoaTraits>* wrap, 502 const std::unique_ptr<ResponseData>& response); 503 }; 504 505 struct ReverseTraits final { 506 static constexpr const char* name = "reverse"; 507 static int Send(QueryWrap<ReverseTraits>* wrap, const char* name); 508 static int Parse( 509 QueryWrap<ReverseTraits>* wrap, 510 const std::unique_ptr<ResponseData>& response); 511 }; 512 513 using QueryAnyWrap = QueryWrap<AnyTraits>; 514 using QueryAWrap = QueryWrap<ATraits>; 515 using QueryAaaaWrap = QueryWrap<AaaaTraits>; 516 using QueryCaaWrap = QueryWrap<CaaTraits>; 517 using QueryCnameWrap = QueryWrap<CnameTraits>; 518 using QueryMxWrap = QueryWrap<MxTraits>; 519 using QueryNsWrap = QueryWrap<NsTraits>; 520 using QueryTxtWrap = QueryWrap<TxtTraits>; 521 using QuerySrvWrap = QueryWrap<SrvTraits>; 522 using QueryPtrWrap = QueryWrap<PtrTraits>; 523 using QueryNaptrWrap = QueryWrap<NaptrTraits>; 524 using QuerySoaWrap = QueryWrap<SoaTraits>; 525 using GetHostByAddrWrap = QueryWrap<ReverseTraits>; 526 527 } // namespace cares_wrap 528 } // namespace node 529 530 #endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS 531 532 #endif // SRC_CARES_WRAP_H_
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
