Changeset 46959 in vbox for trunk

Timestamp:

Jul 4, 2013 5:21:06 AM (12 years ago)

Author:

vboxsync

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

86967

Message:

Main/Network: DHCP server has got the ear in Main, and we able create/describe more complex infrostructures. DHCP server together with Lwip NAT can handle per vm/slot configuration and store them in xml settings.

place-holder: Host interface nameserver list, domain name and search strings, I suppose that this functions should be used on initialization stage and then on host configuration change even or directly from event.

Location:

trunk

Files:

• include/VBox/settings.h (modified) (3 diffs)
• src/VBox/Main/Makefile.kmk (modified) (1 diff)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (5 diffs)
• src/VBox/Main/include/DHCPServerImpl.h (modified) (3 diffs)
• src/VBox/Main/include/HostImpl.h (modified) (2 diffs)
• src/VBox/Main/include/NATNetworkImpl.h (modified) (1 diff)
• src/VBox/Main/include/NATNetworkServiceRunner.h (deleted)
• src/VBox/Main/include/NetworkServiceRunner.h (moved) (moved from trunk/src/VBox/Main/include/DHCPServerRunner.h ) (4 diffs)
• src/VBox/Main/src-client/ConsoleImpl2.cpp (modified) (1 diff)
• src/VBox/Main/src-server/DHCPServerImpl.cpp (modified) (21 diffs)
• src/VBox/Main/src-server/HostImpl.cpp (modified) (3 diffs)
• src/VBox/Main/src-server/NATNetworkImpl.cpp (modified) (9 diffs)
• src/VBox/Main/src-server/NATNetworkServiceRunner.cpp (deleted)
• src/VBox/Main/src-server/NetworkServiceRunner.cpp (moved) (moved from trunk/src/VBox/Main/src-server/DHCPServerRunner.cpp ) (8 diffs)
• src/VBox/Main/src-server/VirtualBoxImpl.cpp (modified) (1 diff)
• src/VBox/Main/src-server/xpcom/server.cpp (modified) (1 diff)
• src/VBox/Main/xml/Settings.cpp (modified) (3 diffs)

trunk/include/VBox/settings.h

@@ -286 +286 @@
 typedef std::list<MachineRegistryEntry> MachinesRegistry;
 
+typedef std::map<DhcpOpt_T, com::Utf8Str> DhcpOptionMap;
+typedef DhcpOptionMap::value_type DhcpOptValuePair;
+typedef DhcpOptionMap::iterator DhcpOptIterator;
+typedef DhcpOptionMap::const_iterator DhcpOptConstIterator;
+
+typedef struct VmNameSlotKey
+{
+    VmNameSlotKey(const com::Utf8Str& aVmName, LONG aSlot): VmName(aVmName),
+      Slot(aSlot){}
+    const com::Utf8Str VmName;
+    LONG      Slot;
+    bool operator< (const VmNameSlotKey& that) const
+    {
+        if (VmName == that.VmName)
+            return Slot < that.Slot;
+        else return VmName < that.VmName;
+    }
+} VmNameSlotKey;
+typedef std::map<VmNameSlotKey, DhcpOptionMap> VmSlot2OptionsMap;
+typedef VmSlot2OptionsMap::value_type VmSlot2OptionsPair;
+typedef VmSlot2OptionsMap::iterator VmSlot2OptionsIterator;
+typedef VmSlot2OptionsMap::const_iterator VmSlot2OptionsConstIterator;
+
 struct DHCPServer
 {
@@ -294 +317 @@
     com::Utf8Str    strNetworkName,
                     strIPAddress,
-                    strIPNetworkMask,
                     strIPLower,
                     strIPUpper;
     bool            fEnabled;
+    std::map<DhcpOpt_T, com::Utf8Str>  GlobalDhcpOptions;
+    VmSlot2OptionsMap VmSlot2OptionsM;
 };
 typedef std::list<DHCPServer> DHCPServersList;
@@ -337 +361 @@
     void readMachineRegistry(const xml::ElementNode &elmMachineRegistry);
     void readDHCPServers(const xml::ElementNode &elmDHCPServers);
+    void readDhcpOptions(DhcpOptionMap& map, const xml::ElementNode& options);
     void readNATNetworks(const xml::ElementNode &elmNATNetworks);
 

trunk/src/VBox/Main/Makefile.kmk

@@ -335 +335 @@
         src-server/BIOSSettingsImpl.cpp \
         src-server/DHCPServerImpl.cpp \
-        src-server/DHCPServerRunner.cpp \
+        src-server/NetworkServiceRunner.cpp \
         src-server/NATNetworkImpl.cpp \
-        $(if $(VBOX_WITH_NAT_SERVICE),src-server/NATNetworkServiceRunner.cpp,) \
         src-server/GuestOSTypeImpl.cpp \
         src-server/HostImpl.cpp \

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -1466 +1466 @@
   </interface>
 
+  <enum 
+      name="DhcpOpt"
+      uuid="40d99bd3-3ece-44d2-a07e-1085fe9c4f0b">
+    <const name="SubnetMask" value="1"/>
+    <const name="TimeOffset" value="2"/>
+    <const name="Router" value="3"/>
+    <const name="TimeServer" value="4"/>
+    <const name="NameServer" value="5"/>
+    <const name="DomainNameServer" value="6"/>
+    <const name="LogServer" value="7"/>
+    <const name="Cookie" value="8"/>
+    <const name="LPRServer" value="9"/>
+    <const name="ImpressServer" value="10"/>
+    <const name="ResourseLocationServer" value="11"/>
+    <const name="HostName" value="12"/>
+    <const name="BootFileSize" value="13"/>
+    <const name="MeritDumpFile" value="14"/>    
+    <const name="DomainName" value="15"/>
+    <const name="SwapServer" value="16"/>
+    <const name="RootPath" value="17"/>
+    <const name="ExtensionPath" value="18"/>
+    <const name="IPForwardingEnableDisable" value="19"/>
+    <const name="NonLocalSourceRoutingEnableDisable" value="20"/>
+    <const name="PolicyFilter" value="21"/>
+    <const name="MaximumDatagramReassemblySize" value="22"/>
+    <const name="DefaultIPTime2Live" value="23"/>
+    <const name="PathMTUAgingTimeout" value="24"/>
+    <const name="IPLayerParametersPerInterface" value="25"/>
+    <const name="InterfaceMTU" value="26"/>
+    <const name="AllSubnetsAreLocal" value="27"/>
+    <const name="BroadcastAddress" value="28"/>
+    <const name="PerformMaskDiscovery" value="29"/>
+    <const name="MaskSupplier" value="30"/>
+    <const name="PerformRouteDiscovery" value="31"/>
+    <const name="RouterSolicitationAddress" value="32"/>
+    <const name="StaticRoute" value="33"/>
+    <const name="TrailerEncapsulation" value="34"/>
+    <const name="ARPCacheTimeout" value="35"/>
+    <const name="EthernetEncapsulation" value="36"/>
+    <const name="TCPDefaultTTL" value="37"/>
+    <const name="TCPKeepAliveInterval" value="38"/>
+    <const name="TCPKeepAliveGarbage" value="39"/>
+    <const name="NetworkInformationServiceDomain" value="40"/>
+    <const name="NetworkInformationServiceServers" value="41"/>
+    <const name="NetworkTimeProtocolServers" value="42"/>
+    <const name="VendorSpecificInformation" value="43"/>
+    <const name="Option_44" value="44"/>
+    <const name="Option_45" value="45"/>
+    <const name="Option_46" value="46"/>
+    <const name="Option_47" value="47"/>
+    <const name="Option_48" value="48"/>
+    <const name="Option_49" value="49"/>
+    <const name="IPAddressLeaseTime" value="51"/>
+    <const name="Option_64" value="64"/>
+    <const name="Option_65" value="65"/>
+    <const name="TFTPServerName" value="66"/>
+    <const name="BootfileName" value="67"/>
+    <const name="Option_68" value="68"/>
+    <const name="Option_69" value="69"/>
+    <const name="Option_70" value="70"/>
+    <const name="Option_71" value="71"/>
+    <const name="Option_72" value="72"/>
+    <const name="Option_73" value="73"/>
+    <const name="Option_74" value="74"/>
+    <const name="Option_75" value="75"/>
+    <const name="Option_119" value="119"/>
+  </enum>
+  
   <interface
     name="IDHCPServer" extends="$unknown"
