Changeset 17566 in vbox for trunk

Timestamp:

Mar 9, 2009 11:22:42 AM (16 years ago)

Author:

vboxsync

Message:

OVF: implement NAT/Bridged network import/export; some network API documentation

Location:

trunk

Files:

• include/VBox/com/string.h (modified) (1 diff)
• src/VBox/Main/ApplianceImpl.cpp (modified) (16 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (6 diffs)

trunk/include/VBox/com/string.h

@@ -428 +428 @@
     bool operator < (const char *that) const { return compare (that) < 0; }
 
+    int compareIgnoreCase(const char *pcsz) const
+    {
+        return ::RTStrICmp(str, pcsz);
+    }
+
     bool isNull() const { return str == NULL; }
     operator bool() const { return !isNull(); }

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -63 +63 @@
 };
 
-struct Network
-{
-    Utf8Str strNetworkName;         // value from NetworkSection/Network/@name
-            // unfortunately the OVF spec is unspecific about how networks should be specified further
-};
-
 struct VirtualHardwareItem
 {
@@ -89 +83 @@
     Utf8Str strConnection;              // "All Ethernet adapters that specify the same abstract network connection name within an OVF
                                         // package shall be deployed on the same network. The abstract network connection name shall be
-                                        // listed in the NetworkSection at the outermost envelope level."
+                                        // listed in the NetworkSection at the outermost envelope level." We ignore this and only set up
+                                        // a network adapter depending on the network name.
     Utf8Str strAddress;                 // "Device-specific. For an Ethernet adapter, this specifies the MAC address."
     Utf8Str strAddressOnParent;         // "For a device, this specifies its location on the controller."
@@ -111 +106 @@
 
 typedef map<Utf8Str, DiskImage> DiskImagesMap;
-typedef map<Utf8Str, Network> NetworksMap;
 
 struct VirtualSystem;
@@ -200 +194 @@
 
     DiskImagesMap           mapDisks;           // map of DiskImage structs, sorted by DiskImage.strDiskId
-
-    NetworksMap             mapNetworks;        // map of Network structs, sorted by Network.strNetworkName
 
     list<VirtualSystem>     llVirtualSystems;   // list of virtual systems, created by and valid after read()
@@ -405 +397 @@
                 return rc;
         }
