Changeset 61170 in vbox for trunk

Timestamp:

May 24, 2016 4:44:44 PM (9 years ago)

Author:

vboxsync

Message:

8238 VBoxSVC settings - NetworkAdapterImpl

Location:

trunk/src/VBox/Main

Files:

• include/NATEngineImpl.h (modified) (1 diff)
• include/NetworkAdapterImpl.h (modified) (3 diffs)
• src-server/NATEngineImpl.cpp (modified) (29 diffs)
• src-server/NetworkAdapterImpl.cpp (modified) (54 diffs)

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2015 Oracle Corporation
+ * Copyright (C) 2006-2016 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2015 Oracle Corporation
+ * Copyright (C) 2006-2016 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -114 +114 @@
     HRESULT i_switchToNatNetworking(const com::Utf8Str &aNatNetworkName);
 
-    typedef std::map<com::Utf8Str, com::Utf8Str> StringsMap;
-
-    struct Data
-    {
-        Data() : mSlot(0),
-                 mEnabled(FALSE),
-                 mAttachmentType(NetworkAttachmentType_Null),
-                 mCableConnected(TRUE),
-                 mLineSpeed(0),
-                 mPromiscModePolicy(NetworkAdapterPromiscModePolicy_Deny),
-                 mTraceEnabled(FALSE),
-                 mBridgedInterface("") /* cannot be null */,
-                 mHostOnlyInterface("") /* cannot be null */,
-                 mNATNetwork("") /* cannot be null */,
-                 mBootPriority(0)
-        {}
-
-        NetworkAdapterType_T mAdapterType;
-        ULONG mSlot;
-        BOOL mEnabled;
-        com::Utf8Str mMACAddress;
-        NetworkAttachmentType_T mAttachmentType;
-        BOOL mCableConnected;
-        ULONG mLineSpeed;
-        NetworkAdapterPromiscModePolicy_T mPromiscModePolicy;
-        BOOL mTraceEnabled;
-        com::Utf8Str mTraceFile;
-        com::Utf8Str mBridgedInterface;
-        com::Utf8Str mHostOnlyInterface;
-        com::Utf8Str mInternalNetwork;
-        com::Utf8Str mNATNetwork;
-        com::Utf8Str mGenericDriver;
-        StringsMap mGenericProperties;
-        ULONG mBootPriority;
-        com::Utf8Str mBandwidthGroup;
-    };
 
     Machine * const     mParent;
@@ -155 +119 @@
     const ComObjPtr<NATEngine> mNATEngine;
 
-    Backupable<Data>    mData;
+    Backupable<settings::NetworkAdapter> mData;
 };
 

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

@@ -29 +29 @@
 #include <VBox/com/array.h>
 
-struct NATEngineData
-{
-    NATEngineData()
-    {}
-
-    settings::NAT s;
-};
-
 struct NATEngine::Data
 {
-    Backupable<NATEngineData> m;
+    Backupable<settings::NAT> m;
 };
 
@@ -68 +60 @@
     mData = new Data();
     mData->m.allocate();
-    mData->m->s.strNetwork.setNull();
-    mData->m->s.strBindIP.setNull();
+    mData->m->strNetwork.setNull();
+    mData->m->strBindIP.setNull();
     unconst(mParent) = aParent;
     unconst(mAdapter) = aAdapter;
@@ -192 +184 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (aMtu)
-        *aMtu = mData->m->s.u32Mtu;
+        *aMtu = mData->m->u32Mtu;
     if (aSockSnd)
-        *aSockSnd = mData->m->s.u32SockSnd;
+        *aSockSnd = mData->m->u32SockSnd;
     if (aSockRcv)
-        *aSockRcv = mData->m->s.u32SockRcv;
+        *aSockRcv = mData->m->u32SockRcv;
     if (aTcpWndSnd)
-        *aTcpWndSnd = mData->m->s.u32TcpSnd;
+        *aTcpWndSnd = mData->m->u32TcpSnd;
     if (aTcpWndRcv)
-        *aTcpWndRcv = mData->m->s.u32TcpRcv;
+        *aTcpWndRcv = mData->m->u32TcpRcv;
 
     return S_OK;
@@ -215 +207 @@
     }
     if (aMtu)
-        mData->m->s.u32Mtu = aMtu;
+        mData->m->u32Mtu = aMtu;
     if (aSockSnd)
-        mData->m->s.u32SockSnd = aSockSnd;
+        mData->m->u32SockSnd = aSockSnd;
     if (aSockRcv)
-        mData->m->s.u32SockRcv = aSockSnd;
+        mData->m->u32SockRcv = aSockSnd;
     if (aTcpWndSnd)