-    uuid="6cfe387c-74fb-4ca7-bff6-973bec8af7a3"
+    uuid="ff0774c5-1f62-4bc3-919c-7fc942bf1d25"
     wsmap="managed"
     >
@@ -1477 +1545 @@
       <link to="IVirtualBox::DHCPServers"/> attribute.
     </desc>
-
+    <!-- We want to keep our "real" servers updated about configuration changes -->
+    <attribute name="eventSource" type="IEventSource" readonly="yes"/>
     <attribute name="enabled" type="boolean">
       <desc>
@@ -1513 +1582 @@
       </desc>
     </attribute>
+    
+    <method name="addGlobalOption">
+      <param name="option" type="DhcpOpt" dir="in"/>
+      <param name="value" type="wstring" dir="in" />
+    </method>
+    
+    <!-- string in format: "option_id:value" -->
+    <attribute name="globalOptions" type="wstring" safearray="yes" readonly="yes"/>
+
+    <!-- string in format: "[vm name]:slot" -->
+    <attribute name="vmConfigs" type="wstring" safearray="yes" readonly="yes"/>
+
+    <!-- VM-slot settings 
+         It's corresponds to dhcpd.conf entries, like:
+
+         host ncd1 { hardware ethernet 0:c0:c3:11:90:23; }
+
+         - in Main we can match (vm name, slot) to ethernet address
+         that why it's easy to configure dhcp server in such way, 
+         then ask user to to enter valid name, 
+         
+         - mac address might change because of adapter type (e1k <-> pcnet) or because
+         of import/export
+         
+         - it's easy to provide vm-name.rom in boot filename VM with network boot.
+         
+         XXX: do we need classic getOptionValueByMAC?
+         
+         XML: O-o-oh, this settings are per VM, so perhaps they should be stored in
+              VM configuration files. And we haven't got the attachment type for 
+              NATNetwork.
+    -->
+    <method name="addVmSlotOption">
+      <param name="vmname" type="wstring" dir="in"/>
+      <param name="slot" type="long" dir="in"/>
+      <param name="option" type="DhcpOpt" dir="in"/>
+      <param name="value" type="wstring" dir="in" />
+    </method>
+
+    <method name="removeVmSlotOptions">
+      <param name="vmname" type="wstring" dir="in"/>
+      <param name="slot" type="long" dir="in"/>
+    </method>
+
+    <!-- returns array of strings in format: "option_id:value" for a given pair (vm, slot) -->
+    <method name="getVmSlotOptions">
+      <param name="vmname" type="wstring" dir="in"/>
+      <param name="slot" type="long" dir="in"/>
+      <param name="option" type="wstring" safearray="yes" dir="return"/>
+    </method>
+    
+    <!-- Returns options by MAC address -->
+    <method name="getMacOptions">
+      <param name="mac" type="wstring" dir="in"/>
+      <param name="option" type="wstring" safearray="yes" dir="return"/>
+    </method>
 
     <method name="setConfiguration">
@@ -8038 +8163 @@
   <interface
     name="IHost" extends="$unknown"
-    uuid="30678943-32df-4830-b413-931b25ac86a0"
+    uuid="a6107246-f939-42c4-82b6-8aca40327b6d"
     wsmap="managed"
     >
@@ -8099 +8224 @@
     <attribute name="networkInterfaces" type="IHostNetworkInterface" safearray="yes" readonly="yes">
       <desc>List of host network interfaces currently defined on the host.</desc>
+    </attribute>
+
+    <attribute name="nameServers" type="wstring" safearray="yes" readonly="yes">
+      <desc> The list of nameservers registered in host's name resolving system.</desc>
+    </attribute>
+
+    <attribute name="domainName" type="wstring" readonly="yes">
+      <desc>Domain name used for name resoving.</desc>
+    </attribute>
+
+    <attribute name="searchStrings" type="wstring" safearray="yes" readonly="yes">
+      <desc>Search string registered for name resoving.</desc>
     </attribute>
 

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

@@ -30 +30 @@
 {
     struct DHCPServer;
+    struct VmNameSlotKey;
 }
+#ifdef RT_OS_WINDOWS
+# define DHCP_EXECUTABLE_NAME "VBoxNetDHCP.exe"
+#else
+# define DHCP_EXECUTABLE_NAME "VBoxNetDHCP"
+#endif
+
+class DHCPServerRunner: public NetworkServiceRunner
+{
+public:
+    DHCPServerRunner():NetworkServiceRunner(DHCP_EXECUTABLE_NAME){}
+    virtual ~DHCPServerRunner(){};
+};
+
+/**
+ *  for server configuration needs, it's perhaps better to use (VM,slot) pair
+ *  (vm-name, slot) <----> (MAC)
+ *  
+ *  but for client configuration, when server will have MACs at hand, it'd be
+ *  easier to requiest options by MAC.
+ *  (MAC) <----> (option-list)
+ *
+ *  Doubts: What should be done if MAC changed for (vm-name, slot), when syncing should? 
+ *  XML: serialization of dependecy (DHCP options) - (VM,slot) shouldn't be done via MAC in 
+ *  the middle.
+ */
+
+typedef std::map<DhcpOpt_T, com::Utf8Str> DhcpOptionMap;
+typedef DhcpOptionMap::value_type DhcpOptValuePair;
+typedef DhcpOptionMap::const_iterator DhcpOptConstIterator;
+typedef DhcpOptionMap::iterator DhcpOptIterator;
+
+typedef std::map<settings::VmNameSlotKey, DhcpOptionMap> VmSlot2OptionsMap;
+typedef VmSlot2OptionsMap::value_type VmSlot2OptionsPair;
+typedef VmSlot2OptionsMap::iterator VmSlot2OptionsIterator;
+
 
 class ATL_NO_VTABLE DHCPServer :
