Changeset 60142 in vbox

Timestamp:

Mar 22, 2016 9:44:59 PM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

106161

Message:

NAT: Make host resolver asynchronous so that a blocked synchronous
lookup doesn't stop the whole tcp/ip stack.

Location:

trunk/src/VBox/Devices/Network

Files:

• DrvNAT.cpp (modified) (6 diffs)
• slirp/hostres.c (modified) (32 diffs)
• slirp/libslirp.h (modified) (2 diffs)
• slirp/slirp.h (modified) (1 diff)
• slirp/udp.c (modified) (1 diff)

trunk/src/VBox/Devices/Network/DrvNAT.cpp

@@ -211 +211 @@
     RTCRITSECT              XmitLock;
 
+    /** Request queue for the async host resolver. */
+    RTREQQUEUE               hHostResQueue;
+    /** Async host resolver thread. */
+    PPDMTHREAD               pHostResThread;
+
 #ifdef RT_OS_DARWIN
     /* Handle of the DNS watcher runloop source. */
@@ -892 +897 @@
 }
 
+
+static DECLCALLBACK(int) drvNATHostResThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
+{
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+
+    if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
+        return VINF_SUCCESS;
+
+    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
+    {
+        RTReqQueueProcess(pThis->hHostResQueue, RT_INDEFINITE_WAIT);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) drvNATReqQueueInterrupt()
+{
+    /*
+     * RTReqQueueProcess loops until request returns a warning or info
+     * status code (other than VINF_SUCCESS).
+     */
+    return VINF_INTERRUPTED;
+}
+
+
+static DECLCALLBACK(int) drvNATHostResWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
+{
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    Assert(pThis != NULL);
+
+    int rc;
+    rc = RTReqQueueCallEx(pThis->hHostResQueue, NULL /*ppReq*/, 0 /*cMillies*/,
+                          RTREQFLAGS_IPRT_STATUS | RTREQFLAGS_NO_WAIT,
+                          (PFNRT)drvNATReqQueueInterrupt, 0);
+    return rc;
+}
+
+
 /**
  * Function called by slirp to check if it's possible to feed incoming data to the network port.
@@ -963 +1008 @@
     STAM_COUNTER_INC(&pThis->StatQueuePktSent);
     LogFlowFuncLeave();
+}
+
+
+/*
+ * Call a function on the slirp thread.
+ */
+int slirp_call(void *pvUser, PRTREQ *ppReq, RTMSINTERVAL cMillies,
+               unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, ...)
+{
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    Assert(pThis);
+
+    int rc;
+
+    va_list va;
+    va_start(va, cArgs);
+
+    rc = RTReqQueueCallV(pThis->hSlirpReqQueue, ppReq, cMillies, fFlags, pfnFunction, cArgs, va);
+
+    va_end(va);
+
+    if (RT_SUCCESS(rc))
+        drvNATNotifyNATThread(pThis, "slirp_vcall");
+
+    return rc;
+}
+
+
+/*
+ * Call a function on the host resolver thread.
+ */
+int slirp_call_hostres(void *pvUser, PRTREQ *ppReq, RTMSINTERVAL cMillies,
+                       unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, ...)
+{
+    PDRVNAT pThis = (PDRVNAT)pvUser;
+    Assert(pThis);
+
+    int rc;
+
+    AssertReturn((pThis->hHostResQueue != NIL_RTREQQUEUE), VERR_INVALID_STATE);
+    AssertReturn((pThis->pHostResThread != NULL), VERR_INVALID_STATE);
+
+    va_list va;
+    va_start(va, cArgs);
+
+    rc = RTReqQueueCallV(pThis->hHostResQueue, ppReq, cMillies, fFlags,
+                         pfnFunction, cArgs, va);
+
+    va_end(va);
+    return rc;
 }
 
@@ -1345 +1440 @@
     }
 
+    RTReqQueueDestroy(pThis->hHostResQueue);
+    pThis->hHostResQueue = NIL_RTREQQUEUE;
+
     RTReqQueueDestroy(pThis->hSlirpReqQueue);
     pThis->hSlirpReqQueue = NIL_RTREQQUEUE;
