Changeset 105726 in vbox for trunk

Timestamp:

Aug 19, 2024 2:05:15 PM (9 months ago)

Author:

vboxsync

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

164430

Message:

Devices/Network: cleaned up header file, memory leak fixes, search domains pushed to guest on host network change only. bugref:10268

Location:

trunk

Files:

• include/VBox/vmm/pdmnetifs.h (modified) (2 diffs)
• src/VBox/Devices/Network/DrvNAT.cpp (modified) (1 diff)
• src/VBox/Devices/Network/DrvNATlibslirp.cpp (modified) (24 diffs)
• src/VBox/Devices/Network/DrvNATlibslirp.h (deleted)
• src/VBox/Main/include/ConsoleImpl.h (modified) (2 diffs)
• src/VBox/Main/src-client/ConsoleImpl.cpp (modified) (5 diffs)
• src/libs/libslirp-4.8.0/src/libslirp.h (modified) (1 diff)
• src/libs/libslirp-4.8.0/src/slirp.c (modified) (1 diff)

trunk/include/VBox/vmm/pdmnetifs.h

@@ -433 +433 @@
 
 
+/**
+ * DNS Setting Update Payload
+ * @sa PGMINETWORKNATCONFIG::pfnNotifyDnsChanged
+ */
+typedef struct PDMINETWORKNATDNSCONFIG
+{
+    /** Domain name.
+     * (The length is per RFC2821 plus null char.) */
+    char                szDomainName[256];
+    /** Number of entries in the ppszNameServers array.   */
+    size_t              cNameServers;
+    /** Name servers (NULL terminated array). */
+    const char * const *papszNameServers;
+    /** Number of entries in the ppszSearchDomains array. */
+    size_t              cSearchDomains;
+    /** Search domains (NULL terminated array). */
+    const char * const *papszSearchDomains;
+} PDMINETWORKNATDNSCONFIG;
+/** Pointer to a const DNS settings update payload.
+ * @sa PGMINETWORKNATCONFIG::pfnNotifyDnsChanged */
+typedef PDMINETWORKNATDNSCONFIG const *PCPDMINETWORKNATDNSCONFIG;
+
+
 /** Pointer to a NAT configuration port.   */
 typedef struct PDMINETWORKNATCONFIG *PPDMINETWORKNATCONFIG;
@@ -455 +478 @@
      * IHostNameResolutionConfigurationChangeEvent.
      */
-    DECLR3CALLBACKMEMBER(void, pfnNotifyDnsChanged, (PPDMINETWORKNATCONFIG pInterface));
+    DECLR3CALLBACKMEMBER(void, pfnNotifyDnsChanged, (PPDMINETWORKNATCONFIG pInterface, PCPDMINETWORKNATDNSCONFIG pDnsConfig));
 
 } PDMINETWORKNATCONFIG;
 /** PDMINETWORKNATCONFIG interface ID. */
-#define PDMINETWORKNATCONFIG_IID                "dc961028-3523-4b52-a93b-e38168a4a9fa"
+#define PDMINETWORKNATCONFIG_IID                "16de6afe-e48f-4cad-abc0-f96507683376"
 /** @} */
 

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

@@ -1097 +1097 @@
  * information ourselves.
  */