@@ -70 +106 @@
     STDMETHOD(COMGETTER(UpperIP))(BSTR *aIPAddress);
 
+    STDMETHOD(AddGlobalOption)(DhcpOpt_T aOption, IN_BSTR aValue);
+    STDMETHOD(COMGETTER(GlobalOptions))(ComSafeArrayOut(BSTR, aValue));
+    STDMETHOD(COMGETTER(VmConfigs))(ComSafeArrayOut(BSTR, aValue));
+    STDMETHOD(AddVmSlotOption)(IN_BSTR aVmName, LONG aSlot, DhcpOpt_T aOption, IN_BSTR aValue);
+    STDMETHOD(RemoveVmSlotOptions)(IN_BSTR aVmName, LONG aSlot);
+    STDMETHOD(GetVmSlotOptions)(IN_BSTR aVmName, LONG aSlot, ComSafeArrayOut(BSTR, aValues));
+    STDMETHOD(GetMacOptions)(IN_BSTR aMAC, ComSafeArrayOut(BSTR, aValues));
+    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
+    
+
     STDMETHOD(SetConfiguration)(IN_BSTR aIPAddress, IN_BSTR aNetworkMask, IN_BSTR aFromIPAddress, IN_BSTR aToIPAddress);
 
@@ -86 +132 @@
 
         Bstr IPAddress;
-        Bstr networkMask;
         Bstr lowerIP;
         Bstr upperIP;
+
         BOOL enabled;
-
         DHCPServerRunner dhcp;
+        
+        DhcpOptionMap GlobalDhcpOptions;
+        VmSlot2OptionsMap VmSlot2Options;
     } m;
-
+    
+    DhcpOptionMap& findOptMapByVmNameSlot(const com::Utf8Str& aVmName, 
+                                   LONG Slot);
 };
 

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

@@ -62 +62 @@
     STDMETHOD(COMGETTER(USBDeviceFilters))(ComSafeArrayOut(IHostUSBDeviceFilter *, aUSBDeviceFilters));
     STDMETHOD(COMGETTER(NetworkInterfaces))(ComSafeArrayOut(IHostNetworkInterface *, aNetworkInterfaces));
+    STDMETHOD(COMGETTER(NameServers))(ComSafeArrayOut(BSTR, aNameServers));
+    STDMETHOD(COMGETTER(DomainName))(BSTR *aDomainName);
+    STDMETHOD(COMGETTER(SearchStrings))(ComSafeArrayOut(BSTR, aSearchStrings));
+
     STDMETHOD(COMGETTER(ProcessorCount))(ULONG *count);
     STDMETHOD(COMGETTER(ProcessorOnlineCount))(ULONG *count);
@@ -147 +151 @@
     HRESULT updateNetIfList();
 
+#ifndef RT_OS_WINDOWS
+    HRESULT parseResolvConf();
+#else
+    HRESULT fetchNameResolvingInformation();
+#endif
+
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
     void registerMetrics(PerformanceCollector *aCollector);

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

@@ -37 +37 @@
 }
 
+#ifdef RT_OS_WINDOWS
+# define NATSR_EXECUTABLE_NAME "VBoxNetLwipNAT.exe"
+#else
+# define NATSR_EXECUTABLE_NAME "VBoxNetLwipNAT"
+#endif
+
+class NATNetworkServiceRunner: public NetworkServiceRunner
+{
+public: 
+    NATNetworkServiceRunner(): NetworkServiceRunner(NATSR_EXECUTABLE_NAME){}
+    virtual ~NATNetworkServiceRunner(){}
+};
 
 class ATL_NO_VTABLE NATNetwork :

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

@@ -23 +23 @@
 typedef enum
 {
-    DHCPCFG_NAME = 1,
-    DHCPCFG_NETNAME,
-    DHCPCFG_TRUNKTYPE,
-    DHCPCFG_TRUNKNAME,
-    DHCPCFG_MACADDRESS,
-    DHCPCFG_IPADDRESS,
-    DHCPCFG_LEASEDB,
-    DHCPCFG_VERBOSE,
-    DHCPCFG_GATEWAY,
-    DHCPCFG_LOWERIP,
-    DHCPCFG_UPPERIP,
-    DHCPCFG_NETMASK,
-    DHCPCFG_HELP,
-    DHCPCFG_VERSION,
-    DHCPCFG_BEGINCONFIG,
-    DHCPCFG_NOTOPT_MAXVAL
-}DHCPCFG;
+    NETCFG_NAME = 1,
+    NETCFG_NETNAME,
+    NETCFG_TRUNKTYPE,
+    NETCFG_TRUNKNAME,
+    NETCFG_MACADDRESS,
+    NETCFG_IPADDRESS,
+    NETCFG_NETMASK,
+    NETCFG_VERBOSE,
+    NETCFG_NOTOPT_MAXVAL
+}NETCFG;
 
 #define TRUNKTYPE_WHATEVER "whatever"
@@ -46 +39 @@
 #define TRUNKTYPE_SRVNAT   "srvnat"
 
-class DHCPServerRunner
+class NetworkServiceRunner
 {
 public:
-    DHCPServerRunner();
-    ~DHCPServerRunner() { stop(); /* don't leave abandoned servers */}
+    NetworkServiceRunner(const char *aProcName):
+      mProcName(aProcName),
+      mProcess(NIL_RTPROCESS)
+    {
+        memset(mOptionEnabled, 0, sizeof(mOptionEnabled));
+    };
+    ~NetworkServiceRunner() { stop(); /* don't leave abandoned servers */}
 
-    int setOption(DHCPCFG opt, const char *val, bool enabled)
+    int setOption(NETCFG opt, const char *val, bool enabled)
     {
-        if (opt == 0 || opt >= DHCPCFG_NOTOPT_MAXVAL)
+        if (opt == 0 || opt >= NETCFG_NOTOPT_MAXVAL)
             return VERR_INVALID_PARAMETER;
         if (isRunning())
@@ -64 +62 @@
     }
 
-    int setOption(DHCPCFG opt, const com::Utf8Str &val, bool enabled)
+    int setOption(NETCFG opt, const com::Utf8Str &val, bool enabled)
     {
         return setOption(opt, val.c_str(), enabled);
@@ -75 +73 @@
     void detachFromServer();
 private:
-    com::Utf8Str mOptions[DHCPCFG_NOTOPT_MAXVAL];
-    bool mOptionEnabled[DHCPCFG_NOTOPT_MAXVAL];
+    com::Utf8Str mOptions[NETCFG_NOTOPT_MAXVAL];
+    bool mOptionEnabled[NETCFG_NOTOPT_MAXVAL];
+    const char *mProcName;
     RTPROCESS mProcess;
 };

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

@@ -115 +115 @@
 #endif /* VBOX_WITH_NETFLT */
 
-#include "DHCPServerRunner.h"
+#include "NetworkServiceRunner.h"
 #include "BusAssignmentManager.h"
 #ifdef VBOX_WITH_EXTPACK

trunk/src/VBox/Main/src-server/DHCPServerImpl.cpp

@@ -18 +18 @@
  */
 
-#include "DHCPServerRunner.h"
+#include "NetworkServiceRunner.h"
 #include "DHCPServerImpl.h"
 #include "AutoCaller.h"
@@ -25 +25 @@
 #include <iprt/cpp/utils.h>
 
+#include <VBox/com/array.h>
 #include <VBox/settings.h>
 
@@ -37 +38 @@
 }
 