@@ -1396 +1494 @@
     pThis->hSlirpReqQueue               = NIL_RTREQQUEUE;
     pThis->hUrgRecvReqQueue             = NIL_RTREQQUEUE;
+    pThis->hHostResQueue                = NIL_RTREQQUEUE;
     pThis->EventRecv                    = NIL_RTSEMEVENT;
     pThis->EventUrgRecv                 = NIL_RTSEMEVENT;
@@ -1590 +1689 @@
 
             rc = RTSemEventCreate(&pThis->EventUrgRecv);
+            AssertRCReturn(rc, rc);
+
+            rc = RTReqQueueCreate(&pThis->hHostResQueue);
+            AssertRCReturn(rc, rc);
+
+            rc = PDMDrvHlpThreadCreate(pThis->pDrvIns, &pThis->pHostResThread,
+                                       pThis, drvNATHostResThread, drvNATHostResWakeup,
+                                       64 * _1K, RTTHREADTYPE_IO, "HOSTRES");
             AssertRCReturn(rc, rc);
 

trunk/src/VBox/Devices/Network/slirp/hostres.c

@@ -105 +105 @@
 struct response
 {
+    PNATState pData;
+
+    uint32_t src;
+    uint16_t sport;
+
     struct label *labels;       /* already encoded in buf */
     size_t qlen;                /* original question */
@@ -115 +120 @@
 
 static int verify_header(PNATState pData, struct mbuf **pMBuf);
-static struct mbuf *respond(PNATState pData, struct mbuf *m, struct response *res);
-struct mbuf *resolve(PNATState pData, struct mbuf *m, struct response *res,
-                     uint16_t qtype, size_t qname);
-struct mbuf *resolve_reverse(PNATState pData, struct mbuf *m, struct response *res,
-                             uint16_t qtype, size_t qname, struct in_addr addr);
-struct mbuf *refuse(PNATState pData, struct mbuf *m, unsigned int rcode);
+static struct mbuf *refuse_mbuf(struct mbuf *m, unsigned int rcode);
+
+static int respond(struct response *res);
+static int resolve(struct response *res, uint16_t qtype, size_t qname);
+static int resolve_reverse(struct response *res, uint16_t qtype, size_t qname,
+                            struct in_addr addr);
+
+static int refuse(struct response *res, unsigned int rcode);
+
+
 static ssize_t append_a(struct response *res, const char *name, struct in_addr addr);
 static ssize_t append_cname(struct response *res, const char *name, const char *cname);
@@ -155 +164 @@
 
 
+static void hostres_async(struct response *res);
+static void hostres_slirp_reply(struct response *res);
+
+
+/*
+ * Host resolver is called on slirp thread from udp.c
+ */
 struct mbuf *
-hostresolver(PNATState pData, struct mbuf *m)
-{
-    int error;
-
-    struct response res;
-
-    error = verify_header(pData, &m);
-    if (error != 0)
+hostresolver(PNATState pData, struct mbuf *m, uint32_t src, uint16_t sport)
+{
+    struct response *res;
+    size_t mlen;
+    int rc;
+
+    rc = verify_header(pData, &m);
+    if (RT_FAILURE(rc))
         return m;
 
-    RT_ZERO(res);
-
-    /*
-     * Do the real work
-     */
-    m = respond(pData, m, &res);
-
-    free_labels(res.labels);
-    return m;
-}
-
-
-struct mbuf *
-refuse(PNATState pData, struct mbuf *m, unsigned int rcode)
-{
-    struct dnsmsg_header *pHdr;
-
-    pHdr = mtod(m, struct dnsmsg_header *);
-    pHdr->qr = QR_Response;
-    pHdr->rcode = rcode;
-    pHdr->ra = 1;
-    pHdr->aa = 0;
-
-    return m;
-}
-
-
+    res = RTMemAllocZ(sizeof(*res));
+    if (res == NULL)
+        return refuse_mbuf(m, RCode_ServFail);
+
+    res->pData = pData;
+    res->src = src;
+    res->sport = sport;
+
+    mlen = m_length(m, NULL);
+    m_copydata(m, 0, mlen, (char *)res->buf);
+    res->end = res->qlen = mlen;
+
+    rc = slirp_call_hostres(pData->pvUser, NULL, 0,
+                            RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                            (PFNRT)hostres_async, 1, res);
+
+    if (RT_FAILURE(rc))
+    {
+        LogErr(("NAT: hostres: failed to post async request: %Rrc\n", rc));
+        RTMemFree(res);
+        return refuse_mbuf(m, RCode_ServFail);
+    }
+
+    m_freem(pData, m);
+    return NULL;
+}
+
+
+/*
+ * Do quick sanity-checks on the request before doing async
+ * resolution.  If we don't like it, immediately drop or convert to
+ * response in place and bounce back the mbuf.
+ */
 static int
 verify_header(PNATState pData, struct mbuf **pMBuf)
@@ -201 +223 @@
 
     m = *pMBuf;
+    mlen = m_length(m, NULL);
 
     /*
@@ -215 +238 @@
     pHdr = mtod(m, struct dnsmsg_header *);
 
+    if (RT_UNLIKELY(mlen < sizeof(*pHdr)))
+    {
+        LogErr(("NAT: hostres: packet too small: %zu bytes\n", mlen));
+        goto drop;              /* can't even refuse it */
+    }
+
+    if (RT_UNLIKELY(mlen > DNS_MAX_UDP_LEN))
+    {
+        LogErr(("NAT: hostres: packet too large: %zu bytes\n", mlen));
+        goto drop;              /* don't echo back huge packets */
+    }
+
     if (RT_UNLIKELY(pHdr->qr != QR_Query))
     {
         LogErr(("NAT: hostres: unexpected response\n"));
-        goto drop;
-    }
-
-    mlen = m_length(m, NULL);
-    if (RT_UNLIKELY(mlen > DNS_MAX_UDP_LEN))
-    {
-        LogErr(("NAT: hostres: packet too large\n"));
-        refuse(pData, m, RCode_FormErr); /* or drop? */
-        return 1;
+        goto drop;              /* ignore */
     }
 
     if (RT_UNLIKELY(pHdr->opcode != OpCode_Query))
     {
-        LogErr(("NAT: hostres: unsupported opcode\n"));
-        refuse(pData, m, RCode_NotImp);
-        return 1;
+        LogErr(("NAT: hostres: unsupported opcode %d\n", pHdr->opcode));
+        refuse_mbuf(m, RCode_NotImp);
+        return VERR_PARSE_ERROR;
     }
 
