Changeset 17275 in vbox

Timestamp:

Mar 3, 2009 1:28:12 PM (16 years ago)

Author:

vboxsync

Message:

networking API renaming

Location:

trunk/src/VBox

Files:

• Frontends/VBoxBFE/NetworkAdapterImpl.cpp (modified) (1 diff)
• Frontends/VBoxBFE/NetworkAdapterImpl.h (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageInfo.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageList.cpp (modified) (2 diffs)
• Frontends/VBoxManage/VBoxManageModifyVM.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/VBoxGlobal.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/VBoxVMSettingsNetwork.cpp (modified) (9 diffs)
• Main/ConsoleImpl.cpp (modified) (7 diffs)
• Main/ConsoleImpl2.cpp (modified) (6 diffs)
• Main/HostImpl.cpp (modified) (17 diffs)
• Main/HostNetworkInterfaceImpl.cpp (modified) (8 diffs)
• Main/NetworkAdapterImpl.cpp (modified) (6 diffs)
• Main/darwin/NetIfList-darwin.cpp (modified) (2 diffs)
• Main/idl/VirtualBox.xidl (modified) (12 diffs)
• Main/include/ConsoleImpl.h (modified) (1 diff)
• Main/include/HostImpl.h (modified) (2 diffs)
• Main/include/HostNetworkInterfaceImpl.h (modified) (4 diffs)
• Main/include/NetworkAdapterImpl.h (modified) (1 diff)
• Main/include/netif.h (modified) (1 diff)
• Main/linux/NetIfList-linux.cpp (modified) (2 diffs)
• Main/solaris/NetIfList-solaris.cpp (modified) (1 diff)
• Main/win/NetIfList-win.cpp (modified) (7 diffs)
• Main/win/svchlp.cpp (modified) (1 diff)
• Main/win/svchlp.h (modified) (1 diff)

trunk/src/VBox/Frontends/VBoxBFE/NetworkAdapterImpl.cpp

@@ -306 +306 @@
 }
 STDMETHODIMP
-NetworkAdapter::AttachToHostInterface()
+NetworkAdapter::AttachToBridgedNetwork()
 {
   AssertMsg(0,("Not implemented yet\n"));

trunk/src/VBox/Frontends/VBoxBFE/NetworkAdapterImpl.h

@@ -107 +107 @@
     // INetworkAdapter methods
     STDMETHOD(AttachToNAT)();
-    STDMETHOD(AttachToHostInterface)();
+    STDMETHOD(AttachToBridgedNetwork)();
     STDMETHOD(AttachToInternalNetwork)();
     STDMETHOD(Detach)();

trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

@@ -683 +683 @@
                         break;
                     }
-                    case NetworkAttachmentType_HostInterface:
+                    case NetworkAttachmentType_Bridged:
                     {
                         Bstr strHostIfDev;

trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

@@ -44 +44 @@
 
 #ifdef VBOX_WITH_HOSTNETIF_API
-static const char *getHostIfTypeText(HostNetworkInterfaceType_T enmType)
+static const char *getHostIfTypeText(HostNetworkInterfaceMediumType_T enmType)
 {
     switch (enmType)
     {
-        case HostNetworkInterfaceType_Ethernet: return "Ethernet";
-        case HostNetworkInterfaceType_PPP: return "PPP";
-        case HostNetworkInterfaceType_SLIP: return "SLIP";
+        case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet";
+        case HostNetworkInterfaceMediumType_PPP: return "PPP";
+        case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
     }
     return "Unknown";
@@ -326 +326 @@
                 networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam());
                 RTPrintf("HardwareAddress: %lS\n", HardwareAddress.raw());
-                HostNetworkInterfaceType_T Type;
-                networkInterface->COMGETTER(Type)(&Type);
+                HostNetworkInterfaceMediumType_T Type;
+                networkInterface->COMGETTER(MediumType)(&Type);
                 RTPrintf("Type:            %s\n", getHostIfTypeText(Type));
                 HostNetworkInterfaceStatus_T Status;

trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

@@ -1384 +1384 @@
                 {
                     CHECK_ERROR_RET(nic, COMSETTER(Enabled) (TRUE), 1);
-                    CHECK_ERROR_RET(nic, AttachToHostInterface(), 1);
+                    CHECK_ERROR_RET(nic, AttachToBridgedNetwork(), 1);
                 }
                 else if (strcmp(nics[n], "intnet") == 0)
@@ -1391 +1391 @@
                     CHECK_ERROR_RET(nic, AttachToInternalNetwork(), 1);
                 }
-#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN)
+#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || (defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT))
                 else if (strcmp(nics[n], "hostonly") == 0)
                 {
                     CHECK_ERROR_RET(nic, COMSETTER(Enabled) (TRUE), 1);
-                    CHECK_ERROR_RET(nic, AttachToHostOnlyNetwork(), 1);
+                    CHECK_ERROR_RET(nic, AttachToHostOnlyInterface(), 1);
                 }
 #endif /* defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) */

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobal.cpp

@@ -2399 +2399 @@
                      * an additional symbolic network/interface name field, use
                      * this name instead */
-                    if (type == KNetworkAttachmentType_HostInterface)
+                    if (type == KNetworkAttachmentType_Bridged)
                         attType = attType.arg (tr ("host interface, %1",
                             "details report (network)").arg (adapter.GetHostInterface()));
@@ -3418 +3418 @@
     mNetworkAttachmentTypes [KNetworkAttachmentType_NAT] =
         tr ("NAT", "NetworkAttachmentType");
