diff --git a/doc/api/dns.md b/doc/api/dns.md
index c41c886034d7ba..3813712305abe8 100644
--- a/doc/api/dns.md
+++ b/doc/api/dns.md
@@ -210,6 +210,7 @@ records. The type and structure of individual results varies based on `rrtype`:
 | `'SOA'`   | start of authority records     | {Object}    | [`dns.resolveSoa()`][]   |
 | `'SRV'`   | service records                | {Object}    | [`dns.resolveSrv()`][]   |
 | `'TXT'`   | text records                   | {string}    | [`dns.resolveTxt()`][]   |
+| `'ANY'`   | any records                    | {Object}    | [`dns.resolveAny()`][]   |
 
 On error, `err` is an [`Error`][] object, where `err.code` is one of the
 [DNS error codes](#dns_error_codes).
@@ -430,6 +431,51 @@ is a two-dimensional array of the text records available for `hostname` (e.g.,
 one record. Depending on the use case, these could be either joined together or
 treated separately.
 
+## dns.resolveAny(hostname, callback)
+
+- `hostname` {string}
+- `callback` {Function}
+  - `err` {Error}
+  - `ret` {Object[][]}
+
+Uses the DNS protocol to resolve all records (also known as `ANY` or `*` query).
+The `ret` argument passed to the `callback` function will be an array containing
+various types of records. Each object has a property `type` that indicates the
+type of the current record. And depending on the `type`, additional properties
+will be present on the object:
+
+| Type | Properties |
+|------|------------|
+| `"A"` | `address` / `ttl` |
+| `"AAAA"` | `address` / `ttl` |
+| `"CNAME"` | `value` |
+| `"MX"` | Refer to [`dns.resolveMx()`][] |
+| `"NAPTR"` | Refer to [`dns.resolveNaptr()`][] |
+| `"NS"` | `value` |
+| `"PTR"` | `value` |
+| `"SOA"` | Refer to [`dns.resolveSoa()`][] |
+| `"SRV"` | Refer to [`dns.resolveSrv()`][] |
+| `"TXT"` | This type of record contains an array property called `entries` which refers to [`dns.resolveTxt()`][], eg. `{ entries: ['...'], type: 'TXT' }` |
+
+Here is a example of the `ret` object passed to the callback:
+
+<!-- eslint-disable -->
+```js
+[ { type: 'A', address: '127.0.0.1', ttl: 299 },
+  { type: 'CNAME', value: 'example.com' },
+  { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
+  { type: 'NS', value: 'ns1.example.com', type: 'NS' },
+  { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
+  { type: 'SOA',
+    nsname: 'ns1.example.com',
+    hostmaster: 'admin.example.com',
+    serial: 156696742,
+    refresh: 900,
+    retry: 900,
+    expire: 1800,
+    minttl: 60 } ]
+```
+
 ## dns.reverse(ip, callback)
 <!-- YAML
 added: v0.1.16
@@ -554,6 +600,7 @@ uses. For instance, _they do not use the configuration from `/etc/hosts`_.
 [`dns.resolveSoa()`]: #dns_dns_resolvesoa_hostname_callback
 [`dns.resolveSrv()`]: #dns_dns_resolvesrv_hostname_callback
 [`dns.resolveTxt()`]: #dns_dns_resolvetxt_hostname_callback
+[`dns.resolveAny()`]: #dns_dns_resolveany_hostname_callback
 [DNS error codes]: #dns_error_codes
 [Implementation considerations section]: #dns_implementation_considerations
 [supported `getaddrinfo` flags]: #dns_supported_getaddrinfo_flags
diff --git a/lib/dns.js b/lib/dns.js
index f69457239c8136..c3678ecc6182e9 100644
--- a/lib/dns.js
+++ b/lib/dns.js
@@ -269,6 +269,7 @@ function resolver(bindingName) {
 
 
 var resolveMap = Object.create(null);
+resolveMap.ANY = resolver('queryAny');
 resolveMap.A = resolver('queryA');
 resolveMap.AAAA = resolver('queryAaaa');
 resolveMap.CNAME = resolver('queryCname');
@@ -364,6 +365,7 @@ module.exports = {
   getServers,
   setServers,
   resolve,
+  resolveAny: resolveMap.ANY,
   resolve4: resolveMap.A,
   resolve6: resolveMap.AAAA,
   resolveCname: resolveMap.CNAME,
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index 25527d6f8c3593..41a5633ee022f1 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -69,6 +69,19 @@ using v8::Value;
 
 namespace {
 
+inline uint16_t cares_get_16bit(const unsigned char* p) {
+  return static_cast<uint32_t>(p[0] << 8U) | (static_cast<uint32_t>(p[1]));
+}
+
+inline uint32_t cares_get_32bit(const unsigned char* p) {
+  return static_cast<uint32_t>(p[0] << 24U) |
+         static_cast<uint32_t>(p[1] << 16U) |
+         static_cast<uint32_t>(p[2] << 8U) |
+         static_cast<uint32_t>(p[3]);
+}
+
+const int ns_t_cname_or_a = -1;
+
 inline const char* ToErrorCodeString(int status) {
   switch (status) {
 #define V(code) case ARES_##code: return #code;
@@ -270,31 +283,41 @@ void ares_sockstate_cb(void* data,
 }
 
 
-Local<Array> HostentToAddresses(Environment* env, struct hostent* host) {
+Local<Array> HostentToAddresses(Environment* env,
+                                struct hostent* host,
+                                Local<Array> append_to = Local<Array>()) {
   EscapableHandleScope scope(env->isolate());
-  Local<Array> addresses = Array::New(env->isolate());
+  auto context = env->context();
+  bool append = !append_to.IsEmpty();
+  Local<Array> addresses = append ? append_to : Array::New(env->isolate());
+  size_t offset = addresses->Length();
 
   char ip[INET6_ADDRSTRLEN];
   for (uint32_t i = 0; host->h_addr_list[i] != nullptr; ++i) {
     uv_inet_ntop(host->h_addrtype, host->h_addr_list[i], ip, sizeof(ip));
     Local<String> address = OneByteString(env->isolate(), ip);
-    addresses->Set(i, address);
+    addresses->Set(context, i + offset, address).FromJust();
   }
 
-  return scope.Escape(addresses);
+  return append ? addresses : scope.Escape(addresses);
 }
 
 
-Local<Array> HostentToNames(Environment* env, struct hostent* host) {
+Local<Array> HostentToNames(Environment* env,
+                            struct hostent* host,
+                            Local<Array> append_to = Local<Array>()) {
   EscapableHandleScope scope(env->isolate());
-  Local<Array> names = Array::New(env->isolate());
+  auto context = env->context();
+  bool append = !append_to.IsEmpty();
+  Local<Array> names = append ? append_to : Array::New(env->isolate());
+  size_t offset = names->Length();
 
   for (uint32_t i = 0; host->h_aliases[i] != nullptr; ++i) {
     Local<String> address = OneByteString(env->isolate(), host->h_aliases[i]);
-    names->Set(i, address);
+    names->Set(context, i + offset, address).FromJust();
   }
 
-  return scope.Escape(names);
+  return append ? names : scope.Escape(names);
 }
 
 void safe_free_hostent(struct hostent* host) {
@@ -604,6 +627,612 @@ class QueryWrap : public AsyncWrap {
 };
 
 
+template<typename T>
+Local<Array> AddrTTLToArray(Environment* env,
+                            const T* addrttls,
+                            size_t naddrttls) {
+  auto isolate = env->isolate();
+  EscapableHandleScope escapable_handle_scope(isolate);
+  auto context = env->context();
+
+  Local<Array> ttls = Array::New(isolate, naddrttls);
+  for (size_t i = 0; i < naddrttls; i++) {
+    auto value = Integer::New(isolate, addrttls[i].ttl);
+    ttls->Set(context, i, value).FromJust();
+  }
+
+  return escapable_handle_scope.Escape(ttls);
+}
+
+
+int ParseGeneralReply(Environment* env,
+                      const unsigned char* buf,
+                      int len,
+                      int* type,
+                      Local<Array> ret,
+                      void* addrttls = nullptr,
+                      int* naddrttls = nullptr) {
+  HandleScope handle_scope(env->isolate());
+  auto context = env->context();
+  hostent* host;
+
+  int status;
+  switch (*type) {
+    case ns_t_a:
+    case ns_t_cname:
+    case ns_t_cname_or_a:
+      status = ares_parse_a_reply(buf,
+                                  len,
+                                  &host,
+                                  static_cast<ares_addrttl*>(addrttls),
+                                  naddrttls);
+      break;
+    case ns_t_aaaa:
+      status = ares_parse_aaaa_reply(buf,
+                                     len,
+                                     &host,
+                                     static_cast<ares_addr6ttl*>(addrttls),
+                                     naddrttls);
+      break;
+    case ns_t_ns:
+      status = ares_parse_ns_reply(buf, len, &host);
+      break;
+    case ns_t_ptr:
+      status = ares_parse_ptr_reply(buf, len, NULL, 0, AF_INET, &host);
+      break;
+    default:
+      CHECK(0 && "Bad NS type");
+      break;
+  }
+
+  if (status != ARES_SUCCESS)
+    return status;
+
+  /* If it's `CNAME`, return the CNAME value;
+   * And if it's `CNAME_OR_A` and it has value in `h_name` and `h_aliases[0]`,
+   * we consider it's a CNAME record, otherwise we consider it's an A record. */
+  if ((*type == ns_t_cname_or_a && host->h_name && host->h_aliases[0]) ||
+      *type == ns_t_cname) {
+    // A cname lookup always returns a single record but we follow the
+    // common API here.
+    *type = ns_t_cname;
+    ret->Set(context,
+             ret->Length(),
+             OneByteString(env->isolate(), host->h_name)).FromJust();
+    ares_free_hostent(host);
+    return ARES_SUCCESS;
+  }
+
+  if (*type == ns_t_cname_or_a)
+    *type = ns_t_a;
+
+  if (*type == ns_t_ns) {
+    HostentToNames(env, host, ret);
+  } else if (*type == ns_t_ptr) {
+    uint32_t offset = ret->Length();
+    for (uint32_t i = 0; host->h_aliases[i] != NULL; i++) {
+      ret->Set(context,
+               i + offset,
+               OneByteString(env->isolate(), host->h_aliases[i])).FromJust();
+    }
+  } else {
+    HostentToAddresses(env, host, ret);
+  }
+
+  ares_free_hostent(host);
+
+  return ARES_SUCCESS;
+}
+
+
+int ParseMxReply(Environment* env,
+                 const unsigned char* buf,
+                 int len,
+                 Local<Array> ret,
+                 bool need_type = false) {
+  HandleScope handle_scope(env->isolate());
+  auto context = env->context();
+
+  struct ares_mx_reply* mx_start;
+  int status = ares_parse_mx_reply(buf, len, &mx_start);
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  Local<String> exchange_symbol = env->exchange_string();
+  Local<String> priority_symbol = env->priority_string();
+  Local<String> type_symbol = env->type_string();
+  Local<String> mx_symbol = env->dns_mx_string();
+
+  uint32_t offset = ret->Length();
+  ares_mx_reply* current = mx_start;
+  for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
+    Local<Object> mx_record = Object::New(env->isolate());
+    mx_record->Set(context,
+                   exchange_symbol,
+                   OneByteString(env->isolate(), current->host)).FromJust();
+    mx_record->Set(context,
+                   priority_symbol,
+                   Integer::New(env->isolate(), current->priority)).FromJust();
+    if (need_type)
+      mx_record->Set(context, type_symbol, mx_symbol).FromJust();
+
+    ret->Set(context, i + offset, mx_record).FromJust();
+  }
+
+  ares_free_data(mx_start);
+  return ARES_SUCCESS;
+}
+
+int ParseTxtReply(Environment* env,
+                  const unsigned char* buf,
+                  int len,
+                  Local<Array> ret,
+                  bool need_type = false) {
+  HandleScope handle_scope(env->isolate());
+  auto context = env->context();
+
+  struct ares_txt_ext* txt_out;
+
+  int status = ares_parse_txt_reply_ext(buf, len, &txt_out);
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  Local<Array> txt_chunk;
+
+  struct ares_txt_ext* current = txt_out;
+  uint32_t i = 0, j;
+  uint32_t offset = ret->Length();
+  for (j = 0; current != nullptr; current = current->next) {
+    Local<String> txt = OneByteString(env->isolate(), current->txt);
+
+    // New record found - write out the current chunk
+    if (current->record_start) {
+      if (!txt_chunk.IsEmpty()) {
+        if (need_type) {
+          Local<Object> elem = Object::New(env->isolate());
+          elem->Set(context, env->entries_string(), txt_chunk).FromJust();
+          elem->Set(context,
+                    env->type_string(),
+                    env->dns_txt_string()).FromJust();
+          ret->Set(context, offset + i++, elem).FromJust();
+        } else {
+          ret->Set(context, offset + i++, txt_chunk).FromJust();
+        }
+      }
+
+      txt_chunk = Array::New(env->isolate());
+      j = 0;
+    }
+
+    txt_chunk->Set(context, j++, txt).FromJust();
+  }
+
+  // Push last chunk if it isn't empty
+  if (!txt_chunk.IsEmpty()) {
+    if (need_type) {
+      Local<Object> elem = Object::New(env->isolate());
+      elem->Set(context, env->entries_string(), txt_chunk).FromJust();
+      elem->Set(context,
+                env->type_string(),
+                env->dns_txt_string()).FromJust();
+      ret->Set(context, offset + i, elem).FromJust();
+    } else {
+      ret->Set(context, offset + i, txt_chunk).FromJust();
+    }
+  }
+
+  ares_free_data(txt_out);
+  return ARES_SUCCESS;
+}
+
+
+int ParseSrvReply(Environment* env,
+                  const unsigned char* buf,
+                  int len,
+                  Local<Array> ret,
+                  bool need_type = false) {
+  HandleScope handle_scope(env->isolate());
+  auto context = env->context();
+
+  struct ares_srv_reply* srv_start;
+  int status = ares_parse_srv_reply(buf, len, &srv_start);
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  Local<String> name_symbol = env->name_string();
+  Local<String> port_symbol = env->port_string();
+  Local<String> priority_symbol = env->priority_string();
+  Local<String> weight_symbol = env->weight_string();
+  Local<String> type_symbol = env->type_string();
+  Local<String> srv_symbol = env->dns_srv_string();
+
+  ares_srv_reply* current = srv_start;
+  int offset = ret->Length();
+  for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
+    Local<Object> srv_record = Object::New(env->isolate());
+    srv_record->Set(context,
+                    name_symbol,
+                    OneByteString(env->isolate(), current->host)).FromJust();
+    srv_record->Set(context,
+                    port_symbol,
+                    Integer::New(env->isolate(), current->port)).FromJust();
+    srv_record->Set(context,
+                    priority_symbol,
+                    Integer::New(env->isolate(), current->priority)).FromJust();
+    srv_record->Set(context,
+                    weight_symbol,
+                    Integer::New(env->isolate(), current->weight)).FromJust();
+    if (need_type)
+      srv_record->Set(context, type_symbol, srv_symbol).FromJust();
+
+    ret->Set(context, i + offset, srv_record).FromJust();
+  }
+
+  ares_free_data(srv_start);
+  return ARES_SUCCESS;
+}
+
+
+int ParseNaptrReply(Environment* env,
+                    const unsigned char* buf,
+                    int len,
+                    Local<Array> ret,
+                    bool need_type = false) {
+  HandleScope handle_scope(env->isolate());
+  auto context = env->context();
+
+  ares_naptr_reply* naptr_start;
+  int status = ares_parse_naptr_reply(buf, len, &naptr_start);
+
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  Local<String> flags_symbol = env->flags_string();
+  Local<String> service_symbol = env->service_string();
+  Local<String> regexp_symbol = env->regexp_string();
+  Local<String> replacement_symbol = env->replacement_string();
+  Local<String> order_symbol = env->order_string();
+  Local<String> preference_symbol = env->preference_string();
+  Local<String> type_symbol = env->type_string();
+  Local<String> naptr_symbol = env->dns_naptr_string();
+
+  ares_naptr_reply* current = naptr_start;
+  int offset = ret->Length();
+  for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
+    Local<Object> naptr_record = Object::New(env->isolate());
+    naptr_record->Set(context,
+                      flags_symbol,
+                      OneByteString(env->isolate(), current->flags)).FromJust();
+    naptr_record->Set(context,
+                      service_symbol,
+                      OneByteString(env->isolate(),
+                                    current->service)).FromJust();
+    naptr_record->Set(context,
+                      regexp_symbol,
+                      OneByteString(env->isolate(),
+                                    current->regexp)).FromJust();
+    naptr_record->Set(context,
+                      replacement_symbol,
+                      OneByteString(env->isolate(),
+                                    current->replacement)).FromJust();
+    naptr_record->Set(context,
+                      order_symbol,
+                      Integer::New(env->isolate(), current->order)).FromJust();
+    naptr_record->Set(context,
+                      preference_symbol,
+                      Integer::New(env->isolate(),
+                                   current->preference)).FromJust();
+    if (need_type)
+      naptr_record->Set(context, type_symbol, naptr_symbol).FromJust();
+
+    ret->Set(context, i + offset, naptr_record).FromJust();
+  }
+
+  ares_free_data(naptr_start);
+  return ARES_SUCCESS;
+}
+
+
+int ParseSoaReply(Environment* env,
+                  unsigned char* buf,
+                  int len,
+                  Local<Object>* ret) {
+  EscapableHandleScope handle_scope(env->isolate());
+  auto context = env->context();
+
+  /* Can't use ares_parse_soa_reply() here which can only parse single record */
+  unsigned int ancount = cares_get_16bit(buf + 6);
+  unsigned char* ptr = buf + NS_HFIXEDSZ;
+  int rr_type, rr_len;
+  char* name;
+  char* rr_name;
+  long temp_len;  // NOLINT(runtime/int)
+  int status = ares_expand_name(ptr, buf, len, &name, &temp_len);
+  if (status != ARES_SUCCESS) {
+    /* returns EBADRESP in case of invalid input */
+    return status == ARES_EBADNAME ? ARES_EBADRESP : status;
+  }
+
+  if (ptr + temp_len + NS_QFIXEDSZ > buf + len) {
+    free(name);
+    return ARES_EBADRESP;
+  }
+  ptr += temp_len + NS_QFIXEDSZ;
+
+  for (unsigned int i = 0; i < ancount; i++) {
+    status = ares_expand_name(ptr, buf, len, &rr_name, &temp_len);
+
+    if (status != ARES_SUCCESS)
+      break;
+
+    ptr += temp_len;
+    if (ptr + NS_RRFIXEDSZ > buf + len) {
+      free(rr_name);
+      status = ARES_EBADRESP;
+      break;
+    }
+
+    rr_type = cares_get_16bit(ptr);
+    rr_len = cares_get_16bit(ptr + 8);
+    ptr += NS_RRFIXEDSZ;
+
+    /* only need SOA */
+    if (rr_type == ns_t_soa) {
+      ares_soa_reply soa;
+
+      status = ares_expand_name(ptr, buf, len, &soa.nsname, &temp_len);
+      if (status != ARES_SUCCESS) {
+        free(rr_name);
+        break;
+      }
+      ptr += temp_len;
+
+      status = ares_expand_name(ptr, buf, len, &soa.hostmaster, &temp_len);
+      if (status != ARES_SUCCESS) {
+        free(rr_name);
+        free(soa.nsname);
+        break;
+      }
+      ptr += temp_len;
+
+      if (ptr + 5 * 4 > buf + len) {
+        free(rr_name);
+        free(soa.nsname);
+        free(soa.hostmaster);
+        status = ARES_EBADRESP;
+        break;
+      }
+
+      soa.serial = cares_get_32bit(ptr + 0 * 4);
+      soa.refresh = cares_get_32bit(ptr + 1 * 4);
+      soa.retry = cares_get_32bit(ptr + 2 * 4);
+      soa.expire = cares_get_32bit(ptr + 3 * 4);
+      soa.minttl = cares_get_32bit(ptr + 4 * 4);
+
+      Local<Object> soa_record = Object::New(env->isolate());
+      soa_record->Set(context,
+                      env->nsname_string(),
+                      OneByteString(env->isolate(), soa.nsname)).FromJust();
+      soa_record->Set(context,
+                      env->hostmaster_string(),
+                      OneByteString(env->isolate(),
+                                    soa.hostmaster)).FromJust();
+      soa_record->Set(context,
+                      env->serial_string(),
+                      Integer::New(env->isolate(), soa.serial)).FromJust();
+      soa_record->Set(context,
+                      env->refresh_string(),
+                      Integer::New(env->isolate(), soa.refresh)).FromJust();
+      soa_record->Set(context,
+                      env->retry_string(),
+                      Integer::New(env->isolate(), soa.retry)).FromJust();
+      soa_record->Set(context,
+                      env->expire_string(),
+                      Integer::New(env->isolate(), soa.expire)).FromJust();
+      soa_record->Set(context,
+                      env->minttl_string(),
+                      Integer::New(env->isolate(), soa.minttl)).FromJust();
+      soa_record->Set(context,
+                      env->type_string(),
+                      env->dns_soa_string()).FromJust();
+
+      free(soa.nsname);
+      free(soa.hostmaster);
+
+      *ret = handle_scope.Escape(soa_record);
+      break;
+    }
+
+    free(rr_name);
+    ptr += rr_len;
+  }
+
+  free(name);
+
+  if (status != ARES_SUCCESS) {
+    return status == ARES_EBADNAME ? ARES_EBADRESP : status;
+  }
+
+  return ARES_SUCCESS;
+}
+
+
+class QueryAnyWrap: public QueryWrap {
+ public:
+  QueryAnyWrap(Environment* env, Local<Object> req_wrap_obj)
+    : QueryWrap(env, req_wrap_obj) {
+  }
+
+  int Send(const char* name) override {
+    ares_query(env()->cares_channel(),
+               name,
+               ns_c_in,
+               ns_t_any,
+               Callback,
+               GetQueryArg());
+    return 0;
+  }
+
+  size_t self_size() const override { return sizeof(*this); }
+
+ protected:
+  void Parse(unsigned char* buf, int len) override {
+    HandleScope handle_scope(env()->isolate());
+    auto context = env()->context();
+    Context::Scope context_scope(context);
+
+    Local<Array> ret = Array::New(env()->isolate());
+    int type, status, old_count;
+
+    /* Parse A records or CNAME records */
+    ares_addrttl addrttls[256];
+    int naddrttls = arraysize(addrttls);
+
+    type = ns_t_cname_or_a;
+    status = ParseGeneralReply(env(),
+                               buf,
+                               len,
+                               &type,
+                               ret,
+                               addrttls,
+                               &naddrttls);
+    int a_count = ret->Length();
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      ParseError(status);
+      return;
+    }
+
+    if (type == ns_t_a) {
+      CHECK_EQ(naddrttls, a_count);
+      for (int i = 0; i < a_count; i++) {
+        Local<Object> obj = Object::New(env()->isolate());
+        obj->Set(context, env()->address_string(), ret->Get(i)).FromJust();
+        obj->Set(context,
+                 env()->ttl_string(),
+                 Integer::New(env()->isolate(), addrttls[i].ttl)).FromJust();
+        obj->Set(context,
+                 env()->type_string(),
+                 env()->dns_a_string()).FromJust();
+        ret->Set(context, i, obj).FromJust();
+      }
+    } else {
+      for (int i = 0; i < a_count; i++) {
+        Local<Object> obj = Object::New(env()->isolate());
+        obj->Set(context, env()->value_string(), ret->Get(i)).FromJust();
+        obj->Set(context,
+                 env()->type_string(),
+                 env()->dns_cname_string()).FromJust();
+        ret->Set(context, i, obj).FromJust();
+      }
+    }
+
+    /* Parse AAAA records */
+    ares_addr6ttl addr6ttls[256];
+    int naddr6ttls = arraysize(addr6ttls);
+
+    type = ns_t_aaaa;
+    status = ParseGeneralReply(env(),
+                               buf,
+                               len,
+                               &type,
+                               ret,
+                               addr6ttls,
+                               &naddr6ttls);
+    int aaaa_count = ret->Length() - a_count;
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      ParseError(status);
+      return;
+    }
+
+    CHECK_EQ(aaaa_count, naddr6ttls);
+    for (uint32_t i = a_count; i < ret->Length(); i++) {
+      Local<Object> obj = Object::New(env()->isolate());
+      obj->Set(context, env()->address_string(), ret->Get(i)).FromJust();
+      obj->Set(context,
+               env()->ttl_string(),
+               Integer::New(env()->isolate(), addr6ttls[i].ttl)).FromJust();
+      obj->Set(context,
+               env()->type_string(),
+               env()->dns_aaaa_string()).FromJust();
+      ret->Set(context, i, obj).FromJust();
+    }
+
+    /* Parse MX records */
+    status = ParseMxReply(env(), buf, len, ret, true);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      ParseError(status);
+      return;
+    }
+
+    /* Parse NS records */
+    type = ns_t_ns;
+    old_count = ret->Length();
+    status = ParseGeneralReply(env(), buf, len, &type, ret);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      ParseError(status);
+      return;
+    }
+    for (uint32_t i = old_count; i < ret->Length(); i++) {
+      Local<Object> obj = Object::New(env()->isolate());
+      obj->Set(context, env()->value_string(), ret->Get(i)).FromJust();
+      obj->Set(context,
+               env()->type_string(),
+               env()->dns_ns_string()).FromJust();
+      ret->Set(context, i, obj).FromJust();
+    }
+
+    /* Parse TXT records */
+    status = ParseTxtReply(env(), buf, len, ret, true);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      ParseError(status);
+      return;
+    }
+
+    /* Parse SRV records */
+    status = ParseSrvReply(env(), buf, len, ret, true);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      return;
+    }
+
+    /* Parse PTR records */
+    type = ns_t_ptr;
+    old_count = ret->Length();
+    status = ParseGeneralReply(env(), buf, len, &type, ret);
+    for (uint32_t i = old_count; i < ret->Length(); i++) {
+      Local<Object> obj = Object::New(env()->isolate());
+      obj->Set(context, env()->value_string(), ret->Get(i)).FromJust();
+      obj->Set(context,
+               env()->type_string(),
+               env()->dns_ptr_string()).FromJust();
+      ret->Set(context, i, obj).FromJust();
+    }
+
+    /* Parse NAPTR records */
+    status = ParseNaptrReply(env(), buf, len, ret, true);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      ParseError(status);
+      return;
+    }
+
+    /* Parse SOA records */
+    Local<Object> soa_record = Local<Object>();
+    status = ParseSoaReply(env(), buf, len, &soa_record);
+    if (status != ARES_SUCCESS && status != ARES_ENODATA) {
+      ParseError(status);
+      return;
+    }
+    if (!soa_record.IsEmpty())
+      ret->Set(context, ret->Length(), soa_record).FromJust();
+
+    CallOnComplete(ret);
+  }
+};
+
+
 class QueryAWrap: public QueryWrap {
  public:
   QueryAWrap(Environment* env, Local<Object> req_wrap_obj)
@@ -622,27 +1251,28 @@ class QueryAWrap: public QueryWrap {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
 
-    hostent* host;
     ares_addrttl addrttls[256];
-    int naddrttls = arraysize(addrttls);
-
-    int status = ares_parse_a_reply(buf, len, &host, addrttls, &naddrttls);
+    int naddrttls = arraysize(addrttls), status;
+    Local<Array> ret = Array::New(env()->isolate());
+
+    int type = ns_t_a;
+    status = ParseGeneralReply(env(),
+                               buf,
+                               len,
+                               &type,
+                               ret,
+                               addrttls,
+                               &naddrttls);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> addresses = HostentToAddresses(env(), host);
-    Local<Array> ttls = Array::New(env()->isolate(), naddrttls);
-
-    auto context = env()->context();
-    for (int i = 0; i < naddrttls; i += 1) {
-      auto value = Integer::New(env()->isolate(), addrttls[i].ttl);
-      ttls->Set(context, i, value).FromJust();
-    }
-    ares_free_hostent(host);
+    Local<Array> ttls = AddrTTLToArray<ares_addrttl>(env(),
+                                                     addrttls,
+                                                     naddrttls);
 
-    CallOnComplete(addresses, ttls);
+    CallOnComplete(ret, ttls);
   }
 };
 
