/*http://www.geoffchappell.com/notes/windows/boot/bcd/objects.htm
* None of these are used but may be handy in the future
* private const string BOOT_MGR = "9dea862c-5cdd-4e70-acc1-f32b344d4795";
* private const string FWBOOT_MGR = "a5a30fa2-3d06-4e9f-b5f4-a01df9d1fcba";
* private const string MEM_DIAG = "2721d73-1db4-4c62-bf78-c548a880142d";
* private const string RESUME = "147aa509-0358-4473-b83b-d950dda00615";
* private const string NTLDR = "466f5a88-0af2-4f76-9038-095b170dc21c";
* private const string CURRENT = "fa926493-6f1c-4193-a414-58f0b2456d1e";
*/
public string UpdateEntry(string bcd, long newOffsetBytes)
{
var charOffsetHex = newOffsetBytes.ToString("X16").Reverse().ToList();
var output = new StringBuilder();
for (var i = 0; i < charOffsetHex.Count; i++)
{
if (i % 2 != 0)
{
continue;
}
if (i + 1 < charOffsetHex.Count)
{
output.Append(charOffsetHex[i + 1]);
}
output.Append(charOffsetHex[i]);
if (i + 2 != charOffsetHex.Count)
{
output.Append(",");
}
}
var newOffsetHex = output.ToString();
var guids = new List <string>();
var regfile = new RegFileObject(bcd);
foreach (var entry in regfile.RegValues)
{
foreach (var value in entry.Value.Values)
{
if (!value.Value.ToLower().Contains("winload.exe"))
{
continue;
}
var matches = Regex.Matches(entry.Key, @"\{(.*?)\}");
guids.AddRange(from Match m in matches select m.Groups[1].Value);
}
}
guids = guids.Distinct().ToList();
foreach (var guid in guids)
{
var regBinary =
regfile.RegValues[@".\Objects\{" + guid + @"}\Elements\11000001"]["Element"]
.Value;
var regBinarySplit = regBinary.Split(',');
var originalOffsetHex = regBinarySplit[32] + "," + regBinarySplit[33] + "," + regBinarySplit[34] + "," +
regBinarySplit[35] + "," +
regBinarySplit[36] + "," + regBinarySplit[37] + "," + regBinarySplit[38] + "," +
regBinarySplit[39];
var regex = new Regex(originalOffsetHex, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, newOffsetHex);
}
return(StringManipulationServices.Encode(bcd));
}
public TftpServerDTO GetComputerTftpServers(string mac)
{
var tftpDto = new TftpServerDTO();
tftpDto.TftpServers = new List <string>();
if (SettingServices.ServerIsNotClustered)
{
tftpDto.TftpServers.Add(
StringManipulationServices.PlaceHolderReplace(
SettingServices.GetSettingValue(SettingStrings.TftpServerIp)));
}
else
{
var clusterServices = new ClusterGroupServices();
var secondaryServerServices = new SecondaryServerServices();
List <ClusterGroupServerEntity> clusterServers;
var computer = new ComputerServices().GetComputerFromMac(mac);
if (computer == null)
{
var cg = new ClusterGroupServices().GetDefaultClusterGroup();
clusterServers = clusterServices.GetActiveClusterServers(cg.Id);
}
else
{
var cg = new ComputerServices().GetClusterGroup(computer.Id);
clusterServers = clusterServices.GetActiveClusterServers(cg.Id);
}
foreach (var tftpServer in clusterServers.Where(x => x.TftpRole == 1))
{
if (tftpServer.ServerId == -1)
{
tftpDto.TftpServers.Add(
StringManipulationServices.PlaceHolderReplace(
SettingServices.GetSettingValue(SettingStrings.TftpServerIp)));
}
else
{
var serverIdentifier =
secondaryServerServices.GetSecondaryServer(tftpServer.ServerId).Name;
var tServer =
new APICall(new SecondaryServerServices().GetToken(serverIdentifier)).ServiceAccountApi
.GetTftpServer();
if (tServer != null)
{
tftpDto.TftpServers.Add(tServer);
}
}
}
}
return(tftpDto);
}
private ValidationResultDTO ValidateFileFolder(FileFolderEntity fileFolder, bool isNewTemplate)
{
var validationResult = new ValidationResultDTO {
Success = true
};
if (string.IsNullOrEmpty(fileFolder.Name))
{
validationResult.Success = false;
validationResult.ErrorMessage = "Name Is Not Valid";
return(validationResult);
}
if (fileFolder.Path.Trim().EndsWith("/") || fileFolder.Path.Trim().EndsWith(@"\"))
{
char[] toRemove = { '/', '\\' };
var trimmed = fileFolder.Path.TrimEnd(toRemove);
fileFolder.Path = trimmed;
}
if (fileFolder.Path.Trim().StartsWith("/") || fileFolder.Path.Trim().StartsWith(@"\"))
{
char[] toRemove = { '/', '\\' };
var trimmed = fileFolder.Path.TrimStart(toRemove);
fileFolder.Path = trimmed;
}
fileFolder.Path = StringManipulationServices.WindowsToUnixFilePath(fileFolder.Path);
if (isNewTemplate)
{
if (_uow.FileFolderRepository.Exists(h => h.Name == fileFolder.Name))
{
validationResult.Success = false;
validationResult.ErrorMessage = "File / Folder Name Already Exists";
return(validationResult);
}
}
else
{
var originalTemplate = _uow.FileFolderRepository.GetById(fileFolder.Id);
if (originalTemplate.Name != fileFolder.Name)
{
if (_uow.FileFolderRepository.Exists(h => h.Name == fileFolder.Name))
{
validationResult.Success = false;
validationResult.ErrorMessage = "File / Folder Already Exists";
return(validationResult);
}
}
}
return(validationResult);
}
public string UpdateLegacy(string bcd, string diskSignature, long windowsPartitionStart)
{
if (diskSignature.Length >= 8)
{
diskSignature = diskSignature.Substring(diskSignature.Length - 8);
}
var hexDiskSignature = diskSignature.Reverse().ToList();
var hexPartitionStart = windowsPartitionStart.ToString("X16").Reverse().ToList();
var reorderedDiskSigHex = HexReorder(hexDiskSignature);
var reorderedPartStartHex = HexReorder(hexPartitionStart);
var regfile = new RegFileObject(bcd);
foreach (var entry in regfile.RegValues)
{
if (entry.Key.EndsWith("11000001") || entry.Key.EndsWith("21000001") || entry.Key.EndsWith("31000003"))
{
var regValue = entry.Value["Element"].Value;
var regValueSplit = regValue.Split(',');
if (regValue.Length <= 263)
{
var originalPartStart = regValueSplit[32] + "," + regValueSplit[33] + "," + regValueSplit[34] +
"," + regValueSplit[35] + "," +
regValueSplit[36] + "," + regValueSplit[37] + "," + regValueSplit[38] +
"," + regValueSplit[39];
var originalDiskSig = regValueSplit[56] + "," + regValueSplit[57] + "," + regValueSplit[58] +
"," + regValueSplit[59];
var regex = new Regex(originalPartStart, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedPartStartHex);
regex = new Regex(originalDiskSig, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedDiskSigHex);
}
else
{
var originalDiskSig = regValueSplit[108] + "," + regValueSplit[109] + "," + regValueSplit[110] +
"," + regValueSplit[111];
var regex = new Regex(originalDiskSig, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedDiskSigHex);
}
}
}
return(StringManipulationServices.Encode(bcd));
}
public string GetStandardLegacy(string diskSignature)
{
if (diskSignature.Length >= 8)
{
diskSignature = diskSignature.Substring(diskSignature.Length - 8);
}
var hexDiskSignature = diskSignature.Reverse().ToList();
var reorderedDiskSigHex = HexReorder(hexDiskSignature);
var path = HttpContext.Current.Server.MapPath("~") + Path.DirectorySeparatorChar + "private" +
Path.DirectorySeparatorChar + "bcd" + Path.DirectorySeparatorChar +
"legacy";
var bcd = File.ReadAllText(path);
var regex = new Regex("DISK_SIGNATURE", RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedDiskSigHex);
return(StringManipulationServices.Encode(bcd));
}
public ActionResultDTO AddImageProfileFileFolder(ImageProfileFileFolderEntity imageProfileFileFolder)
{
imageProfileFileFolder.DestinationFolder =
StringManipulationServices.WindowsToUnixFilePath(imageProfileFileFolder.DestinationFolder);
if (imageProfileFileFolder.DestinationFolder.Trim().EndsWith("/") &&
imageProfileFileFolder.DestinationFolder.Length > 1)
{
char[] toRemove = { '/' };
var trimmed = imageProfileFileFolder.DestinationFolder.TrimEnd(toRemove);
imageProfileFileFolder.DestinationFolder = trimmed;
}
_uow.ImageProfileFileFolderRepository.Insert(imageProfileFileFolder);
_uow.Save();
var actionResult = new ActionResultDTO();
actionResult.Success = true;
actionResult.Id = imageProfileFileFolder.Id;
return(actionResult);
}
public string GetSysprepTag(int tagId, string imageEnvironment)
{
var tag = new SysprepTagServices().GetSysprepTag(tagId);
tag.OpeningTag = StringManipulationServices.EscapeCharacter(tag.OpeningTag, new[] { ">", "<" });
tag.ClosingTag = StringManipulationServices.EscapeCharacter(tag.ClosingTag, new[] { ">", "<", "/" });
tag.Contents = StringManipulationServices.EscapeCharacter(tag.Contents, new[] { ">", "<", "/", "\"" });
var a = tag.Contents.Replace("\r", imageEnvironment == "win" ? "" : "\\r");
var b = a.Replace("\n", "\\n");
if (b.Length >= 5)
{
if (b.Substring(b.Length - 5) == "\\r\\n'")
{
b = b.Substring(0, b.Length - 1) + "\\r\\n'";
}
}
tag.Contents = b;
return(JsonConvert.SerializeObject(tag));
}
public ActionResultDTO AddComputer(ComputerEntity computer)
{
var actionResult = new ActionResultDTO();
computer.Mac = StringManipulationServices.FixMac(computer.Mac);
var validationResult = ValidateComputer(computer, "new");
if (validationResult.Success)
{
_uow.ComputerRepository.Insert(computer);
_uow.Save();
actionResult.Success = true;
actionResult.Id = computer.Id;
}
else
{
actionResult.Success = false;
actionResult.ErrorMessage = validationResult.ErrorMessage;
}
return(actionResult);
}
public string GetComputerNonProxyPath(int computerId, bool isActiveOrCustom)
{
var computer = GetComputer(computerId);
var mode = SettingServices.GetSettingValue(SettingStrings.PxeMode);
var pxeComputerMac = StringManipulationServices.MacToPxeMac(computer.Mac);
string path;
var fileName = isActiveOrCustom ? pxeComputerMac : "default";
if (mode.Contains("ipxe"))
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "pxelinux.cfg" +
Path.DirectorySeparatorChar +
fileName + ".ipxe";
}
else if (mode.Contains("grub"))
{
if (isActiveOrCustom)
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "pxelinux.cfg" +
Path.DirectorySeparatorChar +
pxeComputerMac + ".cfg";
}
else
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "grub" +
Path.DirectorySeparatorChar
+ "grub.cfg";
}
}
else
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "pxelinux.cfg" +
Path.DirectorySeparatorChar +
fileName;
}
return(path);
}
public string DistributionPoint(string dpId, string task)
{
var smb = new SMB();
var dp = new DistributionPointServices().GetDistributionPoint(Convert.ToInt32(dpId));
smb.SharePath = "//" + StringManipulationServices.PlaceHolderReplace(dp.Server) + "/" + dp.ShareName;
smb.Domain = dp.Domain;
smb.DisplayName = dp.DisplayName;
smb.IsPrimary = dp.IsPrimary == 1 ? "true" : "false";
if (task.Contains("upload"))
{
smb.Username = dp.RwUsername;
smb.Password = new EncryptionServices().DecryptText(dp.RwPassword);
}
else
{
smb.Username = dp.RoUsername;
smb.Password = new EncryptionServices().DecryptText(dp.RoPassword);
}
return(JsonConvert.SerializeObject(smb));
}
public string GetStandardEfi(string diskGuid, string recoveryGuid, string windowsGuid)
{
var reorderedDisk = GuidReorder(diskGuid);
var reorderedRecovery = GuidReorder(recoveryGuid);
var reorderedWindows = GuidReorder(windowsGuid);
var path = HttpContext.Current.Server.MapPath("~") + Path.DirectorySeparatorChar + "private" +
Path.DirectorySeparatorChar + "bcd" + Path.DirectorySeparatorChar +
"efi";
var bcd = File.ReadAllText(path);
var regex = new Regex("DISK_GUID", RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedDisk);
regex = new Regex("WINDOWS_GUID", RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedWindows);
regex = new Regex("RECOVERY_GUID", RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedRecovery);
return(StringManipulationServices.Encode(bcd));
}
public string UpdateEfi(string bcd, string diskGuid, string recoveryGuid, string windowsGuid)
{
var reorderedDisk = GuidReorder(diskGuid);
var reorderedRecovery = GuidReorder(recoveryGuid);
var reorderedWindows = GuidReorder(windowsGuid);
var regfile = new RegFileObject(bcd);
foreach (var entry in regfile.RegValues)
{
if (entry.Key.EndsWith("11000001") || entry.Key.EndsWith("21000001") || entry.Key.EndsWith("31000003"))
{
var regValue = entry.Value["Element"].Value;
var regValueSplit = regValue.Split(',');
if (regValue.Length <= 263)
{
var originalDisk = regValueSplit[56] + "," + regValueSplit[57] + "," + regValueSplit[58] +
"," + regValueSplit[59] + "," +
regValueSplit[60] + "," + regValueSplit[61] + "," + regValueSplit[62] +
"," + regValueSplit[63] + "," + regValueSplit[64] + "," + regValueSplit[65] +
"," + regValueSplit[66] + "," +
regValueSplit[67] + "," + regValueSplit[68] + "," + regValueSplit[69] +
"," + regValueSplit[70] + "," + regValueSplit[71];
var originalWindowsOrRecovery = regValueSplit[32] + "," + regValueSplit[33] + "," + regValueSplit[34] +
"," + regValueSplit[35] + "," +
regValueSplit[36] + "," + regValueSplit[37] + "," + regValueSplit[38] +
"," + regValueSplit[39] + "," + regValueSplit[40] + "," + regValueSplit[41] +
"," + regValueSplit[42] + "," +
regValueSplit[43] + "," + regValueSplit[44] + "," + regValueSplit[45] +
"," + regValueSplit[46] + "," + regValueSplit[47];
var regex = new Regex(originalDisk, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedDisk);
regex = new Regex(originalWindowsOrRecovery, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, entry.Key.EndsWith("31000003") ? reorderedRecovery : reorderedWindows);
}
else
{
var originalDisk = regValueSplit[108] + "," + regValueSplit[109] + "," + regValueSplit[110] +
"," + regValueSplit[111] + "," +
regValueSplit[112] + "," + regValueSplit[113] + "," + regValueSplit[114] +
"," + regValueSplit[115] + "," + regValueSplit[116] + "," + regValueSplit[117] +
"," + regValueSplit[118] + "," +
regValueSplit[119] + "," + regValueSplit[120] + "," + regValueSplit[121] +
"," + regValueSplit[122] + "," + regValueSplit[123];
var originalRecovery = regValueSplit[84] + "," + regValueSplit[85] + "," + regValueSplit[86] +
"," + regValueSplit[87] + "," +
regValueSplit[88] + "," + regValueSplit[89] + "," + regValueSplit[90] +
"," + regValueSplit[91] + "," + regValueSplit[92] + "," + regValueSplit[93] +
"," + regValueSplit[94] + "," +
regValueSplit[95] + "," + regValueSplit[96] + "," + regValueSplit[97] +
"," + regValueSplit[98] + "," + regValueSplit[99];
var regex = new Regex(originalDisk, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedDisk);
regex = new Regex(originalRecovery, RegexOptions.IgnoreCase);
bcd = regex.Replace(bcd, reorderedRecovery);
}
}
}
return(StringManipulationServices.Encode(bcd));
}
public string GetComputerProxyPath(int computerId, bool isActiveOrCustom, string proxyType)
{
var computer = GetComputer(computerId);
var pxeComputerMac = StringManipulationServices.MacToPxeMac(computer.Mac);
string path = null;
var biosFile = SettingServices.GetSettingValue(SettingStrings.ProxyBiosFile);
var efi32File = SettingServices.GetSettingValue(SettingStrings.ProxyEfi32File);
var efi64File = SettingServices.GetSettingValue(SettingStrings.ProxyEfi64File);
var fileName = isActiveOrCustom ? pxeComputerMac : "default";
switch (proxyType)
{
case "bios":
if (biosFile.Contains("ipxe"))
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar +
proxyType + Path.DirectorySeparatorChar + "pxelinux.cfg" +
Path.DirectorySeparatorChar + fileName + ".ipxe";
}
else
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar +
proxyType + Path.DirectorySeparatorChar + "pxelinux.cfg" +
Path.DirectorySeparatorChar + fileName;
}
break;
case "efi32":
if (efi32File.Contains("ipxe"))
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar +
proxyType + Path.DirectorySeparatorChar + "pxelinux.cfg" +
Path.DirectorySeparatorChar + fileName + ".ipxe";
}
else
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar +
proxyType + Path.DirectorySeparatorChar + "pxelinux.cfg" +
Path.DirectorySeparatorChar + fileName;
}
break;
case "efi64":
if (efi64File.Contains("ipxe"))
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar +
proxyType + Path.DirectorySeparatorChar + "pxelinux.cfg" +
Path.DirectorySeparatorChar + fileName + ".ipxe";
}
else if (efi64File.Contains("grub"))
{
if (isActiveOrCustom)
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar +
proxyType + Path.DirectorySeparatorChar + "pxelinux.cfg" +
Path.DirectorySeparatorChar + pxeComputerMac + ".cfg";
}
else
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "grub" +
Path.DirectorySeparatorChar + "grub.cfg";
}
}
else
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar +
proxyType + Path.DirectorySeparatorChar + "pxelinux.cfg" +
Path.DirectorySeparatorChar + fileName;
}
break;
}
return(path);
}
public bool CreateBootFiles(int id)
{
var computer = GetComputer(id);
if (new ComputerServices().IsComputerActive(computer.Id))
{
return(false); //Files Will Be Processed When task is done
}
var bootMenu = new ComputerServices().GetComputerBootMenu(computer.Id);
if (bootMenu == null)
{
return(false);
}
var pxeMac = StringManipulationServices.MacToPxeMac(computer.Mac);
string path;
if (SettingServices.GetSettingValue(SettingStrings.ProxyDhcp) == "Yes")
{
var list = new List <Tuple <string, string, string> >
{
Tuple.Create("bios", "", bootMenu.BiosMenu),
Tuple.Create("bios", ".ipxe", bootMenu.BiosMenu),
Tuple.Create("efi32", "", bootMenu.Efi32Menu),
Tuple.Create("efi32", ".ipxe", bootMenu.Efi32Menu),
Tuple.Create("efi64", "", bootMenu.Efi64Menu),
Tuple.Create("efi64", ".ipxe", bootMenu.Efi64Menu),
Tuple.Create("efi64", ".cfg", bootMenu.Efi64Menu)
};
if (SettingServices.ServerIsNotClustered)
{
foreach (var tuple in list)
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar + tuple.Item1 +
Path.DirectorySeparatorChar + "pxelinux.cfg" + Path.DirectorySeparatorChar + pxeMac +
tuple.Item2;
if (!string.IsNullOrEmpty(tuple.Item3))
{
new FileOpsServices().WritePath(path, tuple.Item3);
}
}
}
else
{
if (SettingServices.TftpServerRole)
{
foreach (var tuple in list)
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "proxy" +
Path.DirectorySeparatorChar + tuple.Item1 +
Path.DirectorySeparatorChar + "pxelinux.cfg" + Path.DirectorySeparatorChar + pxeMac +
tuple.Item2;
if (!string.IsNullOrEmpty(tuple.Item3))
{
new FileOpsServices().WritePath(path, tuple.Item3);
}
}
}
var secondaryServers =
new SecondaryServerServices().SearchSecondaryServers().Where(x => x.TftpRole == 1 && x.IsActive == 1);
foreach (var server in secondaryServers)
{
var tftpPath =
new APICall(new SecondaryServerServices().GetToken(server.Name))
.SettingApi.GetSetting("Tftp Path").Value;
foreach (var tuple in list)
{
path = tftpPath + "proxy" + Path.DirectorySeparatorChar + tuple.Item1 +
Path.DirectorySeparatorChar + "pxelinux.cfg" + Path.DirectorySeparatorChar + pxeMac +
tuple.Item2;
new APICall(new SecondaryServerServices().GetToken(server.Name))
.ServiceAccountApi.WriteTftpFile(new TftpFileDTO
{
Path = path,
Contents = tuple.Item3
});
}
}
}
}
else
{
var mode = SettingServices.GetSettingValue(SettingStrings.PxeMode);
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "pxelinux.cfg" +
Path.DirectorySeparatorChar +
pxeMac;
if (SettingServices.ServerIsNotClustered)
{
if (mode.Contains("ipxe"))
{
path += ".ipxe";
}
else if (mode.Contains("grub"))
{
path += ".cfg";
}
if (!string.IsNullOrEmpty(bootMenu.BiosMenu))
{
new FileOpsServices().WritePath(path, bootMenu.BiosMenu);
}
}
else
{
if (SettingServices.TftpServerRole)
{
path = SettingServices.GetSettingValue(SettingStrings.TftpPath) + "pxelinux.cfg" +
Path.DirectorySeparatorChar +
pxeMac;
if (mode.Contains("ipxe"))
{
path += ".ipxe";
}
else if (mode.Contains("grub"))
{
path += ".cfg";
}
if (!string.IsNullOrEmpty(bootMenu.BiosMenu))
{
new FileOpsServices().WritePath(path, bootMenu.BiosMenu);
}
}
var secondaryServers =
new SecondaryServerServices().SearchSecondaryServers().Where(x => x.TftpRole == 1 && x.IsActive == 1);
foreach (var server in secondaryServers)
{
var tftpPath =
new APICall(new SecondaryServerServices().GetToken(server.Name))
.SettingApi.GetSetting("Tftp Path").Value;
path = tftpPath + "pxelinux.cfg" + Path.DirectorySeparatorChar +
pxeMac;
if (mode.Contains("ipxe"))
{
path += ".ipxe";
}
else if (mode.Contains("grub"))
{
path += ".cfg";
}
new APICall(new SecondaryServerServices().GetToken(server.Name))
.ServiceAccountApi.WriteTftpFile(new TftpFileDTO
{
Path = path,
Contents = bootMenu.BiosMenu
});
}
}
}
return(true);
}
public ProxyReservationDTO GetProxyReservation(string mac)
{
var bootClientReservation = new ProxyReservationDTO();
var computer = new ComputerServices().GetComputerFromMac(mac);
if (computer == null)
{
bootClientReservation.BootFile = "NotFound";
return(bootClientReservation);
}
if (computer.ProxyReservation == 0)
{
bootClientReservation.BootFile = "NotEnabled";
return(bootClientReservation);
}
var computerReservation = new ComputerServices().GetComputerProxyReservation(computer.Id);
if (!string.IsNullOrEmpty(computerReservation.NextServer))
{
bootClientReservation.NextServer =
StringManipulationServices.PlaceHolderReplace(computerReservation.NextServer);
}
switch (computerReservation.BootFile)
{
case "bios_pxelinux":
bootClientReservation.BootFile = @"proxy/bios/pxelinux.0";
break;
case "bios_ipxe":
bootClientReservation.BootFile = @"proxy/bios/undionly.kpxe";
break;
case "bios_x86_winpe":
bootClientReservation.BootFile = @"proxy/bios/pxeboot.n12";
bootClientReservation.BcdFile = @"/boot/BCDx86";
break;
case "bios_x64_winpe":
bootClientReservation.BootFile = @"proxy/bios/pxeboot.n12";
bootClientReservation.BcdFile = @"/boot/BCDx64";
break;
case "efi_x86_syslinux":
bootClientReservation.BootFile = @"proxy/efi32/syslinux.efi";
break;
case "efi_x86_ipxe":
bootClientReservation.BootFile = @"proxy/efi32/ipxe.efi";
break;
case "efi_x86_winpe":
bootClientReservation.BootFile = @"proxy/efi32/bootmgfw.efi";
bootClientReservation.BcdFile = @"/boot/BCDx86";
break;
case "efi_x64_syslinux":
bootClientReservation.BootFile = @"proxy/efi64/syslinux.efi";
break;
case "efi_x64_ipxe":
bootClientReservation.BootFile = @"proxy/efi64/ipxe.efi";
break;
case "efi_x64_winpe":
bootClientReservation.BootFile = @"proxy/efi64/bootmgfw.efi";
bootClientReservation.BcdFile = @"/boot/BCDx64";
break;
case "efi_x64_grub":
bootClientReservation.BootFile = @"proxy/efi64/bootx64.efi";
break;
}
return(bootClientReservation);
}
