@encharm/cws 4.4.1 → 4.5.2

package/src/headers/22/base_object_types.h

@@ -0,0 +1,74 @@
+#ifndef SRC_BASE_OBJECT_TYPES_H_
+#define SRC_BASE_OBJECT_TYPES_H_
+
+#include <cinttypes>
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+// List of internalBinding() data wrappers. The first argument should match
+// what the class passes to SET_BINDING_ID(), the second argument should match
+// the C++ class name.
+#define SERIALIZABLE_BINDING_TYPES(V)                                          \
+  V(encoding_binding_data, encoding_binding::BindingData)                      \
+  V(fs_binding_data, fs::BindingData)                                          \
+  V(mksnapshot_binding_data, mksnapshot::BindingData)                          \
+  V(v8_binding_data, v8_utils::BindingData)                                    \
+  V(blob_binding_data, BlobBindingData)                                        \
+  V(process_binding_data, process::BindingData)                                \
+  V(timers_binding_data, timers::BindingData)                                  \
+  V(url_binding_data, url::BindingData)                                        \
+  V(modules_binding_data, modules::BindingData)
+
+#define UNSERIALIZABLE_BINDING_TYPES(V)                                        \
+  V(http2_binding_data, http2::BindingData)                                    \
+  V(http_parser_binding_data, http_parser::BindingData)                        \
+  V(quic_binding_data, quic::BindingData)
+
+// List of (non-binding) BaseObjects that are serializable in the snapshot.
+// The first argument should match what the type passes to
+// SET_OBJECT_ID(), the second argument should match the C++ class
+// name.
+#define SERIALIZABLE_NON_BINDING_TYPES(V)
+
+// Helper list of all binding data wrapper types.
+#define BINDING_TYPES(V)                                                       \
+  SERIALIZABLE_BINDING_TYPES(V)                                                \
+  UNSERIALIZABLE_BINDING_TYPES(V)
+
+// Helper list of all BaseObjects that implement snapshot support.
+#define SERIALIZABLE_OBJECT_TYPES(V)                                           \
+  SERIALIZABLE_BINDING_TYPES(V)                                                \
+  SERIALIZABLE_NON_BINDING_TYPES(V)
+
+#define V(TypeId, NativeType) k_##TypeId,
+enum class BindingDataType : uint8_t { BINDING_TYPES(V) kBindingDataTypeCount };
+// Make sure that we put the bindings first so that we can also use the enums
+// for the bindings as index to the binding data store.
+enum class EmbedderObjectType : uint8_t {
+  BINDING_TYPES(V) SERIALIZABLE_NON_BINDING_TYPES(V)
+  // We do not need to know about all the unserializable non-binding types for
+  // now so we do not list them.
+  kEmbedderObjectTypeCount
+};
+#undef V
+
+// For now, BaseObjects only need to call this when they implement snapshot
+// support.
+#define SET_OBJECT_ID(TypeId)                                                  \
+  static constexpr EmbedderObjectType type_int = EmbedderObjectType::k_##TypeId;
+
+// Binding data should call this so that they can be looked up from the binding
+// data store.
+#define SET_BINDING_ID(TypeId)                                                 \
+  static constexpr BindingDataType binding_type_int =                          \
+      BindingDataType::k_##TypeId;                                             \
+  SET_OBJECT_ID(TypeId)                                                        \
+  static_assert(static_cast<uint8_t>(type_int) ==                              \
+                static_cast<uint8_t>(binding_type_int));
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE_OBJECT_TYPES_H_

package/src/headers/22/blob_serializer_deserializer-inl.h