@@ -665,27 +1295,28 @@ class QueryAaaaWrap: public QueryWrap {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
 
-    hostent* host;
     ares_addr6ttl addrttls[256];
-    int naddrttls = arraysize(addrttls);
-
-    int status = ares_parse_aaaa_reply(buf, len, &host, addrttls, &naddrttls);
+    int naddrttls = arraysize(addrttls), status;
+    Local<Array> ret = Array::New(env()->isolate());
+
+    int type = ns_t_aaaa;
+    status = ParseGeneralReply(env(),
+                               buf,
+                               len,
+                               &type,
+                               ret,
+                               addrttls,
+                               &naddrttls);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> addresses = HostentToAddresses(env(), host);
-    Local<Array> ttls = Array::New(env()->isolate(), naddrttls);
-
-    auto context = env()->context();
-    for (int i = 0; i < naddrttls; i += 1) {
-      auto value = Integer::New(env()->isolate(), addrttls[i].ttl);
-      ttls->Set(context, i, value).FromJust();
-    }
-    ares_free_hostent(host);
+    Local<Array> ttls = AddrTTLToArray<ares_addr6ttl>(env(),
+                                                      addrttls,
+                                                      naddrttls);
 
-    CallOnComplete(addresses, ttls);
+    CallOnComplete(ret, ttls);
   }
 };
 