+
 DHCPServer::~DHCPServer()
 {
 }
 
+
 HRESULT DHCPServer::FinalConstruct()
 {
@@ -46 +49 @@
 }
 
+
 void DHCPServer::FinalRelease()
 {
@@ -52 +56 @@
     BaseFinalRelease();
 }
+
 
 void DHCPServer::uninit()
@@ -63 +68 @@
 }
 
+
 HRESULT DHCPServer::init(VirtualBox *aVirtualBox, IN_BSTR aName)
 {
@@ -75 +81 @@
     unconst(mName) = aName;
     m.IPAddress = "0.0.0.0";
-    m.networkMask = "0.0.0.0";
+    m.GlobalDhcpOptions.insert(DhcpOptValuePair(DhcpOpt_SubnetMask, Bstr("0.0.0.0")));
     m.enabled = FALSE;
+    
     m.lowerIP = "0.0.0.0";
     m.upperIP = "0.0.0.0";
@@ -85 +92 @@
     return S_OK;
 }
+
 
 HRESULT DHCPServer::init(VirtualBox *aVirtualBox,
@@ -98 +106 @@
     unconst(mName) = data.strNetworkName;
     m.IPAddress = data.strIPAddress;
-    m.networkMask = data.strIPNetworkMask;
     m.enabled = data.fEnabled;
     m.lowerIP = data.strIPLower;
     m.upperIP = data.strIPUpper;
 
+    
+    m.GlobalDhcpOptions.clear();
+    m.GlobalDhcpOptions.insert(data.GlobalDhcpOptions.begin(), 
+                               data.GlobalDhcpOptions.end());
+
+    m.VmSlot2Options.clear();
+    m.VmSlot2Options.insert(data.VmSlot2OptionsM.begin(),
+                            data.VmSlot2OptionsM.end());
+
     autoInitSpan.setSucceeded();
 
     return S_OK;
 }
+
 
 HRESULT DHCPServer::saveSettings(settings::DHCPServer &data)
@@ -117 +134 @@
     data.strNetworkName = mName;
     data.strIPAddress = m.IPAddress;
-    data.strIPNetworkMask = m.networkMask;
+
     data.fEnabled = !!m.enabled;
     data.strIPLower = m.lowerIP;
     data.strIPUpper = m.upperIP;
 
-    return S_OK;
-}
+    data.GlobalDhcpOptions.clear();
+    data.GlobalDhcpOptions.insert(m.GlobalDhcpOptions.begin(), 
+                                  m.GlobalDhcpOptions.end());
+    
+    data.VmSlot2OptionsM.clear();
+    data.VmSlot2OptionsM.insert(m.VmSlot2Options.begin(),
+                                m.VmSlot2Options.end());
+    
+    return S_OK;
+}
+
 
 STDMETHODIMP DHCPServer::COMGETTER(NetworkName) (BSTR *aName)
@@ -137 +163 @@
 }
 
+
 STDMETHODIMP DHCPServer::COMGETTER(Enabled) (BOOL *aEnabled)
 {
@@ -148 +175 @@
     return S_OK;
 }
+
 
 STDMETHODIMP DHCPServer::COMSETTER(Enabled) (BOOL aEnabled)
@@ -165 +193 @@
 }
 
+
 STDMETHODIMP DHCPServer::COMGETTER(IPAddress) (BSTR *aIPAddress)
 {
@@ -177 +206 @@
 }
 
+
 STDMETHODIMP DHCPServer::COMGETTER(NetworkMask) (BSTR *aNetworkMask)
 {
@@ -184 +214 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    m.networkMask.cloneTo(aNetworkMask);
-
-    return S_OK;
-}
+    m.GlobalDhcpOptions[DhcpOpt_SubnetMask].cloneTo(aNetworkMask);
+
+    return S_OK;
+}
+
 
 STDMETHODIMP DHCPServer::COMGETTER(LowerIP) (BSTR *aIPAddress)
@@ -195 +226 @@
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    
     m.lowerIP.cloneTo(aIPAddress);
 
@@ -201 +232 @@
 }
 
+
 STDMETHODIMP DHCPServer::COMGETTER(UpperIP) (BSTR *aIPAddress)
 {
@@ -212 +244 @@
     return S_OK;
 }
+
 
 STDMETHODIMP DHCPServer::SetConfiguration (IN_BSTR aIPAddress, IN_BSTR aNetworkMask, IN_BSTR aLowerIP, IN_BSTR aUpperIP)
@@ -225 +258 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     m.IPAddress = aIPAddress;
-    m.networkMask = aNetworkMask;
+    m.GlobalDhcpOptions[DhcpOpt_SubnetMask] = aNetworkMask;
+
     m.lowerIP = aLowerIP;
     m.upperIP = aUpperIP;
@@ -235 +269 @@
 }
 