-        mData->m->s.u32TcpSnd = aTcpWndSnd;
+        mData->m->u32TcpSnd = aTcpWndSnd;
     if (aTcpWndRcv)
-        mData->m->s.u32TcpRcv = aTcpWndRcv;
+        mData->m->u32TcpRcv = aTcpWndRcv;
 
     return S_OK;
@@ -233 +225 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    aRedirects.resize(mData->m->s.mapRules.size());
+    aRedirects.resize(mData->m->mapRules.size());
     size_t i = 0;
     settings::NATRulesMap::const_iterator it;
-    for (it = mData->m->s.mapRules.begin(); it != mData->m->s.mapRules.end(); ++it, ++i)
+    for (it = mData->m->mapRules.begin(); it != mData->m->mapRules.end(); ++it, ++i)
     {
         settings::NATRule r = it->second;
@@ -272 +264 @@
 
     settings::NATRulesMap::iterator it;
-    for (it = mData->m->s.mapRules.begin(); it != mData->m->s.mapRules.end(); ++it)
+    for (it = mData->m->mapRules.begin(); it != mData->m->mapRules.end(); ++it)
     {
         r = it->second;
@@ -292 +284 @@
     r.strGuestIP = aGuestIP;
     r.u16GuestPort = aGuestPort;
-    mData->m->s.mapRules.insert(std::make_pair(name, r));
+    mData->m->mapRules.insert(std::make_pair(name, r));
     mParent->i_setModified(Machine::IsModified_NetworkAdapters);
 
@@ -307 +299 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    settings::NATRulesMap::iterator it = mData->m->s.mapRules.find(aName);
-    if (it == mData->m->s.mapRules.end())
+    settings::NATRulesMap::iterator it = mData->m->mapRules.find(aName);
+    if (it == mData->m->mapRules.end())
         return E_INVALIDARG;
     mData->m.backup();
@@ -317 +309 @@
      */
     settings::NATRule r = it->second;
-    Utf8Str strHostIP = r.strHostIP;
-    Utf8Str strGuestIP = r.strGuestIP;
-    NATProtocol_T proto = r.proto;
-    uint16_t u16HostPort = r.u16HostPort;
-    uint16_t u16GuestPort = r.u16GuestPort;
     ULONG ulSlot;
     mAdapter->COMGETTER(Slot)(&ulSlot);
 
-    mData->m->s.mapRules.erase(aName); /* NB: erase by key, "it" may not be valid */
+    mData->m->mapRules.erase(aName); /* NB: erase by key, "it" may not be valid */
     mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     alock.release();
-    mParent->i_onNATRedirectRuleChange(ulSlot, TRUE, Bstr(aName).raw(), proto, Bstr(strHostIP).raw(),
-                                       u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
+    mParent->i_onNATRedirectRuleChange(ulSlot, TRUE, Bstr(aName).raw(), r.proto, Bstr(r.strHostIP).raw(),
+                                       r.u16HostPort, Bstr(r.strGuestIP).raw(), r.u16GuestPort);
     return S_OK;
 }
@@ -339 +326 @@
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    mData->m->s = data;
+    mData->m.assignCopy(&data);
     return S_OK;
 }
@@ -351 +338 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     HRESULT rc = S_OK;
-    data = mData->m->s;
+    data = *mData->m.data();
     return rc;
 }