@@ -707,21 +1338,16 @@ class QueryCnameWrap: public QueryWrap {
   void Parse(unsigned char* buf, int len) override {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
-    struct hostent* host;
 
-    int status = ares_parse_a_reply(buf, len, &host, nullptr, nullptr);
+    Local<Array> ret = Array::New(env()->isolate());
+    int type = ns_t_cname;
+    int status = ParseGeneralReply(env(), buf, len, &type, ret);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    // A cname lookup always returns a single record but we follow the
-    // common API here.
-    Local<Array> result = Array::New(env()->isolate(), 1);
-    result->Set(0, OneByteString(env()->isolate(), host->h_name));
-    ares_free_hostent(host);
-
-    this->CallOnComplete(result);
+    this->CallOnComplete(ret);
   }
 };
 
@@ -744,29 +1370,14 @@ class QueryMxWrap: public QueryWrap {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
 
-    struct ares_mx_reply* mx_start;
-    int status = ares_parse_mx_reply(buf, len, &mx_start);
+    Local<Array> mx_records = Array::New(env()->isolate());
+    int status = ParseMxReply(env(), buf, len, mx_records);
+
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> mx_records = Array::New(env()->isolate());
-    Local<String> exchange_symbol = env()->exchange_string();
-    Local<String> priority_symbol = env()->priority_string();
-
-    ares_mx_reply* current = mx_start;
-    for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
-      Local<Object> mx_record = Object::New(env()->isolate());
-      mx_record->Set(exchange_symbol,
-                     OneByteString(env()->isolate(), current->host));
-      mx_record->Set(priority_symbol,
-                     Integer::New(env()->isolate(), current->priority));
-      mx_records->Set(i, mx_record);
-    }
-
-    ares_free_data(mx_start);
-
     this->CallOnComplete(mx_records);
   }
 };
