Changeset 5513 for pjproject/branches/projects/uwp/pjlib-util/src/pjlib-util/resolver.c

Timestamp:

Dec 28, 2016 3:40:07 AM (8 years ago)

Author:

nanang

Message:

Re #1900: More merged from trunk (r5512 mistakenly contains merged changes in third-party dir only).

Location:

pjproject/branches/projects/uwp

Files:

• . (modified) (1 prop)
• pjlib-util/src/pjlib-util/resolver.c (modified) (36 diffs)

pjproject/branches/projects/uwp/pjlib-util/src/pjlib-util/resolver.c

@@ -20 +20 @@
 #include <pjlib-util/resolver.h>
 #include <pjlib-util/errno.h>
+#include <pj/compat/socket.h>
 #include <pj/assert.h>
 #include <pj/ctype.h>
@@ -80 +81 @@
 struct nameserver
 {
-    pj_sockaddr_in  addr;               /**< Server address.                */
+    pj_sockaddr     addr;               /**< Server address.                */
 
     enum ns_state   state;              /**< Nameserver state.              */
@@ -180 +181 @@
     pj_ioqueue_key_t    *udp_key;       /**< UDP socket ioqueue key.        */
     unsigned char        udp_rx_pkt[UDPSZ];/**< UDP receive buffer.         */
-    unsigned char        udp_tx_pkt[UDPSZ];/**< UDP receive buffer.         */
-    pj_ssize_t           udp_len;       /**< Length of received packet.     */
+    unsigned char        udp_tx_pkt[UDPSZ];/**< UDP transmit buffer.        */
     pj_ioqueue_op_key_t  udp_op_rx_key; /**< UDP read operation key.        */
     pj_ioqueue_op_key_t  udp_op_tx_key; /**< UDP write operation key.       */
-    pj_sockaddr_in       udp_src_addr;  /**< Source address of packet       */
+    pj_sockaddr          udp_src_addr;  /**< Source address of packet       */
     int                  udp_addr_len;  /**< Source address length.         */
+
+#if PJ_HAS_IPV6
+    /* IPv6 socket */
+    pj_sock_t            udp6_sock;     /**< UDP socket.                    */
+    pj_ioqueue_key_t    *udp6_key;      /**< UDP socket ioqueue key.        */
+    unsigned char        udp6_rx_pkt[UDPSZ];/**< UDP receive buffer.        */
+    //unsigned char      udp6_tx_pkt[UDPSZ];/**< UDP transmit buffer.       */
+    pj_ioqueue_op_key_t  udp6_op_rx_key;/**< UDP read operation key.        */
+    pj_ioqueue_op_key_t  udp6_op_tx_key;/**< UDP write operation key.       */
+    pj_sockaddr          udp6_src_addr; /**< Source address of packet       */
+    int                  udp6_addr_len; /**< Source address length.         */
+#endif
 
     /* Settings */
@@ -238 +250 @@
         resv->udp_sock = PJ_INVALID_SOCKET;
     }
+
+#if PJ_HAS_IPV6
+    if (resv->udp6_key != NULL) {
+        pj_ioqueue_unregister(resv->udp6_key);
+        resv->udp6_key = NULL;
+        resv->udp6_sock = PJ_INVALID_SOCKET;
+    } else if (resv->udp6_sock != PJ_INVALID_SOCKET) {
+        pj_sock_close(resv->udp6_sock);
+        resv->udp6_sock = PJ_INVALID_SOCKET;
+    }
+#endif
 }
 
