public ImportImageAction(IXenConnection connection, EnvelopeType ovfEnv, string directory, Dictionary<string, VmMapping> vmMappings, bool runfixups, SR selectedIsoSr,
string networkUuid, bool isTvmIpStatic, string tvmIpAddress, string tvmSubnetMask, string tvmGateway)
: base(connection, Messages.IMPORT_DISK_IMAGE, networkUuid, isTvmIpStatic, tvmIpAddress, tvmSubnetMask, tvmGateway)
{
m_ovfEnvelope = ovfEnv;
m_directory = directory;
m_vmMappings = vmMappings;
m_runfixups = runfixups;
m_selectedIsoSr = selectedIsoSr;
}
public ImportApplianceAction(IXenConnection connection, EnvelopeType ovfEnv, Package package, Dictionary<string, VmMapping> vmMappings,
bool verifyManifest, bool verifySignature, string password, bool runfixups, SR selectedIsoSr,
string networkUuid, bool isTvmIpStatic, string tvmIpAddress, string tvmSubnetMask, string tvmGateway)
: base(connection, Messages.IMPORT_APPLIANCE, networkUuid, isTvmIpStatic, tvmIpAddress, tvmSubnetMask, tvmGateway)
{
m_ovfEnvelope = ovfEnv;
m_package = package;
m_vmMappings = vmMappings;
m_verifyManifest = verifyManifest;
m_verifySignature = verifySignature;
m_password = password;
m_runfixups = runfixups;
m_selectedIsoSr = selectedIsoSr;
}
/// <summary>
/// Decrypt the files associated with the provided OVF package.
/// </summary>
/// <param name="env">EnvelopeType ovf object</param>
/// <param name="ovfFileName">fullpath/filename</param>
/// <param name="password">password to use during decryption.</param>
public void Decrypt(EnvelopeType env, string ovfFileName, string password)
{
_cancelEncrypt = false;
CryptoFileWrapper(env, ovfFileName, password, false);
if (_cancelEncrypt)
{
Log.Info("Encrypt: CANCELLED successfully.");
}
else
{
SaveAs(env, ovfFileName);
}
}
private void TransformXvaOvf_Network(EnvelopeType env, string vsId, string lang, string refId, XenStruct vmstruct)
{
string networkName = null;
foreach (XenMember n in vmstruct.xenmember)
{
//
// Currently these are the only values we care about.
//
if (n.xenname.ToLower().Equals("name_label") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
networkName = ((string)n.xenvalue);
break;
}
}
foreach (Section_Type section in env.Sections)
{
if (section is NetworkSection_Type)
{
NetworkSection_Type ns = (NetworkSection_Type)section;
foreach (NetworkSection_TypeNetwork net in ns.Network)
{
if (net.Description != null &&
net.Description.msgid != null &&
net.Description.msgid.Equals(mappings[refId]))
{
net.Description.Value = networkName;
break;
}
}
break;
}
}
log.DebugFormat("OVF.TransformXvaOvf_Network completed {0}", vsId);
}
/// <summary>
/// Validate password prior do decrypting, depends on sample encrypted section in The SecuritySection.
/// </summary>
/// <param name="ovfObj">EnvelopeType OVF Object</param>
/// <param name="password">password to check</param>
/// <returns>true = valid password, false = password failed</returns>
public bool CheckPassword(EnvelopeType ovfObj, string password)
{
bool isValid = false;
SecuritySection_Type[] security = FindSections<SecuritySection_Type>(ovfObj.Sections);
if (security != null && security.Length == 1)
{
foreach (Security_Type sec in security[0].Security)
{
EncryptedDataType edt = null;
if (sec.EncryptedData != null && sec.EncryptedData.CipherData != null && sec.EncryptedData.CipherData.Item != null)
{
edt = sec.EncryptedData;
}
if (edt == null && sec.Any != null)
{
foreach (XmlElement xe in sec.Any)
{
if (xe.Name.Contains(":EncryptedData") || xe.Name.Contains(":EncrypteData"))
{
CipherDataType cdt = (CipherDataType)Tools.Deserialize(xe.InnerXml, typeof(CipherDataType));
edt = new EncryptedDataType();
edt.CipherData = cdt;
}
}
}
if (edt != null)
{
if (sec.version != null &&
CheckSecurityVersion(sec.version, Properties.Settings.Default.securityVersion) >= 0)
{
isValid = InternalCheckPassword((byte[])edt.CipherData.Item, password, sec.version);
}
else
{
isValid = DeprecatedCheckPassword((byte[])edt.CipherData.Item, password, sec.version);
}
}
else
{
throw new Exception(Messages.SECURITY_SECTION_INVALID);
}
}
}
if (isValid)
{
Log.Audit(Messages.PASSWORD_SUCCESS);
}
else
{
Log.Audit(Messages.PASSWORD_FAILED);
}
return isValid;
}
private void ProcessCompression(EnvelopeType env, string path, string method, bool compress)
{
if (env.References != null && env.References.File != null && env.References.File.Length > 0)
{
foreach (File_Type file in env.References.File)
{
if (compress)
{
if (method.ToLower() != "gzip" && method.ToLower() != "bzip2")
throw new InvalidDataException(string.Format(Messages.COMPRESS_INVALID_METHOD, method));
}
else
{
if (file.compression == null)
{
Log.Info("File {0} was not marked as compressed, skipped.", file.href);
continue;
}
if (file.compression.ToLower() != "gzip" && file.compression.ToLower() != "bzip2")
{
Log.Error("Invalid compression method File: {0} Method: {1}, must be Gzip or BZip2", file.href, file.compression);
continue;
}
method = file.compression;
}
int slash = file.href.LastIndexOf('/');
string filename = slash >= 0 ? file.href.Substring(slash + 1) : file.href;
filename = Path.Combine(path, filename);
string tempfile = Path.Combine(path, Path.GetFileName(Path.GetTempFileName()));
try
{
if (method.ToLower() == "gzip")
{
using(var inputFile = new FileStream(filename, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
using (var outputFile = new FileStream(tempfile, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None))
{
if (compress)
GZipCompress(inputFile, outputFile);
else
GZipDecompress(inputFile, outputFile);
}
inputFile.Flush();
}
//the original file should be overwritten only if the process has succeeded, so it should
//be done here and not in the finally block, because if compression/decompression fails
//for some reason, the original file is lost
File.Delete(filename);
File.Move(tempfile, filename);
}
else
{
throw new InvalidDataException(string.Format(Messages.COMPRESS_INVALID_METHOD, method));
}
file.compression = compress ? method : null;
}
catch (EndOfStreamException eose)
{
Log.Error("End of Stream: {0}", eose.Message);
}
catch (Exception ex)
{
if (ex is OperationCanceledException)
throw;
var message = string.Format(Messages.COMPRESS_FAILED, filename);
Log.Error("{0} {1}", message, ex.Message);
throw new Exception(message, ex);
}
finally
{
//in case of failure or cancellation delete the temp file;
//in case of success it won't be there, but no exception is thrown
File.Delete(tempfile);
}
FileInfo fi = new FileInfo(filename);
file.size = (ulong)fi.Length;
}
}
}
private void TransformXvaOvf_VBD(EnvelopeType env, string vsId, string lang, XenStruct vmstruct)
{
string diskId = null;
string vhdfilename = "";
bool bootable = false;
string caption = null;
string description = null;
ulong filesize = 0;
ulong capacity = 0;
string vdiuuid = null;
bool isDisk = false;
StringBuilder connection = new StringBuilder();
foreach (XenMember n in vmstruct.xenmember)
{
//
// Currently these are the only values we care about.
//
if (n.xenname.ToLower().Equals("uuid") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
vdiuuid = (string)n.xenvalue;
if (!vdiuuid.ToLower().Contains("null"))
{
diskId = string.Format(@"Xen:{0}/{1}", vsId, vdiuuid);
}
else
{
vdiuuid = null;
}
}
else if (n.xenname.ToLower().Equals("vdi") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
string vdiref = ((string)n.xenvalue);
if (!vdiref.ToLower().Contains("null"))
{
if (!mappings.ContainsKey(vdiref))
{
mappings.Add(vdiref, vdiuuid);
}
}
}
else if (n.xenname.ToLower().Equals("userdevice") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
connection.AppendFormat("device={0},", ((string)n.xenvalue));
}
else if (n.xenname.ToLower().Equals("bootable") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
connection.AppendFormat("bootable={0},", ((string)n.xenvalue));
bootable = Convert.ToBoolean(((string)n.xenvalue));
}
else if (n.xenname.ToLower().Equals("mode") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
connection.AppendFormat("mode={0},", ((string)n.xenvalue));
}
else if (n.xenname.ToLower().Equals("type") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
switch (((string)n.xenvalue).ToUpper())
{
case "CD":
{
isDisk = false;
caption = _ovfrm.GetString("RASD_16_CAPTION");
description = _ovfrm.GetString("RASD_16_DESCRIPTION");
break;
}
case "DISK":
{
caption = _ovfrm.GetString("RASD_19_CAPTION");
description = _ovfrm.GetString("RASD_19_DESCRIPTION");
isDisk = true;
break;
}
}
}
}
if (vdiuuid != null)
connection.AppendFormat("vdi={0}", vdiuuid);
if (isDisk)
{
AddDisk(env, vsId, diskId, lang, vhdfilename, bootable, caption, description, filesize, capacity);
UpdateResourceAllocationSettingData(env, vsId, diskId, "Connection", connection.ToString());
}
else
{
AddCDROM(env, vsId, diskId, caption, description);
}
log.DebugFormat("OVF.TransformXvaOvf_VBD completed {0}", vsId);
}
public OvfStorageResource(RASD_Type type, EnvelopeType envelopeType)
{
rasd = type;
envelope = envelopeType;
file = OVF.FindFileReferenceByRASD(envelope, rasd);
}
/// <summary>
///
/// </summary>
/// <param name="env"></param>
/// <param name="ovfilename"></param>
/// <param name="method"></param>
/// <param name="compress"></param>
public void CompressOvfFiles(EnvelopeType env, string ovfilename, string method, bool compress)
{
ProcessCompression(env, Path.GetDirectoryName(ovfilename), method, compress);
OVF.SaveAs(env, ovfilename);
}
private void AddNetworks(EnvelopeType ovfEnv, string vsId)
{
AddNetworks(ovfEnv, vsId, Properties.Settings.Default.Language);
}
private void AddNetworks(EnvelopeType ovfEnv, string vsId, string lang)
{
if (Win32_NetworkAdapter != null)
{
foreach (ManagementObject mo in Win32_NetworkAdapter)
{
// Only get the physical adapters, not logical (which there are numerous)
//if ((bool)mo["PhysicalAdapter"])
bool addThisNetwork = false;
string macaddress = null;
string description = null;
//
// setPriority is used to determine the description
// 0 = unset
// 1 highest priority
// 2 next
// 3 next
// ...
//
int setPriority = 0;
foreach (PropertyData pd in mo.Properties)
{
if (pd.Name != null && pd.Name.Length > 0)
{
if (pd.Name.ToLower().Equals("macaddress") && pd.Value != null && ((string)pd.Value).Length > 0)
{
macaddress = (string)pd.Value;
}
else if (pd.Name.ToLower().Equals("netconnectionid") && pd.Value != null && ((string)pd.Value).Length > 0)
{
description = (string)pd.Value;
setPriority = 1;
}
else if (pd.Name.ToLower().Equals("name") && pd.Value != null && ((string)pd.Value).Length > 0)
{
if (setPriority == 0 || setPriority > 2)
{
description = (string)pd.Value;
setPriority = 2;
}
}
else if (pd.Name.ToLower().Equals("description") && pd.Value != null && ((string)pd.Value).Length > 0)
{
if (setPriority == 0 || setPriority > 3)
{
description = (string)pd.Value;
setPriority = 3;
}
}
// Below is trying to figure out if this is a Network Connection that
// is to be exported/defined.
// The issue is WMI has different value sets for different types of hardware
// such as hardware as we know it... pci ethernet
// or blade style, which WMI gives a different result.
// WAN/RAS connections.. etc.
// ANY one of the values can set this to true:
// netconnectionstatus
// pnpdeviceid
// physicaladapter
//
else if (pd.Name.ToLower().Equals("netconnectionstatus") && pd.Value != null)
{
if ((UInt16)pd.Value == 0x2)
{
addThisNetwork = true;
}
}
else if (pd.Name.ToLower().Equals("pnpdeviceid") && pd.Value != null && ((string)pd.Value).Length > 0)
{
if ((((string)pd.Value).ToLower().StartsWith("pci") || ((string)pd.Value).ToLower().StartsWith("scsi")))
{
addThisNetwork = true;
}
}
else if (pd.Name.ToLower().Equals("physicaladapter") && pd.Value != null)
{
addThisNetwork = (bool)pd.Value;
}
}
}
if (addThisNetwork)
{
AddNetwork(ovfEnv, vsId, lang, Guid.NewGuid().ToString(), description, macaddress);
}
}
}
else
{
log.Warn("No networks defined, If a network interface is required, the administrator will need to add it after import of OVF/OVA Package.");
}
log.DebugFormat("OVF.AddNetworks completed {0}", vsId);
}
private void AddCPUs(EnvelopeType ovfEnv, string vsId, string lang)
{
UInt64 cpucount = 0;
if (Win32_Processor != null && Win32_Processor.Count > 0)
{
foreach (ManagementObject mo in Win32_Processor)
{
#region FIND BY PROPERTIES NOT EXPLICID
uint numberofcores = 1;
foreach (PropertyData pd in mo.Properties)
{
if (pd.Name.ToLower().Equals("numberofcores") && pd.Value != null)
{
numberofcores = (uint)pd.Value;
}
}
#endregion
cpucount += Convert.ToUInt64(numberofcores);
}
SetCPUs(ovfEnv, vsId, cpucount);
}
else
{
SetCPUs(ovfEnv, vsId, 1);
log.Warn("OVF.AddCPUs, set using default (1) CPU");
}
log.DebugFormat("OVF.AddCPUs completed {0} cpus {1}", vsId, cpucount);
}
private void AddMemory(EnvelopeType ovfEnv, string vsId, string lang)
{
ulong divisor = 1024 * 1024;
ulong totalphysicalmemory = divisor * 512; // 512MB Default Memory
ulong memory = 0;
if (Win32_ComputerSystem != null)
{
#region FIND BY PROPERTIES NOT EXPLICID
foreach (PropertyData pd in Win32_ComputerSystem.Properties)
{
if (pd.Name.ToLower().Equals("totalphysicalmemory") && pd.Value != null)
{
totalphysicalmemory = (ulong)pd.Value;
break;
}
}
#endregion
memory = totalphysicalmemory / divisor;
}
else
{
log.Warn("OVF.AddMemory: could not determine system memory, defaulting to 512MB");
memory = 512L;
}
SetMemory(ovfEnv, vsId, memory, "byte * 2^20");
log.DebugFormat("OVF.AddMemory completed {0} memory {1} (byte * 2 ^ 20)", vsId, memory);
}
private void TransformXvaOvf_VM(EnvelopeType env, string vsId, string lang, XenStruct vmstruct)
{
int PVvalue = 0;
foreach (XenMember n in vmstruct.xenmember)
{
//
// Currently these are the only values we care about.
//
if (n.xenname.ToLower().Equals("uuid"))
{
UpdateVirtualSystemSettingData(env, vsId, "VirtualSystemIdentifier", (string)n.xenvalue);
}
if (n.xenname.ToLower().Equals("name_label"))
{
if (n.xenvalue != null && n.xenvalue is string && ((string)n.xenvalue).Length > 0)
{
UpdateVirtualSystemName(env, vsId, lang, (string)n.xenvalue);
UpdateVirtualSystemSettingData(env, vsId, "ElementName", (string)n.xenvalue);
UpdateVirtualSystemSettingData(env, vsId, "Caption", _ovfrm.GetString("CONVERT_APP_NAME"));
}
}
else if (n.xenname.ToLower().Equals("memory_static_max"))
{
if (n.xenvalue != null && n.xenvalue is string && ((string)n.xenvalue).Length > 0)
{
UInt64 memory = Convert.ToUInt64(n.xenvalue) / MB;
SetMemory(env, vsId, memory, "MB");
}
}
else if (n.xenname.ToLower().Equals("vcpus_max"))
{
if (n.xenvalue != null && n.xenvalue is string && ((string)n.xenvalue).Length > 0)
{
UInt64 cpus = Convert.ToUInt64(n.xenvalue);
SetCPUs(env, vsId, cpus);
}
}
else if (
n.xenname.ToLower().Equals("pv_bootloader") ||
n.xenname.ToLower().Equals("pv_kernel") ||
n.xenname.ToLower().Equals("pv_ramdisk") ||
n.xenname.ToLower().Equals("pv_args") ||
n.xenname.ToLower().Equals("pv_bootloader_args") ||
n.xenname.ToLower().Equals("pv_legacy_args") ||
n.xenname.ToLower().Equals("hvm_boot_policy") ||
n.xenname.ToLower().Equals("hvm_shadow_multiplier")
)
{
if (n.xenvalue != null && n.xenvalue is string && ((string)n.xenvalue).Length > 0)
{
if (n.xenname.ToLower().StartsWith("pv"))
{
PVvalue++;
}
if (n.xenname.ToLower().StartsWith("hvm_boot"))
{
PVvalue--;
}
AddOtherSystemSettingData(env, vsId, lang, n.xenname, (string)n.xenvalue, _ovfrm.GetString("XENSERVER_SPECIFIC_DESCRIPTION"));
}
}
else if (n.xenname.ToLower().Equals("hvm_boot_params"))
{
if (n.xenvalue != null && n.xenvalue is XenStruct && ((XenStruct)n.xenvalue).xenmember != null)
{
string bootorder = "dc";
foreach (XenMember xm in ((XenStruct)n.xenvalue).xenmember)
{
PVvalue--;
if (xm.xenname.ToLower().Equals("order"))
{
if (xm.xenvalue != null && xm.xenvalue is string && ((string)xm.xenvalue).Length > 0)
{
bootorder = (string)xm.xenvalue;
}
}
}
AddOtherSystemSettingData(env, vsId, lang, n.xenname, bootorder, _ovfrm.GetString("XENSERVER_SPECIFIC_DESCRIPTION"));
}
}
else if (n.xenname.ToLower().Equals("platform"))
{
if (n.xenvalue != null && n.xenvalue is XenStruct && ((XenStruct)n.xenvalue).xenmember != null)
{
StringBuilder p = new StringBuilder();
foreach (XenMember xm in ((XenStruct)n.xenvalue).xenmember)
{
if (xm.xenvalue != null && xm.xenvalue is string && ((string)xm.xenvalue).Length > 0)
{
p.AppendFormat("{0}={1}; ", xm.xenname, (string)xm.xenvalue);
}
}
AddOtherSystemSettingData(env, vsId, lang, n.xenname, p.ToString().Trim(), _ovfrm.GetString("XENSERVER_PLATFORM_DESCRIPTION"));
}
}
else if (n.xenname.ToLower().Equals("other_config"))
{
// Ignored, why you say? Because I haven't found one that is 'required' to reproduce the vm, yet.
}
else if (n.xenname.ToLower().Equals("domarch"))
{
// Can't depend on a value here but we need to set it to work correctly.
if (n.xenvalue != null && n.xenvalue is string && ((string)n.xenvalue).Length > 0)
{
string svalue = (string)n.xenvalue;
if (svalue.Equals("hvm"))
{
PVvalue = -10;
}
}
if (PVvalue < 0)
{
UpdateVirtualSystemSettingData(env, vsId, "VirtualSystemType", "hvm-3.0-unknown");
}
else
{
UpdateVirtualSystemSettingData(env, vsId, "VirtualSystemType", "xen-3.0-unknown");
}
}
}
log.DebugFormat("OVF.TransformXvaOvf_VM completed {0}", vsId);
}
private void TransformXvaOvf_VIF(EnvelopeType env, string vsId, string lang, XenStruct vmstruct)
{
string vifuuid = null;
string mac = null;
foreach (XenMember n in vmstruct.xenmember)
{
//
// Currently these are the only values we care about.
//
if (n.xenname.ToLower().Equals("uuid") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
vifuuid = (string)n.xenvalue;
if (vifuuid.ToLower().Contains("null"))
{
vifuuid = null;
}
}
else if (n.xenname.ToLower().Equals("network") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
string netref = ((string)n.xenvalue);
if (!netref.ToLower().Contains("null"))
{
if (!mappings.ContainsKey(netref))
{
mappings.Add(netref, vifuuid);
}
}
}
else if (n.xenname.ToLower().Equals("mac") &&
n.xenvalue != null &&
n.xenvalue is string &&
((string)n.xenvalue).Length > 0)
{
mac = ((string)n.xenvalue);
}
}
AddNetwork(env, vsId, lang, vifuuid, null, mac);
log.DebugFormat("OVF.TransformXvaOvf_VIF completed {0}", vsId);
}
private void TransformXvaOvf_VDI(EnvelopeType env, string vsId, string lang, string refId, DiskInfo di, XenStruct vmstruct)
{
string instanceId = null;
if (mappings.ContainsKey(refId))
{
instanceId = string.Format(@"Xen:{0}/{1}", vsId, mappings[refId]);
}
else
{
instanceId = string.Format(@"Xen:{0}/{1}", vsId, Guid.NewGuid().ToString());
}
string description = null;
string vhdfilename = di.VhdFileName;
ulong filesize = 0;
ulong capacity = 0;
ulong freespace = 0;
foreach (XenMember n in vmstruct.xenmember)
{
if (n.xenname.ToLower().Equals("virtual_size"))
{
capacity = Convert.ToUInt64(n.xenvalue);
}
else if (n.xenname.ToLower().Equals("physical_utilisation"))
{
filesize = Convert.ToUInt64(n.xenvalue);
}
}
freespace = capacity - filesize;
UpdateDisk(env, vsId, instanceId, description, vhdfilename, filesize, capacity, freespace);
log.DebugFormat("OVF.TransformXvaOvf_VDI completed {0}", vsId);
}
private static void CryptoFileWrapper(EnvelopeType env, string ovffilename, string password, bool encrypt)
{
bool process = true;
if ((env.References == null) ||
(env.References.File == null) ||
(env.References.File.Length == 0))
{
Log.Info("OVF.Security: No files to encrypt/decrypt.");
return;
}
try
{
List<DataReference> dataReference = new List<DataReference>();
string cryptoclassname = (string)AlgorithmMap((Properties.Settings.Default.encryptAlgorithmURI.Split(new char[] { '#' }))[1].ToLower().Replace('-', '_'));
int keysize = Convert.ToInt32(Properties.Settings.Default.encryptKeyLength);
string fileuuids = null;
string version = null;
//
// Initial version really only works when there is ONLY ONE SecuritySection::Security
//
#region GET DECRYPT INFO
if (!encrypt)
{
SecuritySection_Type securitysection = null;
foreach (Section_Type section in env.Sections)
{
if (section is SecuritySection_Type)
{
securitysection = (SecuritySection_Type)section;
break;
}
}
foreach (Security_Type securitytype in securitysection.Security)
{
foreach (XenOvf.Definitions.XENC.ReferenceType dataref in securitytype.ReferenceList.Items)
{
if (dataref is DataReference)
{
fileuuids += ":" + ((DataReference)dataref).ValueType;
}
}
if (securitytype.EncryptionMethod != null &&
securitytype.EncryptionMethod.Algorithm != null)
{
string algoname = (securitytype.EncryptionMethod.Algorithm.Split(new char[] { '#' }))[1].ToLower().Replace('-', '_');
object x = Properties.Settings.Default[algoname];
if (x != null)
{
cryptoclassname = (string)x;
keysize = Convert.ToInt32(securitytype.EncryptionMethod.KeySize);
}
}
if (!string.IsNullOrEmpty(securitytype.version))
{
version = securitytype.version;
}
}
}
#endregion
#region PROCESS FILES
foreach (File_Type file in env.References.File)
{
if (encrypt)
{
version = Properties.Settings.Default.securityVersion;
if (file.Id == null)
{
file.Id = "xen_" + Guid.NewGuid().ToString();
DataReference newDataReference = new DataReference();
newDataReference.ValueType = file.Id;
dataReference.Add(newDataReference);
process = true;
}
else
{
Log.Info("File already encrypted, skipping. [{0}]", file.href);
process = false;
}
}
else
{
if (file.Id != null &&
fileuuids != null &&
fileuuids.ToLower().Contains(file.Id.ToLower()))
{
process = true;
file.Id = null;
}
else
{
process = false;
Log.Info("File is not encrypted, skipping. [{0}]", file.href);
}
}
if (process)
{
string fullname = string.Format(@"{0}\{1}", Path.GetDirectoryName(ovffilename), file.href);
Log.Debug(@"{0} : {1}", encrypt ? "Encrypt" : "Decrypt", fullname);
ICryptoTransform trans = CryptoSetup(cryptoclassname, password, encrypt, version);
CryptoFile(trans, fullname, fullname + ".tmp", encrypt);
if (_cancelEncrypt)
{
File.Delete(fullname + ".tmp");
}
else
{
File.Delete(fullname);
File.Move(fullname + ".tmp", fullname);
}
}
}
#endregion
#region BUILD SECURITY SECTION
if (encrypt && process && !_cancelEncrypt)
{
List<Section_Type> sections = new List<Section_Type>();
SecuritySection_Type securitySection = null;
foreach (Section_Type section in env.Sections)
{
if (section is SecuritySection_Type)
{
securitySection = (SecuritySection_Type)section;
}
else
{
sections.Add(section);
}
}
if (securitySection == null)
{
securitySection = new SecuritySection_Type();
securitySection.Info = new Msg_Type();
securitySection.Info.Value = "Encrypted Content Definition";
}
List<Security_Type> secType = new List<Security_Type>();
if (securitySection.Security != null && securitySection.Security.Length > 0)
{
secType.AddRange(securitySection.Security);
}
Security_Type securityType = new Security_Type();
securityType.version = Properties.Settings.Default.securityVersion;
securityType.Id = "xen_" + Guid.NewGuid().ToString();
ReferenceList referenceList = new ReferenceList();
referenceList.Items = dataReference.ToArray();
List<ItemsChoiceType3> ictList = new List<ItemsChoiceType3>();
for (int i = 0; i < dataReference.Count; i++)
{
ictList.Add(ItemsChoiceType3.DataReference);
}
referenceList.ItemsElementName = ictList.ToArray();
EncryptionMethodType encryptMethod = new EncryptionMethodType();
encryptMethod.KeySize = Convert.ToString(_KeySize);
encryptMethod.Algorithm = Properties.Settings.Default.encryptAlgorithmURI;
EncryptedDataType EncryptedData = new EncryptedDataType();
EncryptedData.CipherData = new CipherDataType();
CryptoElement(EncryptedData, KnownEncrypt, cryptoclassname, version, password);
securityType.ReferenceList = referenceList;
securityType.EncryptionMethod = encryptMethod;
securityType.EncryptedData = EncryptedData;
secType.Add(securityType);
securitySection.Security = secType.ToArray();
sections.Add(securitySection);
env.Sections = sections.ToArray();
}
#endregion
}
catch (Exception ex)
{
Log.Error("OVF.Security: Cryptography error: {0}", ex.Message);
throw ex;
}
}
private void AddVssd(EnvelopeType ovfEnv, string vsId, string vhsId)
{
AddVssd(ovfEnv, vsId, vhsId, Properties.Settings.Default.Language);
}
public OvfStorageResourceContainer( EnvelopeType selectedOvfEnvelope, string sysId)
{
rasdArray = OVF.FindDiskRasds(selectedOvfEnvelope, sysId);
this.selectedOvfEnvelope = selectedOvfEnvelope;
}
private void AddVssd(EnvelopeType ovfEnv, string vsId, string vhsId, string lang)
{
if (Win32_ComputerSystem != null)
{
#region FIND BY PROPERTIES NOT EXPLICID
string name = "Generic Computer";
string caption = "Generic Caption";
string description = "Autogenerated OVF/OVA Package";
foreach (PropertyData pd in Win32_ComputerSystem.Properties)
{
if (pd.Name.ToLower().Equals("name") && pd.Value != null)
{
name = (string)pd.Value;
}
else if (pd.Name.ToLower().Equals("caption") && pd.Value != null)
{
caption = (string)pd.Value;
}
else if (pd.Name.ToLower().Equals("description") && pd.Value != null)
{
description = (string)pd.Value;
}
}
#endregion
UpdateVirtualSystemName(ovfEnv, vsId, lang, name);
AddVirtualSystemSettingData(ovfEnv,
vsId,
vhsId,
name,
caption,
description,
Guid.NewGuid().ToString(),
"301"); // 301 == Microsoft (source), hvm-3.0-unknown == (xen source) Microsoft && Linux NOT PV'd, xen-3.0-unknown == PV'd
}
else
{
Random rand = new Random();
string name = string.Format(Messages.AUTOGENERATED, rand.Next());
string caption = string.Format(Messages.UNKNOWN);
string description = string.Format(Messages.UNKNOWN);
UpdateVirtualSystem(ovfEnv, vsId, lang, name);
AddVirtualSystemSettingData(ovfEnv,
vsId,
vhsId,
name,
caption,
description,
Guid.NewGuid().ToString(),
"301");
log.Warn("System definition not available, created defaults");
}
log.Debug("OVF.AddVssd completed");
}
public OvfNetworkResourceContainer(string sysId, EnvelopeType envelopeType)
{
rasdArray = OVF.FindRasdByType(envelopeType, sysId, 10);
}
private void SetDeviceConnections(EnvelopeType ovfEnv, VirtualHardwareSection_Type vhs)
{
int[] connections = new int[16];
int deviceoffset = 0;
List<RASD_Type> rasdList = new List<RASD_Type>();
rasdList.AddRange(vhs.Item);
rasdList.Sort(compareControllerRasd); // sorts based on ResourceType.Value
// For Xen really nothing to do here, does not support the different
// controller types, therefore we must ensure
// via positional on controllers.
// IDE - #1
// SCSI - #2
// IDE 0 Disk 0 Goes to Xen: userdevice=0
// IDE 0 Disk 1 Goes to Xen: userdevice=1
// IDE 1 CD/DVD 0 Goes to Xen: userdevice=2
// IDE 1 Disk 1 UnUsed
// SCSI 0 Disk 0 Goes to Xen: userdevice=3
// SCSI 0 Disk 1 Goes to Xen: userdevice=4
// and so forth.
foreach (RASD_Type rasd in rasdList)
{
switch (rasd.ResourceType.Value)
{
case 5: // IDE Controller #1
case 6: // Parallel SCSI HBA #2
case 7: // FC HBA #3
case 8: // iSCSI HBA #4
case 9: // IB HCA #5
{
List<RASD_Type> connectedrasds = FindConnectedItems(rasd.InstanceID.Value, vhs.Item, null);
foreach (RASD_Type _rasd in connectedrasds)
{
//if (_rasd.Connection != null &&
// _rasd.Connection.Length > 0 &&
// _rasd.Connection[0] != null &&
// _rasd.Connection[0].Value != null &&
// _rasd.Connection[0].Value.Length > 0)
if (_rasd.ResourceType.Value == 15 || _rasd.ResourceType.Value == 16)
{
deviceoffset = 2;
}
else
{
deviceoffset = 0;
}
if (Tools.ValidateProperty("Connection", _rasd))
{
if (!_rasd.Connection[0].Value.ToLower().Contains("device="))
{
_rasd.Connection[0].Value = string.Format("{0},device={1}", _rasd.Connection[0].Value, FindNextAvailable(deviceoffset, connections, 0));
}
}
else
{
_rasd.Connection = new cimString[] { new cimString(string.Format("device={0}", FindNextAvailable(deviceoffset, connections, 0))) };
}
}
break;
}
}
}
}
/// <summary>
/// Check the Envelope to see if the files are compressed.
/// </summary>
/// <param name="env">EnvelopeType</param>
/// <param name="method">out method used: Gzip | BZip2</param>
/// <returns>True|False</returns>
public bool IsCompressed(EnvelopeType env, out string method)
{
if (env.References != null && env.References.File != null && env.References.File.Length > 0)
{
foreach (File_Type file in env.References.File)
{
if (!string.IsNullOrEmpty(file.compression))
{
method = file.compression;
return true;
}
}
}
method = "none";
return false;
}
public void Process(EnvelopeType ovfObj, string pathToOvf, string passcode)
{
Process(XenSession, ovfObj, pathToOvf, passcode);
}
/// <summary>
/// Checks to see if an OVF is encrypted.
/// </summary>
/// <param name="ovfFilename">EnvelopeType OVF object</param>
/// <returns>true = is encrypted, false = not encrypted</returns>
public static bool HasEncryption(EnvelopeType ovfObj)
{
SecuritySection_Type[] security = FindSections<SecuritySection_Type>(ovfObj.Sections);
if (security != null && security.Length > 0)
{
return true; // we now know that a security section is defined therefore something is encrypted.
}
return false;
}
private void TransformXvaOvf_SR(EnvelopeType env, string vsId, string lang, XenStruct vmstruct)
{
//
// Currently this is data for the Environment not necessarily part of the VM
// even if the VM is in this SR it may not exist in the target server therefore
// it is not required in the OVF.
//
log.DebugFormat("OVF.TransformXvaOvf_SR completed {0}", vsId);
}
private void SetIfDeviceIsBootable(EnvelopeType ovfEnv, RASD_Type rasd)
{
// This is a best guess algorithm. without opening the VHD itself, there is no guarrenteed method
// to delineate this, so we guess.
// IF it's created by Kensho/XenConvert there will be a chance of having a clue.
// Otherwise it'll be based upon 'order' and device 0 will win the bootable device.
bool isBootable = true;
VirtualDiskDesc_Type[] disks = null;
foreach (Section_Type sect in ovfEnv.Sections)
{
if (sect is DiskSection_Type)
{
disks = ((DiskSection_Type)sect).Disk;
}
}
if (disks == null)
return;
bool useHostResource = false;
if (Tools.ValidateProperty("HostResource", rasd))
{
log.Debug("Using HostResource to find Disk");
useHostResource = true;
}
else
{
log.Debug("Using InstanceID to find Disk");
}
foreach(VirtualDiskDesc_Type disk in disks)
{
if (useHostResource)
{
if (rasd.HostResource[0].Value.Contains(disk.diskId))
{
isBootable = disk.isBootable;
}
}
else
{
if (rasd.InstanceID.Value.Contains(disk.diskId))
{
isBootable = disk.isBootable;
}
}
}
if (Tools.ValidateProperty("Address", rasd))
{
if ((rasd.ResourceType.Value == 21 ||
rasd.ResourceType.Value == 5) &&
rasd.Address.Value == "0")
{
isBootable = true;
}
}
if (Tools.ValidateProperty("AddressOnParent", rasd))
{
if ((rasd.ResourceType.Value == 17 ||
rasd.ResourceType.Value == 19) &&
rasd.AddressOnParent.Value == "0")
{
isBootable = true;
}
}
if (Tools.ValidateProperty("Connection", rasd))
{
if (rasd.Connection[0].Value.Contains("device=0"))
{
isBootable = true;
}
if (!rasd.Connection[0].Value.Contains("bootable"))
{
rasd.Connection[0].Value = string.Format("{0},bootable={1}", rasd.Connection[0].Value, isBootable);
}
}
else
{
rasd.Connection = new cimString[] { new cimString(string.Format("bootable={0}", isBootable)) };
}
}
/// <summary>
/// An ovf can contain both encrypted and non-encrypted file mixed together.
/// find if file name is encrypted.
/// 1. check the References for the security ID
/// 2. check the Security id section exists.
/// </summary>
/// <param name="ovfObj">OVF Envelope</param>
/// <param name="filename">filename to check</param>
/// <returns>true = encrypted; false = not encrypted</returns>
public static bool IsThisEncrypted(EnvelopeType ovfObj, RASD_Type rasd)
{
bool _isEncrypted = false;
// 15,16,17,19,20 are attached files.
// rest is RASD specific
switch (rasd.ResourceType.Value)
{
case 15:
case 16:
case 17:
case 19:
case 20:
{
File_Type file = FindFileReferenceByRASD(ovfObj, rasd);
if (file != null)
{
if (!string.IsNullOrEmpty(file.Id))
{
_isEncrypted = IsThisIdEncrypted(ovfObj, file.Id);
}
}
break;
}
default:
{
// currently encrypted RASD or Elements, isn't being done, but this can check it.
if (rasd.AnyAttr != null && rasd.AnyAttr.Length > 0)
{
foreach (XmlAttribute xa in rasd.AnyAttr)
{
if (xa.Name.ToLower().Equals("xenc:id"))
{
_isEncrypted = IsThisIdEncrypted(ovfObj, xa.Value);
break;
}
}
}
break;
}
}
return _isEncrypted;
}
public void Process(Session xenSession, EnvelopeType ovfObj, string pathToOvf, string passcode)
{
if (xenSession == null)
throw new InvalidOperationException(Messages.ERROR_NOT_CONNECTED);
string ovfname = Guid.NewGuid().ToString();
vifDeviceIndex = 0;
string encryptionVersion = null;
#region CHECK ENCRYPTION
if (OVF.HasEncryption(ovfObj))
{
if (passcode == null)
{
throw new InvalidDataException(Messages.ERROR_NO_PASSWORD);
}
string fileuuids = null;
SecuritySection_Type[] securitysection = OVF.FindSections<SecuritySection_Type>((ovfObj).Sections);
if (securitysection != null && securitysection.Length >= 0)
{
foreach (Security_Type securitytype in securitysection[0].Security)
{
if (securitytype.ReferenceList.Items != null && securitytype.ReferenceList.Items.Length > 0)
{
foreach (XenOvf.Definitions.XENC.ReferenceType dataref in securitytype.ReferenceList.Items)
{
if (dataref is DataReference)
{
fileuuids += ":" + ((DataReference)dataref).ValueType;
}
}
}
if (securitytype.EncryptionMethod != null && securitytype.EncryptionMethod.Algorithm != null)
{
string algoname = (securitytype.EncryptionMethod.Algorithm.Split(new char[] { '#' }))[1].ToLower().Replace('-', '_');
object x = OVF.AlgorithmMap(algoname);
if (x != null)
{
EncryptionClass = (string)x;
EncryptionKeySize = Convert.ToInt32(securitytype.EncryptionMethod.KeySize);
}
}
if (!string.IsNullOrEmpty(securitytype.version))
{
encryptionVersion = securitytype.version;
}
}
}
}
#endregion
#region FIND DEFAULT SR
Dictionary<XenRef<Pool>, Pool> pools = Pool.get_all_records(xenSession);
foreach (XenRef<Pool> pool in pools.Keys)
{
DefaultSRUUID = pools[pool].default_SR;
break;
}
#endregion
//
// So the process is the same below, change this
//
if (ovfObj.Item is VirtualSystem_Type)
{
VirtualSystem_Type vstemp = (VirtualSystem_Type)ovfObj.Item;
ovfObj.Item = new VirtualSystemCollection_Type();
((VirtualSystemCollection_Type)ovfObj.Item).Content = new Content_Type[] { vstemp };
}
#region Create appliance
XenRef<VM_appliance> applRef = null;
if (ApplianceName != null)
{
var vmAppliance = new VM_appliance {name_label = ApplianceName, Connection = xenSession.Connection};
applRef = VM_appliance.create(xenSession, vmAppliance);
}
#endregion
foreach (VirtualSystem_Type vSystem in ((VirtualSystemCollection_Type)ovfObj.Item).Content)
{
//FIND/SET THE NAME OF THE VM
ovfname = OVF.FindSystemName(ovfObj, vSystem.id);
auditLog.DebugFormat("Import: {0}, {1}", ovfname, pathToOvf);
VirtualHardwareSection_Type vhs = OVF.FindVirtualHardwareSectionByAffinity(ovfObj, vSystem.id, "xen");
XenRef<VM> vmRef = DefineSystem(xenSession, vhs, ovfname);
if (vmRef == null)
{
log.Error(Messages.ERROR_CREATE_VM_FAILED);
throw new ImportException(Messages.ERROR_CREATE_VM_FAILED);
}
HideSystem(xenSession, vmRef);
log.DebugFormat("OVF.Import.Process: DefineSystem completed ({0})", VM.get_name_label(xenSession, vmRef));
#region Set appliance
if (applRef != null)
VM.set_appliance(xenSession, vmRef.opaque_ref, applRef.opaque_ref);
if (ovfObj.Sections != null)
{
StartupSection_Type[] startUpArray = OVF.FindSections<StartupSection_Type>(ovfObj.Sections);
if (startUpArray != null && startUpArray.Length > 0)
{
var startupSection = startUpArray[0];
var itemList = startupSection.Item;
if (itemList != null)
{
var item = itemList.FirstOrDefault(it => it.id == vSystem.id);
if (item != null)
{
VM.set_start_delay(xenSession, vmRef.opaque_ref, item.startDelay);
VM.set_shutdown_delay(xenSession, vmRef.opaque_ref, item.stopDelay);
VM.set_order(xenSession, vmRef.opaque_ref, item.order);
}
}
}
}
#endregion
#region set has_vendor_device
if (Helpers.DundeeOrGreater(xenSession.Connection))
{
var data = vhs.VirtualSystemOtherConfigurationData;
if (data != null)
{
var datum = data.FirstOrDefault(s => s.Name == "VM_has_vendor_device");
if (datum != null)
{
bool hasVendorDevice;
if (bool.TryParse(datum.Value.Value, out hasVendorDevice) && hasVendorDevice)
VM.set_has_vendor_device(xenSession, vmRef.opaque_ref, hasVendorDevice);
}
}
}
#endregion
#region Set vgpu
GPU_group gpuGroup;
VGPU_type vgpuType;
FindGpuGroupAndVgpuType(xenSession, vhs, out gpuGroup, out vgpuType);
if (gpuGroup != null)
{
var other_config = new Dictionary<string, string>();
if (Helpers.FeatureForbidden(xenSession, Host.RestrictVgpu))
VGPU.create(xenSession, vmRef.opaque_ref, gpuGroup.opaque_ref, "0", other_config);
else if (vgpuType != null)
VGPU.create(xenSession, vmRef.opaque_ref, gpuGroup.opaque_ref, "0", other_config, vgpuType.opaque_ref);
}
#endregion
SetDeviceConnections(ovfObj, vhs);
try
{
foreach (RASD_Type rasd in vhs.Item)
{
string thisPassCode = null;
// Check to see if THIS rasd is encrypted, if so, set the passcode.
if (OVF.IsThisEncrypted(ovfObj, rasd))
thisPassCode = passcode;
string compression = "None";
if (rasd.ResourceType.Value == 17 || rasd.ResourceType.Value == 19 || rasd.ResourceType.Value == 21)
{
bool skip = Tools.ValidateProperty("Caption", rasd) &&
(
rasd.Caption.Value.ToUpper().Contains("COM") ||
rasd.Caption.Value.ToUpper().Contains("FLOPPY") ||
rasd.Caption.Value.ToUpper().Contains("ISO")
);
if (!skip)
{
File_Type file = OVF.FindFileReferenceByRASD(ovfObj, rasd);
if (file == null)
continue;
if (IsKnownURIType(file.href))
_filedownloadsize = file.size;
VirtualDiskDesc_Type vdisk = OVF.FindDiskReference(ovfObj, rasd);
SetIfDeviceIsBootable(ovfObj, rasd);
AdditionalSpace = OVF.ComputeCapacity(Convert.ToInt64(vdisk.capacity), vdisk.capacityAllocationUnits); // used in Wim file imports only.
AddResourceSettingData(xenSession, vmRef, rasd, pathToOvf, OVF.FindRasdFileName(ovfObj, rasd, out compression), compression, encryptionVersion, thisPassCode);
}
}
else
{
AddResourceSettingData(xenSession, vmRef, rasd, pathToOvf, OVF.FindRasdFileName(ovfObj, rasd, out compression), compression, encryptionVersion, thisPassCode);
}
}
InstallSection_Type[] installSection = OVF.FindSections<InstallSection_Type>(vSystem.Items);
if (installSection != null && installSection.Length == 1)
{
OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.MarqueeOn, "Import", Messages.START_POST_INSTALL_INSTRUCTIONS));
OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.ImportProgress, "Import", Messages.START_POST_INSTALL_INSTRUCTIONS));
HandleInstallSection(xenSession, vmRef, installSection[0]);
}
ShowSystem(xenSession, vmRef);
}
catch (Exception ex)
{
if (ex is OperationCanceledException)
throw;
log.Error(Messages.ERROR_IMPORT_FAILED);
throw new Exception(Messages.ERROR_IMPORT_FAILED, ex);
}
}
OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.MarqueeOff, "Import", ""));
int _processId = System.Diagnostics.Process.GetCurrentProcess().Id;
string _touchFile = Path.Combine(pathToOvf, "xen__" + _processId);
//added check again as Delete needs write permissions and even if the file does not exist import will fail if the user has read only permissions
if (File.Exists(_touchFile))
File.Delete(_touchFile);
OnUpdate(new XenOvfTranportEventArgs(XenOvfTranportEventType.ImportThreadComplete, "Import", Messages.COMPLETED_IMPORT));
}
public static bool IsThisIdEncrypted(EnvelopeType ovfObj, string id)
{
SecuritySection_Type[] security = FindSections<SecuritySection_Type>(ovfObj.Sections);
if (security != null && security.Length > 0) // if no security section don't bother going any further.
{
foreach (SecuritySection_Type sst in security)
{
foreach (Security_Type st in sst.Security)
{
foreach (XenOvf.Definitions.XENC.DataReference dataref in st.ReferenceList.Items)
{
if (dataref.ValueType != null && dataref.ValueType.Length > 0 &&
dataref.ValueType.Contains(id))
{
return true; // no need to go anyfurther, nicer just to leave now.
}
}
}
}
}
return false; // get here... its not encrypted.
}