@@ -789,17 +1400,15 @@ class QueryNsWrap: public QueryWrap {
   void Parse(unsigned char* buf, int len) override {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
-    struct hostent* host;
 
-    int status = ares_parse_ns_reply(buf, len, &host);
+    int type = ns_t_ns;
+    Local<Array> names = Array::New(env()->isolate());
+    int status = ParseGeneralReply(env(), buf, len, &type, names);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> names = HostentToNames(env(), host);
-    ares_free_hostent(host);
-
     this->CallOnComplete(names);
   }
 };
@@ -822,36 +1431,14 @@ class QueryTxtWrap: public QueryWrap {
   void Parse(unsigned char* buf, int len) override {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
-    struct ares_txt_ext* txt_out;
 
-    int status = ares_parse_txt_reply_ext(buf, len, &txt_out);
+    Local<Array> txt_records = Array::New(env()->isolate());
+    int status = ParseTxtReply(env(), buf, len, txt_records);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> txt_records = Array::New(env()->isolate());
-    Local<Array> txt_chunk;
-
-    struct ares_txt_ext* current = txt_out;
-    uint32_t i = 0;
-    for (uint32_t j = 0; current != nullptr; current = current->next) {
-      Local<String> txt = OneByteString(env()->isolate(), current->txt);
-      // New record found - write out the current chunk
-      if (current->record_start) {
-        if (!txt_chunk.IsEmpty())
-          txt_records->Set(i++, txt_chunk);
-        txt_chunk = Array::New(env()->isolate());
-        j = 0;
-      }
-      txt_chunk->Set(j++, txt);
-    }
-    // Push last chunk if it isn't empty
-    if (!txt_chunk.IsEmpty())
-      txt_records->Set(i, txt_chunk);
-
-    ares_free_data(txt_out);
-
     this->CallOnComplete(txt_records);
   }
 };