@@ -0,0 +1,385 @@
+#ifndef SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_
+#define SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "blob_serializer_deserializer.h"
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "debug_utils-inl.h"
+
+// This is related to the blob that is used in snapshots and single executable
+// applications and has nothing to do with `node_blob.h`.
+
+namespace node {
+
+struct EnvSerializeInfo;
+struct PropInfo;
+struct RealmSerializeInfo;
+
+namespace builtins {
+struct CodeCacheInfo;
+}  // namespace builtins
+
+// These operator<< overload declarations are needed because
+// BlobSerializerDeserializer::ToStr() uses these.
+
+std::ostream& operator<<(std::ostream& output,
+                         const builtins::CodeCacheInfo& info);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<builtins::CodeCacheInfo>& vec);
+
+std::ostream& operator<<(std::ostream& output, const std::vector<uint8_t>& vec);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<PropInfo>& vec);
+
+std::ostream& operator<<(std::ostream& output, const PropInfo& info);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<std::string>& vec);
+
+std::ostream& operator<<(std::ostream& output, const RealmSerializeInfo& i);
+
+std::ostream& operator<<(std::ostream& output, const EnvSerializeInfo& i);
+
+template <typename... Args>
+void BlobSerializerDeserializer::Debug(const char* format,
+                                       Args&&... args) const {
+  if (is_debug) {
+    FPrintF(stderr, format, std::forward<Args>(args)...);
+  }
+}
+
+template <typename T>
+std::string BlobSerializerDeserializer::ToStr(const T& arg) const {
+  std::stringstream ss;
+  ss << arg;
+  return ss.str();
+}
+
+template <typename T>
+std::string BlobSerializerDeserializer::GetName() const {
+#define TYPE_LIST(V)                                                           \
+  V(builtins::CodeCacheInfo)                                                   \
+  V(PropInfo)                                                                  \
+  V(std::string)
+
+#define V(TypeName)                                                            \
+  if constexpr (std::is_same_v<T, TypeName>) {                                 \
+    return #TypeName;                                                          \
+  } else  // NOLINT(readability/braces)
+  TYPE_LIST(V)
+#undef V
+
+  if constexpr (std::is_arithmetic_v<T>) {
+    return (std::is_unsigned_v<T>   ? "uint"
+            : std::is_integral_v<T> ? "int"
+                                    : "float") +
+           std::to_string(sizeof(T) * 8) + "_t";
+  }
+  return "";
+}
+
+// Helper for reading numeric types.
+template <typename Impl>
+template <typename T>
+T BlobDeserializer<Impl>::ReadArithmetic() {
+  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
+  T result;
+  ReadArithmetic(&result, 1);
+  return result;
+}
+
+// Layout of vectors:
+// [ 4/8 bytes ] count
+// [   ...     ] contents (count * size of individual elements)
+template <typename Impl>
+template <typename T>
+std::vector<T> BlobDeserializer<Impl>::ReadVector() {
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("\nReadVector<%s>()(%d-byte)\n", name.c_str(), sizeof(T));
+  }
+  size_t count = static_cast<size_t>(ReadArithmetic<size_t>());
+  if (count == 0) {
+    return std::vector<T>();
+  }
+  if (is_debug) {
+    Debug("Reading %d vector elements...\n", count);
+  }
+  std::vector<T> result;
+  if constexpr (std::is_arithmetic_v<T>) {
+    result = ReadArithmeticVector<T>(count);
+  } else {
+    result = ReadNonArithmeticVector<T>(count);
+  }
+  if (is_debug) {
+    std::string str = std::is_arithmetic_v<T> ? "" : ToStr(result);
+    std::string name = GetName<T>();
+    Debug("ReadVector<%s>() read %s\n", name.c_str(), str.c_str());
+  }
+  return result;
+}
+
+template <typename Impl>
+std::string BlobDeserializer<Impl>::ReadString() {
+  std::string_view view = ReadStringView(StringLogMode::kAddressAndContent);
+  return std::string(view);
+}
+
+template <typename Impl>
+std::string_view BlobDeserializer<Impl>::ReadStringView(StringLogMode mode) {
+  size_t length = ReadArithmetic<size_t>();
+  Debug("ReadStringView(), length=%zu: ", length);
+
+  if (length == 0) {
+    Debug("ReadStringView() read an empty view\n");
+    return std::string_view();
+  }
+
+  std::string_view result(sink.data() + read_total, length);
+  Debug("%p, read %zu bytes", result.data(), result.size());
+  if (mode == StringLogMode::kAddressAndContent) {
+    Debug(", content:%s%s", length > 32 ? "\n" : " ", result);
+  }
+  Debug("\n");
+
+  read_total += length;
+  return result;
+}
+
+// Helper for reading an array of numeric types.
+template <typename Impl>
+template <typename T>
+void BlobDeserializer<Impl>::ReadArithmetic(T* out, size_t count) {
+  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("Read<%s>()(%d-byte), count=%d: ", name.c_str(), sizeof(T), count);
+  }
+
+  size_t size = sizeof(T) * count;
+  memcpy(out, sink.data() + read_total, size);
+
+  if (is_debug) {
+    std::string str =
+        "{ " + std::to_string(out[0]) + (count > 1 ? ", ... }" : " }");
+    Debug("%s, read %zu bytes\n", str.c_str(), size);
+  }
+  read_total += size;
+}
+
+// Helper for reading numeric vectors.
+template <typename Impl>
+template <typename Number>
+std::vector<Number> BlobDeserializer<Impl>::ReadArithmeticVector(size_t count) {
+  static_assert(std::is_arithmetic_v<Number>, "Not an arithmetic type");
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  std::vector<Number> result(count);
+  ReadArithmetic(result.data(), count);
+  return result;
+}
+
+// Helper for reading non-numeric vectors.
+template <typename Impl>
+template <typename T>
+std::vector<T> BlobDeserializer<Impl>::ReadNonArithmeticVector(size_t count) {
+  static_assert(!std::is_arithmetic_v<T>, "Arithmetic type");
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  std::vector<T> result;
+  result.reserve(count);
+  bool original_is_debug = is_debug;
+  is_debug = original_is_debug && !std::is_same_v<T, std::string>;
+  for (size_t i = 0; i < count; ++i) {
+    if (is_debug) {
+      Debug("\n[%d] ", i);
+    }
+    result.push_back(ReadElement<T>());
+  }
+  is_debug = original_is_debug;
+
+  return result;
+}
+
+template <typename Impl>
+template <typename T>
+T BlobDeserializer<Impl>::ReadElement() {
+  if constexpr (std::is_arithmetic_v<T>) {
+    return ReadArithmetic<T>();
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    return ReadString();
+  } else {
+    return impl()->template Read<T>();
+  }
+}
+
+// Helper for writing numeric types.
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteArithmetic(const T& data) {
+  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
+  return WriteArithmetic(&data, 1);
+}
+
+// Layout of vectors:
+// [ 4/8 bytes ] count
+// [   ...     ] contents (count * size of individual elements)
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteVector(const std::vector<T>& data) {
+  if (is_debug) {
+    std::string str = std::is_arithmetic_v<T> ? "" : ToStr(data);
+    std::string name = GetName<T>();
+    Debug("\nAt 0x%x: WriteVector<%s>() (%d-byte), count=%d: %s\n",
+          sink.size(),
+          name.c_str(),
+          sizeof(T),
+          data.size(),
+          str.c_str());
+  }
+
+  size_t written_total = WriteArithmetic<size_t>(data.size());
+  if (data.empty()) {
+    return written_total;
+  }
+
+  if constexpr (std::is_arithmetic_v<T>) {
+    written_total += WriteArithmeticVector<T>(data);
+  } else {
+    written_total += WriteNonArithmeticVector<T>(data);
+  }
+
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("WriteVector<%s>() wrote %d bytes\n", name.c_str(), written_total);
+  }
+
+  return written_total;
+}
+
+// The layout of a written string:
+// [  4/8 bytes     ] length
+// [ |length| bytes ] contents
+template <typename Impl>
+size_t BlobSerializer<Impl>::WriteStringView(std::string_view data,
+                                             StringLogMode mode) {
+  Debug("At 0x%x: WriteStringView(), length=%zu: %p\n",
+        sink.size(),
+        data.size(),
+        data.data());
+  size_t written_total = WriteArithmetic<size_t>(data.size());
+
+  size_t length = data.size();
+  if (length == 0) {
+    Debug("WriteStringView() wrote an empty view\n");
+    return written_total;
+  }
+  sink.insert(sink.end(), data.data(), data.data() + length);
+  written_total += length;
+
+  Debug("WriteStringView() wrote %zu bytes\n", written_total);
+  if (mode == StringLogMode::kAddressAndContent) {
+    Debug("%s", data);
+  }
+
+  return written_total;
+}
+
+template <typename Impl>
+size_t BlobSerializer<Impl>::WriteString(const std::string& data) {
+  return WriteStringView(data, StringLogMode::kAddressAndContent);
+}
+
+static size_t kPreviewCount = 16;
+
+// Helper for writing an array of numeric types.
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteArithmetic(const T* data, size_t count) {
+  static_assert(std::is_arithmetic_v<T>, "Arithmetic type");
+  DCHECK_GT(count, 0);  // Should not write contents for vectors of size 0.
+  if (is_debug) {
+    size_t preview_count = count < kPreviewCount ? count : kPreviewCount;
+    std::string str = "{ ";
+    for (size_t i = 0; i < preview_count; ++i) {
+      str += (std::to_string(data[i]) + ",");
+    }
+    if (count > preview_count) {
+      str += "...";
+    }
+    str += "}";
+    std::string name = GetName<T>();
+    Debug("At 0x%x: Write<%s>() (%zu-byte), count=%zu: %s",
+          sink.size(),
+          name.c_str(),
+          sizeof(T),
+          count,
+          str.c_str());
+  }
+
+  size_t size = sizeof(T) * count;
+  const char* pos = reinterpret_cast<const char*>(data);
+  sink.insert(sink.end(), pos, pos + size);
+
+  if (is_debug) {
+    Debug(", wrote %zu bytes\n", size);
+  }
+  return size;
+}
+
+// Helper for writing numeric vectors.
+template <typename Impl>
+template <typename Number>
+size_t BlobSerializer<Impl>::WriteArithmeticVector(
+    const std::vector<Number>& data) {
+  static_assert(std::is_arithmetic_v<Number>, "Arithmetic type");
+  return WriteArithmetic(data.data(), data.size());
+}
+
+// Helper for writing non-numeric vectors.
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteNonArithmeticVector(
+    const std::vector<T>& data) {
+  static_assert(!std::is_arithmetic_v<T>, "Arithmetic type");
+  DCHECK_GT(data.size(),
+            0);  // Should not write contents for vectors of size 0.
+  size_t written_total = 0;
+  bool original_is_debug = is_debug;
+  is_debug = original_is_debug && !std::is_same_v<T, std::string>;
+  for (size_t i = 0; i < data.size(); ++i) {
+    if (is_debug) {
+      Debug("\n[%d] ", i);
+    }
+    written_total += WriteElement<T>(data[i]);
+  }
+  is_debug = original_is_debug;
+
+  return written_total;
+}
+
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteElement(const T& data) {
+  if constexpr (std::is_arithmetic_v<T>) {
+    return WriteArithmetic<T>(data);
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    return WriteString(data);
+  } else {
+    return impl()->template Write<T>(data);
+  }
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_

package/src/headers/22/blob_serializer_deserializer.h

@@ -0,0 +1,132 @@
+#ifndef SRC_BLOB_SERIALIZER_DESERIALIZER_H_
+#define SRC_BLOB_SERIALIZER_DESERIALIZER_H_
+
+#include <string>
+#include <vector>
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+// This is related to the blob that is used in snapshots and single executable
+// applications and has nothing to do with `node_blob.h`.
+
+namespace node {
+
+class BlobSerializerDeserializer {
+ public:
+  explicit BlobSerializerDeserializer(bool is_debug_v) : is_debug(is_debug_v) {}
+
+  template <typename... Args>
+  void Debug(const char* format, Args&&... args) const;
+
+  template <typename T>
+  std::string ToStr(const T& arg) const;
+
+  template <typename T>
+  std::string GetName() const;
+
+  bool is_debug = false;
+};
+
+enum class StringLogMode {
+  kAddressOnly,  // Can be used when the string contains binary content.
+  kAddressAndContent,
+};
+
+// Child classes are expected to implement T Read<T>() where
+// !std::is_arithmetic_v<T> && !std::is_same_v<T, std::string>
+template <typename Impl>
+class BlobDeserializer : public BlobSerializerDeserializer {
+ public:
+  explicit BlobDeserializer(bool is_debug_v, std::string_view s)
+      : BlobSerializerDeserializer(is_debug_v), sink(s) {}
+  ~BlobDeserializer() = default;
+
+  size_t read_total = 0;
+  std::string_view sink;
+
+  Impl* impl() { return static_cast<Impl*>(this); }
+  const Impl* impl() const { return static_cast<const Impl*>(this); }
+
+  // Helper for reading numeric types.
+  template <typename T>
+  T ReadArithmetic();
+
+  // Layout of vectors:
+  // [ 4/8 bytes ] count
+  // [   ...     ] contents (count * size of individual elements)
+  template <typename T>
+  std::vector<T> ReadVector();
+
+  // ReadString() creates a copy of the data. ReadStringView() doesn't.
+  std::string ReadString();
+  std::string_view ReadStringView(StringLogMode mode);
+
+  // Helper for reading an array of numeric types.
+  template <typename T>
+  void ReadArithmetic(T* out, size_t count);
+
+  // Helper for reading numeric vectors.
+  template <typename Number>
+  std::vector<Number> ReadArithmeticVector(size_t count);
+
+ private:
+  // Helper for reading non-numeric vectors.
+  template <typename T>
+  std::vector<T> ReadNonArithmeticVector(size_t count);
+
+  template <typename T>
+  T ReadElement();
+};
+
+// Child classes are expected to implement size_t Write<T>(const T&) where
+// !std::is_arithmetic_v<T> && !std::is_same_v<T, std::string>
+template <typename Impl>
+class BlobSerializer : public BlobSerializerDeserializer {
+ public:
+  explicit BlobSerializer(bool is_debug_v)
+      : BlobSerializerDeserializer(is_debug_v) {}
+  ~BlobSerializer() = default;
+
+  Impl* impl() { return static_cast<Impl*>(this); }
+  const Impl* impl() const { return static_cast<const Impl*>(this); }
+
+  std::vector<char> sink;
+
+  // Helper for writing numeric types.
+  template <typename T>
+  size_t WriteArithmetic(const T& data);
+
+  // Layout of vectors:
+  // [ 4/8 bytes ] count
+  // [   ...     ] contents (count * size of individual elements)
+  template <typename T>
+  size_t WriteVector(const std::vector<T>& data);
+
+  // The layout of a written string:
+  // [  4/8 bytes     ] length
+  // [ |length| bytes ] contents
+  size_t WriteStringView(std::string_view data, StringLogMode mode);
+  size_t WriteString(const std::string& data);
+
+  // Helper for writing an array of numeric types.
+  template <typename T>
+  size_t WriteArithmetic(const T* data, size_t count);
+
+  // Helper for writing numeric vectors.
+  template <typename Number>
+  size_t WriteArithmeticVector(const std::vector<Number>& data);
+
+ private:
+  // Helper for writing non-numeric vectors.
+  template <typename T>
+  size_t WriteNonArithmeticVector(const std::vector<T>& data);
+
+  template <typename T>
+  size_t WriteElement(const T& data);
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BLOB_SERIALIZER_DESERIALIZER_H_

package/src/headers/{16 → 22}/callback_queue.h

@@ -4,6 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include <atomic>
+#include <memory>
 
 namespace node {
 

package/src/headers/{16 → 22}/cares_wrap.h

@@ -9,8 +9,9 @@
 #include "base_object.h"
 #include "env.h"
 #include "memory_tracker.h"
-#include "util.h"
 #include "node.h"
+#include "node_internals.h"
+#include "util.h"
 
 #include "ares.h"
 #include "v8.h"
@@ -29,6 +30,9 @@ namespace cares_wrap {
 
 constexpr int ns_t_cname_or_a = -1;
 constexpr int DNS_ESETSRVPENDING = -1000;
+constexpr uint8_t DNS_ORDER_VERBATIM = 0;
+constexpr uint8_t DNS_ORDER_IPV4_FIRST = 1;
+constexpr uint8_t DNS_ORDER_IPV6_FIRST = 2;
 
 class ChannelWrap;
 
@@ -194,16 +198,16 @@ class GetAddrInfoReqWrap final : public ReqWrap<uv_getaddrinfo_t> {
  public:
   GetAddrInfoReqWrap(Environment* env,
                      v8::Local<v8::Object> req_wrap_obj,
-                     bool verbatim);
+                     uint8_t order);
 
   SET_NO_MEMORY_INFO()
   SET_MEMORY_INFO_NAME(GetAddrInfoReqWrap)
   SET_SELF_SIZE(GetAddrInfoReqWrap)
 
-  bool verbatim() const { return verbatim_; }
+  uint8_t order() const { return order_; }
 
  private:
-  const bool verbatim_;
+  const uint8_t order_;
 };
 
 class GetNameInfoReqWrap final : public ReqWrap<uv_getnameinfo_t> {
@@ -242,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) {
@@ -300,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>();