Changeset 79553 in vbox for trunk/src/VBox/NetworkServices/Dhcpd

Timestamp:

Jul 5, 2019 10:59:01 AM (6 years ago)

Author:

vboxsync

Message:

Dhcpd: Went over the Config code adding comments, eliminating unnecessary copying (xml string getting, ++) and such. bugref:9288

Location:

trunk/src/VBox/NetworkServices/Dhcpd

Files:

• Config.cpp (modified) (30 diffs)
• Config.h (modified) (1 diff)
• DHCPD.cpp (modified) (4 diffs)
• DhcpOptions.h (modified) (2 diffs)

trunk/src/VBox/NetworkServices/Dhcpd/Config.cpp

@@ -16 +16 @@
  */
 
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
 #include "DhcpdInternal.h"
-#include "Config.h"
 
 #include <iprt/ctype.h>
@@ -27 +30 @@
 #include <iprt/uuid.h>
 
-#include <VBox/com/com.h>
-
-#include <iostream>
-
+#include <VBox/com/com.h>       /* For log initialization. */
+
+#include "Config.h"
+
+
+/**
+ * Configuration file exception.
+ */
 class ConfigFileError
-  : public RTCError
+    : public RTCError
 {
 public:
-    ConfigFileError(const char *pszMessage)
-      : RTCError(pszMessage) {}
+#if 0 /* This just confuses the compiler. */
+    ConfigFileError(const char *a_pszMessage)
+        : RTCError(a_pszMessage)
+    {}
+#endif
+
+    ConfigFileError(const char *a_pszMsgFmt, ...)
+        : RTCError((char *)NULL)
+    {
+        va_list va;
+        va_start(va, a_pszMsgFmt);
+        m_strMsg.printfV(a_pszMsgFmt, va);
+        va_end(va);
+    }
 
     ConfigFileError(const RTCString &a_rstrMessage)
-      : RTCError(a_rstrMessage) {}
+        : RTCError(a_rstrMessage)
+    {}
 };
 
 
+/**
+ * Private default constructor, external users use factor methods.
+ */
 Config::Config()
-  : m_strHome(),
-    m_strNetwork(),
-    m_strBaseName(),
-    m_strTrunk(),
-    m_enmTrunkType(kIntNetTrunkType_Invalid),
-    m_MacAddress(),
-    m_IPv4Address(),
-    m_IPv4Netmask(),
-    m_IPv4PoolFirst(),
-    m_IPv4PoolLast(),
-    m_GlobalOptions(),
-    m_VMMap()
-{
-    return;
-}
-
-
-int Config::init()
-{
-    int rc;
-
-    rc = homeInit();
-    if (RT_FAILURE(rc))
-        return rc;
-
-    return VINF_SUCCESS;
-}
-
-
-int Config::homeInit()
-{
-    /* pathname of ~/.VirtualBox or equivalent */
+    : m_strHome()
+    , m_strNetwork()
+    , m_strBaseName()
+    , m_strTrunk()
+    , m_enmTrunkType(kIntNetTrunkType_Invalid)
+    , m_MacAddress()
+    , m_IPv4Address()
+    , m_IPv4Netmask()
+    , m_IPv4PoolFirst()
+    , m_IPv4PoolLast()
+    , m_GlobalOptions()
+    , m_VMMap()
+{
+}
+
+
+/**
+ * Initializes the object.
+ *
+ * @returns IPRT status code.
+ */
+int Config::i_init()
+{
+    return i_homeInit();
+}
+
+
+/**
+ * Initializes the m_strHome member with the path to ~/.VirtualBox or equivalent.
+ *
+ * @returns IPRT status code.
+ * @todo Too many init functions?
+ */
+int Config::i_homeInit()
+{
     char szHome[RTPATH_MAX];
     int rc = com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome), false);