@@ -875,35 +1462,13 @@ class QuerySrvWrap: public QueryWrap {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
 
-    struct ares_srv_reply* srv_start;
-    int status = ares_parse_srv_reply(buf, len, &srv_start);
+    Local<Array> srv_records = Array::New(env()->isolate());
+    int status = ParseSrvReply(env(), buf, len, srv_records);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> srv_records = Array::New(env()->isolate());
-    Local<String> name_symbol = env()->name_string();
-    Local<String> port_symbol = env()->port_string();
-    Local<String> priority_symbol = env()->priority_string();
-    Local<String> weight_symbol = env()->weight_string();
-
-    ares_srv_reply* current = srv_start;
-    for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
-      Local<Object> srv_record = Object::New(env()->isolate());
-      srv_record->Set(name_symbol,
-                      OneByteString(env()->isolate(), current->host));
-      srv_record->Set(port_symbol,
-                      Integer::New(env()->isolate(), current->port));
-      srv_record->Set(priority_symbol,
-                      Integer::New(env()->isolate(), current->priority));
-      srv_record->Set(weight_symbol,
-                      Integer::New(env()->isolate(), current->weight));
-      srv_records->Set(i, srv_record);
-    }
-
-    ares_free_data(srv_start);
-
     this->CallOnComplete(srv_records);
   }
 };
