Changeset 53165 in vbox for trunk/src/VBox/Main/src-server/win

Timestamp:

Oct 29, 2014 4:26:20 PM (10 years ago)

Author:

vboxsync

Message:

Main/HostDnsService: brush up old Windows code. In general no
functional change is intended, but make search list handling follow
Windows behavior.

File:

• trunk/src/VBox/Main/src-server/win/HostDnsServiceWin.cpp (modified) (5 diffs)

trunk/src/VBox/Main/src-server/win/HostDnsServiceWin.cpp

@@ -1 @@
-/* -*- indent-tabs-mode: nil; -*- */
+/* $Id$ */
+/** @file
+ * Host DNS listener for Windows.
+ */
+
+/*
+ * Copyright (C) 2014 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+#include "../HostDnsService.h"
+
 #include <VBox/com/string.h>
 #include <VBox/com/ptr.h>
 
-
 #include <iprt/assert.h>
 #include <iprt/err.h>
+#include <VBox/log.h>
 
 #include <Windows.h>
 
+#include <algorithm>
+#include <sstream>
 #include <string>
 #include <vector>
-#include "../HostDnsService.h"
 
 struct HostDnsServiceWin::Data
 {
-    HostDnsServiceWin::Data(){}
     HKEY hKeyTcpipParameters;
-#define DATA_DNS_UPDATE_EVENT 0
-#define DATA_SHUTDOWN_EVENT   1
+
+#define DATA_SHUTDOWN_EVENT   0
+#define DATA_DNS_UPDATE_EVENT 1
 #define DATA_MAX_EVENT        2
     HANDLE haDataEvent[DATA_MAX_EVENT];
+
+    Data()
+    {
+        hKeyTcpipParameters = NULL;
+
+        for (size_t i = 0; i < DATA_MAX_EVENT; ++i)
+            haDataEvent[i] = NULL;
+    }
+
+    ~Data()
+    {
+        if (hKeyTcpipParameters != NULL)
+            RegCloseKey(hKeyTcpipParameters);
+
+        for (size_t i = 0; i < DATA_MAX_EVENT; ++i)
+            if (haDataEvent[i] != NULL)
+                CloseHandle(haDataEvent[i]);
+    }
 };
+
+
+HostDnsServiceWin::HostDnsServiceWin()
+ : HostDnsMonitor(true),
+   m(NULL)
+{
+    std::auto_ptr<Data> data(new Data());
+    LONG lrc;
+
+    lrc = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
+                        L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
+                        0,
+                        KEY_READ|KEY_NOTIFY,
+                        &data->hKeyTcpipParameters);
+    if (lrc != ERROR_SUCCESS)
+    {
+        LogRel(("HostDnsServiceWin: failed to open key Tcpip\\Parameters (error %d)\n", lrc));
+        return;
+    }
+
+    for (size_t i = 0; i < DATA_MAX_EVENT; ++i)
+    {
+        data->haDataEvent[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
+        if (data->haDataEvent[i] == NULL)
+        {
+            LogRel(("HostDnsServiceWin: failed to create event (error %d)\n", GetLastError()));
+            return;
+        }
+    }
+
+    m = data.release();
+}
+
+
+HostDnsServiceWin::~HostDnsServiceWin()
+{
+    if (m != NULL)
+        delete m;
+}
+
+
+HRESULT HostDnsServiceWin::init()
+{
+    if (m == NULL)
+        return E_FAIL;
+
+    HRESULT hrc = HostDnsMonitor::init();
+    if (FAILED(hrc))
+        return hrc;
+
+    return updateInfo();
+}
+
+
+void HostDnsServiceWin::monitorThreadShutdown()
+{
+    Assert(m != NULL);
+    SetEvent(m->haDataEvent[DATA_SHUTDOWN_EVENT]);
+}
+
 
 static inline int registerNotification(const HKEY& hKey, HANDLE& hEvent)
@@ -37 +133 @@
 }
 
-HostDnsServiceWin::HostDnsServiceWin():HostDnsMonitor(true), m(NULL)
-{
-    m = new Data();
-
-    m->haDataEvent[DATA_DNS_UPDATE_EVENT] = CreateEvent(NULL,
-      TRUE, FALSE, NULL);
-    AssertReleaseMsg(m->haDataEvent[DATA_DNS_UPDATE_EVENT],
-      ("Failed to create event for DNS event (%d)\n", GetLastError()));
-
-    m->haDataEvent[DATA_SHUTDOWN_EVENT] = CreateEvent(NULL,
-      TRUE, FALSE, NULL);
-    AssertReleaseMsg(m->haDataEvent[DATA_SHUTDOWN_EVENT],
-      ("Failed to create event for Shutdown signal (%d)\n", GetLastError()));
-
-    LONG lrc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
-      TEXT("SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters"),
-      0, KEY_READ|KEY_NOTIFY, &m->hKeyTcpipParameters);
-    AssertReleaseMsg(lrc == ERROR_SUCCESS,
-      ("Failed to open Registry Key for read and update notifications (%d)\n",
-      GetLastError()));
-}
-
-
-HostDnsServiceWin::~HostDnsServiceWin()
-{
-    if (m && !m->hKeyTcpipParameters)
-    {
-        RegCloseKey(m->hKeyTcpipParameters);
-        m->hKeyTcpipParameters = 0;
-
-        CloseHandle(m->haDataEvent[DATA_DNS_UPDATE_EVENT]);
-        CloseHandle(m->haDataEvent[DATA_SHUTDOWN_EVENT]);
-
-        delete m;
-
-        m = NULL;
-    }
-}
-
-
-HRESULT HostDnsServiceWin::init()
-{
-    HRESULT hrc = HostDnsMonitor::init();
-    AssertComRCReturn(hrc, hrc);
-
-    return updateInfo();
-}
-
-
-void HostDnsServiceWin::monitorThreadShutdown()
-{
-    SetEvent(m->haDataEvent[DATA_SHUTDOWN_EVENT]);
-}
-
 
 int HostDnsServiceWin::monitorWorker()
 {
+    Assert(m != NULL);
+
     registerNotification(m->hKeyTcpipParameters,
                          m->haDataEvent[DATA_DNS_UPDATE_EVENT]);
@@ -99 +143 @@
     monitorThreadInitializationDone();
 
-    DWORD dwRc;
-    while (true)
-    {
-        dwRc = WaitForMultipleObjects(DATA_MAX_EVENT,
-                                      m->haDataEvent,
-                                      FALSE,
-                                      INFINITE);
-        AssertMsgReturn(dwRc != WAIT_FAILED,
-                        ("WaitForMultipleObjects failed (%d) to wait! Please debug",
-                         GetLastError()), VERR_INTERNAL_ERROR);
-
-        if ((dwRc - WAIT_OBJECT_0) == DATA_DNS_UPDATE_EVENT)
+    for (;;)
+    {
+        DWORD dwReady;
+
+        dwReady = WaitForMultipleObjects(DATA_MAX_EVENT, m->haDataEvent,
+                                         FALSE, INFINITE);
+
+        if (dwReady == WAIT_OBJECT_0 + DATA_SHUTDOWN_EVENT)
+            break;
+
+        if (dwReady == WAIT_OBJECT_0 + DATA_DNS_UPDATE_EVENT)
         {
             updateInfo();
             notifyAll();
+
             ResetEvent(m->haDataEvent[DATA_DNS_UPDATE_EVENT]);
             registerNotification(m->hKeyTcpipParameters,
@@ -119 +163 @@
 
         }
-        else if ((dwRc - WAIT_OBJECT_0) == DATA_SHUTDOWN_EVENT)
-        {
-            break;
-        }
         else
         {
-            AssertMsgFailedReturn(
-              ("WaitForMultipleObjects returns out of bound index %d. Please debug!",
-                                   dwRc),
-              VERR_INTERNAL_ERROR);
-        }
-    }
+            if (dwReady == WAIT_FAILED)
+                LogRel(("HostDnsServiceWin: WaitForMultipleObjects failed: error %d\n", GetLastError()));
+            else
+                LogRel(("HostDnsServiceWin: WaitForMultipleObjects unexpected return value %d\n", dwReady));
+            return VERR_INTERNAL_ERROR;
+        }
+    }
+
     return VINF_SUCCESS;
 }
 
 
+void vappend(std::vector<std::string> &v, const std::string &s, char sep = ' ')
+{
+    if (s.empty())
+        return;
+
+    std::istringstream stream(s);
+    std::string substr;
+
+    while (std::getline(stream, substr, sep))
+    {
+        if (substr.empty())
+            continue;
+
+        if (std::find(v.cbegin(), v.cend(), substr) != v.cend())
+            continue;
+
+        v.push_back(substr);
+    }
+}
+
+
 HRESULT HostDnsServiceWin::updateInfo()
 {
-    HRESULT hrc;
-    DWORD regIndex;
-    BYTE abDomain[256];
-    BYTE abNameServers[256];
-    BYTE abSearchList[256];
-
-    RT_ZERO(abDomain);
-    RT_ZERO(abNameServers);
-    RT_ZERO(abSearchList);
-
-    regIndex = 0;
-    do {
-        CHAR keyName[256];
+    LONG lrc;
+
+    std::string strNameServer;
+    std::string strDomain;
+    std::string strDhcpNameServer;
+    std::string strDhcpDomain;
+    std::string strSearchList;  /* NB: comma separated, no spaces */
+
+    for (DWORD regIndex = 0; /**/; ++regIndex) {
+        char keyName[256];
         DWORD cbKeyName = sizeof(keyName);
         DWORD keyType = 0;
-        BYTE keyData[1024];
+        char keyData[1024];
         DWORD cbKeyData = sizeof(keyData);
 
-        hrc = RegEnumValueA(m->hKeyTcpipParameters, regIndex, keyName, &cbKeyName, 0,
-                            &keyType, keyData, &cbKeyData);
-        if (   hrc == ERROR_SUCCESS
-            || hrc == ERROR_MORE_DATA)
-        {
-            if (   RTStrICmp("Domain", keyName) == 0
-                && cbKeyData > 1
-                && cbKeyData < sizeof(abDomain))
-                memcpy(abDomain, keyData, cbKeyData);
-
-            else if (   RTStrICmp("DhcpDomain", keyName) == 0
-                     && cbKeyData > 1
-                     && abDomain[0] == 0
-                     && cbKeyData < sizeof(abDomain))
-                memcpy(abDomain, keyData, cbKeyData);
-
-            else if (   RTStrICmp("NameServer", keyName) == 0
-                     && cbKeyData > 1
-                     && cbKeyData < sizeof(abNameServers))
-                memcpy(abNameServers, keyData, cbKeyData);
-
-            else if (   RTStrICmp("DhcpNameServer", keyName) == 0
-                     && cbKeyData > 1
-                     && abNameServers[0] == 0
-                     && cbKeyData < sizeof(abNameServers))
-                memcpy(abNameServers, keyData, cbKeyData);
-
-            else if (   RTStrICmp("SearchList", keyName) == 0
-                     && cbKeyData > 1
-                     && cbKeyData < sizeof(abSearchList))
-              memcpy(abSearchList, keyData, cbKeyData);
-        }
-        regIndex++;
-    } while (hrc != ERROR_NO_MORE_ITEMS);
-
-    /* OK, now parse and update DNS structures. */
-    /* domain name */
+        lrc = RegEnumValueA(m->hKeyTcpipParameters, regIndex,
+                            keyName, &cbKeyName, 0,
+                            &keyType, (LPBYTE)keyData, &cbKeyData);
+
+        if (lrc == ERROR_NO_MORE_ITEMS)
+            break;
+
+        if (lrc == ERROR_MORE_DATA) /* buffer too small; handle? */
+            continue;
+
+        if (lrc != ERROR_SUCCESS)
+        {
+            LogRel(("HostDnsServiceWin: RegEnumValue error %d\n", (int)lrc));
+            return E_FAIL;
+        }
+
+        if (keyType != REG_SZ)
+            continue;
+
+        if (cbKeyData > 0 && keyData[cbKeyData - 1] == '\0')
+            --cbKeyData;     /* don't count trailing NUL if present */
+
+        if (RTStrICmp("NameServer", keyName) == 0)
+        {
+            strNameServer.assign(keyData, cbKeyData);
+            Log2(("... NameServer=\"%s\"\n", strNameServer.c_str()));
+        }
+        else if (RTStrICmp("Domain", keyName) == 0)
+        {
+            strDomain.assign(keyData, cbKeyData);
+            Log2(("... Domain=\"%s\"\n", strDomain.c_str()));
+        }
+        else if (RTStrICmp("DhcpNameServer", keyName) == 0)
+        {
+            strDhcpNameServer.assign(keyData, cbKeyData);
+            Log2(("... DhcpNameServer=\"%s\"\n", strDhcpNameServer.c_str()));
+        }
+        else if (RTStrICmp("DhcpDomain", keyName) == 0)
+        {
+            strDhcpDomain.assign(keyData, cbKeyData);
+            Log2(("... DhcpDomain=\"%s\"\n", strDhcpDomain.c_str()));
+        }
+        else if (RTStrICmp("SearchList", keyName) == 0)
+        {
+            strSearchList.assign(keyData, cbKeyData);
+            Log2(("... SearchList=\"%s\"\n", strSearchList.c_str()));
+        }
+    }
+
     HostDnsInformation info;