-    mNetworkAttachmentTypes [KNetworkAttachmentType_HostInterface] =
-        tr ("Host Interface", "NetworkAttachmentType");
+    mNetworkAttachmentTypes [KNetworkAttachmentType_Bridged] =
+        tr ("Bridged Interface", "NetworkAttachmentType");
     mNetworkAttachmentTypes [KNetworkAttachmentType_Internal] =
         tr ("Internal Network", "NetworkAttachmentType");

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMSettingsNetwork.cpp

@@ -130 +130 @@
             mAdapter.AttachToNAT();
             break;
-        case KNetworkAttachmentType_HostInterface:
-            mAdapter.AttachToHostInterface();
+        case KNetworkAttachmentType_Bridged:
+            mAdapter.AttachToBridgedNetwork();
             break;
         case KNetworkAttachmentType_Internal:
@@ -148 +148 @@
     mAdapter.SetCableConnected (mCbCable->isChecked());
 
-    if (type == KNetworkAttachmentType_HostInterface
+    if (type == KNetworkAttachmentType_Bridged
 #if defined (Q_WS_WIN) && defined (VBOX_WITH_NETFLT)
             || type == KNetworkAttachmentType_HostOnly
@@ -257 +257 @@
 #if defined (Q_WS_X11) && !defined (VBOX_WITH_NETFLT)
     bool enableHostIf = vboxGlobal().toNetworkAttachmentType (aString) ==
-                        KNetworkAttachmentType_HostInterface;
+                        KNetworkAttachmentType_Bridged;
     setTapEnabled (enableHostIf);
 #endif
@@ -312 +312 @@
         mCbNAType->itemText(1), Qt::ToolTipRole);
     mCbNAType->insertItem (2,
-        vboxGlobal().toString (KNetworkAttachmentType_HostInterface));
+        vboxGlobal().toString (KNetworkAttachmentType_Bridged));
     mCbNAType->setItemData (2,
         mCbNAType->itemText(2), Qt::ToolTipRole);
@@ -555 +555 @@
     CHost host = vboxGlobal().virtualBox().GetHost();
     CHostNetworkInterface iFace;