@@ -926,22 +1491,15 @@ class QueryPtrWrap: public QueryWrap {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
 
-    struct hostent* host;
+    int type = ns_t_ptr;
+    Local<Array> aliases = Array::New(env()->isolate());
 
-    int status = ares_parse_ptr_reply(buf, len, NULL, 0, AF_INET, &host);
+    int status = ParseGeneralReply(env(), buf, len, &type, aliases);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> aliases = Array::New(env()->isolate());
-
-    for (uint32_t i = 0; host->h_aliases[i] != NULL; i++) {
-      aliases->Set(i, OneByteString(env()->isolate(), host->h_aliases[i]));
-    }
-
-    ares_free_hostent(host);
-
     this->CallOnComplete(aliases);
   }
 };
@@ -964,42 +1522,13 @@ class QueryNaptrWrap: public QueryWrap {
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(env()->context());
 
-    ares_naptr_reply* naptr_start;
-    int status = ares_parse_naptr_reply(buf, len, &naptr_start);
-
+    Local<Array> naptr_records = Array::New(env()->isolate());
+    int status = ParseNaptrReply(env(), buf, len, naptr_records);
     if (status != ARES_SUCCESS) {
       ParseError(status);
       return;
     }
 
-    Local<Array> naptr_records = Array::New(env()->isolate());
-    Local<String> flags_symbol = env()->flags_string();
-    Local<String> service_symbol = env()->service_string();
-    Local<String> regexp_symbol = env()->regexp_string();
-    Local<String> replacement_symbol = env()->replacement_string();
-    Local<String> order_symbol = env()->order_string();
-    Local<String> preference_symbol = env()->preference_string();
-
-    ares_naptr_reply* current = naptr_start;
-    for (uint32_t i = 0; current != nullptr; ++i, current = current->next) {
-      Local<Object> naptr_record = Object::New(env()->isolate());
-      naptr_record->Set(flags_symbol,
-                        OneByteString(env()->isolate(), current->flags));
-      naptr_record->Set(service_symbol,
-                        OneByteString(env()->isolate(), current->service));
-      naptr_record->Set(regexp_symbol,
-                        OneByteString(env()->isolate(), current->regexp));
-      naptr_record->Set(replacement_symbol,
-                        OneByteString(env()->isolate(), current->replacement));
-      naptr_record->Set(order_symbol,
-                        Integer::New(env()->isolate(), current->order));
-      naptr_record->Set(preference_symbol,
-                        Integer::New(env()->isolate(), current->preference));
-      naptr_records->Set(i, naptr_record);
-    }
-
-    ares_free_data(naptr_start);
-
     this->CallOnComplete(naptr_records);
   }
 };