+
+STDMETHODIMP DHCPServer::AddGlobalOption(DhcpOpt_T aOption, IN_BSTR aValue)
+{
+    CheckComArgStr(aValue);
+    /* store global option */
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    
+    m.GlobalDhcpOptions.insert(
+      DhcpOptValuePair(aOption, Utf8Str(aValue)));
+
+    alock.release();
+
+    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
+    return mVirtualBox->saveSettings();
+}
+
+
+STDMETHODIMP DHCPServer::COMGETTER(GlobalOptions)(ComSafeArrayOut(BSTR, aValue))
+{
+    CheckComArgOutSafeArrayPointerValid(aValue);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    SafeArray<BSTR> sf(m.GlobalDhcpOptions.size());
+    int i = 0;
+    
+    for (DhcpOptIterator it = m.GlobalDhcpOptions.begin(); 
+         it != m.GlobalDhcpOptions.end(); ++it)
+    {
+        Bstr(Utf8StrFmt("%d:%s", (*it).first, (*it).second.c_str())).detachTo(&sf[i]);
+        i++;
+    }
+
+    sf.detachTo(ComSafeArrayOutArg(aValue));
+
+    return S_OK;
+}
+
+
+STDMETHODIMP DHCPServer::COMGETTER(VmConfigs)(ComSafeArrayOut(BSTR, aValue))
+{
+    CheckComArgOutSafeArrayPointerValid(aValue);
+    
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    SafeArray<BSTR> sf(m.VmSlot2Options.size());
+    VmSlot2OptionsIterator it = m.VmSlot2Options.begin();
+    int i = 0;
+    for (;it != m.VmSlot2Options.end(); ++it)
+    {
+        Bstr(Utf8StrFmt("[%s]:%d", 
+                        it->first.VmName.c_str(), 
+                        it->first.Slot)).detachTo(&sf[i]);
+        i++;
+    }
+
+    sf.detachTo(ComSafeArrayOutArg(aValue));
+
+    return S_OK;
+}
+
+
+STDMETHODIMP DHCPServer::AddVmSlotOption(IN_BSTR aVmName, LONG aSlot, DhcpOpt_T aOption, IN_BSTR aValue)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    m.VmSlot2Options[settings::VmNameSlotKey(
+          com::Utf8Str(aVmName), 
+          aSlot)][aOption] = com::Utf8Str(aValue);
+
+
+    alock.release();
+
+    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);    
+    return mVirtualBox->saveSettings();
+}
+
+
+STDMETHODIMP DHCPServer::RemoveVmSlotOptions(IN_BSTR aVmName, LONG aSlot)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    DhcpOptionMap& map = findOptMapByVmNameSlot(com::Utf8Str(aVmName), aSlot);
+
+    map.clear();
+    
+    alock.release();    
+
+    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
+    return mVirtualBox->saveSettings();
+}
+
+
+/**
+ * this is mapping (vm, slot) 
+ */
+STDMETHODIMP DHCPServer::GetVmSlotOptions(IN_BSTR aVmName, LONG aSlot, ComSafeArrayOut(BSTR, aValues))
+{
+    CheckComArgOutSafeArrayPointerValid(aValues);
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    DhcpOptionMap& map = findOptMapByVmNameSlot(com::Utf8Str(aVmName), aSlot);
+
+    SafeArray<BSTR> sf(map.size());
+    int i = 0;
+    
+    for (DhcpOptIterator it = map.begin(); 
+         it != map.end(); ++it)
+    {
+        Bstr(Utf8StrFmt("%d:%s", (*it).first, (*it).second.c_str())).detachTo(&sf[i]);
+        i++;
+    }
+
+    sf.detachTo(ComSafeArrayOutArg(aValues));
+
+    return S_OK;
+}
+
+
+STDMETHODIMP DHCPServer::GetMacOptions(IN_BSTR aMAC, ComSafeArrayOut(BSTR, aValues))
+{
+    CheckComArgOutSafeArrayPointerValid(aValues);
+    
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    HRESULT hrc;
+
+    ComPtr<IMachine> machine;
+    ComPtr<INetworkAdapter> nic;
+    
+    VmSlot2OptionsIterator it;
+    for(it = m.VmSlot2Options.begin();
+        it != m.VmSlot2Options.end();
+        ++it)
+    {
+
+        alock.release();
+        hrc = mVirtualBox->FindMachine(Bstr(it->first.VmName).raw(), machine.asOutParam());
+        alock.acquire();    
+
+        if (FAILED(hrc))
+            continue;
+
+        alock.release();
+        hrc = machine->GetNetworkAdapter(it->first.Slot, nic.asOutParam());
+        alock.acquire();
+
+        if (FAILED(hrc))
+            continue;
+    
+        com::Bstr mac;
+
+        alock.release();
+        hrc = nic->GetMACAddress(mac.asOutParam());
+        alock.acquire();
+
+        if (FAILED(hrc)) /* no MAC address ??? */
+            break;
+    
+        if (!RTStrICmp(com::Utf8Str(mac).c_str(), com::Utf8Str(aMAC).c_str()))
+            return GetVmSlotOptions(Bstr(it->first.VmName).raw(), 
+                                    it->first.Slot, 
+                                    ComSafeArrayOutArg(aValues));
+    } /* end of for */
+    
+    return hrc;
+}
+
+
+STDMETHODIMP DHCPServer::COMGETTER(EventSource)(IEventSource **aEventSource)
+{
+    ReturnComNotImplemented();
+}
+
+
 STDMETHODIMP DHCPServer::Start(IN_BSTR aNetworkName, IN_BSTR aTrunkName, IN_BSTR aTrunkType)
 {
@@ -240 +467 @@
     if (!m.enabled)
         return S_OK;
-
-    m.dhcp.setOption(DHCPCFG_NETNAME, Utf8Str(aNetworkName), true);
+    
+    /* Commmon Network Settings */
+    m.dhcp.setOption(NETCFG_NETNAME, Utf8Str(aNetworkName), true);
+
     Bstr tmp(aTrunkName);
+
     if (!tmp.isEmpty())
-        m.dhcp.setOption(DHCPCFG_TRUNKNAME, Utf8Str(tmp), true);
-    m.dhcp.setOption(DHCPCFG_TRUNKTYPE, Utf8Str(aTrunkType), true);
-    //temporary hack for testing
-    //    DHCPCFG_NAME
+        m.dhcp.setOption(NETCFG_TRUNKNAME, Utf8Str(tmp), true);
+    m.dhcp.setOption(NETCFG_TRUNKTYPE, Utf8Str(aTrunkType), true);
+
+    /* XXX: should this MAC default initialization moved to NetworkServiceRunner? */
     char strMAC[32];
     Guid guid;
     guid.create();
     RTStrPrintf (strMAC, sizeof(strMAC), "08:00:27:%02X:%02X:%02X",
-                 guid.raw()->au8[0], guid.raw()->au8[1], guid.raw()->au8[2]);
-    m.dhcp.setOption(DHCPCFG_MACADDRESS, strMAC, true);
-    m.dhcp.setOption(DHCPCFG_IPADDRESS,  Utf8Str(m.IPAddress), true);
-    //        DHCPCFG_LEASEDB,
-    //        DHCPCFG_VERBOSE,
-    //        DHCPCFG_GATEWAY,
-    m.dhcp.setOption(DHCPCFG_LOWERIP,  Utf8Str(m.lowerIP), true);
-    m.dhcp.setOption(DHCPCFG_UPPERIP,  Utf8Str(m.upperIP), true);
-    m.dhcp.setOption(DHCPCFG_NETMASK,  Utf8Str(m.networkMask), true);
-
-    //        DHCPCFG_HELP,
-    //        DHCPCFG_VERSION,
-    //        DHCPCFG_NOTOPT_MAXVAL
-    m.dhcp.setOption(DHCPCFG_BEGINCONFIG,  "", true);
-
+                 guid.raw()->au8[0],
+                 guid.raw()->au8[1],
+                 guid.raw()->au8[2]);
+    m.dhcp.setOption(NETCFG_MACADDRESS, strMAC, true);
+    m.dhcp.setOption(NETCFG_IPADDRESS,  Utf8Str(m.IPAddress), true);
+    m.dhcp.setOption(NETCFG_NETMASK, Utf8Str(m.GlobalDhcpOptions[DhcpOpt_SubnetMask]), true);
+    
+    /* XXX: This parameters Dhcp Server will fetch via API */
     return RT_FAILURE(m.dhcp.start()) ? E_FAIL : S_OK;
     //m.dhcp.detachFromServer(); /* need to do this to avoid server shutdown on runner destruction */
 }
 