@@ -239 +266 @@
     {
         LogErr(("NAT: hostres: multiple questions\n"));
-        refuse(pData, m, RCode_NotImp);
-        return 1;
+        refuse_mbuf(m, RCode_NotImp);
+        return VERR_PARSE_ERROR;
     }
 
@@ -246 +273 @@
     {
         LogErr(("NAT: hostres: answers in query\n"));
-        refuse(pData, m, RCode_NotImp);
-        return 1;
-    }
-
+        refuse_mbuf(m, RCode_NotImp);
+        return VERR_PARSE_ERROR;
+    }
+
+    /* XXX: let it fail when we parse it? */
     if (RT_UNLIKELY(mlen < sizeof(*pHdr)
                              + /* qname  */ 1
@@ -255 +283 @@
                              + /* qclass */ 2))
     {
-        LogErr(("NAT: hostres: packet too small\n"));
-        refuse(pData, m, RCode_FormErr);
-        return 1;
-    }
-
-    return 0;
+        LogErr(("NAT: hostres: packet too small: %zu bytes\n", mlen));
+        refuse_mbuf(m, RCode_FormErr);
+        return VERR_PARSE_ERROR;
+    }
+
+    return VINF_SUCCESS;
 
   drop:
@@ -266 +294 @@
         m_freem(pData, m);
     *pMBuf = NULL;
-    return 1;
-}
-
-
+    return VERR_PARSE_ERROR;
+}
+
+
+/*
+ * Turn the request in mbuf into an error response.  This is used on
+ * slirp thread for pre-checks before we do async resolution.
+ */
 static struct mbuf *