-static DECLCALLBACK(void) drvNATNotifyDnsChanged(PPDMINETWORKNATCONFIG pInterface)
-{
+static DECLCALLBACK(void) drvNATNotifyDnsChanged(PPDMINETWORKNATCONFIG pInterface, PCPDMINETWORKNATDNSCONFIG pDnsConf)
+{
+    RT_NOREF(pDnsConf);
     PDRVNAT pThis = RT_FROM_MEMBER(pInterface, DRVNAT, INetworkNATCfg);
     drvNATUpdateDNS(pThis, /* fFlapLink */ true);

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

@@ -31 +31 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DRV_NAT
-
-#include "DrvNATlibslirp.h"
-
-
-/**
+#define RTNET_INCL_IN_ADDR
+#include "VBoxDD.h"
+
+#ifdef RT_OS_WINDOWS
+# include <iprt/win/winsock2.h>
+# include <iprt/win/ws2tcpip.h>
+#endif
+
+#include <libslirp.h>
+
+#include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/pdmdrv.h>
+#include <VBox/vmm/pdmnetifs.h>
+#include <VBox/vmm/pdmnetinline.h>
+
+#ifndef RT_OS_WINDOWS
+# include <unistd.h>
+# include <fcntl.h>
+# include <poll.h>
+# include <errno.h>
+#endif
+#ifdef RT_OS_FREEBSD
+# include <netinet/in.h>
+#endif
+
+#ifdef RT_OS_WINDOWS
+# include <iprt/win/winsock2.h>
+# define inet_aton(x, y) inet_pton(2, x, y)
+# define AF_INET6 23
+#endif
+
+#include <iprt/assert.h>
+#include <iprt/critsect.h>
+#include <iprt/cidr.h>
+#include <iprt/file.h>
+#include <iprt/mem.h>
+#include <iprt/net.h>
+#include <iprt/pipe.h>
+#include <iprt/string.h>
+#include <iprt/stream.h>
+#include <iprt/time.h>
+#include <iprt/uuid.h>
+
+#include <iprt/asm.h>
+
+#include <iprt/semaphore.h>
+#include <iprt/req.h>
+#ifdef RT_OS_DARWIN
+# include <SystemConfiguration/SystemConfiguration.h>
+# include <CoreFoundation/CoreFoundation.h>
+#endif
+
+#define COUNTERS_INIT
+#include "slirp/counters.h"
+#include "slirp/resolv_conf_parser.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define DRVNAT_MAXFRAMESIZE (16 * 1024)
+#define DRVNAT_DEFAULT_TIMEOUT (3600*1000)
+
+/**
+ * @todo: This is a bad hack to prevent freezing the guest during high network
+ *        activity. Windows host only. This needs to be fixed properly.
+ */
+#define VBOX_NAT_DELAY_HACK
+
+#define GET_EXTRADATA(pdrvins, node, name, rc, type, type_name, var)                                  \
+    do {                                                                                                \
+        (rc) = (pdrvins)->pHlpR3->pfnCFGMQuery ## type((node), name, &(var));                                               \
+        if (RT_FAILURE((rc)) && (rc) != VERR_CFGM_VALUE_NOT_FOUND)                                      \
+            return PDMDrvHlpVMSetError((pdrvins), (rc), RT_SRC_POS, \
+                                       N_("NAT#%d: configuration query for \"" name "\" " #type_name " failed"), \
+                                       (pdrvins)->iInstance);                                    \
+    } while (0)
+
+#define GET_ED_STRICT(pdrvins, node, name, rc, type, type_name, var)                                  \
+    do {                                                                                                \
+        (rc) = (pdrvins)->pHlpR3->pfnCFGMQuery ## type((node), name, &(var));                                               \
+        if (RT_FAILURE((rc)))                                                                           \
+            return PDMDrvHlpVMSetError((pdrvins), (rc), RT_SRC_POS, \
+                                       N_("NAT#%d: configuration query for \"" name "\" " #type_name " failed"), \
+                                       (pdrvins)->iInstance);                                     \
+    } while (0)
+
+#define GET_EXTRADATA_N(pdrvins, node, name, rc, type, type_name, var, var_size)                      \
+    do {                                                                                                \
+        (rc) = (pdrvins)->pHlpR3->pfnCFGMQuery ## type((node), name, &(var), var_size);                                     \
+        if (RT_FAILURE((rc)) && (rc) != VERR_CFGM_VALUE_NOT_FOUND)                                      \
+            return PDMDrvHlpVMSetError((pdrvins), (rc), RT_SRC_POS, \
+                                       N_("NAT#%d: configuration query for \"" name "\" " #type_name " failed"), \
+                                       (pdrvins)->iInstance);                                     \
+    } while (0)
+
+#define GET_BOOL(rc, pdrvins, node, name, var) \
+    GET_EXTRADATA(pdrvins, node, name, (rc), Bool, bolean, (var))
+#define GET_STRING(rc, pdrvins, node, name, var, var_size) \
+    GET_EXTRADATA_N(pdrvins, node, name, (rc), String, string, (var), (var_size))
+#define GET_STRING_ALLOC(rc, pdrvins, node, name, var) \
+    GET_EXTRADATA(pdrvins, node, name, (rc), StringAlloc, string, (var))
+#define GET_S32(rc, pdrvins, node, name, var) \
+    GET_EXTRADATA(pdrvins, node, name, (rc), S32, int, (var))
+#define GET_S32_STRICT(rc, pdrvins, node, name, var) \
+    GET_ED_STRICT(pdrvins, node, name, (rc), S32, int, (var))
+
+#define DO_GET_IP(rc, node, instance, status, x)                                \
+    do {                                                                            \
+        char    sz##x[32];                                                          \
+        GET_STRING((rc), (node), (instance), #x, sz ## x[0],  sizeof(sz ## x));     \
+        if (rc != VERR_CFGM_VALUE_NOT_FOUND)                                        \
+            (status) = inet_aton(sz ## x, &x);                                      \
+    } while (0)
+
+#define GETIP_DEF(rc, node, instance, x, def)           \
+    do                                                      \
+    {                                                       \
+        int status = 0;                                     \
+        DO_GET_IP((rc), (node), (instance),  status, x);    \
+        if (status == 0 || rc == VERR_CFGM_VALUE_NOT_FOUND) \
+            x.s_addr = def;                                 \
+    } while (0)
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/** Slirp Timer */
+typedef struct slirpTimer
+{
+    struct slirpTimer *next;
+    uint32_t uTimeExpire;
+    SlirpTimerCb pHandler;
+    void *opaque;
+} SlirpTimer;
+
+/**
+ * Main state of Libslirp NAT
+ */
+typedef struct SlirpState
+{
+    unsigned int nsock;
+
+    Slirp *pSlirp;
+    struct pollfd *polls;
+
+    /** Num Polls (not bytes) */
+    unsigned int uPollCap = 0;
+
+    SlirpTimer *pTimerHead;
+} SlirpState;
+typedef SlirpState *pSlirpState;
+
+/**
+ * NAT network transport driver instance data.
+ *
+ * @implements  PDMINETWORKUP
+ */
+typedef struct DRVNAT
+{
+    /** The network interface. */
+    PDMINETWORKUP           INetworkUp;
+    /** The network NAT Engine configuration. */
+    PDMINETWORKNATCONFIG    INetworkNATCfg;
+    /** The port we're attached to. */
+    PPDMINETWORKDOWN        pIAboveNet;
+    /** The network config of the port we're attached to. */
+    PPDMINETWORKCONFIG      pIAboveConfig;
+    /** Pointer to the driver instance. */
+    PPDMDRVINS              pDrvIns;
+    /** Link state */
+    PDMNETWORKLINKSTATE     enmLinkState;
+    /** NAT state */
+    pSlirpState             pNATState;
+    /** TFTP directory prefix. */
+    char                   *pszTFTPPrefix;
+    /** Boot file name to provide in the DHCP server response. */
+    char                   *pszBootFile;
+    /** tftp server name to provide in the DHCP server response. */
+    char                   *pszNextServer;
+    /** Polling thread. */
+    PPDMTHREAD              pSlirpThread;
+    /** Queue for NAT-thread-external events. */
+    RTREQQUEUE              hSlirpReqQueue;
+    /** The guest IP for port-forwarding. */
+    uint32_t                GuestIP;
+    /** Link state set when the VM is suspended. */
+    PDMNETWORKLINKSTATE     enmLinkStateWant;
+
+#ifndef RT_OS_WINDOWS
+    /** The write end of the control pipe. */
+    RTPIPE                  hPipeWrite;
+    /** The read end of the control pipe. */
+    RTPIPE                  hPipeRead;
+# if HC_ARCH_BITS == 32
+    uint32_t                u32Padding;
+# endif
+#else
+    /** for external notification */
+    HANDLE                  hWakeupEvent;
+#endif
+
+#define DRV_PROFILE_COUNTER(name, dsc)     STAMPROFILE Stat ## name
+#define DRV_COUNTING_COUNTER(name, dsc)    STAMCOUNTER Stat ## name
+#include "slirp/counters.h"
+    /** thread delivering packets for receiving by the guest */
+    PPDMTHREAD              pRecvThread;
+    /** event to wakeup the guest receive thread */
+    RTSEMEVENT              EventRecv;
+    /** Receive Req queue (deliver packets to the guest) */
+    RTREQQUEUE              hRecvReqQueue;
+
+    /** makes access to device func RecvAvail and Recv atomical. */
+    RTCRITSECT              DevAccessLock;
+    /** Number of in-flight packets. */
+    volatile uint32_t       cPkts;
+
+    /** Transmit lock taken by BeginXmit and released by EndXmit. */
+    RTCRITSECT              XmitLock;
+
+#ifdef RT_OS_DARWIN
+    /* Handle of the DNS watcher runloop source. */
+    CFRunLoopSourceRef      hRunLoopSrcDnsWatcher;
+#endif
+} DRVNAT;
+AssertCompileMemberAlignment(DRVNAT, StatNATRecvWakeups, 8);
+/** Pointer to the NAT driver instance data. */
+typedef DRVNAT *PDRVNAT;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static void drvNATNotifyNATThread(PDRVNAT pThis, const char *pszWho);
+static void drvNAT_UpdateTimeout(uint32_t *uTimeout, void *opaque);
+static void drvNAT_CheckTimeout(void *opaque);
+static DECLCALLBACK(int) drvNAT_AddPollCb(int iFd, int iEvents, void *opaque);
+static DECLCALLBACK(int64_t) drvNAT_ClockGetNsCb(void *opaque);
+static DECLCALLBACK(int) drvNAT_GetREventsCb(int idx, void *opaque);
+
+
+
+/*
  * PDM Function Implementations
  */
@@ -499 +738 @@
          */
 #ifndef RT_OS_WINDOWS
-        uint32_t uTimeout = 0;
+        uint32_t uTimeout = DRVNAT_DEFAULT_TIMEOUT;
         pThis->pNATState->nsock = 1;
 
@@ -548 +787 @@
 
 #else /* RT_OS_WINDOWS */
-        uint32_t uTimeout = 0;
+        uint32_t uTimeout = DRVNAT_DEFAULT_TIMEOUT;
         pThis->pNATState->nsock = 0;
         slirp_pollfds_fill(pThis->pNATState->pSlirp, &uTimeout, drvNAT_AddPollCb /* SlirpAddPollCb */, pThis /* opaque */);
@@ -775 +1014 @@
 }
 
+/**
+ * @interface_method_impl{PDMINETWORKNATCONFIG,pfnRedirectRuleCommand}
+ */
 static DECLCALLBACK(int) drvNATNetworkNatConfigRedirect(PPDMINETWORKNATCONFIG pInterface, bool fRemove,
                                                         bool fUdp, const char *pHostIp, uint16_t u16HostPort,
@@ -811 +1053 @@
 
 /**
+ * @interface_method_impl{PDMINETWORKNATCONFIG,pfnNotifyDnsChanged}
+ */
+static DECLCALLBACK(void) drvNATNotifyDnsChanged(PPDMINETWORKNATCONFIG pInterface, PCPDMINETWORKNATDNSCONFIG pDnsConf)
+{
+    PDRVNAT const      pThis     = RT_FROM_MEMBER(pInterface, DRVNAT, INetworkNATCfg);
+    SlirpState * const pNATState = pThis->pNATState;
+    AssertReturnVoid(pNATState);
+    AssertReturnVoid(pNATState->pSlirp);
+
+    slirp_set_vdomainname(pNATState->pSlirp, pDnsConf->szDomainName);
+    slirp_set_vdnssearch(pNATState->pSlirp, pDnsConf->papszSearchDomains);
+    /** @todo Convert the papszNameServers entries to IP address and tell about
+     *        the first IPv4 and IPv6 ones. */
+}
+
+
+/*
  * Libslirp Utility Functions
  */
@@ -822 +1081 @@
  */
 static void drvNAT_UpdateTimeout(uint32_t *uTimeout, void *opaque)
+{
+    PDRVNAT pThis = (PDRVNAT)opaque;
+    Assert(pThis);
+
+    uint32_t currTime = drvNAT_ClockGetNsCb(pThis) / (1000 * 1000);
+    SlirpTimer *pCurrent = pThis->pNATState->pTimerHead;
+    while (pCurrent != NULL)
+    {
+        if (pCurrent->uTimeExpire != 0)
+        {
+            int64_t diff = pCurrent->uTimeExpire - currTime;
+
+            if (diff < 0)
+                diff = 0;
+
+            if (diff < *uTimeout)
+                *uTimeout = diff;
+        }
+
+        pCurrent = pCurrent->next;
+    }
+}
+
+/**
+ * Check if timeout has passed in given list of Slirp timers.
+ *
+ * @param   opaque  Pointer to NAT State context.
+ *
+ * @thread  ?
+ */
+static void drvNAT_CheckTimeout(void *opaque)
 {
     PDRVNAT pThis = (PDRVNAT)opaque;
@@ -830 +1120 @@
     while (pCurrent != NULL)
     {
-        if (pCurrent->uTimeExpire != -1)
-        {
-            int64_t diff = pCurrent->uTimeExpire - currTime;
-
-            if (diff < 0)
-                diff = 0;
-
-            if (diff < *uTimeout)
-                *uTimeout = diff;
-        }
-
-        pCurrent = pCurrent->next;
-    }
-}
-
-/**
- * Check if timeout has passed in given list of Slirp timers.
- *
- * @param   opaque  Pointer to NAT State context.
- *
- * @thread  ?
- */
-static void drvNAT_CheckTimeout(void *opaque)
-{
-    PDRVNAT pThis = (PDRVNAT)opaque;
-    Assert(pThis);
-
-    int64_t currTime = drvNAT_ClockGetNsCb(pThis) / (1000 * 1000);
-    SlirpTimer *pCurrent = pThis->pNATState->pTimerHead;
-    while (pCurrent != NULL)
-    {
-        if (pCurrent->uTimeExpire != -1)
+        if (pCurrent->uTimeExpire != 0)
         {
             int64_t diff = pCurrent->uTimeExpire - currTime;
             if (diff <= 0)
             {
-                pCurrent->uTimeExpire = -1;
+                pCurrent->uTimeExpire = 0;
                 pCurrent->pHandler(pCurrent->opaque);
             }
@@ -929 +1188 @@
 }
 
-/**
+
+/*
  * Libslirp Callbacks
  */
@@ -1029 +1289 @@
 
     pNewTimer->next = pThis->pNATState->pTimerHead;
-    pNewTimer->uTimeExpire = -1;
+    pNewTimer->uTimeExpire = -1; /** @todo r=bird: uTimeExpire is unsigned, not signed. Visual C++ barfs at this mixup. */
     pNewTimer->pHandler = slirpTimeCb;
     pNewTimer->opaque = cb_opaque;
@@ -1094 +1354 @@
  * Registers poll. Unused function (other than logging).
  */
-static DECLCALLBACK(void) drvNAT_RegisterPoll(int fd, void *opaque) {
+static DECLCALLBACK(void) drvNAT_RegisterPoll(int fd, void *opaque)
+{
     RT_NOREF(fd, opaque);
     Log4(("Poll registered\n"));
@@ -1102 +1363 @@
  * Unregisters poll. Unused function (other than logging).
  */
-static DECLCALLBACK(void) drvNAT_UnregisterPoll(int fd, void *opaque) {
+static DECLCALLBACK(void) drvNAT_UnregisterPoll(int fd, void *opaque)
+{
     RT_NOREF(fd, opaque);
     Log4(("Poll unregistered\n"));
@@ -1127 +1389 @@
         int cbNew = pThis->pNATState->uPollCap * 2 * sizeof(struct pollfd);
         struct pollfd *pvNew = (struct pollfd *)RTMemRealloc(pThis->pNATState->polls, cbNew);
-        if(pvNew)
+        if (pvNew)
         {
             pThis->pNATState->polls = pvNew;
@@ -1182 +1444 @@
     PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
 
-    if (pThis->pNATState)
-    {
-        slirp_cleanup(pThis->pNATState->pSlirp);
+    SlirpState * const pNATState = pThis->pNATState;
+    if (pNATState)
+    {
+        slirp_cleanup(pNATState->pSlirp);
+
 #ifdef VBOX_WITH_STATISTICS
 # define DRV_PROFILE_COUNTER(name, dsc)     DEREGISTER_COUNTER(name, pThis)
@@ -1190 +1454 @@
 # include "slirp/counters.h"
 #endif
+        RTMemFree(pNATState->polls);
+        pNATState->polls = NULL;
+
+        RTMemFree(pNATState);
         pThis->pNATState = NULL;
     }
@@ -1221 +1489 @@
 static DECLCALLBACK(int) drvNATConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
 {
-    int rc = 0;
-
-    /* Construct PDRVNAT */
-
     RT_NOREF(fFlags);
     PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
-    PDRVNAT         pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
+    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
 
     /*
@@ -1233 +1497 @@
      */
     pThis->pDrvIns                      = pDrvIns;
-    pThis->pNATState                    = (SlirpState *)RTMemAlloc(sizeof(SlirpState));
-    if(pThis->pNATState == NULL)
+
+    SlirpState * const pNATState = (SlirpState *)RTMemAllocZ(sizeof(*pNATState));
+    if (pNATState == NULL)
         return VERR_NO_MEMORY;
-    else
-    {
-        pThis->pNATState->nsock = 0;
-        pThis->pNATState->pTimerHead = NULL;
-        pThis->pNATState->polls = (struct pollfd *)RTMemAlloc(64 * sizeof(struct pollfd));
-        pThis->pNATState->uPollCap = 64;
-    }
+    pThis->pNATState                    = pNATState;
+    pNATState->nsock                    = 0;
+    pNATState->pTimerHead               = NULL;
+    pNATState->polls                    = (struct pollfd *)RTMemAllocZ(64 * sizeof(struct pollfd));
+    AssertReturn(pNATState->polls, VERR_NO_MEMORY);
+    pNATState->uPollCap                 = 64;
+
     pThis->hSlirpReqQueue               = NIL_RTREQQUEUE;
     pThis->EventRecv                    = NIL_RTSEMEVENT;
@@ -1260 +1525 @@
     /* NAT engine configuration */
     pThis->INetworkNATCfg.pfnRedirectRuleCommand = drvNATNetworkNatConfigRedirect;
-    pThis->INetworkNATCfg.pfnNotifyDnsChanged = NULL;
+    pThis->INetworkNATCfg.pfnNotifyDnsChanged    = drvNATNotifyDnsChanged;
 
     /*
@@ -1289 +1554 @@
      * Get the configuration settings.
      */
+    int  rc;
     bool fPassDomain = true;
     GET_BOOL(rc, pDrvIns, pCfg, "PassDomain", fPassDomain);
@@ -1335 +1601 @@
 
     RTNETADDRIPV4 Network, Netmask;
-
     rc = RTCidrStrToIPv4(szNetwork, &Network, &Netmask);
     if (RT_FAILURE(rc))
@@ -1344 +1609 @@
     /* Construct Libslirp Config and Initialzie Slirp */
 
-    LogFlow(("Here is what is coming out of the vbox config:\n \
-            Network: %lu\n \
-            Netmask: %lu\n", Network, Netmask));
-
-#ifndef RT_OS_WINDOWS
+    LogFlow(("Here is what is coming out of the vbox config:\n"
+             "  Network: %lu\n"
+             "  Netmask: %lu\n", Network, Netmask));
+
+#ifndef RT_OS_WINDOWS /** @todo r=bird: Why do we need special windows code here?!? */
     struct in_addr vnetwork = RTNetIPv4AddrHEToInAddr(&Network);
     struct in_addr vnetmask = RTNetIPv4AddrHEToInAddr(&Netmask);
@@ -1371 +1636 @@
 #endif
 
+    /** @todo r=bird: This is leaked.  It can be a stack structure since libslirp
+     *        only copies values from it and doesn't retain the pointer. */
     SlirpConfig *pSlirpCfg = new SlirpConfig { 0 };
 
@@ -1398 +1665 @@
     pSlirpCfg->vdomainname = NULL;
 
+    /** @todo r=bird: This is leaked.  It can be a static structure.   */
     SlirpCb *slirpCallbacks = (struct SlirpCb *)RTMemAlloc(sizeof(SlirpCb));
 
@@ -1432 +1700 @@
 
     rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pRecvThread, pThis, drvNATRecv,
-                                drvNATRecvWakeup, 256 * _1K, RTTHREADTYPE_IO, "NATRX");
+                               drvNATRecvWakeup, 256 * _1K, RTTHREADTYPE_IO, "NATRX");
     AssertRCReturn(rc, rc);
 
@@ -1463 +1731 @@
 
     rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pSlirpThread, pThis, drvNATAsyncIoThread,
-                                drvNATAsyncIoWakeup, 256 * _1K, RTTHREADTYPE_IO, "NAT");
+                               drvNATAsyncIoWakeup, 256 * _1K, RTTHREADTYPE_IO, "NAT");
     AssertRCReturn(rc, rc);
 

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -103 +103 @@
 struct VUSBIRHCONFIG;
 typedef struct VUSBIRHCONFIG *PVUSBIRHCONFIG;
+
+struct PDMINETWORKNATDNSCONFIG;
 
 #include <list>
@@ -437 +439 @@
     HRESULT clearAllEncryptionPasswords();
 
-    void notifyNatDnsChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, ULONG ulInstanceMax);
+    void notifyNatDnsChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, ULONG ulInstanceMax,
+                            struct PDMINETWORKNATDNSCONFIG const *pDnsConfig);
     Utf8Str VRDPServerErrorToMsg(int vrc);
 

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

@@ -4512 +4512 @@
 
 
-/*
+/** Helper that converts a BSTR safe array into a C-string array. */
+static char **bstrSafeArrayToC(SafeArray<BSTR> const &a_rStrings, size_t *pcEntries) RT_NOEXCEPT
+{
+    if (pcEntries)
+        *pcEntries = 0;
+
+    /*
+     * The array is NULL terminated.
+     */
+    const size_t cStrings = a_rStrings.size();
+    char **papszRet = (char **)RTMemAllocZ((cStrings + 1) * sizeof(papszRet[0]));
+    AssertReturn(papszRet, NULL);
+
+    /*
+     * The individual strings.
+     */
+    for (size_t i = 0; i < cStrings; i++)
+    {
+        int vrc = RTUtf16ToUtf8Ex((PCRTUTF16)a_rStrings[i], RTSTR_MAX, &papszRet[i], 0, NULL);
+        AssertRC(vrc);
+        if (RT_FAILURE(vrc))
+        {
+            while (i-- > 0)
+            {
+                RTStrFree(papszRet[i]);
+                papszRet[i] = NULL;
+            }
+            return NULL;
+        }
+
+    }
+        if (pcEntries)
+            *pcEntries = cStrings;
+    return papszRet;
+}
+
+
+/**
  * IHostNameResolutionConfigurationChangeEvent
  *
@@ -4520 +4557 @@
 HRESULT Console::i_onNATDnsChanged()
 {
-    HRESULT hrc;
-
     AutoCaller autoCaller(this);
     AssertComRCReturnRC(autoCaller.hrc());
 
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-#if 0 /* XXX: We don't yet pass this down to pfnNotifyDnsChanged */
-    ComPtr<IVirtualBox> pVirtualBox;
-    hrc = mMachine->COMGETTER(Parent)(pVirtualBox.asOutParam());
+    /* We wrap PDMINETWORKNATDNSCONFIG to simplify freeing memory allocations
+       in it (exceptions, AssertReturn, regular returns). */
+    struct DnsConfigCleanupWrapper
+    {
+        PDMINETWORKNATDNSCONFIG Core;
+
+        DnsConfigCleanupWrapper()
+        {
+            Core.szDomainName[0]    = '\0';
+            Core.cNameServers       = 0;
+            Core.papszNameServers   = NULL;
+            Core.cSearchDomains     = 0;
+            Core.papszSearchDomains = NULL;
+        }
+
+        void freeStrArray(char **papsz)
+        {
+            if (papsz)
+            {
+                for (size_t i = 0; papsz[i] != NULL; i++)
+                    RTStrFree(papsz[i]);
+                RTMemFree(papsz);
+            }
+        }
+
+        ~DnsConfigCleanupWrapper()
+        {
+            freeStrArray((char **)Core.papszNameServers);
+            Core.papszNameServers   = NULL;
+            freeStrArray((char **)Core.papszSearchDomains);
+            Core.papszSearchDomains = NULL;
+        }
+    } DnsConfig;
+
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); /** @todo r=bird: Why a write lock? */
+
+    ComPtr<IVirtualBox> ptrVirtualBox;
+    HRESULT hrc = mMachine->COMGETTER(Parent)(ptrVirtualBox.asOutParam());
     if (FAILED(hrc))
         return S_OK;
 
-    ComPtr<IHost> pHost;
-    hrc = pVirtualBox->COMGETTER(Host)(pHost.asOutParam());
+    ComPtr<IHost> ptrHost;
+    hrc = ptrVirtualBox->COMGETTER(Host)(ptrHost.asOutParam());
     if (FAILED(hrc))
         return S_OK;
 
-    SafeArray<BSTR> aNameServers;
-    hrc = pHost->COMGETTER(NameServers)(ComSafeArrayAsOutParam(aNameServers));
-    if (FAILED(hrc))
-        return S_OK;
-
-    const size_t cNameServers = aNameServers.size();
-    Log(("DNS change - %zu nameservers\n", cNameServers));
-
-    for (size_t i = 0; i < cNameServers; ++i)
-    {
-        com::Utf8Str strNameServer(aNameServers[i]);
-        Log(("- nameserver[%zu] = \"%s\"\n", i, strNameServer.c_str()));
-    }
-
-    com::Bstr domain;
-    pHost->COMGETTER(DomainName)(domain.asOutParam());
-    Log(("domain name = \"%s\"\n", com::Utf8Str(domain).c_str()));
-#endif /* 0 */
-
-    ComPtr<IPlatform> pPlatform;
-    hrc = mMachine->COMGETTER(Platform)(pPlatform.asOutParam());
+    /* Domain name: */
+    {
+        com::Bstr bstrDomain;
+        ptrHost->COMGETTER(DomainName)(bstrDomain.asOutParam());
+        com::Utf8Str const strDomainName(bstrDomain);
+        int vrc = RTStrCopy(DnsConfig.Core.szDomainName, sizeof(DnsConfig.Core.szDomainName), strDomainName.c_str());
+        AssertRC(vrc);
+    }
+    Log(("domain name = \"%s\"\n", DnsConfig.Core.szDomainName));
+
+    /* Name servers: */
+    {
+        SafeArray<BSTR> nameServers;
+        hrc = ptrHost->COMGETTER(NameServers)(ComSafeArrayAsOutParam(nameServers));
+        if (FAILED(hrc))
+            return S_OK;
+        DnsConfig.Core.papszNameServers = bstrSafeArrayToC(nameServers, &DnsConfig.Core.cNameServers);
+        if (!DnsConfig.Core.papszNameServers)
+            return E_OUTOFMEMORY;
+    }
+    Log(("DNS change - %zu nameservers\n", DnsConfig.Core.cNameServers));
+    for (size_t i = 0; i < DnsConfig.Core.cNameServers; i++)
+        Log(("- papszNameServers[%zu] = \"%s\"\n", i, DnsConfig.Core.papszNameServers[i]));
+
+    /* Search domains: */
+    {
+        SafeArray<BSTR> searchDomains;
+        hrc = ptrHost->COMGETTER(SearchStrings)(ComSafeArrayAsOutParam(searchDomains));
+        if (FAILED(hrc))
+            return S_OK;
+        DnsConfig.Core.papszSearchDomains = bstrSafeArrayToC(searchDomains, &DnsConfig.Core.cSearchDomains);
+        if (!DnsConfig.Core.papszSearchDomains)
+            return E_OUTOFMEMORY;
+    }
+    Log(("Search Domain change - %u domains\n", DnsConfig.Core.cSearchDomains));
+    for (size_t i = 0; i < DnsConfig.Core.cSearchDomains; i++)
+        Log(("- papszSearchDomain[%zu] = \"%s\"\n", i, DnsConfig.Core.papszSearchDomains[i]));
+
+    /*
+     * Notify all the NAT drivers.
+     */
+    /** @todo r=bird: This is the worst way of "enumerating" network devices
+     *        ever conceived. */
+    ComPtr<IPlatform> ptrPlatform;
+    hrc = mMachine->COMGETTER(Platform)(ptrPlatform.asOutParam());
     AssertComRCReturn(hrc, hrc);
 
     ChipsetType_T enmChipsetType;
-    hrc = pPlatform->COMGETTER(ChipsetType)(&enmChipsetType);
+    hrc = ptrPlatform->COMGETTER(ChipsetType)(&enmChipsetType);
     AssertComRCReturn(hrc, hrc);
 
@@ -4570 +4663 @@
         ULONG const ulInstanceMax = PlatformProperties::s_getMaxNetworkAdapters(enmChipsetType);
 
-        notifyNatDnsChange(ptrVM.rawUVM(), ptrVM.vtable(), "pcnet", ulInstanceMax);
-        notifyNatDnsChange(ptrVM.rawUVM(), ptrVM.vtable(), "e1000", ulInstanceMax);
-        notifyNatDnsChange(ptrVM.rawUVM(), ptrVM.vtable(), "virtio-net", ulInstanceMax);
+        notifyNatDnsChange(ptrVM.rawUVM(), ptrVM.vtable(), "pcnet", ulInstanceMax, &DnsConfig.Core);
+        notifyNatDnsChange(ptrVM.rawUVM(), ptrVM.vtable(), "e1000", ulInstanceMax, &DnsConfig.Core);
+        notifyNatDnsChange(ptrVM.rawUVM(), ptrVM.vtable(), "virtio-net", ulInstanceMax, &DnsConfig.Core);
     }
 
@@ -4579 +4672 @@
 
 
-/*
+/**
  * This routine walks over all network device instances, checking if
  * device instance has DrvNAT attachment and triggering DrvNAT DNS
  * change callback.
  */
-void Console::notifyNatDnsChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, ULONG ulInstanceMax)
+void Console::notifyNatDnsChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, ULONG ulInstanceMax,
+                                 PCPDMINETWORKNATDNSCONFIG pDnsConfig)
 {
     Log(("notifyNatDnsChange: looking for DrvNAT attachment on %s device instances\n", pszDevice));
@@ -4600 +4694 @@
             pNetNatCfg = (PPDMINETWORKNATCONFIG)pBase->pfnQueryInterface(pBase, PDMINETWORKNATCONFIG_IID);
             if (pNetNatCfg && pNetNatCfg->pfnNotifyDnsChanged)
-                pNetNatCfg->pfnNotifyDnsChanged(pNetNatCfg);
+                pNetNatCfg->pfnNotifyDnsChanged(pNetNatCfg, pDnsConfig);
         }
     }

trunk/src/libs/libslirp-4.8.0/src/libslirp.h

@@ -351 +351 @@
 const char *slirp_version_string(void);
 
+#ifdef VBOX
+char *slirp_set_vdomainname(Slirp *, char const *);
+char *slirp_get_vdomainname(Slirp *);
+int slirp_set_vdnssearch(Slirp *, const char * const *);
+#endif
+
 #ifdef __cplusplus
 } /* extern "C" */

trunk/src/libs/libslirp-4.8.0/src/slirp.c

@@ -1653 +1653 @@
     }
 }
+
+#ifdef VBOX
+
+char *slirp_set_vdomainname(Slirp *pSlirp, const char *vdomainname)
+{
+    pSlirp->vdomainname = g_strdup(vdomainname);
+    return pSlirp->vdomainname;
+}
+
+char *slirp_get_vdomainname(Slirp *pSlirp)
+{
+    return pSlirp->vdomainname;
+}
+
+int slirp_set_vdnssearch(Slirp *pSlirp, const char * const *ppszSearchDomains)
+{
+    return translate_dnssearch(pSlirp, (const char **)ppszSearchDomains);
+}
+
+#endif /* VBOX */