+
 STDMETHODIMP DHCPServer::Stop (void)
 {
     return RT_FAILURE(m.dhcp.stop()) ? E_FAIL : S_OK;
 }
+
+DhcpOptionMap& DHCPServer::findOptMapByVmNameSlot(const com::Utf8Str& aVmName, 
+                                           LONG aSlot)
+{
+    return m.VmSlot2Options[settings::VmNameSlotKey(
+          com::Utf8Str(aVmName),
+          aSlot)];
+}

trunk/src/VBox/Main/src-server/HostImpl.cpp

@@ -134 +134 @@
 #include <iprt/mem.h>
 #include <iprt/system.h>
+#ifndef RT_OS_WINDOWS
+# include <iprt/path.h>
+#endif
 #ifdef RT_OS_SOLARIS
-# include <iprt/path.h>
 # include <iprt/ctype.h>
 #endif
@@ -215 +217 @@
 
     HostPowerService        *pHostPowerService;
+
+    /* Name resolving */
+    std::list<com::Bstr>     llNameServers;
+    std::list<com::Bstr>     llSearchStrings;
+    Bstr                     DomainName;
+    /* XXX: we need timestamp when these values were set, on repeate in some 
+     *  (~1h?, 5 min?) period, this values should be refetched from host syetem.
+     */
 };
 
+#ifndef RT_OS_WINDOWS
+static char g_aszResolvConf[RTPATH_MAX];
+
+static inline char *getResolvConfPath()
+{
+    int rc = VINF_SUCCESS;
+    if (!g_aszResolvConf[0]) return g_aszResolvConf;
+# ifdef RT_OS_OS2
+    /*
+     * This was in an old Slirp code:
+     * IBM's "Technical Document # - 16070238", clearly says \MPTN\ETC\RESOLV2 
+     * no redolv.conf (remark to code in old Slirp code)
+     */
+    if (RTEnvExists("ETC"))
+    {
+        RTStrmPrintf(g_aszResolvConf, MAX_PATH, "%/RESOLV2", RTEnvGet("ETC"));
+        rc = RTFileExists(g_aszResolvConf);
+        if (RT_SUCCESS(rc))
+            return g_aszResolvConf;
+    }
+
+    RT_ZERO(g_aszResolvConf);
+    RTStrmPrintf(g_aszResolvConf, MAX_PATH, "%/RESOLV2", _PATH_ETC);
+# else
+    strcmp(g_aszResolvConf, "/etc/resolv.conf");
+# endif    
+    return g_aszResolvConf;
+}
+#endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -797 +836 @@
 #endif
 }
+
+
+/**
+ * This method return the list of registered name servers 
+ */
+STDMETHODIMP Host::COMGETTER(NameServers)(ComSafeArrayOut(BSTR, aNameServers))
+{
+    return E_NOTIMPL;
+}
+
+
+/**
+ * This method returns the domain name of the host
+ */
+STDMETHODIMP Host::COMGETTER(DomainName)(BSTR *aDomainName)
+{
+    return E_NOTIMPL;
+}
+
+
+/**
+ * This method returns the search string.
+ */
+STDMETHODIMP Host::COMGETTER(SearchStrings)(ComSafeArrayOut(BSTR, aSearchStrings))
+{
+    return E_NOTIMPL;
+}
+
 
 STDMETHODIMP Host::COMGETTER(USBDeviceFilters)(ComSafeArrayOut(IHostUSBDeviceFilter*, aUSBDeviceFilters))

trunk/src/VBox/Main/src-server/NATNetworkImpl.cpp

@@ -18 +18 @@
  */
 
-#include "DHCPServerRunner.h"
+#include "NetworkServiceRunner.h"
 #include "DHCPServerImpl.h"
 #include "NATNetworkImpl.h"
@@ -35 +35 @@
 #include "VBoxEvents.h"
 
-#include "NATNetworkServiceRunner.h"
 #include "VirtualBoxImpl.h"
 
@@ -632 +631 @@
 
     if (!m->fEnabled) return S_OK;
-    m->NATRunner.setOption(NATSCCFG_NAME, mName, true);
-    m->NATRunner.setOption(NATSCCFG_TRUNKTYPE, Utf8Str(aTrunkType), true);
-    m->NATRunner.setOption(NATSCCFG_IPADDRESS, m->IPv4Gateway, true);
-    m->NATRunner.setOption(NATSCCFG_NETMASK, m->IPv4NetworkMask, true);
-    
-    /* port-forwarding */
-    
-    for (constNATRuleMapIterator it = m->mapName2PortForwardRule4.begin();
-         it != m->mapName2PortForwardRule4.end(); ++it)
-    {
-        settings::NATRule r = it->second;
-        m->NATRunner.setOption(NATSCCFG_PORTFORWARD4, 
-                               Bstr(Utf8StrFmt("%s:%d:[%s]:%d:[%s]:%d",
-                                               r.strName.c_str(),
-                                               r.proto,
-                                               r.strHostIP.isEmpty() ? 
-                                                      "0.0.0.0" :
-                                                       r.strHostIP.c_str(),
-                                               r.u16HostPort,
-                                               r.strGuestIP.c_str(),
-                                               r.u16GuestPort)), true);
-    }
+
+    m->NATRunner.setOption(NETCFG_NETNAME, mName, true);
+    m->NATRunner.setOption(NETCFG_TRUNKTYPE, Utf8Str(aTrunkType), true);
+    m->NATRunner.setOption(NETCFG_IPADDRESS, m->IPv4Gateway, true);
+    m->NATRunner.setOption(NETCFG_NETMASK, m->IPv4NetworkMask, true);
+
+    /* No portforwarding rules from command-line, all will be fetched via API */
 
     if (m->fNeedDhcpServer)
@@ -682 +666 @@
                   return E_FAIL;
                 /* breakthrough */
-            case S_OK:
+
             {
                 LogFunc(("gateway: %s, dhcpserver:%s, dhcplowerip:%s, dhcpupperip:%s\n", 
@@ -689 +673 @@
                          Utf8Str(m->IPv4DhcpServerLowerIp.raw()).c_str(), 
                          Utf8Str(m->IPv4DhcpServerUpperIp.raw()).c_str()));
-                         
+
+                m->dhcpServer->AddGlobalOption(DhcpOpt_Router, m->IPv4Gateway.raw());
 
                 rc = m->dhcpServer->SetEnabled(true);
+
                 BSTR dhcpip = NULL;
                 BSTR netmask = NULL;
                 BSTR lowerip = NULL;
                 BSTR upperip = NULL;
+
                 m->IPv4DhcpServer.cloneTo(&dhcpip);
                 m->IPv4NetworkMask.cloneTo(&netmask);
-                
                 m->IPv4DhcpServerLowerIp.cloneTo(&lowerip); 
                 m->IPv4DhcpServerUpperIp.cloneTo(&upperip);
@@ -705 +691 @@
                                                      lowerip,
                                                      upperip);