-respond(PNATState pData, struct mbuf *m, struct response *res)
+refuse_mbuf(struct mbuf *m, unsigned int rcode)
+{
+    struct dnsmsg_header *pHdr;
+
+    pHdr = mtod(m, struct dnsmsg_header *);
+    pHdr->qr = QR_Response;
+    pHdr->rcode = rcode;
+    pHdr->ra = 1;
+    pHdr->aa = 0;
+
+    return m;
+}
+
+
+/*
+ * Actuall resolution runs on the dedicated host resolver thread.
+ */
+static void
+hostres_async(struct response *res)
+{
+    int rc;
+
+    /* build reply in res->buf[] */
+    respond(res);
+
+    free_labels(res->labels);
+
+    rc = slirp_call(res->pData->pvUser, NULL, 0,
+                    RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
+                    (PFNRT)hostres_slirp_reply, 1, res);
+
+    if (RT_FAILURE(rc))
+    {
+        LogErr(("NAT: hostres: failed to post async reply: %Rrc\n", rc));
+        RTMemFree(res);
+    }
+}
+
+
+/*
+ * We are  back to the slirp thread to send the reply.
+ */
+static void
+hostres_slirp_reply(struct response *res)
+{
+    PNATState pData = res->pData;
+    struct sockaddr_in src, dst;
+    struct mbuf *m = NULL;
+    size_t mlen;
+    int ok;
+
+    mlen = if_maxlinkhdr + sizeof(struct ip) + sizeof(struct udphdr);
+    mlen += res->end;
+
+    if (mlen <= MHLEN)
+    {
+        m = m_gethdr(pData, M_NOWAIT, MT_HEADER);
+    }
+    else
+    {
+        void *pvBuf;            /* ignored */
+        size_t cbBuf;
+
+        m = slirp_ext_m_get(pData, mlen, &pvBuf, &cbBuf);
+    }
+
+    if (m == NULL)
+        goto out;
+
+    /* reserve leading space for ethernet header */
+    m->m_data += if_maxlinkhdr;
+
+    /* reserve leading space for protocol headers */
+    m->m_pkthdr.header = mtod(m, void *);
+    m->m_data += sizeof(struct ip) + sizeof(struct udphdr);
+
+    m->m_len = 0;
+    ok = m_append(pData, m, res->end, (c_caddr_t)res->buf);
+    if (!ok)
+    {
+        m_freem(pData, m);
+        goto out;
+    }
+
+    src.sin_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_DNS);
+    src.sin_port = RT_H2N_U16_C(53);
+    dst.sin_addr.s_addr = res->src;
+    dst.sin_port = res->sport;
+
+    udp_output2(pData, NULL, m, &src, &dst, IPTOS_LOWDELAY);
+
+  out:
+    RTMemFree(res);
+}
+
+
+static int
+respond(struct response *res)
 {
     struct dnsmsg_header *pHdr;
@@ -281 +410 @@
     struct label *l;
 
-    /**
-     * Copy the request into the contiguous buffer for the response
-     * and parse the question.
-     */
-
-    mlen = m_length(m, NULL);
-    m_copydata(m, 0, mlen, (char *)res->buf);
-    res->end = res->qlen = mlen;
-
     /* convert header to response */
     pHdr = (struct dnsmsg_header *)res->buf;
@@ -305 +425 @@
      * compression in the answer.
      */
-    while (off < mlen) {
+    while (off < res->qlen) {
         size_t loff, llen;
         uint8_t c;
@@ -319 +439 @@
         {
             LogErr(("NAT: hostres: label pointer in the qname\n"));
-            return refuse(pData, m, RCode_FormErr);
+            return refuse(res, RCode_FormErr);
         }
 
@@ -325 +445 @@
         {
             LogErr(("NAT: hostres: unexpected high bits\n"));
-            return refuse(pData, m, RCode_FormErr);
+            return refuse(res, RCode_FormErr);
         }
 
@@ -335 +455 @@
         ++off;
 
-        if (loff + 1 + llen > mlen)
+        if (loff + 1 + llen > res->qlen)
         {
             LogErr(("NAT: hostres: length byte points beyound packet boundary\n"));
-            return refuse(pData, m, RCode_FormErr);
+            return refuse(res, RCode_FormErr);
         }
 
@@ -355 +475 @@
             {
                 LogErr(("NAT: hostres: dot inside label\n"));
-                return refuse(pData, m, RCode_FormErr);
+                return refuse(res, RCode_FormErr);
             }
 
@@ -361 +481 @@
             {
                 LogErr(("NAT: hostres: nul byte inside label\n"));
-                return refuse(pData, m, RCode_FormErr);
+                return refuse(res, RCode_FormErr);
             }
         }
@@ -375 +495 @@
      * QTYPE and QCLASS
      */
-    if (RT_UNLIKELY(off + 4 > mlen))
+    if (RT_UNLIKELY(off + 4 > res->qlen))
     {
         LogErr(("NAT: hostres: question too short\n"));
-        return refuse(pData, m, RCode_FormErr);
+        return refuse(res, RCode_FormErr);
     }
 
@@ -393 +513 @@
     {
         LogErr(("NAT: hostres: unsupported qclass %d\n", qclass));
-        return refuse(pData, m, RCode_NotImp);
+        return refuse(res, RCode_NotImp);
     }
 
@@ -402 +522 @@
     {
         LogErr(("NAT: hostres: unsupported qtype %d\n", qtype));
-        return refuse(pData, m, RCode_NotImp);
+        return refuse(res, RCode_NotImp);
     }
 
@@ -415 +535 @@
      * pointers, so truncating the buffer is safe.
      */
-    if (off < mlen)
-    {
-        int trailer = mlen - off;
-
-        LogDbg(("NAT: hostres: question %zu < mlen %zu\n", off, mlen));
+    if (off < res->qlen)
+    {
+        int trailer = res->qlen - off;
+
+        LogDbg(("NAT: hostres: question %zu < mlen %zu\n", off, res->qlen));
 
         if (pHdr->nscount == 0 && pHdr->arcount == 0)
         {
             LogErr(("NAT: hostres: unexpected %d bytes after the question\n", trailer));
-            return refuse(pData, m, RCode_FormErr);
+            return refuse(res, RCode_FormErr);
         }
 
@@ -433 +553 @@
                 pHdr->arcount != 0 ? "additional" : ""));
 
-        m_adj(m, -trailer);
-        mlen -= trailer;
-        res->end = res->qlen = mlen;
+        res->qlen -= trailer;
+        res->end = res->qlen;
 
         pHdr->nscount = 0;
@@ -448 +567 @@
      */
     if (get_in_addr_arpa(&in_addr_arpa, res->labels))
-        return resolve_reverse(pData, m, res, qtype, qname, in_addr_arpa);
+        return resolve_reverse(res, qtype, qname, in_addr_arpa);
     else
-        return resolve(pData, m, res, qtype, qname);
-}
-
-
-struct mbuf *
-resolve(PNATState pData, struct mbuf *m, struct response *res,
-        uint16_t qtype, size_t qname)
+        return resolve(res, qtype, qname);
+}
+
+
+static int
+resolve(struct response *res, uint16_t qtype, size_t qname)
 {
     struct dnsmsg_header *pHdr;
@@ -485 +603 @@
 #ifdef VBOX_WITH_DNSMAPPING_IN_HOSTRESOLVER
     {
-        PDNSMAPPINGENTRY pDNSMapingEntry = getDNSMapByName(pData, name);
+        PDNSMAPPINGENTRY pDNSMapingEntry = getDNSMapByName(res->pData, name);
         if (pDNSMapingEntry != NULL)
         {
@@ -520 +638 @@
     {
         /* LogErr: h_errno */
-        return refuse(pData, m, RCode_NXDomain);
+        return refuse(res, RCode_NXDomain);
     }
 
@@ -537 +655 @@
 
 #ifdef VBOX_WITH_DNSMAPPING_IN_HOSTRESOLVER
-    alterHostentWithDataFromDNSMap(pData, h);
+    alterHostentWithDataFromDNSMap(res->pData, h);
 #endif
 
@@ -557 +675 @@
                     name, h->h_name));
             if (nbytes < 0)
-                return refuse(pData, m, RCode_ServFail);
+                return refuse(res, RCode_ServFail);
             else
             {
@@ -598 +716 @@
                     cname, addr.s_addr));
             if (nbytes < 0)