-    if (RT_FAILURE(rc))
-    {
-        LogDHCP(("unable to find VirtualBox home directory: %Rrs", rc));
-        return rc;
-    }
-
-    m_strHome.assign(szHome);
-    return VINF_SUCCESS;
-}
-
-
-void Config::setNetwork(const RTCString &aStrNetwork)
+    if (RT_SUCCESS(rc))
+        rc = m_strHome.assignNoThrow(szHome);
+    else
+    {
+        LogFunc(("unable to locate the VirtualBox home directory: %Rrc", rc)); /* no release log at this point. */
+        RTMsgError("unable to locate the VirtualBox home directory: %Rrs", rc);
+    }
+    return rc;
+}
+
+
+/**
+ * Internal worker for the public factory methods that creates an instance and
+ * calls i_init() on it.
+ *
+ * @returns Config instance on success, NULL on failure.
+ */
+/*static*/ Config *Config::i_createInstanceAndCallInit()
+{
+    Config *pConfig;
+    try
+    {
+        pConfig = new Config();
+    }
+    catch (std::bad_alloc &)
+    {
+        return NULL;
+    }
+
+    int rc = pConfig->i_init();
+    if (RT_SUCCESS(rc))
+        return pConfig;
+    delete pConfig;
+    return NULL;
+}
+
+
+/**
+ * Internal network name (m_strNetwork) setter.
+ *
+ * Can only be called once.  Will also invoke i_sanitizeBaseName to update
+ * m_strBaseName.
+ *
+ * @throws std::bad_alloc
+ */
+void Config::i_setNetwork(const RTCString &aStrNetwork)
 {
     AssertReturnVoid(m_strNetwork.isEmpty());
 
     m_strNetwork = aStrNetwork;
-    sanitizeBaseName();
-}
-
-
-/*
+    i_sanitizeBaseName();
+}
+
+
+/**
+ * Interal worker for i_setNetwork() that sets m_strBaseName to sanitized the
+ * version of m_strNetwork suitable for use as a path component.
+ */
+void Config::i_sanitizeBaseName()
+{
+    if (m_strNetwork.isNotEmpty())
+    {
+        m_strBaseName = m_strNetwork;
+
+/** @todo make IPRT function for this.   */
+        char ch;
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+        static const char s_szIllegals[] = "/\\\"*:<>?|\t\v\n\r\f\a\b"; /** @todo all control chars... */
+        for (char *psz = m_strBaseName.mutableRaw(); (ch = *psz) != '\0'; ++psz)
+            if (strchr(s_szIllegals, ch))
+                *psz = '_';
+#else
+        for (char *psz = m_strBaseName.mutableRaw(); (ch = *psz) != '\0'; ++psz)
+            if (RTPATH_IS_SEP(ch))
+                *psz = '_';
+#endif
+        m_strBaseName.jolt(); /* Not really necessary, but it's protocol. */
+    }
+    else
+        m_strBaseName.setNull();
+}
+
+
+/**
+ * Worker for i_complete() that initializes the release log of the process.
+ *
  * Requires network name to be known as the log file name depends on
  * it.  Alternatively, consider passing the log file name via the
  * command line?
- */
-int Config::logInit()
+ *
+ * @todo make the log file directly configurable?
+ */
+int Config::i_logInit()
 {
     if (m_strHome.isEmpty() || m_strBaseName.isEmpty())
@@ -124 +217 @@
         if (*p != '_' && !RT_C_IS_ALNUM(*p))
             *p = '_';
-
 
     int rc = com::VBoxLogRelCreate("DHCP Server",
@@ -146 +238 @@
 
 
-int Config::complete()
-{
-    int rc;
-
+/**
+ * Post process and validate the configuration after it has been loaded.
+ */
+int Config::i_complete()
+{
     if (m_strNetwork.isEmpty())
     {
@@ -156 +249 @@
     }
 
-    logInit();
+    i_logInit();
 
     bool fMACGenerated = false;
@@ -164 +257 @@
     {
         RTUUID Uuid;
-        RTUuidCreate(&Uuid);
+        int rc = RTUuidCreate(&Uuid);
+        AssertReturn(rc, rc);
 
         m_MacAddress.au8[0] = 0x08;
@@ -193 +287 @@
     /* valid netmask */
     int cPrefixBits;
-    rc = RTNetMaskToPrefixIPv4(&m_IPv4Netmask, &cPrefixBits);
+    int rc = RTNetMaskToPrefixIPv4(&m_IPv4Netmask, &cPrefixBits);
     if (RT_FAILURE(rc) || cPrefixBits == 0)
     {
@@ -226 +320 @@
     /* our own address is not inside the pool */
     if (   RT_N2H_U32(m_IPv4PoolFirst.u) <= RT_N2H_U32(m_IPv4Address.u)
-        && RT_N2H_U32(m_IPv4Address.u)  <= RT_N2H_U32(m_IPv4PoolLast.u))
+        && RT_N2H_U32(m_IPv4Address.u)   <= RT_N2H_U32(m_IPv4PoolLast.u))
     {
         LogDHCP(("server address inside the pool range %RTnaipv4 - %RTnaipv4: %RTnaipv4\n",
@@ -242 +336 @@
 
 
-Config *Config::hardcoded()
-{
-    int rc;
-
-    std::unique_ptr<Config> config(new Config());
-    rc = config->init();
-    if (RT_FAILURE(rc))
+/*static*/ Config *Config::hardcoded()
+{
+    std::unique_ptr<Config> config(i_createInstanceAndCallInit());
+    AssertReturn(config.get() != NULL, NULL);
+    try
+    {
+        config->i_setNetwork("HostInterfaceNetworking-vboxnet0");
+        config->m_strTrunk.assign("vboxnet0");
+    }
+    catch (std::bad_alloc &)
+    {
         return NULL;
-
-    config->setNetwork("HostInterfaceNetworking-vboxnet0");
-    config->m_strTrunk.assign("vboxnet0");
+    }
     config->m_enmTrunkType = kIntNetTrunkType_NetFlt;
 
@@ -263 +359 @@
 
 
-    config->m_IPv4Address.u = RT_H2N_U32_C(0xc0a838fe); /* 192.168.56.254 */
-    config->m_IPv4Netmask.u = RT_H2N_U32_C(0xffffff00); /* 255.255.255.0 */
+    config->m_IPv4Address.u     = RT_H2N_U32_C(0xc0a838fe); /* 192.168.56.254 */
+    config->m_IPv4Netmask.u     = RT_H2N_U32_C(0xffffff00); /* 255.255.255.0 */
 
     /* flip to test naks */
 #if 1
-    config->m_IPv4PoolFirst.u = RT_H2N_U32_C(0xc0a8385a); /* 192.168.56.90 */
-    config->m_IPv4PoolLast.u = RT_H2N_U32_C(0xc0a83863); /* 192.168.56.99 */
+    config->m_IPv4PoolFirst.u   = RT_H2N_U32_C(0xc0a8385a); /* 192.168.56.90 */
+    config->m_IPv4PoolLast.u    = RT_H2N_U32_C(0xc0a83863); /* 192.168.56.99 */
 #else
-    config->m_IPv4PoolFirst.u = RT_H2N_U32_C(0xc0a838c9); /* 192.168.56.201 */
-    config->m_IPv4PoolLast.u = RT_H2N_U32_C(0xc0a838dc); /* 192.168.56.220 */
+    config->m_IPv4PoolFirst.u   = RT_H2N_U32_C(0xc0a838c9); /* 192.168.56.201 */
+    config->m_IPv4PoolLast.u    = RT_H2N_U32_C(0xc0a838dc); /* 192.168.56.220 */
 #endif
 
-    rc = config->complete();
+    int rc = config->i_complete();
     AssertRCReturn(rc, NULL);
 
@@ -282 +378 @@
 
 
-/* compatibility with old VBoxNetDHCP */
-static const RTGETOPTDEF g_aCompatOptions[] =
-{
-    { "--ip-address",     'i',   RTGETOPT_REQ_IPV4ADDR },
-    { "--lower-ip",       'l',   RTGETOPT_REQ_IPV4ADDR },
-    { "--mac-address",    'a',   RTGETOPT_REQ_MACADDR },
-    { "--need-main",      'M',   RTGETOPT_REQ_BOOL },
-    { "--netmask",        'm',   RTGETOPT_REQ_IPV4ADDR },
-    { "--network",        'n',   RTGETOPT_REQ_STRING },
-    { "--trunk-name",     't',   RTGETOPT_REQ_STRING },
-    { "--trunk-type",     'T',   RTGETOPT_REQ_STRING },
-    { "--upper-ip",       'u',   RTGETOPT_REQ_IPV4ADDR },
-};
-
-
-Config *Config::compat(int argc, char **argv)
-{
+
+/*static*/ Config *Config::compat(int argc, char **argv)
+{
+    /* compatibility with old VBoxNetDHCP */
+    static const RTGETOPTDEF s_aCompatOptions[] =
+    {
+        { "--ip-address",     'i',   RTGETOPT_REQ_IPV4ADDR },
+        { "--lower-ip",       'l',   RTGETOPT_REQ_IPV4ADDR },
+        { "--mac-address",    'a',   RTGETOPT_REQ_MACADDR },
+        { "--need-main",      'M',   RTGETOPT_REQ_BOOL },
+        { "--netmask",        'm',   RTGETOPT_REQ_IPV4ADDR },
+        { "--network",        'n',   RTGETOPT_REQ_STRING },
+        { "--trunk-name",     't',   RTGETOPT_REQ_STRING },
+        { "--trunk-type",     'T',   RTGETOPT_REQ_STRING },
+        { "--upper-ip",       'u',   RTGETOPT_REQ_IPV4ADDR },
+    };
+
     RTGETOPTSTATE State;
-    int rc;
-
-    rc = RTGetOptInit(&State, argc, argv,
-                      g_aCompatOptions, RT_ELEMENTS(g_aCompatOptions), 1,
-                      RTGETOPTINIT_FLAGS_NO_STD_OPTS);
+    int rc = RTGetOptInit(&State, argc, argv, s_aCompatOptions, RT_ELEMENTS(s_aCompatOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     AssertRCReturn(rc, NULL);
 
-    std::unique_ptr<Config> config(new Config());
-    rc = config->init();
-    if (RT_FAILURE(rc))
-        return NULL;
+    std::unique_ptr<Config> config(i_createInstanceAndCallInit());
+    AssertReturn(config.get() != NULL, NULL);
 
     for (;;)
     {
-        RTGETOPTUNION Val;
-
-        rc = RTGetOpt(&State, &Val);
+        RTGETOPTUNION ValueUnion;
+        rc = RTGetOpt(&State, &ValueUnion);
         if (rc == 0)            /* done */
             break;
@@ -330 +419 @@
                     return NULL;
                 }
-                config->m_MacAddress = Val.MacAddr;
+                config->m_MacAddress = ValueUnion.MacAddr;
                 break;
 
@@ -339 +428 @@
                     return NULL;
                 }
-                config->m_IPv4Address = Val.IPv4Addr;
+                config->m_IPv4Address = ValueUnion.IPv4Addr;
                 break;
 
@@ -348 +437 @@
                     return NULL;
                 }
-                config->m_IPv4PoolFirst = Val.IPv4Addr;
+                config->m_IPv4PoolFirst = ValueUnion.IPv4Addr;
                 break;
 
@@ -361 +450 @@
                     return NULL;
                 }
-                config->m_IPv4Netmask = Val.IPv4Addr;
+                config->m_IPv4Netmask = ValueUnion.IPv4Addr;
                 break;
 
@@ -370 +459 @@
                     return NULL;
                 }
-                config->setNetwork(Val.psz);
+                config->i_setNetwork(ValueUnion.psz);
                 break;
 
@@ -379 +468 @@
                     return NULL;
                 }
-                config->m_strTrunk.assign(Val.psz);
+                config->m_strTrunk.assign(ValueUnion.psz);
                 break;
 
@@ -388 +477 @@
                     return NULL;
                 }
-                else if (strcmp(Val.psz, "none") == 0)
+                else if (strcmp(ValueUnion.psz, "none") == 0)
                     config->m_enmTrunkType = kIntNetTrunkType_None;
-                else if (strcmp(Val.psz, "whatever") == 0)
+                else if (strcmp(ValueUnion.psz, "whatever") == 0)
                     config->m_enmTrunkType = kIntNetTrunkType_WhateverNone;
-                else if (strcmp(Val.psz, "netflt") == 0)
+                else if (strcmp(ValueUnion.psz, "netflt") == 0)
                     config->m_enmTrunkType = kIntNetTrunkType_NetFlt;
-                else if (strcmp(Val.psz, "netadp") == 0)
+                else if (strcmp(ValueUnion.psz, "netadp") == 0)
                     config->m_enmTrunkType = kIntNetTrunkType_NetAdp;
                 else
                 {
-                    RTMsgError("Unknown trunk type '%s'", Val.psz);
+                    RTMsgError("Unknown trunk type '%s'", ValueUnion.psz);
                     return NULL;
                 }
@@ -409 +498 @@
                     return NULL;
                 }
-                config->m_IPv4PoolLast = Val.IPv4Addr;
+                config->m_IPv4PoolLast = ValueUnion.IPv4Addr;
                 break;
 
             case VINF_GETOPT_NOT_OPTION:
-                RTMsgError("%s: Unexpected command line argument", Val.psz);
+                RTMsgError("%s: Unexpected command line argument", ValueUnion.psz);
                 return NULL;
 
             default:
-                RTGetOptPrintError(rc, &Val);
+                RTGetOptPrintError(rc, &ValueUnion);
                 return NULL;
         }
     }
 
-    rc = config->complete();
+    rc = config->i_complete();
     if (RT_FAILURE(rc))
         return NULL;
@@ -430 +519 @@
 
 
+Config *Config::create(int argc, char **argv)
+{
 #define DHCPD_GETOPT_COMMENT 256 /* No short option for --comment */
-static const RTGETOPTDEF g_aOptions[] =
-{
-    { "--config",       'c',                  RTGETOPT_REQ_STRING },
-    { "--comment",      DHCPD_GETOPT_COMMENT, RTGETOPT_REQ_STRING }
-};
-
-
-Config *Config::create(int argc, char **argv)
-{
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--config",       'c',                  RTGETOPT_REQ_STRING },
+        { "--comment",      DHCPD_GETOPT_COMMENT, RTGETOPT_REQ_STRING }
+    };
+
     RTGETOPTSTATE State;
-    int rc;
-
-    rc = RTGetOptInit(&State, argc, argv,
-                      g_aOptions, RT_ELEMENTS(g_aOptions), 1,
-                      RTGETOPTINIT_FLAGS_NO_STD_OPTS);
+    int rc = RTGetOptInit(&State, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
     AssertRCReturn(rc, NULL);
 
     std::unique_ptr<Config> config;
+
     for (;;)
     {
-        RTGETOPTUNION Val;
-
-        rc = RTGetOpt(&State, &Val);
+        RTGETOPTUNION ValueUnion;
+        rc = RTGetOpt(&State, &ValueUnion);
         if (rc == 0)            /* done */
             break;
@@ -462 +546 @@
                 if (config.get() != NULL)
                 {
-                    printf("Duplicate option: --config '%s'\n", Val.psz);
+                    RTMsgError("Duplicate option: --config '%s'\n", ValueUnion.psz);
                     return NULL;
                 }
 
-                printf("reading config from %s\n", Val.psz);
-                config.reset(Config::read(Val.psz));
+                RTMsgInfo("reading config from '%s'...\n", ValueUnion.psz);
+                config.reset(Config::i_read(ValueUnion.psz));
                 if (config.get() == NULL)
                     return NULL;
-
                 break;
 
@@ -481 +564 @@
 
             case VINF_GETOPT_NOT_OPTION:
-                RTMsgError("Unexpected command line argument: '%s'", Val.psz);
+                RTMsgError("Unexpected command line argument: '%s'", ValueUnion.psz);
                 return NULL;
 
             default:
-                RTGetOptPrintError(rc, &Val);
+                RTGetOptPrintError(rc, &ValueUnion);
                 return NULL;
         }
     }
 
-    if (config.get() == NULL)
+    if (config.get() != NULL)
+    {
+        rc = config->i_complete();
+        if (RT_SUCCESS(rc))
+            return config.release();
+    }
+    else
+        RTMsgError("No configuration file specified (--config file)!\n");
+    return NULL;
+}
+
+
+/**
+ *
+ * @note The release log has is not operational when this method is called.
+ */
+Config *Config::i_read(const char *pszFileName)
+{
+    if (pszFileName == NULL || pszFileName[0] == '\0')
+    {
+        RTMsgError("Empty configuration filename");
         return NULL;
-
-    rc = config->complete();
-    if (RT_FAILURE(rc))
-        return NULL;
-
-    return config.release();
-}
-
-
-Config *Config::read(const char *pszFileName)
-{
-    int rc;
-
-    if (pszFileName == NULL || pszFileName[0] == '\0')
-        return NULL;
+    }
 
     xml::Document doc;
@@ -516 +605 @@
     catch (const xml::EIPRTFailure &e)
     {
-        LogDHCP(("%s\n", e.what()));
+        LogFunc(("%s\n", e.what()));
+        RTMsgError("%s\n", e.what());
         return NULL;
     }
     catch (const RTCError &e)
     {
-        LogDHCP(("%s\n", e.what()));
+        LogFunc(("%s\n", e.what()));
+        RTMsgError("%s\n", e.what());
         return NULL;
     }
     catch (...)
     {
-        LogDHCP(("Unknown exception while reading and parsing '%s'\n",
-                 pszFileName));
+        LogFunc(("Unknown exception while reading and parsing '%s'\n", pszFileName));
+        RTMsgError("Unknown exception while reading and parsing '%s'\n", pszFileName);
         return NULL;
     }
 
-    std::unique_ptr<Config> config(new Config());
-    rc = config->init();
-    if (RT_FAILURE(rc))
+    std::unique_ptr<Config> config(i_createInstanceAndCallInit());
+    AssertReturn(config.get() != NULL, NULL);
+
+    try
+    {
+        config->i_parseConfig(doc.getRootElement());
+    }
+    catch (const RTCError &e)
+    {
+        LogFunc(("%s\n", e.what()));
+        RTMsgError("%s\n", e.what());
         return NULL;
-
-    try
-    {
-        config->parseConfig(doc.getRootElement());
-    }
-    catch (const RTCError &e)
-    {
-        LogDHCP(("%s\n", e.what()));
+    }
+    catch (...)
+    {
+        LogFunc(("Unexpected exception\n"));
+        RTMsgError("Unexpected exception\n");
         return NULL;
     }
-    catch (...)
-    {
-        LogDHCP(("Unexpected exception\n"));
-        return NULL;
-    }
 
     return config.release();
@@ -555 +646 @@
 
 
-void Config::parseConfig(const xml::ElementNode *root)
-{
-    if (root == NULL)
+/**
+ * Internal worker for i_read() that parses the root element and everything
+ * below it.
+ *
+ * @throws stuff.
+ */
+void Config::i_parseConfig(const xml::ElementNode *pElmRoot)
+{
+    /*
+     * Check the root element and call i_parseServer to do real work.
+     */
+    if (pElmRoot == NULL)
         throw ConfigFileError("Empty config file");
 
-    /*
-     * XXX: NAMESPACE API IS COMPLETELY BROKEN, SO IGNORE IT FOR NOW
-     */
-    if (!root->nameEquals("DHCPServer"))
-    {
-        const char *name = root->getName();
-        throw ConfigFileError(RTCStringFmt("Unexpected root element \"%s\"",
-                                           name ? name : "(null)"));
-    }
-
-    parseServer(root);
-
+    /** @todo XXX: NAMESPACE API IS COMPLETELY BROKEN, SO IGNORE IT FOR NOW */
+
+    if (!pElmRoot->nameEquals("DHCPServer"))
+        throw ConfigFileError("Unexpected root element '%s'", pElmRoot->getName());
+
+    i_parseServer(pElmRoot);
+
+#if 0 /** @todo convert to LogRel2 stuff */
     // XXX: debug
     for (optmap_t::const_iterator it = m_GlobalOptions.begin(); it != m_GlobalOptions.end(); ++it) {
@@ -590 +686 @@
         std::cout << std::endl;
     }
-}
-
-
-static void getIPv4AddrAttribute(const xml::ElementNode *pNode, const char *pcszAttrName,
-                                 RTNETADDRIPV4 *pAddr)
-{
-    RTCString strAddr;
-    bool fHasAttr = pNode->getAttributeValue(pcszAttrName, &strAddr);
-    if (!fHasAttr)
-        throw ConfigFileError(RTCStringFmt("%s attribute missing",
-                                           pcszAttrName));
-
-    int rc = RTNetStrToIPv4Addr(strAddr.c_str(), pAddr);
-    if (RT_FAILURE(rc))
-        throw ConfigFileError(RTCStringFmt("%s attribute invalid",
-                                           pcszAttrName));
-}
-
-
-void Config::parseServer(const xml::ElementNode *server)
+#endif
+}
+
+
+/**
+ * Internal worker for parsing the elements under /DHCPServer/.
+ *
+ * @param   pElmServer          The DHCPServer element.
+ * @throws  ConfigFileError
+ */
+void Config::i_parseServer(const xml::ElementNode *pElmServer)
 {
     /*
-     * DHCPServer attributes
+     * <DHCPServer> attributes
      */
-    RTCString strNetworkName;
-    bool fHasNetworkName = server->getAttributeValue("networkName", &strNetworkName);
-    if (!fHasNetworkName)
+    const char *pszNetworkName;
+    if (pElmServer->getAttributeValue("networkName", &pszNetworkName))
+        i_setNetwork(pszNetworkName);
+    else
         throw ConfigFileError("DHCPServer/@networkName missing");
-
-    setNetwork(strNetworkName);
-
-    RTCString strTrunkType;
-    if (!server->getAttributeValue("trunkType", &strTrunkType))
+    /** @todo log file override.  */
+    /** @todo log level (dhcpd group flags).  */
+    /** @todo log flags.  */
+    /** @todo control logging to stderr/out.  */
+    /** @todo if we like we could open the release log now.   */
+
+    const char *pszTrunkType;
+    if (!pElmServer->getAttributeValue("trunkType", &pszTrunkType))
         throw ConfigFileError("DHCPServer/@trunkType missing");
-    if (strTrunkType == "none")
+    if (strcmp(pszTrunkType, "none") == 0)
         m_enmTrunkType = kIntNetTrunkType_None;
-    else if (strTrunkType == "whatever")
+    else if (strcmp(pszTrunkType, "whatever") == 0)
         m_enmTrunkType = kIntNetTrunkType_WhateverNone;
-    else if (strTrunkType == "netflt")
+    else if (strcmp(pszTrunkType, "netflt") == 0)
         m_enmTrunkType = kIntNetTrunkType_NetFlt;
-    else if (strTrunkType == "netadp")
+    else if (strcmp(pszTrunkType, "netadp") == 0)
         m_enmTrunkType = kIntNetTrunkType_NetAdp;
     else
-        throw ConfigFileError(RTCStringFmt("Invalid DHCPServer/@trunkType value: %s", strTrunkType.c_str()));
+        throw ConfigFileError("Invalid DHCPServer/@trunkType value: %s", pszTrunkType);
 
     if (   m_enmTrunkType == kIntNetTrunkType_NetFlt
         || m_enmTrunkType == kIntNetTrunkType_NetAdp)
     {
-        RTCString strTrunk;
-        if (!server->getAttributeValue("trunkName", &strTrunk))
+        if (!pElmServer->getAttributeValue("trunkName", &m_strTrunk))
             throw ConfigFileError("DHCPServer/@trunkName missing");
-        m_strTrunk = strTrunk;
     }
     else
         m_strTrunk = "";
 
-    getIPv4AddrAttribute(server, "IPAddress", &m_IPv4Address);
-    getIPv4AddrAttribute(server, "networkMask", &m_IPv4Netmask);
-    getIPv4AddrAttribute(server, "lowerIP", &m_IPv4PoolFirst);
-    getIPv4AddrAttribute(server, "upperIP", &m_IPv4PoolLast);
+    i_getIPv4AddrAttribute(pElmServer, "IPAddress", &m_IPv4Address);
+    i_getIPv4AddrAttribute(pElmServer, "networkMask", &m_IPv4Netmask);
+    i_getIPv4AddrAttribute(pElmServer, "lowerIP", &m_IPv4PoolFirst);
+    i_getIPv4AddrAttribute(pElmServer, "upperIP", &m_IPv4PoolLast);
 
     /*
-     * DHCPServer children
+     * <DHCPServer> children
      */
-    xml::NodesLoop it(*server);
-    const xml::ElementNode *node;
-    while ((node = it.forAllNodes()) != NULL)
+    xml::NodesLoop it(*pElmServer);
+    const xml::ElementNode *pElmChild;
+    while ((pElmChild = it.forAllNodes()) != NULL)
     {
         /*
          * Global options
          */
-        if (node->nameEquals("Options"))
-        {
-            parseGlobalOptions(node);
-        }
-
+        if (pElmChild->nameEquals("Options"))
+            i_parseGlobalOptions(pElmChild);
         /*
          * Per-VM configuration
          */
-        else if (node->nameEquals("Config"))
-        {
-            parseVMConfig(node);
-        }
-    }
-}
-
-
-void Config::parseGlobalOptions(const xml::ElementNode *options)
+        else if (pElmChild->nameEquals("Config"))
+            i_parseVMConfig(pElmChild);
+        else
+            LogDHCP(("Ignoring unexpected DHCPServer child: %s\n", pElmChild->getName()));
+    }
+}
+
+
+/**
+ * Internal worker for parsing the elements under /DHCPServer/Options/.
+ *
+ * @param   pElmServer          The <Options> element.
+ * @throws  ConfigFileError
+ */
+void Config::i_parseGlobalOptions(const xml::ElementNode *options)
 {
     xml::NodesLoop it(*options);
-    const xml::ElementNode *node;
-    while ((node = it.forAllNodes()) != NULL)
-    {
-        if (node->nameEquals("Option"))
-        {
-            parseOption(node, m_GlobalOptions);
-        }
+    const xml::ElementNode *pElmChild;
+    while ((pElmChild = it.forAllNodes()) != NULL)
+    {
+        if (pElmChild->nameEquals("Option"))
+            i_parseOption(pElmChild, m_GlobalOptions);
         else
-        {
-            throw ConfigFileError(RTCStringFmt("Unexpected element \"%s\"",
-                                               node->getName()));
-        }
-    }
-}
-
-
-/**
+            throw ConfigFileError("Unexpected element <%s>", pElmChild->getName());
+    }
+}
+
+
+/**
+ * Internal worker for parsing the elements under /DHCPServer/Config/.
+ *
  * VM Config entries are generated automatically from VirtualBox.xml
  * with the MAC fetched from the VM config.  The client id is nowhere
  * in the picture there, so VM config is indexed with plain RTMAC, not
  * ClientId (also see getOptions below).
- */
-void Config::parseVMConfig(const xml::ElementNode *config)
-{
-    RTMAC mac;
-    int rc;
-
-    RTCString strMac;
-    bool fHasMac = config->getAttributeValue("MACAddress", &strMac);
-    if (!fHasMac)
-        throw ConfigFileError(RTCStringFmt("Config missing MACAddress attribute"));
-
-    rc = parseMACAddress(mac, strMac);
-    if (RT_FAILURE(rc))
-    {
-        throw ConfigFileError(RTCStringFmt("Malformed MACAddress attribute \"%s\"",
-                                           strMac.c_str()));
-    }
-
-    vmmap_t::iterator vmit( m_VMMap.find(mac) );
+ *
+ * @param   pElmServer          The <Config> element.
+ * @throws  ConfigFileError
+ */
+void Config::i_parseVMConfig(const xml::ElementNode *pElmConfig)
+{
+    /*
+     * Attributes:
+     */
+    /* The MAC address: */
+    RTMAC MacAddr;
+    i_getMacAddressAttribute(pElmConfig, "MACAddress", &MacAddr);
+
+    vmmap_t::iterator vmit( m_VMMap.find(MacAddr) );
     if (vmit != m_VMMap.end())
-    {
-        throw ConfigFileError(RTCStringFmt("Duplicate Config for MACAddress \"%s\"",
-                                           strMac.c_str()));
-    }
-
-    optmap_t &vmopts = m_VMMap[mac];
-
-    xml::NodesLoop it(*config);
-    const xml::ElementNode *node;
-    while ((node = it.forAllNodes()) != NULL)
-        if (node->nameEquals("Option"))
-            parseOption(node, vmopts);
+        throw ConfigFileError("Duplicate Config for MACAddress %RTmac", &MacAddr);
+
+    optmap_t &vmopts = m_VMMap[MacAddr];
+
+    /* Name - optional: */
+    const char *pszName = NULL;
+    if (pElmConfig->getAttributeValue("name", &pszName))
+    {
+        /** @todo */
+    }
+
+    /* Fixed IP address assignment - optional: */
+    if (pElmConfig->findAttribute("FixedIPAddress") != NULL)
+    {
+        /** @todo */
+    }
+
+    /*
+     * Process the children.
+     */
+    xml::NodesLoop it(*pElmConfig);
+    const xml::ElementNode *pElmChild;
+    while ((pElmChild = it.forAllNodes()) != NULL)
+        if (pElmChild->nameEquals("Option"))
+            i_parseOption(pElmChild, vmopts);
         else
-            throw ConfigFileError(RTCStringFmt("Unexpected element \"%s\"",
-                                               node->getName()));
-}
-
-
-int Config::parseMACAddress(RTMAC &aMac, const RTCString &aStr)
-{
-    RTMAC mac;
-    int rc;
-
-    rc = RTNetStrToMacAddr(aStr.c_str(), &mac);
-    if (RT_FAILURE(rc))
-        return rc;
-    if (rc == VWRN_TRAILING_CHARS)
-        return VERR_INVALID_PARAMETER;
-
-    aMac = mac;
-    return VINF_SUCCESS;
-}
-
-
-int Config::parseClientId(OptClientId &aId, const RTCString &aStr)
-{
-    RT_NOREF(aId, aStr);
-    return VERR_GENERAL_FAILURE;
-}
-
-
-/**
- * Parse <Option/> element and add the option to the specified optmap.
- */
-void Config::parseOption(const xml::ElementNode *option, optmap_t &optmap)
-{
-    int rc;
+            throw ConfigFileError("Unexpected element '%s' under '%s'", pElmChild->getName(), pElmConfig->getName());
+}
+
+
+/**
+ * Internal worker for parsing <Option> elements found under
+ * /DHCPServer/Options/ and /DHCPServer/Config/
+ *
+ * @param   pElmServer          The <Option> element.
+ * @param   optmap              The option map to add the option to.
+ * @throws  ConfigFileError
+ */
+void Config::i_parseOption(const xml::ElementNode *pElmOption, optmap_t &optmap)
+{
+    /* The 'name' attribute: */
+    const char *pszName;
+    if (!pElmOption->getAttributeValue("name", &pszName))
+        throw ConfigFileError("missing option name");
 
     uint8_t u8Opt;
-    RTCString strName;
-    bool fHasName = option->getAttributeValue("name", &strName);
-    if (fHasName)
-    {
-        const char *pcszName = strName.c_str();
-
-        rc = RTStrToUInt8Full(pcszName, 10, &u8Opt);
+    int rc = RTStrToUInt8Full(pszName, 10, &u8Opt);
+    if (rc != VINF_SUCCESS) /* no warnings either */
+        throw ConfigFileError("Bad option name '%s'", pszName);
+
+    /* The opional 'encoding' attribute: */
+    uint32_t u32Enc = 0;        /* XXX: DhcpOptEncoding_Legacy */
+    const char *pszEncoding;
+    if (pElmOption->getAttributeValue("encoding", &pszEncoding))
+    {
+        rc = RTStrToUInt32Full(pszEncoding, 10, &u32Enc);
         if (rc != VINF_SUCCESS) /* no warnings either */
-            throw ConfigFileError(RTCStringFmt("Bad option \"%s\"", pcszName));
-
-    }
-    else
-        throw ConfigFileError("missing option name");
-
-
-    uint32_t u32Enc = 0;        /* XXX: DhcpOptEncoding_Legacy */
-    RTCString strEncoding;
-    bool fHasEncoding = option->getAttributeValue("encoding", &strEncoding);
-    if (fHasEncoding)
-    {
-        const char *pcszEnc = strEncoding.c_str();
-
-        rc = RTStrToUInt32Full(pcszEnc, 10, &u32Enc);
-        if (rc != VINF_SUCCESS) /* no warnings either */
-            throw ConfigFileError(RTCStringFmt("Bad encoding \"%s\"", pcszEnc));
+            throw ConfigFileError("Bad option encoding '%s'", pszEncoding);
 
         switch (u32Enc)
         {
-        case 0:                 /* XXX: DhcpOptEncoding_Legacy */
-        case 1:                 /* XXX: DhcpOptEncoding_Hex */
-            break;
-        default:
-            throw ConfigFileError(RTCStringFmt("Unknown encoding \"%s\"", pcszEnc));
+            case 0:                 /* XXX: DhcpOptEncoding_Legacy */
+            case 1:                 /* XXX: DhcpOptEncoding_Hex */
+                break;
+            default:
+                throw ConfigFileError("Unknown encoding '%s'", pszEncoding);
         }
     }
 
-
-    /* value may be omitted for OptNoValue options like rapid commit */
-    RTCString strValue;
-    option->getAttributeValue("value", &strValue);
-
-    /* XXX: TODO: encoding, handle hex */
-    DhcpOption *opt = DhcpOption::parse(u8Opt, u32Enc, strValue.c_str());
+    /* The 'value' attribute. May be omitted for OptNoValue options like rapid commit. */
+    const char *pszValue;
+    if (!pElmOption->getAttributeValue("value", &pszValue))
+        pszValue = "";
+
+    /** @todo XXX: TODO: encoding, handle hex */
+    DhcpOption *opt = DhcpOption::parse(u8Opt, u32Enc, pszValue);
     if (opt == NULL)
-        throw ConfigFileError(RTCStringFmt("Bad option \"%s\"", strName.c_str()));
-
+        throw ConfigFileError("Bad option '%s' (encoding %u): '%s' ", pszName, u32Enc, pszValue ? pszValue : "");
+
+    /* Add it to the map: */
     optmap << opt;
 }
@@ -821 +890 @@
 
 /**
- * Set m_strBaseName to sanitized version of m_strNetwork that can be
- * used in a path component.
- */
-void Config::sanitizeBaseName()
-{
-    if (m_strNetwork.isNotEmpty())
-    {
-        m_strBaseName = m_strNetwork;
-
-        char ch;
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-        static const char s_szIllegals[] = "/\\\"*:<>?|\t\v\n\r\f\a\b"; /** @todo all control chars... */
-        for (char *psz = m_strBaseName.mutableRaw(); (ch = *psz) != '\0'; ++psz)
-            if (strchr(s_szIllegals, ch))
-                *psz = '_';
-#else
-        for (char *psz = m_strBaseName.mutableRaw(); (ch = *psz) != '\0'; ++psz)
-            if (RTPATH_IS_SEP(ch))
-                *psz = '_';
-#endif
-        m_strBaseName.jolt(); /* Not really necessary, but it's protocol. */
+ * Helper for retrieving a IPv4 attribute.
+ *
+ * @param   pElm            The element to get the attribute from.
+ * @param   pszAttrName     The name of the attribute
+ * @param   pAddr           Where to return the address.
+ * @throws  ConfigFileError
+ */
+/*static*/ void Config::i_getIPv4AddrAttribute(const xml::ElementNode *pElm, const char *pszAttrName, PRTNETADDRIPV4 pAddr)
+{
+    const char *pszAttrValue;
+    if (pElm->getAttributeValue(pszAttrName, &pszAttrValue))
+    {
+        int rc = RTNetStrToIPv4Addr(pszAttrValue, pAddr);
+        if (RT_SUCCESS(rc))
+            return;
+        throw ConfigFileError("%s attribute %s is not a valid IPv4 address: '%s' -> %Rrc",
+                              pElm->getName(), pszAttrName, pszAttrValue, rc);
     }
     else
-        m_strBaseName.setNull();
-}
-
-
-optmap_t Config::getOptions(const OptParameterRequest &reqOpts,
-                            const ClientId &id,
-                            const OptVendorClassId &vendor) const
-{
-    optmap_t optmap;
-
+        throw ConfigFileError("Required %s attribute missing on element %s", pszAttrName, pElm->getName());
+}
+
+
+/**
+ * Helper for retrieving a MAC address attribute.
+ *
+ * @param   pElm            The element to get the attribute from.
+ * @param   pszAttrName     The name of the attribute
+ * @param   pMacAddr        Where to return the MAC address.
+ * @throws  ConfigFileError
+ */
+/*static*/ void Config::i_getMacAddressAttribute(const xml::ElementNode *pElm, const char *pszAttrName, PRTMAC pMacAddr)
+{
+    const char *pszAttrValue;
+    if (pElm->getAttributeValue(pszAttrName, &pszAttrValue))
+    {
+        int rc = RTNetStrToMacAddr(pszAttrValue, pMacAddr);
+        if (RT_SUCCESS(rc) && rc != VWRN_TRAILING_CHARS)
+            return;
+        throw ConfigFileError("%s attribute %s is not a valid MAC address: '%s' -> %Rrc",
+                              pElm->getName(), pszAttrName, pszAttrValue, rc);
+    }
+    else
+        throw ConfigFileError("Required %s attribute missing on element %s", pszAttrName, pElm->getName());
+}
+
+
+/**
+ * Method used by DHCPD to assemble a list of options for the client.
+ *
+ * @returns a_rRetOpts for convenience
+ * @param   a_rRetOpts      Where to put the requested options.
+ * @param   reqOpts         The requested options.
+ * @param   id              The client ID.
+ * @param   idVendorClass   The vendor class ID.
+ * @param   idUserClass     The user class ID.
+ */
+optmap_t &Config::getOptions(optmap_t &a_rRetOpts, const OptParameterRequest &reqOpts, const ClientId &id,
+                             const OptVendorClassId &idVendorClass /*= OptVendorClassId()*/,
+                             const OptUserClassId &idUserClass /*= OptUserClassId()*/) const
+{
     const optmap_t *vmopts = NULL;
     vmmap_t::const_iterator vmit( m_VMMap.find(id.mac()) );
@@ -859 +956 @@
         vmopts = &vmit->second;
 
-    RT_NOREF(vendor); /* not yet */
-
-
-    optmap << new OptSubnetMask(m_IPv4Netmask);
+    RT_NOREF(idVendorClass, idUserClass); /* not yet */
+
+    a_rRetOpts << new OptSubnetMask(m_IPv4Netmask);
 
     const OptParameterRequest::value_t& reqValue = reqOpts.value();
@@ -868 +964 @@
     {
         uint8_t optreq = *itOptReq;
-        std::cout << ">>> requested option " << (int)optreq << std::endl;
+        LogRel2((">>> requested option %d (%#x)\n", optreq, optreq));
 
         if (optreq == OptSubnetMask::optcode)
         {
-            std::cout << "... always supplied" << std::endl;
+            LogRel2(("... always supplied\n"));
             continue;
         }
@@ -881 +977 @@
             if (it != vmopts->end())
             {
-                optmap << it->second;
-                std::cout << "... found in VM options" << std::endl;
+                a_rRetOpts << it->second;
+                LogRel2(("... found in VM options\n"));
                 continue;
             }
@@ -890 +986 @@
         if (it != m_GlobalOptions.end())
         {
-            optmap << it->second;
-            std::cout << "... found in global options" << std::endl;
+            a_rRetOpts << it->second;
+            LogRel2(("... found in global options\n"));
             continue;
         }
 
-        // std::cout << "... not found" << std::endl;
-    }
-
-
-    /* XXX: testing ... */
+        LogRel3(("... not found\n"));
+    }
+
+
+#if 0 /* bird disabled this as it looks dubious and testing only. */
+    /** @todo XXX: testing ... */
     if (vmopts != NULL)
     {
-        for (optmap_t::const_iterator it = vmopts->begin(); it != vmopts->end(); ++it) {
+        for (optmap_t::const_iterator it = vmopts->begin(); it != vmopts->end(); ++it)
+        {
             std::shared_ptr<DhcpOption> opt(it->second);
-            if (optmap.count(opt->optcode()) == 0 && opt->optcode() > 127)
+            if (a_rRetOpts.count(opt->optcode()) == 0 && opt->optcode() > 127)
             {
-                optmap << opt;
-                std::cout << "... forcing VM option " << (int)opt->optcode() << std::endl;
+                a_rRetOpts << opt;
+                LogRel2(("... forcing VM option %d (%#x)\n", opt->optcode(), opt->optcode()));
             }
         }
     }
 
-    for (optmap_t::const_iterator it = m_GlobalOptions.begin(); it != m_GlobalOptions.end(); ++it) {
+    for (optmap_t::const_iterator it = m_GlobalOptions.begin(); it != m_GlobalOptions.end(); ++it)
+    {
         std::shared_ptr<DhcpOption> opt(it->second);
-        if (optmap.count(opt->optcode()) == 0 && opt->optcode() > 127)
+        if (a_rRetOpts.count(opt->optcode()) == 0 && opt->optcode() > 127)
         {
-            optmap << opt;
-            std::cout << "... forcing global option " << (int)opt->optcode() << std::endl;
+            a_rRetOpts << opt;
+            LogRel2(("... forcing global option %d (%#x)", opt->optcode(), opt->optcode()));
         }
     }
-
-    return optmap;
-}
+#endif
+
+    return a_rRetOpts;
+}

trunk/src/VBox/NetworkServices/Dhcpd/Config.h

@@ -30 +30 @@
 #include <VBox/intnet.h>
 
-
 #include "DhcpOptions.h"
 #include "ClientId.h"
 
 
+/**
+ * DHCP server configuration.
+ */
 class Config
 {
-    /** XXX: TODO: also store fixed address assignments, etc? */
+    /** @todo XXX: also store fixed address assignments, etc? */
     typedef std::map<RTMAC, optmap_t> vmmap_t;
 
-    RTCString m_strHome;   /* path of ~/.VirtualBox or equivalent */
+    RTCString       m_strHome;          /**< path of ~/.VirtualBox or equivalent, */
 
-    RTCString m_strNetwork;
-    RTCString m_strBaseName; /* m_strNetwork sanitized to be usable in a path component */
+    RTCString       m_strNetwork;       /**< The name of the internal network the DHCP server is connected to. */
+    RTCString       m_strBaseName;      /**< m_strNetwork sanitized to be usable in a path component. */
 
-    RTCString m_strTrunk;
-    INTNETTRUNKTYPE m_enmTrunkType;
+    RTCString       m_strTrunk;         /**< The trunk name of the internal network. */
+    INTNETTRUNKTYPE m_enmTrunkType;     /**< The trunk type of the internal network. */
 
-    RTMAC m_MacAddress;
+    RTMAC           m_MacAddress;       /**< The MAC address for the DHCP server. */
 
-    RTNETADDRIPV4 m_IPv4Address;
-    RTNETADDRIPV4 m_IPv4Netmask;
+    RTNETADDRIPV4   m_IPv4Address;      /**< The IPv4 address of the DHCP server. */
+    RTNETADDRIPV4   m_IPv4Netmask;      /**< The IPv4 netmask for the DHCP server. */
 
-    RTNETADDRIPV4 m_IPv4PoolFirst;
-    RTNETADDRIPV4 m_IPv4PoolLast;
+    RTNETADDRIPV4   m_IPv4PoolFirst;    /**< The first IPv4 address in the pool. */
+    RTNETADDRIPV4   m_IPv4PoolLast;     /**< The last IPV4 address in the pool (inclusive like all other 'last' variables). */
 
-    optmap_t m_GlobalOptions;
-    vmmap_t m_VMMap;
+
+    optmap_t        m_GlobalOptions;    /**< Global DHCP option. */
+    vmmap_t         m_VMMap;            /**< Per MAC address (VM) DHCP options. */
+    /** @todo r=bird: optmap_t is too narrow for adding configuration options such
+     *        as max-lease-time, min-lease-time, default-lease-time and such like
+     *        that does not translate directly to any specific DHCP option. */
+    /** @todo r=bird: Additionally, I'd like to have a more generic option groups
+     *        that fits inbetween m_VMMap (mac based) and m_GlobalOptions.
+     *        Pattern/wildcard matching on MAC address, possibly also client ID,
+     *        vendor class and user class, including simple lists of these. */
 
 private:
     Config();
 
-    int init();
-    int homeInit();
-    int logInit();
-    int complete();
-
-public: /* factory methods */
-    static Config *hardcoded();                   /* for testing */
-    static Config *create(int argc, char **argv); /* --config */
-    static Config *compat(int argc, char **argv); /* old VBoxNetDHCP flags */
-
-public: /* accessors */
-    const RTCString &getHome() const { return m_strHome; }
-
-    const RTCString &getNetwork() const { return m_strNetwork; }
-    void setNetwork(const RTCString &aStrNetwork);
-
-    const RTCString &getBaseName() const { return m_strBaseName; }
-    const RTCString &getTrunk() const { return m_strTrunk; }
-    INTNETTRUNKTYPE getTrunkType() const { return m_enmTrunkType; }
-
-    const RTMAC &getMacAddress() const { return m_MacAddress; }
-
-    RTNETADDRIPV4 getIPv4Address() const { return m_IPv4Address; }
-    RTNETADDRIPV4 getIPv4Netmask() const { return m_IPv4Netmask; }
-
-    RTNETADDRIPV4 getIPv4PoolFirst() const { return m_IPv4PoolFirst; }
-    RTNETADDRIPV4 getIPv4PoolLast() const { return m_IPv4PoolLast; }
+    int                 i_init();
+    int                 i_homeInit();
+    static Config      *i_createInstanceAndCallInit();
+    int                 i_logInit();
+    int                 i_complete();
 
 public:
-    optmap_t getOptions(const OptParameterRequest &reqOpts, const ClientId &id,
-                        const OptVendorClassId &vendor = OptVendorClassId()) const;
+    /** @name Factory methods
+     * @{ */
+    static Config      *hardcoded();                   /**< For testing. */
+    static Config      *create(int argc, char **argv); /**< --config */
+    static Config      *compat(int argc, char **argv); /**< Old VBoxNetDHCP command line parsing. */
+    /** @} */
+
+    /** @name Accessors
+     * @{ */
+    const RTCString    &getHome() const             { return m_strHome; }
+
+    const RTCString    &getNetwork() const          { return m_strNetwork; }
+
+    const RTCString    &getBaseName() const         { return m_strBaseName; }
+    const RTCString    &getTrunk() const            { return m_strTrunk; }
+    INTNETTRUNKTYPE     getTrunkType() const        { return m_enmTrunkType; }
+
+    const RTMAC        &getMacAddress() const       { return m_MacAddress; }
+
+    RTNETADDRIPV4       getIPv4Address() const      { return m_IPv4Address; }
+    RTNETADDRIPV4       getIPv4Netmask() const      { return m_IPv4Netmask; }
+
+    RTNETADDRIPV4       getIPv4PoolFirst() const    { return m_IPv4PoolFirst; }
+    RTNETADDRIPV4       getIPv4PoolLast() const     { return m_IPv4PoolLast; }
+    /** @} */
+
+    optmap_t           &getOptions(optmap_t &a_rRetOpts, const OptParameterRequest &reqOpts, const ClientId &id,
+                                   const OptVendorClassId &idVendorClass = OptVendorClassId(),
+                                   const OptUserClassId &idUserClass = OptUserClassId()) const;
 
 private:
-    static Config *read(const char *pszFileName);
-    void parseConfig(const xml::ElementNode *root);
-    void parseServer(const xml::ElementNode *server);
-    void parseGlobalOptions(const xml::ElementNode *options);
-    void parseVMConfig(const xml::ElementNode *config);
-    void parseOption(const xml::ElementNode *option, optmap_t &optmap);
+    /** @name Configuration file reading and parsing
+     * @{ */
+    static Config      *i_read(const char *pszFileName);
+    void                i_parseConfig(const xml::ElementNode *root);
+    void                i_parseServer(const xml::ElementNode *server);
+    void                i_parseGlobalOptions(const xml::ElementNode *options);
+    void                i_parseVMConfig(const xml::ElementNode *config);
+    void                i_parseOption(const xml::ElementNode *option, optmap_t &optmap);
 
-    int parseMACAddress(RTMAC &aMac, const RTCString &aStr);
-    int parseClientId(OptClientId &aId, const RTCString &aStr);
+    static void         i_getIPv4AddrAttribute(const xml::ElementNode *pElm, const char *pcszAttrName, PRTNETADDRIPV4 pAddr);
+    static void         i_getMacAddressAttribute(const xml::ElementNode *pElm, const char *pszAttrName, PRTMAC pMacAddr);
+    /** @} */
 
-    void sanitizeBaseName();
+    void                i_setNetwork(const RTCString &aStrNetwork);
+    void                i_sanitizeBaseName();
 };
 

trunk/src/VBox/NetworkServices/Dhcpd/DHCPD.cpp

@@ -36 +36 @@
         return VERR_INVALID_STATE;
 
+    /** @todo r=bird: This must be configurable so main can read the database and
+     * fish assignments out of it.  (That's the most efficient and accurate way of
+     * figuring  out the IP address of a VM.) */
+
     /* leases file name */
     m_strLeasesFileName = pConfig->getHome();
@@ -171 +175 @@
 
     OptParameterRequest optlist(req);
-    reply->addOptions(m_pConfig->getOptions(optlist, req.clientId()));
+    optmap_t replyOptions;
+    reply->addOptions(m_pConfig->getOptions(replyOptions, optlist, req.clientId()));
 
     // reply->maybeUnicast(req); /* XXX: we reject ciaddr != 0 above */
@@ -209 +214 @@
 
     OptParameterRequest optlist(req);
-    ack->addOptions(m_pConfig->getOptions(optlist, req.clientId()));
+    optmap_t replyOptions;
+    ack->addOptions(m_pConfig->getOptions(replyOptions, optlist, req.clientId()));
 
     ack->addOption(OptMessage("Ok, ok, here it is"));
@@ -236 +242 @@
         return NULL;
 
-    optmap_t info(m_pConfig->getOptions(params, req.clientId()));
+    optmap_t info;
+    m_pConfig->getOptions(info, params, req.clientId());
     if (info.empty())
         return NULL;

trunk/src/VBox/NetworkServices/Dhcpd/DhcpOptions.h

@@ -608 +608 @@
 
 
-/*
- * Define the DHCP options we want to use.
+/** @name The DHCP options types.
+ * @{
  */
 typedef OptValue<1, RTNETADDRIPV4>      OptSubnetMask;
@@ -636 +636 @@
 typedef OptString<66>                   OptTFTPServer;   /* when overloaded */
 typedef OptString<67>                   OptBootFileName; /* when overloaded */
+typedef OptList<77, uint8_t>            OptUserClassId;
 typedef OptNoValue<80>                  OptRapidCommit;  /* RFC4039 */
+/** @} */
 
 #endif /* !VBOX_INCLUDED_SRC_Dhcpd_DhcpOptions_h */