@@ -358 +345 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (mData->m->s.strNetwork != aNetwork)
-    {
-        mData->m.backup();
-        mData->m->s.strNetwork = aNetwork;
+    if (mData->m->strNetwork != aNetwork)
+    {
+        mData->m.backup();
+        mData->m->strNetwork = aNetwork;
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -371 +358 @@
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (!mData->m->s.strNetwork.isEmpty())
-    {
-        aNetwork = mData->m->s.strNetwork;
-        Log(("Getter (this:%p) Network: %s\n", this, mData->m->s.strNetwork.c_str()));
+    if (!mData->m->strNetwork.isEmpty())
+    {
+        aNetwork = mData->m->strNetwork;
+        Log(("Getter (this:%p) Network: %s\n", this, mData->m->strNetwork.c_str()));
     }
     return S_OK;
@@ -382 +369 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (mData->m->s.strBindIP != aHostIP)
-    {
-        mData->m.backup();
-        mData->m->s.strBindIP = aHostIP;
+    if (mData->m->strBindIP != aHostIP)
+    {
+        mData->m.backup();
+        mData->m->strBindIP = aHostIP;
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -395 +382 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (!mData->m->s.strBindIP.isEmpty())
-        aBindIP = mData->m->s.strBindIP;
+    if (!mData->m->strBindIP.isEmpty())
+        aBindIP = mData->m->strBindIP;
     return S_OK;
 }
@@ -403 +390 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (mData->m->s.strTFTPPrefix != aTFTPPrefix)
-    {
-        mData->m.backup();
-        mData->m->s.strTFTPPrefix = aTFTPPrefix;
+    if (mData->m->strTFTPPrefix != aTFTPPrefix)
+    {
+        mData->m.backup();
+        mData->m->strTFTPPrefix = aTFTPPrefix;
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -417 +404 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (!mData->m->s.strTFTPPrefix.isEmpty())
-    {
-        aTFTPPrefix = mData->m->s.strTFTPPrefix;
-        Log(("Getter (this:%p) TFTPPrefix: %s\n", this, mData->m->s.strTFTPPrefix.c_str()));
+    if (!mData->m->strTFTPPrefix.isEmpty())
+    {
+        aTFTPPrefix = mData->m->strTFTPPrefix;
+        Log(("Getter (this:%p) TFTPPrefix: %s\n", this, mData->m->strTFTPPrefix.c_str()));
     }
     return S_OK;
@@ -428 +415 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (mData->m->s.strTFTPBootFile != aTFTPBootFile)
-    {
-        mData->m.backup();
-        mData->m->s.strTFTPBootFile = aTFTPBootFile;
+    if (mData->m->strTFTPBootFile != aTFTPBootFile)
+    {
+        mData->m.backup();
+        mData->m->strTFTPBootFile = aTFTPBootFile;
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -441 +428 @@
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (!mData->m->s.strTFTPBootFile.isEmpty())
-    {
-        aTFTPBootFile = mData->m->s.strTFTPBootFile;
-        Log(("Getter (this:%p) BootFile: %s\n", this, mData->m->s.strTFTPBootFile.c_str()));
+    if (!mData->m->strTFTPBootFile.isEmpty())
+    {
+        aTFTPBootFile = mData->m->strTFTPBootFile;
+        Log(("Getter (this:%p) BootFile: %s\n", this, mData->m->strTFTPBootFile.c_str()));
     }
     return S_OK;
@@ -453 +440 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (mData->m->s.strTFTPNextServer != aTFTPNextServer)
-    {
-        mData->m.backup();
-        mData->m->s.strTFTPNextServer = aTFTPNextServer;
+    if (mData->m->strTFTPNextServer != aTFTPNextServer)
+    {
+        mData->m.backup();
+        mData->m->strTFTPNextServer = aTFTPNextServer;
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -465 +452 @@
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (!mData->m->s.strTFTPNextServer.isEmpty())
-    {
-        aTFTPNextServer =  mData->m->s.strTFTPNextServer;
-        Log(("Getter (this:%p) NextServer: %s\n", this, mData->m->s.strTFTPNextServer.c_str()));
+    if (!mData->m->strTFTPNextServer.isEmpty())
+    {
+        aTFTPNextServer =  mData->m->strTFTPNextServer;
+        Log(("Getter (this:%p) NextServer: %s\n", this, mData->m->strTFTPNextServer.c_str()));
     }
     return S_OK;
@@ -478 +465 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->m->s.fDNSPassDomain != RT_BOOL(aDNSPassDomain))
-    {
-        mData->m.backup();
-        mData->m->s.fDNSPassDomain = RT_BOOL(aDNSPassDomain);
+    if (mData->m->fDNSPassDomain != RT_BOOL(aDNSPassDomain))
+    {
+        mData->m.backup();
+        mData->m->fDNSPassDomain = RT_BOOL(aDNSPassDomain);
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -490 +477 @@
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    *aDNSPassDomain = mData->m->s.fDNSPassDomain;
+    *aDNSPassDomain = mData->m->fDNSPassDomain;
     return S_OK;
 }
@@ -499 +486 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->m->s.fDNSProxy != RT_BOOL(aDNSProxy))
-    {
-        mData->m.backup();
-        mData->m->s.fDNSProxy = RT_BOOL(aDNSProxy);
+    if (mData->m->fDNSProxy != RT_BOOL(aDNSProxy))
+    {
+        mData->m.backup();
+        mData->m->fDNSProxy = RT_BOOL(aDNSProxy);
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -511 +498 @@
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    *aDNSProxy = mData->m->s.fDNSProxy;
+    *aDNSProxy = mData->m->fDNSProxy;
     return S_OK;
 }
@@ -519 +506 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    *aDNSUseHostResolver = mData->m->s.fDNSUseHostResolver;
+    *aDNSUseHostResolver = mData->m->fDNSUseHostResolver;
     return S_OK;
 }
@@ -526 +513 @@
 HRESULT NATEngine::setDNSUseHostResolver(BOOL aDNSUseHostResolver)
 {
-    if (mData->m->s.fDNSUseHostResolver != RT_BOOL(aDNSUseHostResolver))
-    {
-        mData->m.backup();
-        mData->m->s.fDNSUseHostResolver = RT_BOOL(aDNSUseHostResolver);
+    if (mData->m->fDNSUseHostResolver != RT_BOOL(aDNSUseHostResolver))
+    {
+        mData->m.backup();
+        mData->m->fDNSUseHostResolver = RT_BOOL(aDNSUseHostResolver);
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -538 +525 @@
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    ULONG uAliasMode = (mData->m->s.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
-    uAliasMode |= (mData->m->s.fAliasLog ? NATAliasMode_AliasLog : 0);
-    uAliasMode |= (mData->m->s.fAliasProxyOnly ? NATAliasMode_AliasProxyOnly : 0);
+    ULONG uAliasMode = (mData->m->fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
+    uAliasMode |= (mData->m->fAliasLog ? NATAliasMode_AliasLog : 0);
+    uAliasMode |= (mData->m->fAliasProxyOnly ? NATAliasMode_AliasProxyOnly : 0);
     if (uAliasMode != aAliasMode)
     {
         mData->m.backup();
-        mData->m->s.fAliasUseSamePorts = RT_BOOL(aAliasMode & NATAliasMode_AliasUseSamePorts);
-        mData->m->s.fAliasLog = RT_BOOL(aAliasMode & NATAliasMode_AliasLog);
-        mData->m->s.fAliasProxyOnly = RT_BOOL(aAliasMode & NATAliasMode_AliasProxyOnly);
+        mData->m->fAliasUseSamePorts = RT_BOOL(aAliasMode & NATAliasMode_AliasUseSamePorts);
+        mData->m->fAliasLog = RT_BOOL(aAliasMode & NATAliasMode_AliasLog);
+        mData->m->fAliasProxyOnly = RT_BOOL(aAliasMode & NATAliasMode_AliasProxyOnly);
         mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     }
@@ -555 +542 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    ULONG uAliasMode = (mData->m->s.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
-    uAliasMode |= (mData->m->s.fAliasLog ? NATAliasMode_AliasLog : 0);
-    uAliasMode |= (mData->m->s.fAliasProxyOnly ? NATAliasMode_AliasProxyOnly : 0);
+    ULONG uAliasMode = (mData->m->fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
+    uAliasMode |= (mData->m->fAliasLog ? NATAliasMode_AliasLog : 0);
+    uAliasMode |= (mData->m->fAliasProxyOnly ? NATAliasMode_AliasProxyOnly : 0);
     *aAliasMode = uAliasMode;
     return S_OK;

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

@@ -65 +65 @@
  *  @param aParent  Handle of the parent object.
  */
-HRESULT NetworkAdapter::init(Machine *aParent, ULONG aSlot)
-{
-    LogFlowThisFunc(("aParent=%p, aSlot=%d\n", aParent, aSlot));
+HRESULT NetworkAdapter::init(Machine *aParent, ULONG uSlot)
+{
+    LogFlowThisFunc(("aParent=%p, uSlot=%d\n", aParent, uSlot));
 
     ComAssertRet(aParent, E_INVALIDARG);
     uint32_t maxNetworkAdapters = Global::getMaxNetworkAdapters(aParent->i_getChipsetType());
-    ComAssertRet(aSlot < maxNetworkAdapters, E_INVALIDARG);
+    ComAssertRet(uSlot < maxNetworkAdapters, E_INVALIDARG);
 
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -85 +85 @@
 
     /* initialize data */
-    mData->mSlot = aSlot;
+    mData->ulSlot = uSlot;
 
     /* default to Am79C973 */
-    mData->mAdapterType = NetworkAdapterType_Am79C973;
+    mData->type = NetworkAdapterType_Am79C973;
 
     /* Confirm a successful initialization */
@@ -214 +214 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aAdapterType = mData->mAdapterType;
+    *aAdapterType = mData->type;
 
     return S_OK;
@@ -247 +247 @@
     }
 
-    if (mData->mAdapterType != aAdapterType)
+    if (mData->type != aAdapterType)
     {
         mData.backup();
-        mData->mAdapterType = aAdapterType;
+        mData->type = aAdapterType;
 
         // leave the lock before informing callbacks
@@ -268 +268 @@
 
 
-HRESULT NetworkAdapter::getSlot(ULONG *aSlot)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aSlot = mData->mSlot;
+HRESULT NetworkAdapter::getSlot(ULONG *uSlot)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *uSlot = mData->ulSlot;
 
     return S_OK;
@@ -281 +281 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aEnabled = mData->mEnabled;
+    *aEnabled = mData->fEnabled;
 
     return S_OK;
@@ -294 +294 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mEnabled != aEnabled)
+    if (mData->fEnabled != aEnabled)
     {
         mData.backup();
-        mData->mEnabled = aEnabled;
-        if (aEnabled && mData->mMACAddress.isEmpty())
+        mData->fEnabled = aEnabled;
+        if (aEnabled && mData->strMACAddress.isEmpty())
             i_generateMACAddress();
 
@@ -320 +320 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    ComAssertRet(!mData->mEnabled || !mData->mMACAddress.isEmpty(), E_FAIL);
-
-    aMACAddress = mData->mMACAddress;
+    ComAssertRet(!mData->fEnabled || !mData->strMACAddress.isEmpty(), E_FAIL);
+
+    aMACAddress = mData->strMACAddress;
 
     return S_OK;
@@ -334 +334 @@
      * Are we supposed to generate a MAC?
      */
-    if (mData->mEnabled && aMACAddress.isEmpty())
+    if (mData->fEnabled && aMACAddress.isEmpty())
         i_generateMACAddress();
     else
     {
-        if (mData->mMACAddress != aMACAddress)
+        if (mData->strMACAddress != aMACAddress)
         {
-            if (mData->mEnabled || !aMACAddress.isEmpty())
+            if (mData->fEnabled || !aMACAddress.isEmpty())
             {
                 /*
@@ -374 +374 @@
 
             if (SUCCEEDED(rc))
-                mData->mMACAddress = aMACAddress;
+                mData->strMACAddress = aMACAddress;
         }
     }
@@ -412 +412 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aAttachmentType = mData->mAttachmentType;
+    *aAttachmentType = mData->mode;
 
     return S_OK;
@@ -425 +425 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mAttachmentType != aAttachmentType)
+    if (mData->mode != aAttachmentType)
     {
         mData.backup();
 
         /* there must an internal network name */
-        if (mData->mInternalNetwork.isEmpty())
+        if (mData->strInternalNetworkName.isEmpty())
         {
             Log(("Internal network name not defined, setting to default \"intnet\"\n"));
-            mData->mInternalNetwork = "intnet";
+            mData->strInternalNetworkName = "intnet";
         }
 
         /* there must a NAT network name */
-        if (mData->mNATNetwork.isEmpty())
+        if (mData->strNATNetworkName.isEmpty())
         {
             Log(("NAT network name not defined, setting to default \"NatNetwork\"\n"));
-            mData->mNATNetwork = "NatNetwork";
+            mData->strNATNetworkName = "NatNetwork";
         }
 
-        NetworkAttachmentType_T oldAttachmentType = mData->mAttachmentType;
-        mData->mAttachmentType = aAttachmentType;
+        NetworkAttachmentType_T oldAttachmentType = mData->mode;
+        mData->mode = aAttachmentType;
 
         // leave the lock before informing callbacks
@@ -454 +454 @@
 
         if (oldAttachmentType == NetworkAttachmentType_NATNetwork)
-            i_checkAndSwitchFromNatNetworking(mData->mNATNetwork);
+            i_checkAndSwitchFromNatNetworking(mData->strNATNetworkName);
 
         if (aAttachmentType == NetworkAttachmentType_NATNetwork)
-            i_switchToNatNetworking(mData->mNATNetwork);
+            i_switchToNatNetworking(mData->strNATNetworkName);
 
         /* Adapt the CFGM logic and notify the guest => changeAdapter=TRUE. */
@@ -470 +470 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    aBridgedInterface = mData->mBridgedInterface;
+    aBridgedInterface = mData->strBridgedName;
 
     return S_OK;
@@ -483 +483 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mBridgedInterface != aBridgedInterface)
+    if (mData->strBridgedName != aBridgedInterface)
     {
         /* if an empty/null string is to be set, bridged interface must be
          * turned off */
         if (aBridgedInterface.isEmpty()
-            && mData->mAttachmentType == NetworkAttachmentType_Bridged)
+            && mData->mode == NetworkAttachmentType_Bridged)
         {
             return setError(E_FAIL,
@@ -495 +495 @@
 
         mData.backup();
-        mData->mBridgedInterface = aBridgedInterface;
+        mData->strBridgedName = aBridgedInterface;
 
         // leave the lock before informing callbacks
@@ -517 +517 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    aHostOnlyInterface = mData->mHostOnlyInterface;
+    aHostOnlyInterface = mData->strHostOnlyName;
 
     return S_OK;
@@ -530 +530 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mHostOnlyInterface != aHostOnlyInterface)
+    if (mData->strHostOnlyName != aHostOnlyInterface)
     {
         /* if an empty/null string is to be set, host only interface must be
          * turned off */
         if ( aHostOnlyInterface.isEmpty()
-             && mData->mAttachmentType == NetworkAttachmentType_HostOnly)
+             && mData->mode == NetworkAttachmentType_HostOnly)
         {
             return setError(E_FAIL,
@@ -542 +542 @@
 
         mData.backup();
-        mData->mHostOnlyInterface = aHostOnlyInterface;
+        mData->strHostOnlyName = aHostOnlyInterface;
 
         // leave the lock before informing callbacks
@@ -565 +565 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    aInternalNetwork = mData->mInternalNetwork;
+    aInternalNetwork = mData->strInternalNetworkName;
 
     return S_OK;
@@ -578 +578 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mInternalNetwork != aInternalNetwork)
+    if (mData->strInternalNetworkName != aInternalNetwork)
     {
         /* if an empty/null string is to be set, internal networking must be
          * turned off */
-        if (aInternalNetwork.isEmpty() && mData->mAttachmentType == NetworkAttachmentType_Internal)
+        if (aInternalNetwork.isEmpty() && mData->mode == NetworkAttachmentType_Internal)
         {
             return setError(E_FAIL,
@@ -588 +588 @@
         }
         mData.backup();
-        mData->mInternalNetwork = aInternalNetwork;
+        mData->strInternalNetworkName = aInternalNetwork;
 
         // leave the lock before informing callbacks
@@ -610 +610 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    aNATNetwork = mData->mNATNetwork;
+    aNATNetwork = mData->strNATNetworkName;
 
     return S_OK;
@@ -624 +624 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mNATNetwork != aNATNetwork)
+    if (mData->strNATNetworkName != aNATNetwork)
     {
         /* if an empty/null string is to be set, host only interface must be
          * turned off */
         if (aNATNetwork.isEmpty()
-            && mData->mAttachmentType == NetworkAttachmentType_NATNetwork)
+            && mData->mode == NetworkAttachmentType_NATNetwork)
             return setError(E_FAIL,
                             tr("Empty or null NAT network name is not valid"));
@@ -635 +635 @@
         mData.backup();
 
-        Bstr oldNatNetworkName = mData->mNATNetwork;
-        mData->mNATNetwork = aNATNetwork;
+        Bstr oldNatNetworkName = mData->strNATNetworkName;
+        mData->strNATNetworkName = aNATNetwork;
 
         // leave the lock before informing callbacks
@@ -660 +660 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    aGenericDriver = mData->mGenericDriver;
+    aGenericDriver = mData->strGenericDriver;
 
     return S_OK;
@@ -673 +673 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mGenericDriver != aGenericDriver)
+    if (mData->strGenericDriver != aGenericDriver)
     {
         mData.backup();
-        mData->mGenericDriver = aGenericDriver;
+        mData->strGenericDriver = aGenericDriver;
 
         /* leave the lock before informing callbacks */
@@ -692 +692 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aConnected = mData->mCableConnected;
+    *aConnected = mData->fCableConnected;
 
     return S_OK;
@@ -706 +706 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (aConnected != mData->mCableConnected)
+    if (aConnected != mData->fCableConnected)
     {
         mData.backup();
-        mData->mCableConnected = aConnected;
+        mData->fCableConnected = aConnected;
 
         // leave the lock before informing callbacks
@@ -730 +730 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aSpeed = mData->mLineSpeed;
+    *aSpeed = mData->ulLineSpeed;
 
     return S_OK;
@@ -743 +743 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (aSpeed != mData->mLineSpeed)
+    if (aSpeed != mData->ulLineSpeed)
     {
         mData.backup();
-        mData->mLineSpeed = aSpeed;
+        mData->ulLineSpeed = aSpeed;
 
         // leave the lock before informing callbacks
@@ -766 +766 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aPromiscModePolicy = mData->mPromiscModePolicy;
+    *aPromiscModePolicy = mData->enmPromiscModePolicy;
 
     return S_OK;
@@ -793 +793 @@
     {
         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        if (aPromiscModePolicy != mData->mPromiscModePolicy)
+        if (aPromiscModePolicy != mData->enmPromiscModePolicy)
         {
             mData.backup();
-            mData->mPromiscModePolicy = aPromiscModePolicy;
+            mData->enmPromiscModePolicy = aPromiscModePolicy;
 
             alock.release();
@@ -813 +813 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aEnabled = mData->mTraceEnabled;
+    *aEnabled = mData->fTraceEnabled;
 
     return S_OK;
@@ -826 +826 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (aEnabled != mData->mTraceEnabled)
+    if (aEnabled != mData->fTraceEnabled)
     {
         mData.backup();
-        mData->mTraceEnabled = aEnabled;
+        mData->fTraceEnabled = aEnabled;
 
         // leave the lock before informing callbacks
@@ -849 +849 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    aTraceFile = mData->mTraceFile;
+    aTraceFile = mData->strTraceFile;
 
     return S_OK;
@@ -863 +863 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mTraceFile != aTraceFile)
+    if (mData->strTraceFile != aTraceFile)
     {
         mData.backup();
-        mData->mTraceFile = aTraceFile;
+        mData->strTraceFile = aTraceFile;
 
         // leave the lock before informing callbacks
@@ -895 +895 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aBootPriority = mData->mBootPriority;
+    *aBootPriority = mData->ulBootPriority;
 
     return S_OK;
@@ -908 +908 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (aBootPriority != mData->mBootPriority)
+    if (aBootPriority != mData->ulBootPriority)
     {
         mData.backup();
-        mData->mBootPriority = aBootPriority;
+        mData->ulBootPriority = aBootPriority;
 
         // leave the lock before informing callbacks
@@ -934 +934 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     aValue = "";
-    settings::StringsMap::const_iterator it = mData->mGenericProperties.find(aKey);
-    if (it != mData->mGenericProperties.end())
+    settings::StringsMap::const_iterator it = mData->genericProperties.find(aKey);
+    if (it != mData->genericProperties.end())
         aValue = it->second; // source is a Utf8Str
 
@@ -948 +948 @@
     if (FAILED(adep.rc())) return adep.rc();
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    bool fGenericChange = (mData->mAttachmentType == NetworkAttachmentType_Generic);
+    bool fGenericChange = (mData->mode == NetworkAttachmentType_Generic);
     /* Generic properties processing.
      * Look up the old value first; if nothing's changed then do nothing.
      */
     Utf8Str strOldValue;
-    settings::StringsMap::const_iterator it = mData->mGenericProperties.find(aKey);
-    if (it != mData->mGenericProperties.end())
+    settings::StringsMap::const_iterator it = mData->genericProperties.find(aKey);
+    if (it != mData->genericProperties.end())
         strOldValue = it->second;
 
@@ -960 +960 @@
     {
         if (aValue.isEmpty())
-            mData->mGenericProperties.erase(aKey);
+            mData->genericProperties.erase(aKey);
         else
-            mData->mGenericProperties[aKey] = aValue;
+            mData->genericProperties[aKey] = aValue;
 
         /* leave the lock before informing callbacks */
@@ -989 +989 @@
     /// @todo make use of aNames according to the documentation
     NOREF(aNames);
-    aReturnNames.resize(mData->mGenericProperties.size());
-    aReturnValues.resize(mData->mGenericProperties.size());
+    aReturnNames.resize(mData->genericProperties.size());
+    aReturnValues.resize(mData->genericProperties.size());
 
     size_t i = 0;
 
-    for (settings::StringsMap::const_iterator it = mData->mGenericProperties.begin();
-         it != mData->mGenericProperties.end();
+    for (settings::StringsMap::const_iterator it = mData->genericProperties.begin();
+         it != mData->genericProperties.end();
          ++it, ++i)
     {
@@ -1039 +1039 @@
     HRESULT rc = S_OK;
 
-    mData->mAdapterType = data.type;
-    mData->mEnabled = data.fEnabled;
     /* MAC address (can be null) */
     rc = i_updateMacAddress(data.strMACAddress);
     if (FAILED(rc)) return rc;
-    /* cable (required) */
-    mData->mCableConnected = data.fCableConnected;
-    /* line speed (defaults to 100 Mbps) */
-    mData->mLineSpeed = data.ulLineSpeed;
-    mData->mPromiscModePolicy = data.enmPromiscModePolicy;
-    /* tracing (defaults to false) */
-    mData->mTraceEnabled = data.fTraceEnabled;
-    mData->mTraceFile = data.strTraceFile;
-    /* boot priority (defaults to 0, i.e. lowest) */
-    mData->mBootPriority = data.ulBootPriority;
-    /* bandwidth group */
-    mData->mBandwidthGroup = data.strBandwidthGroup;
-    if (mData->mBandwidthGroup.isNotEmpty())
+
+    mData.assignCopy(&data);
+
+    if (mData->strBandwidthGroup.isNotEmpty())
     {
         ComObjPtr<BandwidthGroup> group;
@@ -1064 +1053 @@
     }
 
+    // Load NAT engine settings.
     mNATEngine->i_loadSettings(data.nat);
-    mData->mBridgedInterface = data.strBridgedName;
-    mData->mInternalNetwork = data.strInternalNetworkName;
-    mData->mHostOnlyInterface = data.strHostOnlyName;
-    mData->mGenericDriver = data.strGenericDriver;
-    mData->mGenericProperties = data.genericProperties;
-    mData->mNATNetwork = data.strNATNetworkName;
 
     // leave the lock before setting attachment type
@@ -1097 +1081 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    data.fEnabled = !!mData->mEnabled;
-    data.strMACAddress = mData->mMACAddress;
-    data.fCableConnected = !!mData->mCableConnected;
-
-    data.enmPromiscModePolicy = mData->mPromiscModePolicy;
-    data.ulLineSpeed = mData->mLineSpeed;
-
-    data.fTraceEnabled = !!mData->mTraceEnabled;
-
-    data.strTraceFile = mData->mTraceFile;
-
-    data.ulBootPriority = mData->mBootPriority;
-
-    data.strBandwidthGroup = mData->mBandwidthGroup;
-
-    data.type = mData->mAdapterType;
-
-    data.mode = mData->mAttachmentType;
+    data = *mData.data();
 
     mNATEngine->i_saveSettings(data.nat);
-
-    data.strBridgedName = mData->mBridgedInterface;
-
-    data.strHostOnlyName = mData->mHostOnlyInterface;
-
-    data.strInternalNetworkName = mData->mInternalNetwork;
-
-    data.strGenericDriver = mData->mGenericDriver;
-    data.genericProperties = mData->mGenericProperties;
-
-    data.strNATNetworkName = mData->mNATNetwork;
 
     return S_OK;
@@ -1141 +1097 @@
 
     bool fChanged = mData.isBackedUp();
-    fChanged |= (mData->mAdapterType == NetworkAttachmentType_NAT? mNATEngine->i_isModified() : false);
+    fChanged |= (mData->type == NetworkAttachmentType_NAT? mNATEngine->i_isModified() : false);
     return fChanged;
 }
@@ -1217 +1173 @@
     /* this will back up current data */
     mData.assignCopy(aThat->mData);
+
 }
 
@@ -1241 +1198 @@
         defaultType == NetworkAdapterType_I82545EM)
     {
-        if (e1000enabled) mData->mAdapterType = defaultType;
-    }
-    else mData->mAdapterType = defaultType;
+        if (e1000enabled) mData->mode = defaultType;
+    }
+    else mData->mode = defaultType;
 
     /* Enable the first one adapter to the NAT */
-    if (mData->mSlot == 0)
-    {
-        mData->mEnabled = true;
-        if (mData->mMACAddress.isEmpty())
+    if (mData->ulSlot == 0)
+    {
+        mData->fEnabled = true;
+        if (mData->strMACAddress.isEmpty())
             i_generateMACAddress();
-        mData->mAttachmentType = NetworkAttachmentType_NAT;
-    }
-    mData->mCableConnected = true;
+        mData->type = NetworkAttachmentType_NAT;
+    }
+    mData->fCableConnected = true;
 }
 
@@ -1277 +1234 @@
     Host::i_generateMACAddress(mac);
     LogFlowThisFunc(("generated MAC: '%s'\n", mac.c_str()));
-    mData->mMACAddress = mac;
+    mData->strMACAddress = mac;
 }
 
@@ -1288 +1245 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mData->mBandwidthGroup.isNotEmpty())
+    if (mData->strBandwidthGroup.isNotEmpty())
     {
         ComObjPtr<BandwidthGroup> pBwGroup;
-        hrc = mParent->i_getBandwidthGroup(mData->mBandwidthGroup, pBwGroup, true /* fSetError */);
+        hrc = mParent->i_getBandwidthGroup(mData->strBandwidthGroup, pBwGroup, true /* fSetError */);
 
         Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence
@@ -1318 +1275 @@
         strBwGroup = static_cast<BandwidthGroup *>(iBw)->i_getName();
 
-    if (mData->mBandwidthGroup != strBwGroup)
+    if (mData->strBandwidthGroup != strBwGroup)
     {
         ComObjPtr<BandwidthGroup> pBwGroup;
@@ -1352 +1309 @@
 
     ComObjPtr<BandwidthGroup> pOldBwGroup;
-    if (!mData->mBandwidthGroup.isEmpty())
+    if (!mData->strBandwidthGroup.isEmpty())
         {
-            HRESULT hrc = mParent->i_getBandwidthGroup(mData->mBandwidthGroup, pOldBwGroup, false /* fSetError */);
+            HRESULT hrc = mParent->i_getBandwidthGroup(mData->strBandwidthGroup, pOldBwGroup, false /* fSetError */);
             NOREF(hrc);
             Assert(SUCCEEDED(hrc)); /* This is not allowed to fail because the existence of
@@ -1364 +1321 @@
     {
         pOldBwGroup->i_release();
-        mData->mBandwidthGroup = Utf8Str::Empty;
+        mData->strBandwidthGroup = Utf8Str::Empty;
     }
 
     if (aBwGroup)
     {
-        mData->mBandwidthGroup = aBwGroup->i_getName();
+        mData->strBandwidthGroup = aBwGroup->i_getName();
         aBwGroup->i_reference();
     }