-        else if (    (!strcmp(pcszElemName, "NetworkSection"))
+       else if (    (!strcmp(pcszElemName, "NetworkSection"))            // we ignore NetworkSections for now
                   || (    (!strcmp(pcszElemName, "Section"))
                        && (!strcmp(pcszTypeAttr, "ovf:NetworkSection_Type"))
@@ -547 +539 @@
                                         const xml::Node *pSectionElem)
 {
-    // contains "Disk" child elements
-    xml::NodesLoop loopNetworks(*pSectionElem, "Network");
-    const xml::Node *pelmNetwork;
-    while ((pelmNetwork = loopNetworks.forAllNodes()))
-    {
-        Network n;
-        if (!(pelmNetwork->getAttributeValue("name", n.strNetworkName)))
-            return setError(VBOX_E_FILE_ERROR,
-                            tr("Error reading \"%s\": missing 'name' attribute in 'Network', line %d"),
-                            pcszPath,
-                            pelmNetwork->getLineNumber());
-
-        m->mapNetworks[n.strNetworkName] = n;
-    }
+    // we ignore network sections for now
+
+//     xml::NodesLoop loopNetworks(*pSectionElem, "Network");
+//     const xml::Node *pelmNetwork;
+//     while ((pelmNetwork = loopNetworks.forAllNodes()))
+//     {
+//         Network n;
+//         if (!(pelmNetwork->getAttributeValue("name", n.strNetworkName)))
+//             return setError(VBOX_E_FILE_ERROR,
+//                             tr("Error reading \"%s\": missing 'name' attribute in 'Network', line %d"),
+//                             pcszPath,
+//                             pelmNetwork->getLineNumber());
+//
+//         m->mapNetworks[n.strNetworkName] = n;
+//     }
 
     return S_OK;
@@ -802 +795 @@
                             at the outermost envelope level." */
 
-                        // make sure we have a matching NetworkSection/Network
-                        NetworksMap::iterator it = m->mapNetworks.find(i.strConnection);
-                        if (it == m->mapNetworks.end())
-                            return setError(VBOX_E_FILE_ERROR,
-                                            tr("Error reading \"%s\": Invalid connection \"%s\"; cannot find matching NetworkSection/Network element, line %d"),
-                                            pcszPath,
-                                            i.strConnection.c_str(),
-                                            i.ulLineNumber);
-
+                        // only store the name
                         vsys.llNetworkNames.push_back(i.strConnection);
                     }
@@ -1427 +1412 @@
 #endif /* VBOX_WITH_USB */
 
-            NetworksMap::const_iterator itN;
-            for (itN = m->mapNetworks.begin();
-                 itN != m->mapNetworks.end();
-                 ++itN)
-            {
-                const Network &nw = itN->second;
-                pNewDesc->addEntry(VirtualSystemDescriptionType_LogicalNetwork,
-                                   "",
-                                   nw.strNetworkName,
-                                   nw.strNetworkName);
-            }
-
             /* Network Controller */
             // @todo: there is no hardware specification in the OVF file; supposedly the
@@ -1464 +1437 @@
                 {
                     Utf8Str strNetwork = *nwIt; // logical network to connect to
+                    // make sure it's one of these two
+                    if (    (strNetwork.compareIgnoreCase("Null"))
+                         && (strNetwork.compareIgnoreCase("Bridged"))
+                         && (strNetwork.compareIgnoreCase("Internal"))
+                         && (strNetwork.compareIgnoreCase("HostOnly"))
+                       )
+                        strNetwork = "NAT";
+
                     pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
                                        "",      // ref
                                        strNetwork,      // orig
                                        Utf8StrFmt("%RI32", (uint32_t)nwAdapterVBox),   // conf
-                                       Utf8StrFmt("network=%s", strNetwork.c_str()));       // extra conf
+                                       Utf8StrFmt("type=%s", strNetwork.c_str()));       // extra conf
                 }
             }
@@ -2014 +1995 @@
                      ++nwIt, ++a)
                 {
-                    const Utf8Str &nwTypeVBox = (*nwIt)->strVbox;
+                    const VirtualSystemDescriptionEntry* pvsys = *nwIt;
+
+                    const Utf8Str &nwTypeVBox = pvsys->strVbox;
                     uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
-                    ComPtr<INetworkAdapter> nwVBox;
-                    rc = pNewMachine->GetNetworkAdapter((ULONG)a, nwVBox.asOutParam());
+                    ComPtr<INetworkAdapter> pNetworkAdapter;
+                    rc = pNewMachine->GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
                     if (FAILED(rc)) throw rc;
                     /* Enable the network card & set the adapter type */
-                    /* NAT is set as default */
-                    rc = nwVBox->COMSETTER(Enabled)(true);
+                    rc = pNetworkAdapter->COMSETTER(Enabled)(true);
                     if (FAILED(rc)) throw rc;
-                    rc = nwVBox->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
+                    rc = pNetworkAdapter->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
                     if (FAILED(rc)) throw rc;
+
+                    // default is NAT; change to "bridged" if extra conf says so
+                    if (!pvsys->strExtraConfig.compareIgnoreCase("type=Bridged"))
+                    {
+                        rc = pNetworkAdapter->AttachToBridgedInterface();
+                        if (FAILED(rc)) throw rc;
+                    }
                 }
             }
@@ -2514 +2503 @@
         xml::Node *pelmNetworkSectionInfo = pelmNetworkSection->createChild("Info");
         pelmNetworkSectionInfo->addContent("Logical networks used in the package");
