#include "ovfreader.h"

using namespace std;

using namespace ovf;

OVFReader::OVFReader(const void *pvBuf, size_t cbSize, const RTCString &path)

: m_strPath(path)

{

xml::XmlMemParser parser;

parser.read(pvBuf, cbSize,

m_strPath,

m_doc);

/* Start the parsing */

parse();

}

OVFReader::OVFReader(const RTCString &path)

: m_strPath(path)

{

xml::XmlFileParser parser;

parser.read(m_strPath,

m_doc);

/* Start the parsing */

parse();

}

void OVFReader::parse()

{

const xml::ElementNode *pRootElem = m_doc.getRootElement();

if ( !pRootElem

|| strcmp(pRootElem->getName(), "Envelope")

)

throw OVFLogicError(N_("Root element in OVF file must be \"Envelope\"."));

// OVF has the following rough layout:

/*

// get all "File" child elements of "References" section so we can look up files easily;

// first find the "References" sections so we can look up files

xml::ElementNodesList listFileElements; // receives all /Envelope/References/File nodes

const xml::ElementNode *pReferencesElem;

if ((pReferencesElem = pRootElem->findChildElement("References")))

pReferencesElem->getChildElements(listFileElements, "File");

// now go though the sections

LoopThruSections(pReferencesElem, pRootElem);

}

void OVFReader::LoopThruSections(const xml::ElementNode *pReferencesElem,

const xml::ElementNode *pCurElem)

{

xml::NodesLoop loopChildren(*pCurElem);

const xml::ElementNode *pElem;

while ((pElem = loopChildren.forAllNodes()))

{

const char *pcszElemName = pElem->getName();

const char *pcszTypeAttr = "";

const xml::AttributeNode *pTypeAttr;

if ( ((pTypeAttr = pElem->findAttribute("xsi:type")))

|| ((pTypeAttr = pElem->findAttribute("type")))

)

pcszTypeAttr = pTypeAttr->getValue();

if ( (!strcmp(pcszElemName, "DiskSection"))

|| ( (!strcmp(pcszElemName, "Section"))

&& (!strcmp(pcszTypeAttr, "ovf:DiskSection_Type"))

)

)

{

HandleDiskSection(pReferencesElem, pElem);

}

else if ( (!strcmp(pcszElemName, "NetworkSection"))

|| ( (!strcmp(pcszElemName, "Section"))

&& (!strcmp(pcszTypeAttr, "ovf:NetworkSection_Type"))

)

)

{

HandleNetworkSection(pElem);

}

else if ( (!strcmp(pcszElemName, "DeploymentOptionSection")))

{

// TODO

}

else if ( (!strcmp(pcszElemName, "Info")))

{

// child of VirtualSystemCollection -- TODO

}

else if ( (!strcmp(pcszElemName, "ResourceAllocationSection")))

{

// child of VirtualSystemCollection -- TODO

}

else if ( (!strcmp(pcszElemName, "StartupSection")))

{

// child of VirtualSystemCollection -- TODO

}

else if ( (!strcmp(pcszElemName, "VirtualSystem"))

|| ( (!strcmp(pcszElemName, "Content"))

&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystem_Type"))

)

)

{

HandleVirtualSystemContent(pElem);

}

else if ( (!strcmp(pcszElemName, "VirtualSystemCollection"))

|| ( (!strcmp(pcszElemName, "Content"))

&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystemCollection_Type"))

)

)

{

// TODO ResourceAllocationSection

// recurse for this, since it has VirtualSystem elements as children

LoopThruSections(pReferencesElem, pElem);

}

}

}

void OVFReader::HandleDiskSection(const xml::ElementNode *pReferencesElem,

const xml::ElementNode *pSectionElem)

{

// contains "Disk" child elements

xml::NodesLoop loopDisks(*pSectionElem, "Disk");

const xml::ElementNode *pelmDisk;

while ((pelmDisk = loopDisks.forAllNodes()))

{

DiskImage d;

const char *pcszBad = NULL;

const char *pcszDiskId;

const char *pcszFormat;

if (!(pelmDisk->getAttributeValue("diskId", pcszDiskId)))

pcszBad = "diskId";

else if (!(pelmDisk->getAttributeValue("format", pcszFormat)))

pcszBad = "format";

else if (!(pelmDisk->getAttributeValue("capacity", d.iCapacity)))

pcszBad = "capacity";

else

{

d.strDiskId = pcszDiskId;

d.strFormat = pcszFormat;

if (!(pelmDisk->getAttributeValue("populatedSize", d.iPopulatedSize)))

// optional

d.iPopulatedSize = -1;

// optional vbox:uuid attribute (if OVF was exported by VirtualBox != 3.2)

pelmDisk->getAttributeValue("vbox:uuid", d.uuidVbox);

const char *pcszFileRef;

if (pelmDisk->getAttributeValue("fileRef", pcszFileRef)) // optional

{

// look up corresponding /References/File nodes (list built above)

const xml::ElementNode *pFileElem;

if ( pReferencesElem

&& ((pFileElem = pReferencesElem->findChildElementFromId(pcszFileRef)))

)

{

// copy remaining values from file node then

const char *pcszBadInFile = NULL;

const char *pcszHref;

if (!(pFileElem->getAttributeValue("href", pcszHref)))

pcszBadInFile = "href";

else if (!(pFileElem->getAttributeValue("size", d.iSize)))

d.iSize = -1; // optional

d.strHref = pcszHref;

// if (!(pFileElem->getAttributeValue("size", d.iChunkSize))) TODO

d.iChunkSize = -1; // optional

const char *pcszCompression;

if (pFileElem->getAttributeValue("compression", pcszCompression))

d.strCompression = pcszCompression;

if (pcszBadInFile)

throw OVFLogicError(N_("Error reading \"%s\": missing or invalid attribute '%s' in 'File' element, line %d"),

m_strPath.c_str(),

pcszBadInFile,

pFileElem->getLineNumber());

}

else

throw OVFLogicError(N_("Error reading \"%s\": cannot find References/File element for ID '%s' referenced by 'Disk' element, line %d"),

m_strPath.c_str(),

pcszFileRef,

pelmDisk->getLineNumber());

}

}

if (pcszBad)

throw OVFLogicError(N_("Error reading \"%s\": missing or invalid attribute '%s' in 'DiskSection' element, line %d"),

m_strPath.c_str(),

pcszBad,

pelmDisk->getLineNumber());

// suggest a size in megabytes to help callers with progress reports

d.ulSuggestedSizeMB = 0;

if (d.iCapacity != -1)

d.ulSuggestedSizeMB = d.iCapacity / _1M;

else if (d.iPopulatedSize != -1)

d.ulSuggestedSizeMB = d.iPopulatedSize / _1M;

else if (d.iSize != -1)

d.ulSuggestedSizeMB = d.iSize / _1M;

if (d.ulSuggestedSizeMB == 0)

d.ulSuggestedSizeMB = 10000; // assume 10 GB, this is for the progress bar only anyway

m_mapDisks[d.strDiskId] = d;

}

}

void OVFReader::HandleNetworkSection(const xml::ElementNode * /* pSectionElem */)