@@ -1021,7 +1550,8 @@ class QuerySoaWrap: public QueryWrap {
  protected:
   void Parse(unsigned char* buf, int len) override {
     HandleScope handle_scope(env()->isolate());
-    Context::Scope context_scope(env()->context());
+    auto context = env()->context();
+    Context::Scope context_scope(context);
 
     ares_soa_reply* soa_out;
     int status = ares_parse_soa_reply(buf, len, &soa_out);
@@ -1033,20 +1563,30 @@ class QuerySoaWrap: public QueryWrap {
 
     Local<Object> soa_record = Object::New(env()->isolate());
 
-    soa_record->Set(env()->nsname_string(),
-                    OneByteString(env()->isolate(), soa_out->nsname));
-    soa_record->Set(env()->hostmaster_string(),
-                    OneByteString(env()->isolate(), soa_out->hostmaster));
-    soa_record->Set(env()->serial_string(),
-                    Integer::New(env()->isolate(), soa_out->serial));
-    soa_record->Set(env()->refresh_string(),
-                    Integer::New(env()->isolate(), soa_out->refresh));
-    soa_record->Set(env()->retry_string(),
-                    Integer::New(env()->isolate(), soa_out->retry));
-    soa_record->Set(env()->expire_string(),
-                    Integer::New(env()->isolate(), soa_out->expire));
-    soa_record->Set(env()->minttl_string(),
-                    Integer::New(env()->isolate(), soa_out->minttl));
+    soa_record->Set(context,
+                    env()->nsname_string(),
+                    OneByteString(env()->isolate(),
+                                  soa_out->nsname)).FromJust();
+    soa_record->Set(context,
+                    env()->hostmaster_string(),
+                    OneByteString(env()->isolate(),
+                                  soa_out->hostmaster)).FromJust();
+    soa_record->Set(context,
+                    env()->serial_string(),
+                    Integer::New(env()->isolate(), soa_out->serial)).FromJust();
+    soa_record->Set(context,
+                    env()->refresh_string(),
+                    Integer::New(env()->isolate(),
+                                 soa_out->refresh)).FromJust();
+    soa_record->Set(context,
+                    env()->retry_string(),
+                    Integer::New(env()->isolate(), soa_out->retry)).FromJust();
+    soa_record->Set(context,
+                    env()->expire_string(),
+                    Integer::New(env()->isolate(), soa_out->expire)).FromJust();
+    soa_record->Set(context,
+                    env()->minttl_string(),
+                    Integer::New(env()->isolate(), soa_out->minttl)).FromJust();
 
     ares_free_data(soa_out);
 
@@ -1501,8 +2041,8 @@ void CaresTimerCloseCb(uv_handle_t* handle) {
 
 
 void CaresTimerClose(Environment* env,
-                            uv_handle_t* handle,
-                            void* arg) {
+                     uv_handle_t* handle,
+                     void* arg) {
   uv_close(handle, CaresTimerCloseCb);
 }
 
@@ -1526,6 +2066,7 @@ void Initialize(Local<Object> target,
       CaresTimerClose,
       nullptr);
 
+  env->SetMethod(target, "queryAny", Query<QueryAnyWrap>);
   env->SetMethod(target, "queryA", Query<QueryAWrap>);
   env->SetMethod(target, "queryAaaa", Query<QueryAaaaWrap>);
   env->SetMethod(target, "queryCname", Query<QueryCnameWrap>);
diff --git a/src/env.h b/src/env.h
index 527618d7c65409..a0f4c30e8dd4b9 100644
--- a/src/env.h
+++ b/src/env.h
@@ -105,6 +105,16 @@ namespace node {
   V(dest_string, "dest")                                                      \
   V(detached_string, "detached")                                              \
   V(disposed_string, "_disposed")                                             \
+  V(dns_a_string, "A")                                                        \
+  V(dns_aaaa_string, "AAAA")                                                  \
+  V(dns_cname_string, "CNAME")                                                \
+  V(dns_mx_string, "MX")                                                      \
+  V(dns_naptr_string, "NAPTR")                                                \
+  V(dns_ns_string, "NS")                                                      \
+  V(dns_ptr_string, "PTR")                                                    \
+  V(dns_soa_string, "SOA")                                                    \
+  V(dns_srv_string, "SRV")                                                    \
+  V(dns_txt_string, "TXT")                                                    \
   V(domain_string, "domain")                                                  \
   V(emitting_top_level_domain_error_string, "_emittingTopLevelDomainError")   \
   V(exchange_string, "exchange")                                              \
@@ -113,6 +123,7 @@ namespace node {
   V(irq_string, "irq")                                                        \
   V(encoding_string, "encoding")                                              \
   V(enter_string, "enter")                                                    \
+  V(entries_string, "entries")                                                \
   V(env_pairs_string, "envPairs")                                             \
   V(errno_string, "errno")                                                    \
   V(error_string, "error")                                                    \
@@ -151,6 +162,7 @@ namespace node {
   V(issuer_string, "issuer")                                                  \
   V(issuercert_string, "issuerCertificate")                                   \
   V(kill_signal_string, "killSignal")                                         \
+  V(length_string, "length")                                                  \
   V(mac_string, "mac")                                                        \
   V(max_buffer_string, "maxBuffer")                                           \
   V(message_string, "message")                                                \
@@ -231,6 +243,7 @@ namespace node {
   V(timeout_string, "timeout")                                                \
   V(times_string, "times")                                                    \
   V(tls_ticket_string, "tlsTicket")                                           \
+  V(ttl_string, "ttl")                                                        \
   V(type_string, "type")                                                      \
   V(uid_string, "uid")                                                        \
   V(unknown_string, "<unknown>")                                              \
diff --git a/test/internet/test-dns-any.js b/test/internet/test-dns-any.js
new file mode 100644
index 00000000000000..7650c59a613de3
--- /dev/null
+++ b/test/internet/test-dns-any.js
@@ -0,0 +1,198 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const dns = require('dns');
+const net = require('net');
+
+let running = false;
+const queue = [];
+
+const isIPv4 = net.isIPv4;
+const isIPv6 = net.isIPv6;
+
+dns.setServers([ '8.8.8.8', '8.8.4.4' ]);
+
+function checkWrap(req) {
+  assert.ok(typeof req === 'object');
+}
+
+const checkers = {
+  checkA(r) {
+    assert.ok(isIPv4(r.address));
+    assert.strictEqual(typeof r.ttl, 'number');
+    assert.strictEqual(r.type, 'A');
+  },
+  checkAAAA(r) {
+    assert.ok(isIPv6(r.address));
+    assert.strictEqual(typeof r.ttl, 'number');
+    assert.strictEqual(r.type, 'AAAA');
+  },
+  checkCNAME(r) {
+    assert.ok(r.value);
+    assert.strictEqual(typeof r.value, 'string');
+    assert.strictEqual(r.type, 'CNAME');
+  },
+  checkMX(r) {
+    assert.strictEqual(typeof r.exchange, 'string');
+    assert.strictEqual(typeof r.priority, 'number');
+    assert.strictEqual(r.type, 'MX');
+  },
+  checkNAPTR(r) {
+    assert.strictEqual(typeof r.flags, 'string');
+    assert.strictEqual(typeof r.service, 'string');
+    assert.strictEqual(typeof r.regexp, 'string');
+    assert.strictEqual(typeof r.replacement, 'string');
+    assert.strictEqual(typeof r.order, 'number');
+    assert.strictEqual(typeof r.preference, 'number');
+    assert.strictEqual(r.type, 'NAPTR');
+  },
+  checkNS(r) {
+    assert.strictEqual(typeof r.value, 'string');
+    assert.strictEqual(r.type, 'NS');
+  },
+  checkPTR(r) {
+    assert.strictEqual(typeof r.value, 'string');
+    assert.strictEqual(r.type, 'PTR');
+  },
+  checkTXT(r) {
+    assert.ok(Array.isArray(r.entries));
+    assert.ok(r.entries.length > 0);
+    r.entries.forEach((txt) => {
+      assert.strictEqual(txt.indexOf('v=spf1'), 0);
+    });
+    assert.strictEqual(r.type, 'TXT');
+  },
+  checkSOA(r) {
+    assert.strictEqual(typeof r.nsname, 'string');
+    assert.strictEqual(typeof r.hostmaster, 'string');
+    assert.strictEqual(typeof r.serial, 'number');
+    assert.strictEqual(typeof r.refresh, 'number');
+    assert.strictEqual(typeof r.retry, 'number');
+    assert.strictEqual(typeof r.expire, 'number');
+    assert.strictEqual(typeof r.minttl, 'number');
+    assert.strictEqual(r.type, 'SOA');
+  },
+  checkSRV(r) {
+    assert.strictEqual(typeof r.name, 'string');
+    assert.strictEqual(typeof r.port, 'number');
+    assert.strictEqual(typeof r.priority, 'number');
+    assert.strictEqual(typeof r.weight, 'number');
+    assert.strictEqual(r.type, 'SRV');
+  }
+};
+
+function TEST(f) {
+  function next() {
+    const f = queue.shift();
+    if (f) {
+      running = true;
+      f(done);
+    }
+  }
+
+  function done() {
+    running = false;
+    process.nextTick(next);
+  }
+
+  queue.push(f);
+
+  if (!running) {
+    next();
+  }
+}
+
+TEST(function test_google(done) {
+  const req = dns.resolve(
+    'google.com',
+    'ANY',
+    common.mustCall(function(err, ret) {
+      assert.ifError(err);
+      assert.ok(Array.isArray(ret));
+      assert.ok(ret.length > 0);
+
+      /* current google.com has A / AAAA / MX / NS / TXT and SOA records */
+      const types = {};
+      ret.forEach((obj) => {
+        types[obj.type] = true;
+        checkers[`check${obj.type}`](obj);
+      });
+      assert.ok(
+        types.A && types.AAAA && types.MX &&
+        types.NS && types.TXT && types.SOA);
+
+      done();
+    }));
+
+  checkWrap(req);
+});
+
+TEST(function test_sip2sip_for_naptr(done) {
+  const req = dns.resolve(
+    'sip2sip.info',
+    'ANY',
+    common.mustCall(function(err, ret) {
+      assert.ifError(err);
+      assert.ok(Array.isArray(ret));
+      assert.ok(ret.length > 0);
+
+      /* current sip2sip.info has A / NS / NAPTR and SOA records */
+      const types = {};
+      ret.forEach((obj) => {
+        types[obj.type] = true;
+        checkers[`check${obj.type}`](obj);
+      });
+      assert.ok(types.A && types.NS && types.NAPTR && types.SOA);
+
+      done();
+    }));
+
+  checkWrap(req);
+});
+
+TEST(function test_google_for_cname_and_srv(done) {
+  const req = dns.resolve(
+    '_jabber._tcp.google.com',
+    'ANY',
+    common.mustCall(function(err, ret) {
+      assert.ifError(err);
+      assert.ok(Array.isArray(ret));
+      assert.ok(ret.length > 0);
+
+      const types = {};
+      ret.forEach((obj) => {
+        types[obj.type] = true;
+        checkers[`check${obj.type}`](obj);
+      });
+      assert.ok(types.SRV);
+
+      done();
+    }));
+
+  checkWrap(req);
+});
+
+TEST(function test_ptr(done) {
+  const req = dns.resolve(
+    '8.8.8.8.in-addr.arpa',
+    'ANY',
+    common.mustCall(function(err, ret) {
+      assert.ifError(err);
+      assert.ok(Array.isArray(ret));
+      assert.ok(ret.length > 0);
+
+      /* current 8.8.8.8.in-addr.arpa has PTR record */
+      const types = {};
+      ret.forEach((obj) => {
+        types[obj.type] = true;
+        checkers[`check${obj.type}`](obj);
+      });
+      assert.ok(types.PTR);
+
+      done();
+    }));
+
+  checkWrap(req);
+});