-        // @todo for each network:
-        // xml::Node *pelmNetwork = pelmNetworkSection->createChild("Network");
+        // for now, set up a map so we have a list of unique network names (to make
+        // sure the same network name is only added once)
+        map<Utf8Str, bool> mapNetworks;
+                // we fill this later below when we iterate over the networks
 
         // and here come the virtual systems:
@@ -2570 +2561 @@
                 const VirtualSystemDescriptionEntry &desc = *itD;
 
-                OVFResourceType_T type = (OVFResourceType_T)0;     // if this becomes != 0 then we do stuff
-                Utf8Str strDescription;         // must also be set then
+                OVFResourceType_T type = (OVFResourceType_T)0;      // if this becomes != 0 then we do stuff
+                Utf8Str strDescription;                             // results in <rasd:Description>...</rasd:Description> block
+                Utf8Str strCaption;                                 // results in <rasd:Caption>...</rasd:Caption> block
                 int32_t lVirtualQuantity = -1;
                 uint64_t uTemp;
+                bool fAutomaticAllocation = false;
+                Utf8Str strConnection;                              // results in <rasd:Connection>...</rasd:Connection> block
 
                 switch (desc.type)
@@ -2607 +2601 @@
                     break;
 
-                    case VirtualSystemDescriptionType_HardDiskControllerIDE:
+//                     case VirtualSystemDescriptionType_HardDiskControllerIDE:
+//                         strDescription = "Memory Size";
+//                         type = OVFResourceType_Memory; // 4
+//                         desc.strVbox.toInt(uTemp);
+//                         lVirtualQuantity = (int32_t)(uTemp / _1M);
+//                     break;
+
+//                     case VirtualSystemDescriptionType_HardDiskControllerSATA:
+//                         strDescription = "Memory Size";
+//                         type = OVFResourceType_Memory; // 4
+//                         desc.strVbox.toInt(uTemp);
+//                         lVirtualQuantity = (int32_t)(uTemp / _1M);
+//                     break;
+
+//                     case VirtualSystemDescriptionType_HardDiskControllerSCSI:
+//                         strDescription = "Memory Size";
+//                         type = OVFResourceType_Memory; // 4
+//                         desc.strVbox.toInt(uTemp);
+//                         lVirtualQuantity = (int32_t)(uTemp / _1M);
+//                     break;
+
+//                     case VirtualSystemDescriptionType_HardDiskImage:
+//                         strDescription = "Memory Size";
+//                         type = OVFResourceType_Memory; // 4
+//                         desc.strVbox.toInt(uTemp);
+//                         lVirtualQuantity = (int32_t)(uTemp / _1M);
+//                     break;
+
+//                     case VirtualSystemDescriptionType_Floppy:
+//                         strDescription = "Memory Size";
+//                         type = OVFResourceType_Memory; // 4
+//                         desc.strVbox.toInt(uTemp);
+//                         lVirtualQuantity = (int32_t)(uTemp / _1M);
+//                     break;
+
+//                     case VirtualSystemDescriptionType_CDROM:
+//                         strDescription = "Memory Size";
+//                         type = OVFResourceType_Memory; // 4
+//                         desc.strVbox.toInt(uTemp);
+//                         lVirtualQuantity = (int32_t)(uTemp / _1M);
+//                     break;
+
+                    case VirtualSystemDescriptionType_NetworkAdapter:
+                        /* <Item>
+                                <rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
+                                <rasd:Caption>Ethernet adapter on 'VM Network'</rasd:Caption>
+                                <rasd:Connection>VM Network</rasd:Connection>
+                                <rasd:ElementName>VM network</rasd:ElementName>
+                                <rasd:InstanceID>3</rasd:InstanceID>
+                                <rasd:ResourceType>10</rasd:ResourceType>
+                            </Item> */
+                        fAutomaticAllocation = true;
+                        strCaption = Utf8StrFmt("Ethernet adapter on '%s'", desc.strOvf.c_str());
+                        type = OVFResourceType_EthernetAdapter; // 10
+                        strConnection = desc.strOvf;
+
+                        mapNetworks[desc.strOvf] = true;
                     break;