-                return refuse(pData, m, RCode_ServFail);
+                return refuse(res, RCode_ServFail);
             else
             {
@@ -634 +752 @@
 
   out:
-    if (nanswers > 0)
-    {
-        int ok = m_append(pData, m, res->end - oend, (caddr_t)&res->buf[oend]);
-        if (!ok)
-        {
-            /* XXX: this may fail part way: restore old lenght, clear TC? */
-            return refuse(pData, m, RCode_ServFail);
-        }
-        pHdr->ancount = RT_H2N_U16(nanswers);
-    }
-    memcpy(mtod(m, char *), res->buf, sizeof(struct dnsmsg_header));
-    return m;
-}
-
-
-struct mbuf *
-resolve_reverse(PNATState pData, struct mbuf *m, struct response *res,
-                uint16_t qtype, size_t qname, struct in_addr in_addr_arpa)
+    pHdr->ancount = RT_H2N_U16(nanswers);
+    return VINF_SUCCESS;
+}
+
+
+static int
+resolve_reverse(struct response *res, uint16_t qtype, size_t qname,
+                struct in_addr in_addr_arpa)
 {
     struct dnsmsg_header *pHdr;
@@ -684 +792 @@
      */
     {
-        PDNSMAPPINGENTRY pReverseMapping = getDNSMapByAddr(pData, &in_addr_arpa.s_addr);
+        PDNSMAPPINGENTRY pReverseMapping = getDNSMapByAddr(res->pData, &in_addr_arpa.s_addr);
         if (pReverseMapping != NULL)
         {
@@ -712 +820 @@
     {
         /* LogErr: h_errno */
-        return refuse(pData, m, RCode_NXDomain);
+        return refuse(res, RCode_NXDomain);
     }
 
@@ -731 +839 @@
                     name, h->h_name));
             if (nbytes < 0)
-                return refuse(pData, m, RCode_ServFail);
+                return refuse(res, RCode_ServFail);
             else
             {
@@ -741 +849 @@
 
   out:
-    if (nanswers > 0)
-    {
-        int ok = m_append(pData, m, res->end - oend, (caddr_t)&res->buf[oend]);
-        if (!ok)
-        {
-            /* XXX: this may fail part way: restore old lenght, clear TC? */
-            return refuse(pData, m, RCode_ServFail);
-        }
-        pHdr->ancount = RT_H2N_U16(nanswers);
-    }
-    memcpy(mtod(m, char *), res->buf, sizeof(struct dnsmsg_header));
-    return m;
-}
-
+    pHdr->ancount = RT_H2N_U16(nanswers);
+    return VINF_SUCCESS;
+}
+
+
+static int
+refuse(struct response *res, unsigned int rcode)
+{
+    struct dnsmsg_header *pHdr = (struct dnsmsg_header *)res->buf;
+    pHdr->rcode = rcode;
+
+    return VINF_SUCCESS;
+}
 
 