-    CProgress progress = host.CreateHostNetworkInterface (iName, iFace);
+    CProgress progress = host.CreateHostOnlyNetworkInterface (iName, iFace);
     if (host.isOk())
     {
@@ -614 +614 @@
     {
         /* Delete interface */
-        CProgress progress = host.RemoveHostNetworkInterface (iFace.GetId(), iFace);
+        CProgress progress = host.RemoveHostOnlyNetworkInterface (iFace.GetId(), iFace);
         if (host.isOk())
         {
@@ -673 +673 @@
 #if defined(Q_WS_WIN) && defined(VBOX_WITH_NETFLT)
         /* display real for not host-only and viceversa */
-        if((enmAttachmentType == KNetworkAttachmentType_HostOnly) != it->GetReal())
+        if((enmAttachmentType == KNetworkAttachmentType_HostOnly)
+                == (it->GetInterfaceType() == KHostNetworkInterfaceType_HostOnly))
 #endif
             itemsList << new VBoxNIListItem (it->GetName());
@@ -807 +808 @@
 
 #if defined (Q_WS_WIN) || defined (VBOX_WITH_NETFLT)
-        if ((type == KNetworkAttachmentType_HostInterface
+        if ((type == KNetworkAttachmentType_Bridged
 #if defined (Q_WS_WIN) && defined (VBOX_WITH_NETFLT)
                 || type == KNetworkAttachmentType_HostOnly
@@ -885 +886 @@
     KNetworkAttachmentType enmType = vboxGlobal().toNetworkAttachmentType (page->mCbNAType->currentText());
 
-    bool isHostInterfaceAttached = enmType == KNetworkAttachmentType_HostInterface;
+    bool isHostInterfaceAttached = enmType == KNetworkAttachmentType_Bridged;
 
     mNIList->setEnabled (isHostInterfaceAttached);

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -4239 +4239 @@
         switch (netattach)
         {
-            case NetworkAttachmentType_HostInterface:
+            case NetworkAttachmentType_Bridged:
             {
 #ifdef RT_OS_WINDOWS
@@ -5657 +5657 @@
  *  @note The caller must lock this object for writing.
  */
-HRESULT Console::attachToHostInterface(INetworkAdapter *networkAdapter)
+HRESULT Console::attachToBridgedInterface(INetworkAdapter *networkAdapter)
 {
 #if !defined(RT_OS_LINUX) || defined(VBOX_WITH_NETFLT)
@@ -5679 +5679 @@
     NetworkAttachmentType_T attachment;
     networkAdapter->COMGETTER(AttachmentType)(&attachment);
-    Assert(attachment == NetworkAttachmentType_HostInterface);
+    Assert(attachment == NetworkAttachmentType_Bridged);
 # endif /* VBOX_STRICT */
 
@@ -5735 +5735 @@
             if (fcntl(maTapFD[slot], F_SETFL, O_NONBLOCK) != -1)
             {
-                Log(("attachToHostInterface: %RTfile %ls\n", maTapFD[slot], tapDeviceName.raw()));
+                Log(("attachToBridgedInterface: %RTfile %ls\n", maTapFD[slot], tapDeviceName.raw()));
                 /*
                  * Here is the right place to communicate the TAP file descriptor and
@@ -5788 +5788 @@
  *  @note The caller must lock this object for writing.
  */
-HRESULT Console::detachFromHostInterface(INetworkAdapter *networkAdapter)
+HRESULT Console::detachFromBridgedInterface(INetworkAdapter *networkAdapter)
 {
 #if !defined(RT_OS_LINUX) || defined(VBOX_WITH_NETFLT)
@@ -5808 +5808 @@
     NetworkAttachmentType_T attachment;
     networkAdapter->COMGETTER(AttachmentType)(&attachment);
-    Assert(attachment == NetworkAttachmentType_HostInterface);
+    Assert(attachment == NetworkAttachmentType_Bridged);
 # endif /* VBOX_STRICT */
 
@@ -5880 +5880 @@
         NetworkAttachmentType_T attachment;
         networkAdapter->COMGETTER(AttachmentType)(&attachment);
-        if (attachment == NetworkAttachmentType_HostInterface)
-        {
-            HRESULT rc2 = detachFromHostInterface(networkAdapter);
+        if (attachment == NetworkAttachmentType_Bridged)
+        {
+            HRESULT rc2 = detachFromBridgedInterface(networkAdapter);
             if (FAILED(rc2) && SUCCEEDED(rc))
                 rc = rc2;

trunk/src/VBox/Main/ConsoleImpl2.cpp

@@ -1292 +1292 @@
             }
 
-            case NetworkAttachmentType_HostInterface:
+            case NetworkAttachmentType_Bridged:
             {
                 /*
                  * Perform the attachment if required (don't return on error!)
                  */
-                hrc = pConsole->attachToHostInterface(networkAdapter);
+                hrc = pConsole->attachToBridgedInterface(networkAdapter);
                 if (SUCCEEDED(hrc))
                 {
@@ -1333 +1333 @@
                     if(FAILED(hrc))
                     {
-                        LogRel(("NetworkAttachmentType_HostInterface: COMGETTER(HostInterface) failed, hrc (0x%x)", hrc));
+                        LogRel(("NetworkAttachmentType_Bridged: COMGETTER(HostInterface) failed, hrc (0x%x)", hrc));
                         H();
                     }
@@ -1382 +1382 @@
                     {
                         AssertBreakpoint();
-                        LogRel(("NetworkAttachmentType_HostInterface: FindByName failed, rc (0x%x)", rc));
+                        LogRel(("NetworkAttachmentType_Bridged: FindByName failed, rc (0x%x)", rc));
                         return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
                                           N_("Inexistent host networking interface, name '%ls'"),
@@ -1388 +1388 @@
                     }
 
-                    BOOL real;
-                    hrc = hostInterface->COMGETTER(Real)(&real);
+                    HostNetworkInterfaceType_T ifType;
+                    hrc = hostInterface->COMGETTER(InterfaceType)(&ifType);
                     if(FAILED(hrc))
                     {
-                        LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(Real) failed, hrc (0x%x)", hrc));
+                        LogRel(("NetworkAttachmentType_Bridged: COMGETTER(InterfaceType) failed, hrc (0x%x)", hrc));
                         H();
                     }
 
-                    if(!real)
-                    {
-                        LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(Real) failed, hrc (0x%x)", hrc));
+                    if(ifType != HostNetworkInterfaceType_Bridged)
+                    {
                         return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
-                                                              N_("Interface ('%ls') is a Host Adapter interface"),
+                                                              N_("Interface ('%ls') is not a Bridged Adapter interface"),
                                                               HifName.raw());
                     }
@@ -1408 +1407 @@
                     if(FAILED(hrc))
                     {
-                        LogRel(("NetworkAttachmentType_HostInterface: COMGETTER(Id) failed, hrc (0x%x)", hrc));
+                        LogRel(("NetworkAttachmentType_Bridged: COMGETTER(Id) failed, hrc (0x%x)", hrc));
                         H();
                     }
@@ -1691 +1690 @@
                 }
 
-                BOOL real;
-                hrc = hostInterface->COMGETTER(Real)(&real);
+                HostNetworkInterfaceType_T ifType;
+                hrc = hostInterface->COMGETTER(InterfaceType)(&ifType);
                 if(FAILED(hrc))
                 {
-                    LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(Real) failed, hrc (0x%x)", hrc));
+                    LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(InterfaceType) failed, hrc (0x%x)", hrc));
                     H();
                 }
 
-                if(real)
+                if(ifType != HostNetworkInterfaceType_HostOnly)
                 {
-                    LogRel(("NetworkAttachmentType_HostOnly: COMGETTER(Real) failed, hrc (0x%x)", hrc));
                     return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
-                                                          N_("Interface ('%ls') is not a Host Adapter interface"),
+                                                          N_("Interface ('%ls') is not a Host-Only Adapter interface"),
                                                           HifName.raw());
                 }
+
 
                 Guid hostIFGuid;

trunk/src/VBox/Main/HostImpl.cpp

@@ -610 +610 @@
     ComObjPtr<HostNetworkInterface> IfObj;
     IfObj.createObject();
-    if (SUCCEEDED(IfObj->init(Bstr(szNICDesc), Guid(Uuid), true)))
+    if (SUCCEEDED(IfObj->init(Bstr(szNICDesc), Guid(Uuid), HostNetworkInterfaceType_Bridged)))
         pList->push_back(IfObj);
 }
@@ -725 +725 @@
             iface.createObject();
             /* remove the curly bracket at the end */
-            if (SUCCEEDED (iface->init (name, Guid (IfGuid), true)))
+            if (SUCCEEDED (iface->init (name, Guid (IfGuid), HostNetworkInterfaceType_Bridged)))
             {
                 pPist->push_back (iface);
@@ -771 +771 @@
         ComObjPtr<HostNetworkInterface> IfObj;
         IfObj.createObject();
-        if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), Guid(pEtherNICs->Uuid), true)))
+        if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), Guid(pEtherNICs->Uuid), HostNetworkInterfaceType_Bridged)))
             list.push_back(IfObj);
 
@@ -926 +926 @@
                     /* remove the curly bracket at the end */
                     szNetworkGUID [strlen(szNetworkGUID) - 1] = '\0';
-                    if (SUCCEEDED (iface->init (name, Guid (szNetworkGUID + 1), true)))
+                    if (SUCCEEDED (iface->init (name, Guid (szNetworkGUID + 1), HostNetworkInterfaceType_Bridged)))
                         list.push_back (iface);
                 }
@@ -1052 +1052 @@
                         ComObjPtr<HostNetworkInterface> IfObj;
                         IfObj.createObject();
-                        if (SUCCEEDED(IfObj->init(Bstr(pReq->ifr_name), Guid(uuid), true)))
+                        if (SUCCEEDED(IfObj->init(Bstr(pReq->ifr_name), Guid(uuid), HostNetworkInterfaceType_Bridged)))
                             list.push_back(IfObj);
                     }
@@ -1359 +1359 @@
 {
     SVCHlpMsg::Code msgCode;
-    /* for SVCHlpMsg::CreateHostNetworkInterface */
+    /* for SVCHlpMsg::CreateHostOnlyNetworkInterface */
     Bstr name;
     ComObjPtr <HostNetworkInterface> iface;
-    /* for SVCHlpMsg::RemoveHostNetworkInterface */
+    /* for SVCHlpMsg::RemoveHostOnlyNetworkInterface */
     Guid guid;
 };
 
 STDMETHODIMP
-Host::CreateHostNetworkInterface (IN_BSTR aName,
+Host::CreateHostOnlyNetworkInterface (IN_BSTR aName,
                                   IHostNetworkInterface **aHostNetworkInterface,
                                   IProgress **aProgress)
@@ -1407 +1407 @@
     AssertReturn (d.get(), E_OUTOFMEMORY);
 
-    d->msgCode = SVCHlpMsg::CreateHostNetworkInterface;
+    d->msgCode = SVCHlpMsg::CreateHostOnlyNetworkInterface;
     d->name = aName;
     d->iface = iface;
@@ -1427 +1427 @@
 
 STDMETHODIMP
-Host::RemoveHostNetworkInterface (IN_GUID aId,
+Host::RemoveHostOnlyNetworkInterface (IN_GUID aId,
                                   IHostNetworkInterface **aHostNetworkInterface,
                                   IProgress **aProgress)
@@ -1465 +1465 @@
     AssertReturn (d.get(), E_OUTOFMEMORY);
 
-    d->msgCode = SVCHlpMsg::RemoveHostNetworkInterface;
+    d->msgCode = SVCHlpMsg::RemoveHostOnlyNetworkInterface;
     d->guid = aId;
 
@@ -3005 +3005 @@
     switch (d->msgCode)
     {
-        case SVCHlpMsg::CreateHostNetworkInterface:
-        {
-            LogFlowFunc (("CreateHostNetworkInterface:\n"));
+        case SVCHlpMsg::CreateHostOnlyNetworkInterface:
+        {
+            LogFlowFunc (("CreateHostOnlyNetworkInterface:\n"));
             LogFlowFunc (("Network connection name = '%ls'\n", d->name.raw()));
 
@@ -3027 +3027 @@
                 switch (reply)
                 {
-                    case SVCHlpMsg::CreateHostNetworkInterface_OK:
+                    case SVCHlpMsg::CreateHostOnlyNetworkInterface_OK:
                     {
                         /* read the GUID */
@@ -3037 +3037 @@
 
                         /* initialize the object returned to the caller by
-                         * CreateHostNetworkInterface() */
-                        rc = d->iface->init (d->name, guid, false);
+                         * CreateHostOnlyNetworkInterface() */
+                        rc = d->iface->init (d->name, guid, HostNetworkInterfaceType_HostOnly);
                         endLoop = true;
                         break;
@@ -3066 +3066 @@
             break;
         }
-        case SVCHlpMsg::RemoveHostNetworkInterface:
-        {
-            LogFlowFunc (("RemoveHostNetworkInterface:\n"));
+        case SVCHlpMsg::RemoveHostOnlyNetworkInterface:
+        {
+            LogFlowFunc (("RemoveHostOnlyNetworkInterface:\n"));
             LogFlowFunc (("Network connection GUID = {%RTuuid}\n", d->guid.raw()));
 
@@ -3147 +3147 @@
     switch (aMsgCode)
     {
-        case SVCHlpMsg::CreateHostNetworkInterface:
-        {
-            LogFlowFunc (("CreateHostNetworkInterface:\n"));
+        case SVCHlpMsg::CreateHostOnlyNetworkInterface:
+        {
+            LogFlowFunc (("CreateHostOnlyNetworkInterface:\n"));
 
             Utf8Str name;
@@ -3162 +3162 @@
             {
                 /* write success followed by GUID */
-                vrc = aClient->write (SVCHlpMsg::CreateHostNetworkInterface_OK);
+                vrc = aClient->write (SVCHlpMsg::CreateHostOnlyNetworkInterface_OK);
                 if (RT_FAILURE (vrc)) break;
                 vrc = aClient->write (guid);
@@ -3180 +3180 @@
             break;
         }
-        case SVCHlpMsg::RemoveHostNetworkInterface:
-        {
-            LogFlowFunc (("RemoveHostNetworkInterface:\n"));
+        case SVCHlpMsg::RemoveHostOnlyNetworkInterface:
+        {
+            LogFlowFunc (("RemoveHostOnlyNetworkInterface:\n"));
 
             Guid guid;
@@ -3459 +3459 @@
 }
 
+STDMETHODIMP Host::FindHostNetworkInterfacesOfType(HostNetworkInterfaceType type, ComSafeArrayOut (IHostNetworkInterface *, aNetworkInterfaces))
+{
+    com::SafeIfaceArray <IHostNetworkInterface> hostNetworkInterfaces;
+    HRESULT hr = COMGETTER(NetworkInterfaces) (ComSafeArrayAsOutParam (hostNetworkInterfaces));
+    if(FAILED(hr))
+    {
+        return hr;
+    }
+
+    std::list <ComObjPtr <IHostNetworkInterface> > list;
+
+    for (size_t i = 0; i < hostNetworkInterfaces.size(); ++i)
+    {
+        IHostNetworkInterface * networkInterface = hostNetworkInterfaces[i];
+        HostNetworkInterfaceType t;
+        hr = networkInterface->COMGETTER(InterfaceType)(&t);
+        if(FAILED(hr))
+        {
+            return hr;
+        }
+
+        if(t == type)
+        {
+            list.push_back (networkInterface);
+        }
+    }
+
+    SafeIfaceArray <IHostNetworkInterface> filteredNetworkInterfaces (list);
+    filteredNetworkInterfaces.detachTo (ComSafeArrayOutArg (aNetworkInterfaces));
+
+    return S_OK;
+}
+
+
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

trunk/src/VBox/Main/HostNetworkInterfaceImpl.cpp

@@ -51 +51 @@
  * @param   aGuid GUID of the host network interface
  */
-HRESULT HostNetworkInterface::init (Bstr aInterfaceName, Guid aGuid, BOOL aReal)
+HRESULT HostNetworkInterface::init (Bstr aInterfaceName, Guid aGuid, HostNetworkInterfaceType_T ifType)
 {
     LogFlowThisFunc (("aInterfaceName={%ls}, aGuid={%s}\n",
@@ -65 +65 @@
     unconst (mInterfaceName) = aInterfaceName;
     unconst (mGuid) = aGuid;
-    mReal = aReal;
+    mIfType = ifType;
 
 
@@ -112 +112 @@
  * @param   aGuid GUID of the host network interface
  */
-HRESULT HostNetworkInterface::init (Bstr aInterfaceName, BOOL aReal, PNETIFINFO pIf)
+HRESULT HostNetworkInterface::init (Bstr aInterfaceName, HostNetworkInterfaceType_T ifType, PNETIFINFO pIf)
 {
 //    LogFlowThisFunc (("aInterfaceName={%ls}, aGuid={%s}\n",
@@ -127 +127 @@
     unconst (mInterfaceName) = aInterfaceName;
     unconst (mGuid) = pIf->Uuid;
-    mReal = aReal;
+    mIfType = ifType;
 
     m.IPAddress = pIf->IPAddress.u;
@@ -135 +135 @@
     m.hardwareAddress = composeHardwareAddress(&pIf->MACAddress);
 #ifdef RT_OS_WINDOWS
-    m.type = (HostNetworkInterfaceType)pIf->enmType;
+    m.mediumType = (HostNetworkInterfaceMediumType)pIf->enmMediumType;
     m.status = (HostNetworkInterfaceStatus)pIf->enmStatus;
 #else /* !RT_OS_WINDOWS */
@@ -285 +285 @@
  * @param   aType address of result pointer
  */
-STDMETHODIMP HostNetworkInterface::COMGETTER(Type) (HostNetworkInterfaceType_T *aType)
+STDMETHODIMP HostNetworkInterface::COMGETTER(MediumType) (HostNetworkInterfaceMediumType_T *aType)
 {
     CheckComArgOutPointerValid(aType);
@@ -292 +292 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    *aType = m.type;
+    *aType = m.mediumType;
 
     return S_OK;
@@ -316 +316 @@
 
 /**
- * Returns true if this is a "real" adapter, false if this is  a Virtualbox Host Adapter
- *
- * @returns COM status code
- * @param   aReal address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(Real) (BOOL *aReal)
-{
-    CheckComArgOutPointerValid(aReal);
-
-    AutoCaller autoCaller (this);
-    CheckComRCReturnRC (autoCaller.rc());
-
-    *aReal = mReal;
+ * Returns network interface type
+ *
+ * @returns COM status code
+ * @param   aType address of result pointer
+ */
+STDMETHODIMP HostNetworkInterface::COMGETTER(InterfaceType) (HostNetworkInterfaceType_T *aType)
+{
+    CheckComArgOutPointerValid(aType);
+
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    *aType = mIfType;
 
     return S_OK;

trunk/src/VBox/Main/NetworkAdapterImpl.cpp

@@ -713 +713 @@
 }
 
-STDMETHODIMP NetworkAdapter::AttachToHostInterface()
+STDMETHODIMP NetworkAdapter::AttachToBridgedNetwork()
 {
     AutoCaller autoCaller (this);
@@ -725 +725 @@
 
     /* don't do anything if we're already host interface attached */
-    if (mData->mAttachmentType != NetworkAttachmentType_HostInterface)
+    if (mData->mAttachmentType != NetworkAttachmentType_Bridged)
     {
         mData.backup();
@@ -732 +732 @@
         detach();
 
-        mData->mAttachmentType = NetworkAttachmentType_HostInterface;
+        mData->mAttachmentType = NetworkAttachmentType_Bridged;
 
         /* leave the lock before informing callbacks */
@@ -925 +925 @@
         CheckComRCReturnRC (rc);
 
-        rc = AttachToHostInterface();
+        rc = AttachToBridgedNetwork();
         CheckComRCReturnRC (rc);
     }
@@ -1034 +1034 @@
             break;
         }
-        case NetworkAttachmentType_HostInterface:
+        case NetworkAttachmentType_Bridged:
         {
             Key attachmentNode = aAdapterNode.createKey ("HostInterface");
@@ -1200 +1200 @@
             break;
         }
-        case NetworkAttachmentType_HostInterface:
+        case NetworkAttachmentType_Bridged:
         {
             /* reset handle and device name */

trunk/src/VBox/Main/darwin/NetIfList-darwin.cpp

@@ -68 +68 @@
         PNETIFINFO pNew = (PNETIFINFO)RTMemAllocZ(RT_OFFSETOF(NETIFINFO, szName[cbNameLen]));
         pNew->MACAddress = pEtherNICs->Mac;
-        pNew->enmType = NETIF_T_ETHERNET;
+        pNew->enmMediumType = NETIF_T_ETHERNET;
         pNew->Uuid = pEtherNICs->Uuid;
         Assert(sizeof(pNew->szShortName) > sizeof(pEtherNICs->szBSDName));
@@ -126 +126 @@
         ComObjPtr<HostNetworkInterface> IfObj;
         IfObj.createObject();
-        if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), TRUE, pNew)))
+        if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), HostNetworkInterfaceType_Bridged, pNew)))
             list.push_back(IfObj);
         RTMemFree(pNew);

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

@@ -6364 +6364 @@
 
   <enum
-    name="HostNetworkInterfaceType"
-    uuid="763754FA-3246-4539-9590-9E603EDBF706"
+    name="HostNetworkInterfaceMediumType"
+    uuid="1aa54aaf-2497-45a2-bfb1-8eb225e93d5b"
   >
     <desc>
@@ -6421 +6421 @@
   </enum>
 
+  <enum
+    name="HostNetworkInterfaceType"
+    uuid="4cd97025-b31b-430b-98dd-211e85cf389f"
+  >
+    <desc>
+      Network interface type.
+    </desc>
+    <const name="Bridged"               value="1"/>
+    <const name="HostOnly"              value="2"/>
+  </enum>
+
   <interface
      name="IHostNetworkInterface" extends="$unknown"
-     uuid="4fc2445f-fb73-4f55-b3b4-ecee47c7077b"
+     uuid="c312bf73-b353-4add-9db7-481b891ec08c"
      wsmap="managed"
      >
@@ -6460 +6471 @@
     </attribute>
 
-    <attribute name="type" type="HostNetworkInterfaceType" readonly="yes">
+    <attribute name="mediumType" type="HostNetworkInterfaceMediumType" readonly="yes">
       <desc>Type of protocol encapsulation used.</desc>
     </attribute>
@@ -6468 +6479 @@
     </attribute>
 
-    <attribute name="real" type="boolean" readonly="yes">
-      <desc>True if this is a real interface false
-      if this is a Virtualbox Host Adapter interface.</desc>
+    <attribute name="interfaceType" type="HostNetworkInterfaceType" readonly="yes">
+      <desc>specifies the host interface type.</desc>
     </attribute>
   </interface>
@@ -6476 +6486 @@
   <interface
      name="IHost" extends="$unknown"
-     uuid="234a43b3-66a5-4f15-a2a5-c46dbf4c4508"
+     uuid="96128709-69b5-43cc-9393-b3895f3b866a"
      wsmap="managed"
      >
@@ -6624 +6634 @@
 
 <if target="midl">
-    <method name="createHostNetworkInterface">
-      <desc>
-        Creates a new adapter for Host Interface Networking.
+    <method name="createHostOnlyNetworkInterface">
+      <desc>
+        Creates a new adapter for Host Only Networking.
         <result name="E_INVALIDARG">
           Host network interface @a name already exists.
@@ -6647 +6657 @@
       </param>
     </method>
-    <method name="removeHostNetworkInterface">
-      <desc>
-        Removes the given host network interface.
+    <method name="removeHostOnlyNetworkInterface">
+      <desc>
+        Removes the given Host Only Networking interface.
         <result name="VBOX_E_OBJECT_NOT_FOUND">
           No host network interface matching @a id found.
@@ -6830 +6840 @@
       <param name="networkInterface" type="IHostNetworkInterface" dir="return">
         <desc>Found host network interface object.</desc>
+      </param>
+    </method>
+    <method name="findHostNetworkInterfacesOfType">
+      <desc>
+        Searches through all host network interfaces and returns a list of interfaces of the specified type
+      </desc>
+      <param name="type" type="HostNetworkInterfaceType" dir="in">
+        <desc>type of the host network interfaces to search for.</desc>
+      </param>
+      <param name="networkInterfaces" type="IHostNetworkInterface" safearray="yes" dir="return">
+        <desc>Found host network interface objects.</desc>
       </param>
     </method>
@@ -10290 +10311 @@
   <enum
     name="NetworkAttachmentType"
-    uuid="64e770dc-dd1d-4879-9f12-5bd6bc879b78"
+    uuid="44bce1ee-99f7-4e8e-89fc-80597fd9eeaf"
   >
     <desc>
@@ -10300 +10321 @@
     </const>
     <const name="NAT"                   value="1"/>
-    <const name="HostInterface"         value="2"/>
+    <const name="Bridged"               value="2"/>
     <const name="Internal"              value="3"/>
     <const name="HostOnly"              value="4"/>
@@ -10324 +10345 @@
   <interface
      name="INetworkAdapter" extends="$unknown"
-     uuid="4a1ee64e-6c5f-47dd-acfa-f834d7cb74fb"
+     uuid="8eca30de-a883-40ee-b856-aac86f1ec383"
      wsmap="managed"
      >
@@ -10412 +10433 @@
     </method>
 
-    <method name="attachToHostInterface">
-      <desc>
-        Attach the network adapter to a host interface.
+    <method name="attachToBridgedNetwork">
+      <desc>
+        Attach the network adapter to a bridged host interface.
       </desc>
     </method>

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

@@ -403 +403 @@
     HRESULT callTapSetupApplication(bool isStatic, RTFILE tapFD, Bstr &tapDevice,
                                     Bstr &tapSetupApplication);
-    HRESULT attachToHostInterface(INetworkAdapter *networkAdapter);
-    HRESULT detachFromHostInterface(INetworkAdapter *networkAdapter);
+    HRESULT attachToBridgedInterface(INetworkAdapter *networkAdapter);
+    HRESULT detachFromBridgedInterface(INetworkAdapter *networkAdapter);
     HRESULT powerDownHostInterfaces();
 

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

@@ -100 +100 @@
 #ifdef RT_OS_WINDOWS
 
-    STDMETHOD(CreateHostNetworkInterface) (IN_BSTR aName,
+    STDMETHOD(CreateHostOnlyNetworkInterface) (IN_BSTR aName,
                                            IHostNetworkInterface **aHostNetworkInterface,
                                            IProgress **aProgress);
-    STDMETHOD(RemoveHostNetworkInterface) (IN_GUID aId,
+    STDMETHOD(RemoveHostOnlyNetworkInterface) (IN_GUID aId,
                                            IHostNetworkInterface **aHostNetworkInterface,
                                            IProgress **aProgress);
@@ -115 +115 @@
     STDMETHOD(FindHostNetworkInterfaceByName) (IN_BSTR aName, IHostNetworkInterface **networkInterface);
     STDMETHOD(FindHostNetworkInterfaceById) (IN_GUID id, IHostNetworkInterface **networkInterface);
+    STDMETHOD(FindHostNetworkInterfacesOfType) (HostNetworkInterfaceType type, ComSafeArrayOut (IHostNetworkInterface *, aNetworkInterfaces));
 
     // public methods only for internal purposes

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

@@ -60 +60 @@
 
     // public initializer/uninitializer for internal purposes only
-    HRESULT init (Bstr interfaceName, Guid guid, BOOL aReal);
+    HRESULT init (Bstr interfaceName, Guid guid, HostNetworkInterfaceType_T ifType);
 #ifdef VBOX_WITH_HOSTNETIF_API
-    HRESULT init (Bstr aInterfaceName, BOOL aReal, struct NETIFINFO *pIfs);
+    HRESULT init (Bstr aInterfaceName, HostNetworkInterfaceType_T ifType, struct NETIFINFO *pIfs);
 #endif
 
@@ -73 +73 @@
     STDMETHOD(COMGETTER(IPV6NetworkMask)) (BSTR *aIPV6Mask);
     STDMETHOD(COMGETTER(HardwareAddress)) (BSTR *aHardwareAddress);
-    STDMETHOD(COMGETTER(Type)) (HostNetworkInterfaceType_T *aType);
+    STDMETHOD(COMGETTER(MediumType)) (HostNetworkInterfaceMediumType_T *aType);
     STDMETHOD(COMGETTER(Status)) (HostNetworkInterfaceStatus_T *aStatus);
-    STDMETHOD(COMGETTER(Real)) (BOOL *aReal);
+    STDMETHOD(COMGETTER(InterfaceType)) (HostNetworkInterfaceType_T *aType);
 
     // for VirtualBoxSupportErrorInfoImpl
@@ -83 +83 @@
     const Bstr mInterfaceName;
     const Guid mGuid;
-    BOOL mReal;
+    HostNetworkInterfaceType_T mIfType;
 
     struct Data
     {
         Data() : IPAddress (0), networkMask (0),
-            type (HostNetworkInterfaceType_Unknown),
+            mediumType (HostNetworkInterfaceMediumType_Unknown),
             status(HostNetworkInterfaceStatus_Down){}
 
@@ -96 +96 @@
         Bstr IPV6NetworkMask;
         Bstr hardwareAddress;
-        HostNetworkInterfaceType_T type;
+        HostNetworkInterfaceMediumType_T mediumType;
         HostNetworkInterfaceStatus_T status;
     } m;

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

@@ -127 +127 @@
     // INetworkAdapter methods
     STDMETHOD(AttachToNAT)();
-    STDMETHOD(AttachToHostInterface)();
+    STDMETHOD(AttachToBridgedNetwork)();
     STDMETHOD(AttachToInternalNetwork)();
     STDMETHOD(AttachToHostOnlyNetwork)();

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

@@ -62 +62 @@
     RTNETADDRIPV6  IPv6NetMask;
     RTMAC          MACAddress;
-    NETIFTYPE      enmType;
+    NETIFTYPE      enmMediumType;
     NETIFSTATUS    enmStatus;
     RTUUID         Uuid;

trunk/src/VBox/Main/linux/NetIfList-linux.cpp

@@ -52 +52 @@
         {
             case ARPHRD_ETHER:
-                pInfo->enmType = NETIF_T_ETHERNET;
+                pInfo->enmMediumType = NETIF_T_ETHERNET;
                 break;
             default:
-                pInfo->enmType = NETIF_T_UNKNOWN;
+                pInfo->enmMediumType = NETIF_T_UNKNOWN;
                 break;
         }
@@ -142 +142 @@
                 if (RT_FAILURE(rc))
                     break;
-                if (Info.enmType == NETIF_T_ETHERNET)
+                if (Info.enmMediumType == NETIF_T_ETHERNET)
                 {
                     ComObjPtr<HostNetworkInterface> IfObj;
                     IfObj.createObject();
-                    if (SUCCEEDED(IfObj->init(Bstr(pszName), TRUE, &Info)))
+                    if (SUCCEEDED(IfObj->init(Bstr(pszName), HostNetworkInterfaceType_Bridged, &Info)))
                         list.push_back(IfObj);
                 }

trunk/src/VBox/Main/solaris/NetIfList-solaris.cpp

@@ -186 +186 @@
     Uuid.Gen.au8Node[5] = Info.MACAddress.au8[5];
     Info.Uuid = Uuid;
-    Info.enmType = NETIF_T_ETHERNET;
+    Info.enmMediumType = NETIF_T_ETHERNET;
 
     ComObjPtr<HostNetworkInterface> IfObj;
     IfObj.createObject();
-    if (SUCCEEDED(IfObj->init(Bstr(szNICDesc), TRUE, &Info)))
+    if (SUCCEEDED(IfObj->init(Bstr(szNICDesc), HostNetworkInterfaceType_Bridged, &Info)))
         pList->push_back(IfObj);
 }

trunk/src/VBox/Main/win/NetIfList-win.cpp

@@ -361 +361 @@
 }
 
+static HRESULT VBoxNetCfgWinEnableDHCP(IWbemServices * pSvc, IWbemClassObject *pObj,  in_addr* aIp,  in_addr * aMask, UINT cIp)
+{
+    IWbemClassObject * pClass;
+    BSTR ClassName = SysAllocString(L"Win32_NetworkAdapterConfiguration");
+    HRESULT hr;
+    if(ClassName)
+    {
+        hr = pSvc->GetObject(ClassName, 0, NULL, &pClass, NULL);
+        if(SUCCEEDED(hr))
+        {
+            BSTR ObjPath;
+            hr = netIfAdapterConfigPath(pObj, &ObjPath);
+            if(SUCCEEDED(hr))
+            {
+                IWbemClassObject * pOutParams;
+
+                hr = netIfExecMethod(pSvc, pClass, ObjPath,
+                                bstr_t(L"EnableDHCP"), NULL, NULL, 0, &pOutParams);
+                if(SUCCEEDED(hr))
+                {
+                }
+                SysFreeString(ObjPath);
+            }
+            pClass->Release();
+        }
+        SysFreeString(ClassName);
+    }
+    else
+    {
+        DWORD dwError = GetLastError();
+        Assert(0);
+        hr = HRESULT_FROM_WIN32( dwError );
+    }
+
+    return hr;
+}
 
 static int collectNetIfInfo(Bstr &strName, PNETIFINFO pInfo)
@@ -448 +484 @@
                     else
                         memcpy(pInfo->MACAddress.au8, pAdapter->PhysicalAddress, sizeof(pInfo->MACAddress));
-                    pInfo->enmType = NETIF_T_ETHERNET;
+                    pInfo->enmMediumType = NETIF_T_ETHERNET;
                     pInfo->enmStatus = pAdapter->OperStatus == IfOperStatusUp ? NETIF_S_UP : NETIF_S_DOWN;
                     RTStrFree(pszUuid);
@@ -464 +500 @@
 # define VBOX_APP_NAME L"VirtualBox"
 
-static int vboxNetWinAddComponent(std::list <ComObjPtr <HostNetworkInterface> > * pPist, INetCfgComponent * pncc, bool bReal)
+static int vboxNetWinAddComponent(std::list <ComObjPtr <HostNetworkInterface> > * pPist, INetCfgComponent * pncc, HostNetworkInterfaceType enmType)
 {
     LPWSTR              lpszName;
@@ -496 +532 @@
             iface.createObject();
             /* remove the curly bracket at the end */
-            if (SUCCEEDED (iface->init (name, bReal, &Info)))
+            if (SUCCEEDED (iface->init (name, enmType, &Info)))
             {
                 pPist->push_back (iface);
@@ -624 +660 @@
                             if(!_wcsnicmp(pId, L"sun_VBoxNetAdp", sizeof(L"sun_VBoxNetAdp")/2))
                             {
-                                vboxNetWinAddComponent(&list, pMpNcc, false);
+                                vboxNetWinAddComponent(&list, pMpNcc, HostNetworkInterfaceType_HostOnly);
                             }
                             CoTaskMemFree(pId);
@@ -765 +801 @@
                     }
 
-                    if (SUCCEEDED (iface->init (name, TRUE, &Info)))
+                    if (SUCCEEDED (iface->init (name, HostNetworkInterfaceType_Bridged, &Info)))
                         list.push_back (iface);
                 }
@@ -841 +877 @@
                                         if(uComponentStatus == 0)
                                         {
-                                            vboxNetWinAddComponent(&list, pMpNcc, true);
+                                            vboxNetWinAddComponent(&list, pMpNcc, HostNetworkInterfaceType_Bridged);
                                         }
                                     }

trunk/src/VBox/Main/win/svchlp.cpp

@@ -272 +272 @@
         switch (msgCode)
         {
-            case SVCHlpMsg::CreateHostNetworkInterface:
-            case SVCHlpMsg::RemoveHostNetworkInterface:
+            case SVCHlpMsg::CreateHostOnlyNetworkInterface:
+            case SVCHlpMsg::RemoveHostOnlyNetworkInterface:
             {
                 vrc = Host::networkInterfaceHelperServer (this, msgCode);

trunk/src/VBox/Main/win/svchlp.h

@@ -38 +38 @@
         Error, /* Utf8Str string (may be null but must present) */
 
-        CreateHostNetworkInterface = 100, /* see usage in code */
-        CreateHostNetworkInterface_OK, /* see usage in code */
-        RemoveHostNetworkInterface, /* see usage in code */
+        CreateHostOnlyNetworkInterface = 100, /* see usage in code */
+        CreateHostOnlyNetworkInterface_OK, /* see usage in code */
+        RemoveHostOnlyNetworkInterface, /* see usage in code */
     };
 };