-                    case VirtualSystemDescriptionType_HardDiskControllerSATA:
-                    break;
-                    case VirtualSystemDescriptionType_HardDiskControllerSCSI:
-                    break;
-
-                    case VirtualSystemDescriptionType_HardDiskImage:
-                    break;
-
-                    case VirtualSystemDescriptionType_Floppy:
-                    break;
-
-                    case VirtualSystemDescriptionType_CDROM:
-                    break;
-
-                    case VirtualSystemDescriptionType_LogicalNetwork:
-                    break;
-
-                    case VirtualSystemDescriptionType_NetworkAdapter:
-                    break;
-
-                    case VirtualSystemDescriptionType_USBController:
-                    break;
-
-                    case VirtualSystemDescriptionType_SoundCard:
-                    break;
+
+//                     case VirtualSystemDescriptionType_USBController:
+//                         strDescription = "Memory Size";
+//                         type = OVFResourceType_Memory; // 4
+//                         desc.strVbox.toInt(uTemp);
+//                         lVirtualQuantity = (int32_t)(uTemp / _1M);
+//                     break;
+
+/*                    case VirtualSystemDescriptionType_SoundCard:
+                        strDescription = "Memory Size";
+                        type = OVFResourceType_Memory; // 4
+                        desc.strVbox.toInt(uTemp);
+                        lVirtualQuantity = (int32_t)(uTemp / _1M);
+                    break;*/
                 }
 
@@ -2641 +2680 @@
                     pItem = pelmVirtualHardwareSection->createChild("Item");
 
-                    pItem->createChild("rasd:Description")->addContent(strDescription.c_str());
+                    if (fAutomaticAllocation)
+                        pItem->createChild("rasd:AutomaticAllocation")->addContent("true");
+
+                    if (strDescription.length())
+                        pItem->createChild("rasd:Description")->addContent(strDescription.c_str());
+                    if (strCaption.length())
+                        pItem->createChild("rasd:Caption")->addContent(strCaption.c_str());
+
+                    if (strConnection.length())
+                        pItem->createChild("rasd:Connection")->addContent(strConnection.c_str());
 
                     // <rasd:InstanceID>1</rasd:InstanceID>
                     pItem->createChild("rasd:InstanceID")->addContent(Utf8StrFmt("%d", ulInstanceID).c_str());
+                    ++ulInstanceID;
 
                     // <rasd:ResourceType>3</rasd:ResourceType>
@@ -2655 +2704 @@
                 }
             }
+        }
+
+        // finally, fill in the network section we set up empty above according
+        // to the networks we found with the hardware items
+        map<Utf8Str, bool>::const_iterator itN;
+        for (itN = mapNetworks.begin();
+             itN != mapNetworks.end();
+             ++itN)
+        {
+            const Utf8Str &strNetwork = itN->first;
+            xml::Node *pelmNetwork = pelmNetworkSection->createChild("Network");
+            pelmNetwork->setAttribute("ovf:name", strNetwork.c_str());
+            pelmNetwork->createChild("<Description>")->addContent("Logical network used by this appliance.");
         }
 
@@ -3208 +3270 @@
 
 //     <const name="NetworkAdapter" value="13" />