@@ -245 +268 @@
 {
     pj_ioqueue_callback socket_cb;
+    pj_sockaddr bound_addr;
+    pj_ssize_t rx_pkt_size;
     pj_status_t status;
 
@@ -270 +295 @@
 
     /* Start asynchronous read to the UDP socket */
-    resv->udp_len = sizeof(resv->udp_rx_pkt);
+    rx_pkt_size = sizeof(resv->udp_rx_pkt);
     resv->udp_addr_len = sizeof(resv->udp_src_addr);
     status = pj_ioqueue_recvfrom(resv->udp_key, &resv->udp_op_rx_key,
-                                 resv->udp_rx_pkt, &resv->udp_len,
+                                 resv->udp_rx_pkt, &rx_pkt_size,
                                  PJ_IOQUEUE_ALWAYS_ASYNC,
                                  &resv->udp_src_addr, &resv->udp_addr_len);
     if (status != PJ_EPENDING)
         return status;
+
+
+#if PJ_HAS_IPV6
+    /* Also setup IPv6 socket */
+
+    /* Create the UDP socket */
+    status = pj_sock_socket(pj_AF_INET6(), pj_SOCK_DGRAM(), 0,
+                            &resv->udp6_sock);
+    if (status != PJ_SUCCESS) {
+        /* Skip IPv6 socket on system without IPv6 (see ticket #1953) */
+        if (status == PJ_STATUS_FROM_OS(OSERR_EAFNOSUPPORT)) {
+            PJ_LOG(3,(resv->name.ptr,
+                      "System does not support IPv6, resolver will "
+                      "ignore any IPv6 nameservers"));
+            return PJ_SUCCESS;
+        }
+        return status;
+    }
+
+    /* Bind to any address/port */
+    pj_sockaddr_init(pj_AF_INET6(), &bound_addr, NULL, 0);
+    status = pj_sock_bind(resv->udp6_sock, &bound_addr,
+                          pj_sockaddr_get_len(&bound_addr));
+    if (status != PJ_SUCCESS)
+        return status;
+
+    /* Register to ioqueue */
+    pj_bzero(&socket_cb, sizeof(socket_cb));
+    socket_cb.on_read_complete = &on_read_complete;
+    status = pj_ioqueue_register_sock(resv->pool, resv->ioqueue,
+                                      resv->udp6_sock, resv, &socket_cb,
+                                      &resv->udp6_key);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    pj_ioqueue_op_key_init(&resv->udp6_op_rx_key,
+                           sizeof(resv->udp6_op_rx_key));
+    pj_ioqueue_op_key_init(&resv->udp6_op_tx_key,
+                           sizeof(resv->udp6_op_tx_key));
+
+    /* Start asynchronous read to the UDP socket */
+    rx_pkt_size = sizeof(resv->udp6_rx_pkt);
+    resv->udp6_addr_len = sizeof(resv->udp6_src_addr);
+    status = pj_ioqueue_recvfrom(resv->udp6_key, &resv->udp6_op_rx_key,
+                                 resv->udp6_rx_pkt, &rx_pkt_size,
+                                 PJ_IOQUEUE_ALWAYS_ASYNC,
+                                 &resv->udp6_src_addr, &resv->udp6_addr_len);
+    if (status != PJ_EPENDING)
+        return status;
+#else
+    PJ_UNUSED_ARG(bound_addr);
+#endif
 
     return PJ_SUCCESS;
@@ -475 +552 @@
         struct nameserver *ns = &resolver->ns[i];
 
-        status = pj_sockaddr_in_init(&ns->addr, &servers[i], 
-                                     (pj_uint16_t)(ports ? ports[i] : PORT));
+        status = pj_sockaddr_init(pj_AF_INET(), &ns->addr, &servers[i], 
+                                  (pj_uint16_t)(ports ? ports[i] : PORT));
+        if (status != PJ_SUCCESS)
+            status = pj_sockaddr_init(pj_AF_INET6(), &ns->addr, &servers[i], 
+                                      (pj_uint16_t)(ports ? ports[i] : PORT));
         if (status != PJ_SUCCESS) {
             pj_mutex_unlock(resolver->mutex);
@@ -580 +660 @@
 {
     unsigned pkt_size;
-    unsigned i, server_cnt;
+    unsigned i, server_cnt, send_cnt;
     unsigned servers[PJ_DNS_RESOLVER_MAX_NS];
     pj_time_val now;
@@ -613 +693 @@
 
     /* Check if the socket is available for sending */
-    if (pj_ioqueue_is_pending(resolver->udp_key, &resolver->udp_op_tx_key)) {
+    if (pj_ioqueue_is_pending(resolver->udp_key, &resolver->udp_op_tx_key)
+#if PJ_HAS_IPV6
+        || (resolver->udp6_key &&
+            pj_ioqueue_is_pending(resolver->udp6_key,
+                                  &resolver->udp6_op_tx_key))
+#endif
+        )
+    {
         ++q->transmit_cnt;
         PJ_LOG(4,(resolver->name.ptr,
@@ -638 +725 @@
 
     /* Send the packet to name servers */
+    send_cnt = 0;
     for (i=0; i<server_cnt; ++i) {
+        char addr[PJ_INET6_ADDRSTRLEN];
         pj_ssize_t sent  = (pj_ssize_t) pkt_size;
         struct nameserver *ns = &resolver->ns[servers[i]];
 
-        status = pj_ioqueue_sendto(resolver->udp_key,
-                                   &resolver->udp_op_tx_key,
-                                   resolver->udp_tx_pkt, &sent, 0,
-                                   &resolver->ns[servers[i]].addr,
-                                   sizeof(pj_sockaddr_in));
+        if (ns->addr.addr.sa_family == pj_AF_INET()) {
+            status = pj_ioqueue_sendto(resolver->udp_key,
+                                       &resolver->udp_op_tx_key,
+                                       resolver->udp_tx_pkt, &sent, 0,
+                                       &ns->addr,
+                                       pj_sockaddr_get_len(&ns->addr));
+            if (status == PJ_SUCCESS || status == PJ_EPENDING)
+                send_cnt++;
+        }
+#if PJ_HAS_IPV6
+        else if (resolver->udp6_key) {
+            status = pj_ioqueue_sendto(resolver->udp6_key,
+                                       &resolver->udp6_op_tx_key,
+                                       resolver->udp_tx_pkt, &sent, 0,
+                                       &ns->addr,
+                                       pj_sockaddr_get_len(&ns->addr));
+            if (status == PJ_SUCCESS || status == PJ_EPENDING)
+                send_cnt++;
+        }
+#endif
+        else {
+            continue;
+        }
 
         PJ_PERROR(4,(resolver->name.ptr, status,
@@ -652 +759 @@
                   (q->transmit_cnt==0? "Transmitting":"Re-transmitting"),
                   (int)pkt_size, servers[i],
-                  pj_inet_ntoa(ns->addr.sin_addr), 
-                  (int)pj_ntohs(ns->addr.sin_port),
+                  pj_sockaddr_print(&ns->addr, addr, sizeof(addr), 2),
+                  pj_sockaddr_get_port(&ns->addr),
                   pj_dns_get_type_name(q->key.qtype), 
                   q->key.name));
@@ -662 +769 @@
         }
     }
+
+    if (send_cnt == 0)
+        return PJLIB_UTIL_EDNSNOWORKINGNS;
 
     ++q->transmit_cnt;
@@ -747 +857 @@
     struct res_key key;
     struct cached_res *cache;
-    pj_dns_async_query *q;
+    pj_dns_async_query *q, *p_q = NULL;
     pj_uint32_t hval;
     pj_status_t status = PJ_SUCCESS;
@@ -760 +870 @@
     /* Check type */
     PJ_ASSERT_RETURN(type > 0 && type < 0xFFFF, PJ_EINVAL);
-
-    if (p_query)
-        *p_query = NULL;
 
     /* Build resource key for looking up hash tables */
@@ -823 +930 @@
             status = PJ_SUCCESS;
 
-            goto on_return;
+            /*
+             * We cannot write to *p_query after calling cb because what
+             * p_query points to may have been freed by cb.
+             * Refer to ticket #1974.
+             */
+            pj_mutex_unlock(resolver->mutex);
+            return status;
         }
 
@@ -855 +968 @@
          * query completes.
          */
+        p_q = nq;
         status = PJ_SUCCESS;
         goto on_return;
@@ -882 +996 @@
                    0, q->hbufkey, q);
 
+    p_q = q;
+
+on_return:
     if (p_query)
-        *p_query = q;
-
-on_return:
+        *p_query = p_q;
+
     pj_mutex_unlock(resolver->mutex);
     return status;
@@ -1027 +1143 @@
 
 
+/* 
+ * DNS response containing A and/or AAAA packet. 
+ */
+PJ_DEF(pj_status_t) pj_dns_parse_addr_response(
+                                            const pj_dns_parsed_packet *pkt,
+                                            pj_dns_addr_record *rec)
+{
+    enum { MAX_SEARCH = 20 };
+    pj_str_t hostname, alias = {NULL, 0}, *resname;
+    pj_size_t bufstart = 0;
+    pj_size_t bufleft;
+    unsigned i, ansidx, cnt=0;
+
+    PJ_ASSERT_RETURN(pkt && rec, PJ_EINVAL);
+
+    /* Init the record */
+    pj_bzero(rec, sizeof(*rec));
+
+    bufleft = sizeof(rec->buf_);
+
+    /* Return error if there's error in the packet. */
+    if (PJ_DNS_GET_RCODE(pkt->hdr.flags))
+        return PJ_STATUS_FROM_DNS_RCODE(PJ_DNS_GET_RCODE(pkt->hdr.flags));
+
+    /* Return error if there's no query section */
+    if (pkt->hdr.qdcount == 0)
+        return PJLIB_UTIL_EDNSINANSWER;
+
+    /* Return error if there's no answer */
+    if (pkt->hdr.anscount == 0)
+        return PJLIB_UTIL_EDNSNOANSWERREC;
+
+    /* Get the hostname from the query. */
+    hostname = pkt->q[0].name;
+
+    /* Copy hostname to the record */
+    if (hostname.slen > (int)bufleft) {
+        return PJ_ENAMETOOLONG;
+    }
+
+    pj_memcpy(&rec->buf_[bufstart], hostname.ptr, hostname.slen);
+    rec->name.ptr = &rec->buf_[bufstart];
+    rec->name.slen = hostname.slen;
+
+    bufstart += hostname.slen;
+    bufleft -= hostname.slen;
+
+    /* Find the first RR which name matches the hostname. */
+    for (ansidx=0; ansidx < pkt->hdr.anscount; ++ansidx) {
+        if (pj_stricmp(&pkt->ans[ansidx].name, &hostname)==0)
+            break;
+    }
+
+    if (ansidx == pkt->hdr.anscount)
+        return PJLIB_UTIL_EDNSNOANSWERREC;
+
+    resname = &hostname;
+
+    /* Keep following CNAME records. */
+    while (pkt->ans[ansidx].type == PJ_DNS_TYPE_CNAME &&
+           cnt++ < MAX_SEARCH)
+    {
+        resname = &pkt->ans[ansidx].rdata.cname.name;
+
+        if (!alias.slen)
+            alias = *resname;
+
+        for (i=0; i < pkt->hdr.anscount; ++i) {
+            if (pj_stricmp(resname, &pkt->ans[i].name)==0)
+                break;
+        }
+
+        if (i==pkt->hdr.anscount)
+            return PJLIB_UTIL_EDNSNOANSWERREC;
+
+        ansidx = i;
+    }
+
+    if (cnt >= MAX_SEARCH)
+        return PJLIB_UTIL_EDNSINANSWER;
+
+    if (pkt->ans[ansidx].type != PJ_DNS_TYPE_A &&
+        pkt->ans[ansidx].type != PJ_DNS_TYPE_AAAA)
+    {
+        return PJLIB_UTIL_EDNSINANSWER;
+    }
+
+    /* Copy alias to the record, if present. */
+    if (alias.slen) {
+        if (alias.slen > (int)bufleft)
+            return PJ_ENAMETOOLONG;
+
+        pj_memcpy(&rec->buf_[bufstart], alias.ptr, alias.slen);
+        rec->alias.ptr = &rec->buf_[bufstart];
+        rec->alias.slen = alias.slen;
+
+        bufstart += alias.slen;
+        bufleft -= alias.slen;
+    }
+
+    /* Get the IP addresses. */
+    cnt = 0;
+    for (i=0; i < pkt->hdr.anscount && cnt < PJ_DNS_MAX_IP_IN_A_REC ; ++i) {
+        if ((pkt->ans[i].type == PJ_DNS_TYPE_A ||
+             pkt->ans[i].type == PJ_DNS_TYPE_AAAA) &&
+            pj_stricmp(&pkt->ans[i].name, resname)==0)
+        {
+            if (pkt->ans[i].type == PJ_DNS_TYPE_A) {
+                rec->addr[cnt].af = pj_AF_INET();
+                rec->addr[cnt].ip.v4 = pkt->ans[i].rdata.a.ip_addr;
+            } else {
+                rec->addr[cnt].af = pj_AF_INET6();
+                rec->addr[cnt].ip.v6 = pkt->ans[i].rdata.aaaa.ip_addr;
+            }
+            ++cnt;
+        }
+    }
+    rec->addr_count = cnt;
+
+    if (cnt == 0)
+        return PJLIB_UTIL_EDNSNOANSWERREC;
+
+    return PJ_SUCCESS;
+}
+
+
 /* Set nameserver state */
 static void set_nameserver_state(pj_dns_resolver *resolver,
@@ -1035 +1277 @@
     struct nameserver *ns = &resolver->ns[index];
     enum ns_state old_state = ns->state;
+    char addr[PJ_INET6_ADDRSTRLEN];
 
     ns->state = state;
@@ -1048 +1291 @@
 
     PJ_LOG(5, (resolver->name.ptr, "Nameserver %s:%d state changed %s --> %s",
-               pj_inet_ntoa(ns->addr.sin_addr),
-               (int)pj_ntohs(ns->addr.sin_port),
+               pj_sockaddr_print(&ns->addr, addr, sizeof(addr), 2),
+               pj_sockaddr_get_port(&ns->addr),
                state_names[old_state], state_names[state]));
 }
@@ -1128 +1371 @@
 /* Update name server status */
 static void report_nameserver_status(pj_dns_resolver *resolver,
-                                     const pj_sockaddr_in *ns_addr,
+                                     const pj_sockaddr *ns_addr,
                                      const pj_dns_parsed_packet *pkt)
 {
@@ -1148 +1391 @@
     }
 
-    if (!pkt || rcode == PJ_DNS_RCODE_SERVFAIL ||
+    /* Some nameserver is reported to respond with PJ_DNS_RCODE_SERVFAIL for
+     * missing AAAA record, and the standard doesn't seem to specify that
+     * SERVFAIL should prevent the server to be contacted again for other
+     * queries. So let's not mark nameserver as bad for SERVFAIL response.
+     */
+    if (!pkt || /* rcode == PJ_DNS_RCODE_SERVFAIL || */
                 rcode == PJ_DNS_RCODE_REFUSED ||
                 rcode == PJ_DNS_RCODE_NOTAUTH) 
@@ -1165 +1413 @@
         struct nameserver *ns = &resolver->ns[i];
 
-        if (ns->addr.sin_addr.s_addr == ns_addr->sin_addr.s_addr &&
-            ns->addr.sin_port == ns_addr->sin_port &&
-            ns->addr.sin_family == ns_addr->sin_family)
-        {
+        if (pj_sockaddr_cmp(&ns->addr, ns_addr) == 0) {
             if (q_id == ns->q_id) {
                 /* Calculate response time */
@@ -1233 +1478 @@
         ttl = resolver->settings.cache_max_ttl;
 
+    /* Get a cache response entry */
+    cache = (struct cached_res *) pj_hash_get(resolver->hrescache, key,
+                                              sizeof(*key), &hval);
+
     /* If TTL is zero, clear the same entry in the hash table */
     if (ttl == 0) {
-        cache = (struct cached_res *) pj_hash_get(resolver->hrescache, key, 
-                                                  sizeof(*key), &hval);
         /* Remove the entry before releasing its pool (see ticket #1710) */
         pj_hash_set(NULL, resolver->hrescache, key, sizeof(*key), hval, NULL);
@@ -1246 +1493 @@
     }
 
-    /* Get a cache response entry */
-    cache = (struct cached_res *) pj_hash_get(resolver->hrescache, key, 
-                                              sizeof(*key), &hval);
     if (cache == NULL) {
-        cache = alloc_entry(resolver);
-    } else if (cache->ref_cnt > 1) {
-        /* When cache entry is being used by callback (to app), just decrement
-         * ref_cnt so it will be freed after the callback returns and allocate
-         * new entry.
-         */
-        cache->ref_cnt--;
         cache = alloc_entry(resolver);
     } else {
@@ -1262 +1499 @@
         pj_hash_set(NULL, resolver->hrescache, key, sizeof(*key), hval, NULL);
 
-        /* Reset cache to avoid bloated cache pool */
-        reset_entry(&cache);
+        if (cache->ref_cnt > 1) {
+            /* When cache entry is being used by callback (to app),
+             * just decrement ref_cnt so it will be freed after
+             * the callback returns and allocate new entry.
+             */
+            cache->ref_cnt--;
+            cache = alloc_entry(resolver);
+        } else {
+            /* Reset cache to avoid bloated cache pool */
+            reset_entry(&cache);
+        }
     }
 
@@ -1391 +1637 @@
     pj_dns_parsed_packet *dns_pkt;
     pj_dns_async_query *q;
+    char addr[PJ_INET6_ADDRSTRLEN];
+    pj_sockaddr *src_addr;
+    int *src_addr_len;
+    unsigned char *rx_pkt;
+    pj_ssize_t rx_pkt_size;
     pj_status_t status;
     PJ_USE_EXCEPTION;
@@ -1396 +1647 @@
 
     resolver = (pj_dns_resolver *) pj_ioqueue_get_user_data(key);
+    pj_assert(resolver);
+
+#if PJ_HAS_IPV6
+    if (key == resolver->udp6_key) {
+        src_addr = &resolver->udp6_src_addr;
+        src_addr_len = &resolver->udp6_addr_len;
+        rx_pkt = resolver->udp6_rx_pkt;
+        rx_pkt_size = sizeof(resolver->udp6_rx_pkt);
+    } else 
+#endif
+    {
+        src_addr = &resolver->udp_src_addr;
+        src_addr_len = &resolver->udp_addr_len;
+        rx_pkt = resolver->udp_rx_pkt;
+        rx_pkt_size = sizeof(resolver->udp_rx_pkt);
+    }
+
     pj_mutex_lock(resolver->mutex);
 
@@ -1405 +1673 @@
         status = (pj_status_t)-bytes_read;
         pj_strerror(status, errmsg, sizeof(errmsg));
-        PJ_LOG(4,(resolver->name.ptr, 
-                  "DNS resolver read error from %s:%d: %s", 
-                  pj_inet_ntoa(resolver->udp_src_addr.sin_addr),
-                  pj_ntohs(resolver->udp_src_addr.sin_port),
-                  errmsg));
+        PJ_LOG(4,(resolver->name.ptr, "DNS resolver read error: %s", errmsg));
 
         goto read_next_packet;
@@ -1417 +1681 @@
               "Received %d bytes DNS response from %s:%d",
               (int)bytes_read, 
-              pj_inet_ntoa(resolver->udp_src_addr.sin_addr),
-              pj_ntohs(resolver->udp_src_addr.sin_port)));
+              pj_sockaddr_print(src_addr, addr, sizeof(addr), 2),
+              pj_sockaddr_get_port(src_addr)));
 
 
@@ -1433 +1697 @@
     dns_pkt = NULL;
     PJ_TRY {
-        status = pj_dns_parse_packet(pool, resolver->udp_rx_pkt, 
+        status = pj_dns_parse_packet(pool, rx_pkt, 
                                      (unsigned)bytes_read, &dns_pkt);
     }
@@ -1442 +1706 @@
 
     /* Update nameserver status */
-    report_nameserver_status(resolver, &resolver->udp_src_addr, dns_pkt);
+    report_nameserver_status(resolver, src_addr, dns_pkt);
 
     /* Handle parse error */
@@ -1451 +1715 @@
         PJ_LOG(3,(resolver->name.ptr, 
                   "Error parsing DNS response from %s:%d: %s", 
-                  pj_inet_ntoa(resolver->udp_src_addr.sin_addr), 
-                  pj_ntohs(resolver->udp_src_addr.sin_port), 
+                  pj_sockaddr_print(src_addr, addr, sizeof(addr), 2),
+                  pj_sockaddr_get_port(src_addr),
                   errmsg));
         goto read_next_packet;
@@ -1464 +1728 @@
         PJ_LOG(5,(resolver->name.ptr, 
                   "DNS response from %s:%d id=%d discarded",
-                  pj_inet_ntoa(resolver->udp_src_addr.sin_addr), 
-                  pj_ntohs(resolver->udp_src_addr.sin_port),
+                  pj_sockaddr_print(src_addr, addr, sizeof(addr), 2),
+                  pj_sockaddr_get_port(src_addr),
                   (unsigned)dns_pkt->hdr.id));
         goto read_next_packet;
@@ -1528 +1792 @@
         pj_pool_release(pool);
     }
-    bytes_read = sizeof(resolver->udp_rx_pkt);
-    resolver->udp_addr_len = sizeof(resolver->udp_src_addr);
-    status = pj_ioqueue_recvfrom(resolver->udp_key, op_key, 
-                                 resolver->udp_rx_pkt,
-                                 &bytes_read, PJ_IOQUEUE_ALWAYS_ASYNC,
-                                 &resolver->udp_src_addr, 
-                                 &resolver->udp_addr_len);
+
+    status = pj_ioqueue_recvfrom(key, op_key, rx_pkt, &rx_pkt_size,
+                                 PJ_IOQUEUE_ALWAYS_ASYNC,
+                                 src_addr, src_addr_len);
+
     if (status != PJ_EPENDING) {
         char errmsg[PJ_ERR_MSG_SIZE];
@@ -1634 +1896 @@
     PJ_LOG(3,(resolver->name.ptr, "  Name servers:"));
     for (i=0; i<resolver->ns_count; ++i) {
+        char addr[PJ_INET6_ADDRSTRLEN];
         struct nameserver *ns = &resolver->ns[i];
 
         PJ_LOG(3,(resolver->name.ptr,
                   "   NS %d: %s:%d (state=%s until %ds, rtt=%d ms)",
-                  i, pj_inet_ntoa(ns->addr.sin_addr),
-                  pj_ntohs(ns->addr.sin_port),
+                  i,
+                  pj_sockaddr_print(&ns->addr, addr, sizeof(addr), 2),
+                  pj_sockaddr_get_port(&ns->addr),
                   state_names[ns->state],
                   ns->state_expiry.sec - now.sec,