{

// we ignore network sections for now

}

void OVFReader::HandleVirtualSystemContent(const xml::ElementNode *pelmVirtualSystem)

{

VirtualSystem vsys;

// peek under the <VirtualSystem> node whether we have a <vbox:Machine> node;

// that case case, the caller can completely ignore the OVF but only load the VBox machine XML

vsys.pelmVboxMachine = pelmVirtualSystem->findChildElement("vbox", "Machine");

// now look for real OVF

const xml::AttributeNode *pIdAttr = pelmVirtualSystem->findAttribute("id");

if (pIdAttr)

vsys.strName = pIdAttr->getValue();

xml::NodesLoop loop(*pelmVirtualSystem); // all child elements

const xml::ElementNode *pelmThis;

while ((pelmThis = loop.forAllNodes()))

{

const char *pcszElemName = pelmThis->getName();

const char *pcszTypeAttr = "";

if (!strcmp(pcszElemName, "Section")) // OVF 0.9 used "Section" element always with a varying "type" attribute

{

const xml::AttributeNode *pTypeAttr;

if ( ((pTypeAttr = pelmThis->findAttribute("type")))

|| ((pTypeAttr = pelmThis->findAttribute("xsi:type")))

)

pcszTypeAttr = pTypeAttr->getValue();

else

throw OVFLogicError(N_("Error reading \"%s\": element \"Section\" has no \"type\" attribute, line %d"),

m_strPath.c_str(),

pelmThis->getLineNumber());

}

if ( (!strcmp(pcszElemName, "EulaSection"))

|| (!strcmp(pcszTypeAttr, "ovf:EulaSection_Type"))

)

{

/* <EulaSection>

const xml::ElementNode *pelmLicense;

if ((pelmLicense = pelmThis->findChildElement("License")))

vsys.strLicenseText = pelmLicense->getValue();

}

if ( (!strcmp(pcszElemName, "ProductSection"))

|| (!strcmp(pcszTypeAttr, "ovf:ProductSection_Type"))

)

{

/* <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">

const xml::ElementNode *pelmProduct;

if ((pelmProduct = pelmThis->findChildElement("Product")))

vsys.strProduct = pelmProduct->getValue();

const xml::ElementNode *pelmVendor;

if ((pelmVendor = pelmThis->findChildElement("Vendor")))

vsys.strVendor = pelmVendor->getValue();

const xml::ElementNode *pelmVersion;

if ((pelmVersion = pelmThis->findChildElement("Version")))

vsys.strVersion = pelmVersion->getValue();

const xml::ElementNode *pelmProductUrl;

if ((pelmProductUrl = pelmThis->findChildElement("ProductUrl")))

vsys.strProductUrl = pelmProductUrl->getValue();

const xml::ElementNode *pelmVendorUrl;

if ((pelmVendorUrl = pelmThis->findChildElement("VendorUrl")))

vsys.strVendorUrl = pelmVendorUrl->getValue();

}

else if ( (!strcmp(pcszElemName, "VirtualHardwareSection"))

|| (!strcmp(pcszTypeAttr, "ovf:VirtualHardwareSection_Type"))

)

{

const xml::ElementNode *pelmSystem, *pelmVirtualSystemType;

if ((pelmSystem = pelmThis->findChildElement("System")))

{

/* <System>

if ((pelmVirtualSystemType = pelmSystem->findChildElement("VirtualSystemType")))

vsys.strVirtualSystemType = pelmVirtualSystemType->getValue();

}

xml::NodesLoop loopVirtualHardwareItems(*pelmThis, "Item"); // all "Item" child elements

const xml::ElementNode *pelmItem;

while ((pelmItem = loopVirtualHardwareItems.forAllNodes()))

{

VirtualHardwareItem i;

i.ulLineNumber = pelmItem->getLineNumber();

xml::NodesLoop loopItemChildren(*pelmItem); // all child elements

const xml::ElementNode *pelmItemChild;

while ((pelmItemChild = loopItemChildren.forAllNodes()))

{

const char *pcszItemChildName = pelmItemChild->getName();

if (!strcmp(pcszItemChildName, "Description"))

i.strDescription = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "Caption"))

i.strCaption = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "ElementName"))

i.strElementName = pelmItemChild->getValue();

else if ( (!strcmp(pcszItemChildName, "InstanceID"))

|| (!strcmp(pcszItemChildName, "InstanceId"))

)

pelmItemChild->copyValue(i.ulInstanceID);

else if (!strcmp(pcszItemChildName, "HostResource"))

i.strHostResource = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "ResourceType"))

{

uint32_t ulType;

pelmItemChild->copyValue(ulType);

i.resourceType = (ResourceType_T)ulType;

i.fResourceRequired = true;

const char *pcszAttValue;

if (pelmItem->getAttributeValue("required", pcszAttValue))

{

if (!strcmp(pcszAttValue, "false"))

i.fResourceRequired = false;

}

}

else if (!strcmp(pcszItemChildName, "OtherResourceType"))

i.strOtherResourceType = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "ResourceSubType"))

i.strResourceSubType = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "AutomaticAllocation"))

i.fAutomaticAllocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;

else if (!strcmp(pcszItemChildName, "AutomaticDeallocation"))

i.fAutomaticDeallocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;

else if (!strcmp(pcszItemChildName, "Parent"))

pelmItemChild->copyValue(i.ulParent);

else if (!strcmp(pcszItemChildName, "Connection"))

i.strConnection = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "Address"))

{

i.strAddress = pelmItemChild->getValue();

pelmItemChild->copyValue(i.lAddress);

}

else if (!strcmp(pcszItemChildName, "AddressOnParent"))

i.strAddressOnParent = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "AllocationUnits"))

i.strAllocationUnits = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "VirtualQuantity"))

pelmItemChild->copyValue(i.ullVirtualQuantity);

else if (!strcmp(pcszItemChildName, "Reservation"))

pelmItemChild->copyValue(i.ullReservation);

else if (!strcmp(pcszItemChildName, "Limit"))

pelmItemChild->copyValue(i.ullLimit);

else if (!strcmp(pcszItemChildName, "Weight"))

pelmItemChild->copyValue(i.ullWeight);

else if (!strcmp(pcszItemChildName, "ConsumerVisibility"))

i.strConsumerVisibility = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "MappingBehavior"))

i.strMappingBehavior = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "PoolID"))

i.strPoolID = pelmItemChild->getValue();

else if (!strcmp(pcszItemChildName, "BusNumber")) // seen in some old OVF, but it's not listed in the OVF specs

pelmItemChild->copyValue(i.ulBusNumber);

else if ( pelmItemChild->getPrefix() == NULL

|| strcmp(pelmItemChild->getPrefix(), "vmw"))

throw OVFLogicError(N_("Error reading \"%s\": unknown element \"%s\" under Item element, line %d"),

m_strPath.c_str(),

pcszItemChildName,

i.ulLineNumber);

}

// store!

vsys.mapHardwareItems[i.ulInstanceID] = i;

}

HardDiskController *pPrimaryIDEController = NULL; // will be set once found

// now go thru all hardware items and handle them according to their type;

// in this first loop we handle all items _except_ hard disk images,

// which we'll handle in a second loop below

HardwareItemsMap::const_iterator itH;

for (itH = vsys.mapHardwareItems.begin();

itH != vsys.mapHardwareItems.end();

++itH)

{

const VirtualHardwareItem &i = itH->second;

// do some analysis

switch (i.resourceType)

{

case ResourceType_Processor: // 3

/* <rasd:Caption>1 virtual CPU</rasd:Caption>

if (i.ullVirtualQuantity < UINT16_MAX)

vsys.cCPUs = (uint16_t)i.ullVirtualQuantity;

else

throw OVFLogicError(N_("Error reading \"%s\": CPU count %RI64 is larger than %d, line %d"),

m_strPath.c_str(),

i.ullVirtualQuantity,

UINT16_MAX,

i.ulLineNumber);

break;

case ResourceType_Memory: // 4

if ( (i.strAllocationUnits == "MegaBytes") // found in OVF created by OVF toolkit

|| (i.strAllocationUnits == "MB") // found in MS docs

|| (i.strAllocationUnits == "byte * 2^20") // suggested by OVF spec DSP0243 page 21

)

vsys.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;

else

throw OVFLogicError(N_("Error reading \"%s\": Invalid allocation unit \"%s\" specified with memory size item, line %d"),

m_strPath.c_str(),

i.strAllocationUnits.c_str(),

i.ulLineNumber);

break;

case ResourceType_IDEController: // 5

{

/* <Item>

HardDiskController hdc;

hdc.system = HardDiskController::IDE;

hdc.idController = i.ulInstanceID;

hdc.strControllerType = i.strResourceSubType;

hdc.lAddress = i.lAddress;

if (!pPrimaryIDEController)

// this is the first IDE controller found: then mark it as "primary"

hdc.fPrimary = true;

else

{

// this is the second IDE controller found: If VMware exports two

// IDE controllers, it seems that they are given an "Address" of 0

// an 1, respectively, so assume address=0 means primary controller

if ( pPrimaryIDEController->lAddress == 0

&& hdc.lAddress == 1

)

{

pPrimaryIDEController->fPrimary = true;

hdc.fPrimary = false;

}

else if ( pPrimaryIDEController->lAddress == 1

&& hdc.lAddress == 0

)

{

pPrimaryIDEController->fPrimary = false;

hdc.fPrimary = false;

}

else

// then we really can't tell, just hope for the best

hdc.fPrimary = false;

}

vsys.mapControllers[i.ulInstanceID] = hdc;

if (!pPrimaryIDEController)

pPrimaryIDEController = &vsys.mapControllers[i.ulInstanceID];

break;

}

case ResourceType_ParallelSCSIHBA: // 6 SCSI controller

{

/* <Item>

HardDiskController hdc;

hdc.system = HardDiskController::SCSI;

hdc.idController = i.ulInstanceID;

hdc.strControllerType = i.strResourceSubType;

vsys.mapControllers[i.ulInstanceID] = hdc;

break;

}

case ResourceType_EthernetAdapter: // 10

{

/* <Item>

// only store the name

EthernetAdapter ea;

ea.strAdapterType = i.strResourceSubType;

ea.strNetworkName = i.strConnection;

vsys.llEthernetAdapters.push_back(ea);

break;

}

case ResourceType_FloppyDrive: // 14

vsys.fHasFloppyDrive = true; // we have no additional information

break;

case ResourceType_CDDrive: // 15

/* <Item ovf:required="false">

// I tried to see what happens if I set an ISO for the CD-ROM in VMware Workstation,

// but then the ovftool dies with "Device backing not supported". So I guess if

// VMware can't export ISOs, then we don't need to be able to import them right now.

vsys.fHasCdromDrive = true; // we have no additional information

break;

case ResourceType_HardDisk: // 17

// handled separately in second loop below

break;

case ResourceType_OtherStorageDevice: // 20 SATA controller

{

/* <Item>

if ( i.strCaption.startsWith("sataController", RTCString::CaseInsensitive)

&& !i.strResourceSubType.compare("AHCI", RTCString::CaseInsensitive)

)

{

HardDiskController hdc;

hdc.system = HardDiskController::SATA;

hdc.idController = i.ulInstanceID;

hdc.strControllerType = i.strResourceSubType;

vsys.mapControllers[i.ulInstanceID] = hdc;

}

else

throw OVFLogicError(N_("Error reading \"%s\": Host resource of type \"Other Storage Device (%d)\" is supported with SATA AHCI controllers only, line %d"),

m_strPath.c_str(),

ResourceType_OtherStorageDevice,

i.ulLineNumber);

break;

}

case ResourceType_USBController: // 23

/* <Item ovf:required="false">

vsys.fHasUsbController = true; // we have no additional information

break;

case ResourceType_SoundCard: // 35

/* <Item ovf:required="false">

vsys.strSoundCardType = i.strResourceSubType;

break;

default:

{

/* If this unknown resource type isn't required, we simply skip it. */

if (i.fResourceRequired)

{

throw OVFLogicError(N_("Error reading \"%s\": Unknown resource type %d in hardware item, line %d"),

m_strPath.c_str(),

i.resourceType,

i.ulLineNumber);

}

}

} // end switch

}