-            break;
             }
-            
-        default:
-            return E_FAIL;
+            case S_OK:
+                break;
+                
+            default:
+                return E_FAIL;
         }
 
@@ -728 +715 @@
 #else
     NOREF(aTrunkType);
-    return E_NOTIMPL;
+    ReturnComNotImplemented();
 #endif
 }
@@ -741 +728 @@
     }
     else return E_FAIL;
-        
 #else
-    return E_NOTIMPL;
+    ReturnComNotImplemented();
 #endif
 }
@@ -818 +804 @@
         m->IPv4DhcpServerLowerIp = aszDhcpLowerIp;
         m->IPv4DhcpServerUpperIp = aszDhcpUpperIp;
-        LogFunc(("network: %RTnaipv4, dhcpserver:%RTnaipv4, dhcplowerip:%RTnaipv4, dhcpupperip:%RTnaipv4\n", network, dhcpserver, dhcplowerip, dhcpupperip));
+
+        LogFunc(("network: %RTnaipv4, dhcpserver:%RTnaipv4, dhcplowerip:%RTnaipv4, dhcpupperip:%RTnaipv4\n", 
+                 network, 
+                 dhcpserver, 
+                 dhcplowerip, 
+                 dhcpupperip));
     }
     /* we need IPv4NetworkMask for NAT's gw service start */

trunk/src/VBox/Main/src-server/NetworkServiceRunner.cpp

@@ -15 +15 @@
  * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
  */
-#include "DHCPServerRunner.h"
+#include "NetworkServiceRunner.h"
 #include <iprt/process.h>
 #include <iprt/param.h>
@@ -22 +22 @@
 struct ARGDEF
 {
-    DHCPCFG Type;
+    NETCFG Type;
     const char * Name;
 };
 
-#ifdef RT_OS_WINDOWS
-# define DHCP_EXECUTABLE_NAME "VBoxNetDHCP.exe"
-#else
-# define DHCP_EXECUTABLE_NAME "VBoxNetDHCP"
-#endif
-
 static const ARGDEF g_aArgDefs[] =
 {
-    {DHCPCFG_NAME, "--name"},
-    {DHCPCFG_NETNAME, "--network"},
-    {DHCPCFG_TRUNKTYPE, "--trunk-type"},
-    {DHCPCFG_TRUNKNAME, "--trunk-name"},
-    {DHCPCFG_MACADDRESS, "--mac-address"},
-    {DHCPCFG_IPADDRESS, "--ip-address"},
-    {DHCPCFG_LEASEDB, "--lease-db"},
-    {DHCPCFG_VERBOSE, "--verbose"},
-    {DHCPCFG_BEGINCONFIG, "--begin-config"},
-    {DHCPCFG_GATEWAY, "--gateway"},
-    {DHCPCFG_LOWERIP, "--lower-ip"},
-    {DHCPCFG_UPPERIP, "--upper-ip"},
-    {DHCPCFG_NETMASK, "--netmask"},
-    {DHCPCFG_HELP, "--help"},
-    {DHCPCFG_VERSION, "--version"}
+    {NETCFG_NAME, "--name"},
+    {NETCFG_NETNAME, "--network"},
+    {NETCFG_TRUNKTYPE, "--trunk-type"},
+    {NETCFG_TRUNKNAME, "--trunk-name"},
+    {NETCFG_MACADDRESS, "--mac-address"},
+    {NETCFG_IPADDRESS, "--ip-address"},
+    {NETCFG_VERBOSE, "--verbose"},
+    {NETCFG_NETMASK, "--netmask"},
 };
 
-static const ARGDEF * getArgDef(DHCPCFG type)
+static const ARGDEF * getArgDef(NETCFG type)
 {
     for (unsigned i = 0; i < RT_ELEMENTS(g_aArgDefs); i++)
@@ -60 +47 @@
 }
 
-DHCPServerRunner::DHCPServerRunner()
-{
-    mProcess = NIL_RTPROCESS;
-    for (unsigned i = 0; i < DHCPCFG_NOTOPT_MAXVAL; i++)
-    {
-        mOptionEnabled[i] = false;
-    }
-}
-
-void DHCPServerRunner::detachFromServer()
+void NetworkServiceRunner::detachFromServer()
 {
     mProcess = NIL_RTPROCESS;
 }
 