+        size_t a;
+        for (a = 0;
+             a < SchemaDefs::NetworkAdapterCount;
+             ++a)
+        {
+            ComPtr<INetworkAdapter> pNetworkAdapter;
+            BOOL fEnabled;
+            NetworkAdapterType_T adapterType;
+            NetworkAttachmentType_T attachmentType;
+
+            rc = GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
+            if (FAILED(rc)) throw rc;
+            /* Enable the network card & set the adapter type */
+            rc = pNetworkAdapter->COMGETTER(Enabled)(&fEnabled);
+            if (FAILED(rc)) throw rc;
+
+            if (fEnabled)
+            {
+                Utf8Str strAttachmentType;
+
+                rc = pNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
+                if (FAILED(rc)) throw rc;
+
+                rc = pNetworkAdapter->COMGETTER(AttachmentType)(&attachmentType);
+                if (FAILED(rc)) throw rc;
+
+                switch (attachmentType)
+                {
+                    case NetworkAttachmentType_Null:
+                        strAttachmentType = "Null";
+                    break;
+
+                    case NetworkAttachmentType_NAT:
+                        strAttachmentType = "NAT";
+                    break;
+
+                    case NetworkAttachmentType_Bridged:
+                        strAttachmentType = "Bridged";
+                    break;
+
+                    case NetworkAttachmentType_Internal:
+                        strAttachmentType = "Internal";
+                    break;
+
+                    case NetworkAttachmentType_HostOnly:
+                        strAttachmentType = "HostOnly";
+                    break;
+                }
+
+                pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
+                                   "",      // ref
+                                   strAttachmentType,      // orig
+                                   Utf8StrFmt("%RI32", (uint32_t)adapterType),   // conf
+                                   Utf8StrFmt("type=%s", strAttachmentType.c_str()));       // extra conf
+            }
+        }
 
 //     <const name="USBController" value="14" />

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

@@ -3071 +3071 @@
     <const name="Floppy" value="10" />
     <const name="CDROM" value="11" />
-    <const name="LogicalNetwork" value="12" />
-    <const name="NetworkAdapter" value="13" />
-    <const name="USBController" value="14" />
-    <const name="SoundCard" value="15" />
+    <const name="NetworkAdapter" value="12" />
+    <const name="USBController" value="13" />
+    <const name="SoundCard" value="14" />
 
   </enum>
@@ -3166 +3165 @@
       </li>
       <li>
-        "LogicalNetwork": a logical network to which virtual machines can connect. This is taken from
-        the Network section in the OVF that is shared between several virtual systems. OVF has no
-        formal description of how the network shall be set up (e.g. whether to use NAT or host interface
-        networking), but OVFs typically name the logical networks "nat" or "bridged" to suggest such
-        a configuration.
-      </li>
-      <li>
         "NetworkAdapter": a network adapter. The array item in aVboxValues[] will specify the hardware
         for the network adapter, whereas the array item in aExtraConfigValues[] will have a string
-        of the "network=&lt;nw&gt;" format, where &lt;nw&gt; must be one of the networks as specified with the
-        LogicalNetwork type.
+        of the "type=&lt;X&gt;" format, where &lt;X&gt; must be either "NAT" or "Bridged".
       </li>
       <li>
@@ -6516 +6507 @@
       <desc>Specifies whether the IP V6 is supported/enabled for the interface.</desc>
     </attribute>
-    
+
     <attribute name="IPV6Address" type="wstring" readonly="yes">
       <desc>Returns the IP V6 address of the interface.</desc>
@@ -6524 +6515 @@
       <desc>Returns the IP V6 network mask of the interface.</desc>
     </attribute>
-    
+
     <attribute name="hardwareAddress" type="wstring" readonly="yes">
       <desc>Returns the hardware address. For Ethernet it is MAC address.</desc>
@@ -6540 +6531 @@
       <desc>specifies the host interface type.</desc>
     </attribute>
-    
+
     <method name="enableStaticIpConfig">
       <desc>sets and enables the static IP V4 configuration for the given interface.</desc>
@@ -10481 +10472 @@
      wsmap="managed"
      >
+    <desc>
+        Represents a virtual network adapter that is attached to a virtual machine.
+        Each virtual machine has a fixed number of network adapter slots with one
+        instance of this attached to each of them. Call
+        <link to="IMachine::getNetworkAdapter" /> to get the network adapter that
+        is attached to a given slot in a given machine.
+
+        Each network adapter can be in one of five attachment modes, which are
+        represented by the <link to="NetworkAttachmentType" /> enumeration;
+        see the <link to="#attachmentType" /> attribute.
+    </desc>
+
     <attribute name="adapterType" type="NetworkAdapterType">
       <desc>