// now run through the items for a second time, but handle only

// hard disk images; otherwise the code would fail if a hard

// disk image appears in the OVF before its hard disk controller

for (itH = vsys.mapHardwareItems.begin();

itH != vsys.mapHardwareItems.end();

++itH)

{

const VirtualHardwareItem &i = itH->second;

// do some analysis

switch (i.resourceType)

{

case ResourceType_HardDisk: // 17

{

/* <Item>

// look up the hard disk controller element whose InstanceID equals our Parent;

// this is how the connection is specified in OVF

ControllersMap::const_iterator it = vsys.mapControllers.find(i.ulParent);

if (it == vsys.mapControllers.end())

throw OVFLogicError(N_("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid parent %d, line %d"),

m_strPath.c_str(),

i.ulInstanceID,

i.ulParent,

i.ulLineNumber);

//const HardDiskController &hdc = it->second;

VirtualDisk vd;

vd.idController = i.ulParent;

i.strAddressOnParent.toInt(vd.ulAddressOnParent);

// ovf://disk/lamp

// 123456789012345

if (i.strHostResource.startsWith("ovf://disk/"))

vd.strDiskId = i.strHostResource.substr(11);

else if (i.strHostResource.startsWith("ovf:/disk/"))

vd.strDiskId = i.strHostResource.substr(10);

else if (i.strHostResource.startsWith("/disk/"))

vd.strDiskId = i.strHostResource.substr(6);

if ( !(vd.strDiskId.length())

|| (m_mapDisks.find(vd.strDiskId) == m_mapDisks.end())

)

throw OVFLogicError(N_("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid host resource \"%s\", line %d"),

m_strPath.c_str(),

i.ulInstanceID,

i.strHostResource.c_str(),

i.ulLineNumber);

vsys.mapVirtualDisks[vd.strDiskId] = vd;

break;

}

default:

break;

}

}

}

else if ( (!strcmp(pcszElemName, "OperatingSystemSection"))

|| (!strcmp(pcszTypeAttr, "ovf:OperatingSystemSection_Type"))

)

{

uint64_t cimos64;

if (!(pelmThis->getAttributeValue("id", cimos64)))

throw OVFLogicError(N_("Error reading \"%s\": missing or invalid 'ovf:id' attribute in operating system section element, line %d"),

m_strPath.c_str(),

pelmThis->getLineNumber());

vsys.cimos = (CIMOSType_T)cimos64;

const xml::ElementNode *pelmCIMOSDescription;

if ((pelmCIMOSDescription = pelmThis->findChildElement("Description")))

vsys.strCimosDesc = pelmCIMOSDescription->getValue();

const xml::ElementNode *pelmVBoxOSType;

if ((pelmVBoxOSType = pelmThis->findChildElement("vbox", // namespace

"OSType"))) // element name

vsys.strTypeVbox = pelmVBoxOSType->getValue();

}

else if ( (!strcmp(pcszElemName, "AnnotationSection"))

|| (!strcmp(pcszTypeAttr, "ovf:AnnotationSection_Type"))

)

{

const xml::ElementNode *pelmAnnotation;

if ((pelmAnnotation = pelmThis->findChildElement("Annotation")))

vsys.strDescription = pelmAnnotation->getValue();

}

}

// now create the virtual system

m_llVirtualSystems.push_back(vsys);

}

OVFLogicError::OVFLogicError(const char *aFormat, ...)

{

char *pszNewMsg;

va_list args;

va_start(args, aFormat);

RTStrAPrintfV(&pszNewMsg, aFormat, args);

setWhat(pszNewMsg);

RTStrFree(pszNewMsg);

va_end(args);

}