-    info.domain = (char*)abDomain;
-
-    /* server list */
-    strList2List(info.servers, (char *)abNameServers);
-    /* search list */
-    strList2List(info.searchList, (char *)abSearchList);
+
+    if (!strNameServer.empty())
+        vappend(info.servers, strNameServer);
+    else if (!strDhcpNameServer.empty())
+        vappend(info.servers, strDhcpNameServer);
+
+    if (!strDomain.empty())
+    {
+        info.domain = strDomain;
+
+        info.searchList.push_back(strDomain);
+        if (!strDhcpDomain.empty() && strDhcpDomain != strDomain)
+            info.searchList.push_back(strDhcpDomain);
+    }
+    else if (!strDhcpDomain.empty())
+    {
+        info.domain = strDhcpDomain;
+        info.searchList.push_back(strDomain);
+    }
+
+    vappend(info.searchList, strSearchList, ',');
+    if (info.searchList.size() == 1)
+        info.searchList.clear();
 
     HostDnsMonitor::setInfo(info);
@@ -204 +293 @@
     return S_OK;
 }
-
-
-void HostDnsServiceWin::strList2List(std::vector<std::string>& lst, char *strLst)
-{
-    char *next, *current;
-    char address[512];
-
-    AssertPtrReturnVoid(strLst);
-
-    if (strlen(strLst) == 0)
-      return;
-
-    current = strLst;
-    do {
-        RT_ZERO(address);
-        next = RTStrStr(current, " ");
-
-        if (next)
-          strncpy(address, current, RT_MIN(sizeof(address)-1, next - current));
-        else
-          strcpy(address, current);
-
-        lst.push_back(std::string(address));
-
-        current = next + 1;
-    } while(next);
-
-}