-int DHCPServerRunner::start()
+int NetworkServiceRunner::start()
 {
     if (isRunning())
         return VINF_ALREADY_INITIALIZED;
 
-    const char * args[DHCPCFG_NOTOPT_MAXVAL * 2];
+    const char * args[NETCFG_NOTOPT_MAXVAL * 2];
 
     /* get the path to the executable */
@@ -91 +69 @@
     {
         suffix++;
-        strcpy(suffix, DHCP_EXECUTABLE_NAME);
+        strcpy(suffix, mProcName);
     }
-    else
-        exePath = DHCP_EXECUTABLE_NAME;
 
     int index = 0;
@@ -100 +76 @@
     args[index++] = exePath;
 
-    for (unsigned i = 0; i < DHCPCFG_NOTOPT_MAXVAL; i++)
+    for (unsigned i = 0; i < NETCFG_NOTOPT_MAXVAL; i++)
     {
         if (mOptionEnabled[i])
         {
-            const ARGDEF *pArgDef = getArgDef((DHCPCFG)i);
+            const ARGDEF *pArgDef = getArgDef((NETCFG)i);
             if (!pArgDef)
                 continue;
-            args[index++] = pArgDef->Name;      // e.g. "--network"
+            args[index++] = pArgDef->Name;
 
-            /* value can be null for e.g. --begin-config has no value
-             * and thus check the mOptions string length here
-             */
             if (mOptions[i].length())
                 args[index++] = mOptions[i].c_str();  // value
@@ -119 +92 @@
     args[index++] = NULL;
 
-    int rc = RTProcCreate(exePath, args, RTENV_DEFAULT, 0, &mProcess);
+    int rc = RTProcCreate(suffix ? exePath : mProcName, args, RTENV_DEFAULT, 0, &mProcess);
     if (RT_FAILURE(rc))
         mProcess = NIL_RTPROCESS;
@@ -126 +99 @@
 }
 
-int DHCPServerRunner::stop()
+int NetworkServiceRunner::stop()
 {
     if (!isRunning())
@@ -136 +109 @@
 }
 
-bool DHCPServerRunner::isRunning()
+bool NetworkServiceRunner::isRunning()
 {
     if (mProcess == NIL_RTPROCESS)

trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

@@ -61 +61 @@
 #include "SystemPropertiesImpl.h"
 #include "GuestOSTypeImpl.h"
-#include "DHCPServerRunner.h"
+#include "NetworkServiceRunner.h"
 #include "DHCPServerImpl.h"
 #include "NATNetworkImpl.h"

trunk/src/VBox/Main/src-server/xpcom/server.cpp

@@ -67 +67 @@
 #include "BandwidthControlImpl.h"
 #include "BandwidthGroupImpl.h"
-#include "DHCPServerRunner.h"
+#include "NetworkServiceRunner.h"
 #include "DHCPServerImpl.h"
 #include "GuestOSTypeImpl.h"

trunk/src/VBox/Main/xml/Settings.cpp

@@ -1302 +1302 @@
             if (    (pelmServer->getAttributeValue("networkName", srv.strNetworkName))
                  && (pelmServer->getAttributeValue("IPAddress", srv.strIPAddress))
-                 && (pelmServer->getAttributeValue("networkMask", srv.strIPNetworkMask))
+                    && (pelmServer->getAttributeValue("networkMask", srv.GlobalDhcpOptions[DhcpOpt_SubnetMask]))
                  && (pelmServer->getAttributeValue("lowerIP", srv.strIPLower))
                  && (pelmServer->getAttributeValue("upperIP", srv.strIPUpper))
                  && (pelmServer->getAttributeValue("enabled", srv.fEnabled))
                )
+            {
+                xml::NodesLoop nlOptions(*pelmServer, "Options");
+                const xml::ElementNode *options;
+                /* XXX: Options are in 1:1 relation to DHCPServer */
+
+                while ((options = nlOptions.forAllNodes()))
+                {
+                    readDhcpOptions(srv.GlobalDhcpOptions, *options);
+                } /* end of forall("Options") */
+                xml::NodesLoop nlConfig(*pelmServer, "Config");
+                const xml::ElementNode *cfg;
+                while ((cfg = nlConfig.forAllNodes()))
+                {
+                    com::Utf8Str strVmName;
+                    uint32_t u32Slot;
+                    cfg->getAttributeValue("vm-name", strVmName);
+                    cfg->getAttributeValue("slot", (uint32_t&)u32Slot);
+                    readDhcpOptions(srv.VmSlot2OptionsM[VmNameSlotKey(strVmName, u32Slot)],
+                                   *cfg);
+                }
                 llDhcpServers.push_back(srv);
+            }
             else
                 throw ConfigFileError(this, pelmServer, N_("Required DHCPServer/@networkName, @IPAddress, @networkMask, @lowerIP, @upperIP or @enabled attribute is missing"));
         }
     }
+}
+
+void MainConfigFile::readDhcpOptions(DhcpOptionMap& map, 
+                                     const xml::ElementNode& options)
+{
+    xml::NodesLoop nl2(options, "Option");
+    const xml::ElementNode *opt;
+    while((opt = nl2.forAllNodes()))
+    {
+        DhcpOpt_T OptName; 
+        com::Utf8Str OptValue;
+        opt->getAttributeValue("name", (uint32_t&)OptName);
+
+        if (OptName == DhcpOpt_SubnetMask)
+            continue;
+
+        opt->getAttributeValue("value", OptValue);
+                    
+        map.insert(
+          std::map<DhcpOpt_T, Utf8Str>::value_type(OptName, OptValue));
+    } /* end of forall("Option") */
+
 }
 
@@ -1446 +1489 @@
 #endif
         srv.strIPAddress = "192.168.56.100";
-        srv.strIPNetworkMask = "255.255.255.0";
+        srv.GlobalDhcpOptions[DhcpOpt_SubnetMask] = "255.255.255.0";
         srv.strIPLower = "192.168.56.101";
         srv.strIPUpper = "192.168.56.254";
@@ -1489 +1532 @@
         const DHCPServer &d = *it;
         xml::ElementNode *pelmThis = pelmDHCPServers->createChild("DHCPServer");
+        DhcpOptConstIterator itOpt;
+        itOpt = d.GlobalDhcpOptions.find(DhcpOpt_SubnetMask);
+
         pelmThis->setAttribute("networkName", d.strNetworkName);
         pelmThis->setAttribute("IPAddress", d.strIPAddress);
-        pelmThis->setAttribute("networkMask", d.strIPNetworkMask);
+        if (itOpt != d.GlobalDhcpOptions.end())
+            pelmThis->setAttribute("networkMask", itOpt->second);
         pelmThis->setAttribute("lowerIP", d.strIPLower);
         pelmThis->setAttribute("upperIP", d.strIPUpper);
         pelmThis->setAttribute("enabled", (d.fEnabled) ? 1 : 0);        // too bad we chose 1 vs. 0 here
-    }
+        /* We assume that if there're only 1 element it means that */
+        int cOpt = d.GlobalDhcpOptions.size(); 
+        /* We don't want duplicate validation check of networkMask here*/
+        if (   (   itOpt == d.GlobalDhcpOptions.end()
+                && cOpt > 0)
+            || cOpt > 1)
+        {
+            xml::ElementNode *pelmOptions = pelmThis->createChild("Options");
+            for (itOpt = d.GlobalDhcpOptions.begin();
+                 itOpt != d.GlobalDhcpOptions.end();
+                 ++itOpt)
+            {
+                if (itOpt->first == DhcpOpt_SubnetMask)
+                    continue;
+                
+                xml::ElementNode *pelmOpt = pelmOptions->createChild("Option");
+                
+                if (!pelmOpt)
+                    break;
+                
+                pelmOpt->setAttribute("name", itOpt->first);
+                pelmOpt->setAttribute("value", itOpt->second);
+            }
+        } /* end of if */
+        
+        if (d.VmSlot2OptionsM.size() > 0)
+        {
+            VmSlot2OptionsConstIterator itVmSlot;
+            DhcpOptConstIterator itOpt1;
+            for(itVmSlot = d.VmSlot2OptionsM.begin();
+                itVmSlot != d.VmSlot2OptionsM.end();
+                ++itVmSlot)
+            {
+                xml::ElementNode *pelmCfg = pelmThis->createChild("Config");
+                pelmCfg->setAttribute("vm-name", itVmSlot->first.VmName);
+                pelmCfg->setAttribute("slot", itVmSlot->first.Slot);
+                
+                for (itOpt1 = itVmSlot->second.begin();
+                     itOpt1 != itVmSlot->second.end();
+                     ++itOpt1)
+                {
+                    xml::ElementNode *pelmOpt = pelmCfg->createChild("Option");
+                    pelmOpt->setAttribute("name", itOpt1->first);
+                    pelmOpt->setAttribute("value", itOpt1->second);
+                }
+            }
+        } /* and of if */
+
+     }
 
     /* TODO: bump main version ? */