trunk/src/VBox/Devices/Network/slirp/libslirp.h

@@ -38 +38 @@
 
 #include <VBox/types.h>
+#include <iprt/req.h>
 
 typedef struct NATState *PNATState;
@@ -71 +72 @@
 void slirp_urg_output(void *pvUser, struct mbuf *, const uint8_t *pu8Buf, int cb);
 void slirp_post_sent(PNATState pData, void *pvArg);
+
+int slirp_call(void *pvUser, PRTREQ *ppReq, RTMSINTERVAL cMillies,
+               unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, ...);
+
+int slirp_call_hostres(void *pvUser, PRTREQ *ppReq, RTMSINTERVAL cMillies,
+                       unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, ...);
+
 
 void slirp_update_guest_addr_guess(PNATState pData, uint32_t guess, const char *msg);

trunk/src/VBox/Devices/Network/slirp/slirp.h

@@ -352 +352 @@
 
 /* hostres.c */
-struct mbuf *hostresolver(PNATState, struct mbuf *);
+struct mbuf *hostresolver(PNATState, struct mbuf *, uint32_t src, uint16_t sport);
 
 /*slirp.c*/

trunk/src/VBox/Devices/Network/slirp/udp.c

@@ -199 +199 @@
         m_adj(m, sizeof(struct udpiphdr));
 
-        m = hostresolver(pData, m);
+        m = hostresolver(pData, m, ip->ip_src.s_addr, uh->uh_sport);
         if (m == NULL)
             goto done_free_mbuf;