public void Parent_Root()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.Null(fs.Root.Parent);
}
protected override void DoRun()
{
DirectoryInfo di = new DirectoryInfo(_srcDir.Value);
if (!di.Exists)
{
Console.WriteLine("The source directory doesn't exist!");
Environment.Exit(1);
}
CDBuilder builder = new CDBuilder();
if (_volLabelSwitch.IsPresent)
{
builder.VolumeIdentifier = _volLabelSwitch.Value;
}
if (_bootImage.IsPresent)
{
builder.SetBootImage(new FileStream(_bootImage.Value, FileMode.Open, FileAccess.Read), BootDeviceEmulation.NoEmulation, 0);
}
PopulateFromFolder(builder, di, di.FullName);
builder.Build(_isoFileParam.Value);
}
private void BuildSingleDensityArea()
{
CDBuilder builder = NewCDBuilderInstance(SINGLE_DENSITY_AREA_LBA_START, SINGLE_DENSITY_AREA_LBA_END);
byte[] ip0000Data = GDImageUtility.LoadBootstrapInMemory(SingleDensityArea.BootstrapFilePath);
_singleDensityAreaBootstrapFileName = GDImageUtility.GetBootBinaryFileName(ip0000Data);
// Handle track02
List <string> cdda = new List <string>
{
_singleDensityAreaAudioTrackPath
};
_singleDensityAreaTracks.AddRange(ReadCDDA(cdda));
// Handle track01
DirectoryInfo di = new DirectoryInfo(SingleDensityArea.SourceDataDirectory);
PopulateFromDirectory(builder, di, di.FullName, null, SINGLE_DENSITY_AREA_LBA_END);
using (BuiltStream isoStream = (BuiltStream)builder.Build())
{
_lastProgress = 0;
WriteDataTrack(true, isoStream, ip0000Data, _singleDensityAreaTracks);
}
}
public void Equals()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.Equal(fs.GetFileInfo("foo.txt"), fs.GetFileInfo("foo.txt"));
}
public void BootImage()
{
byte[] memoryStream = new byte[33 * 512];
for (int i = 0; i < memoryStream.Length; ++i)
{
memoryStream[i] = (byte)i;
}
CDBuilder builder = new CDBuilder();
builder.SetBootImage(new MemoryStream(memoryStream), BootDeviceEmulation.HardDisk, 0x543);
CDReader fs = new CDReader(builder.Build(), false);
Assert.True(fs.HasBootImage);
using (Stream bootImg = fs.OpenBootImage())
{
Assert.Equal(memoryStream.Length, bootImg.Length);
for (int i = 0; i < bootImg.Length; ++i)
{
if (memoryStream[i] != bootImg.ReadByte())
{
Assert.True(false, "Boot image corrupted");
}
}
}
Assert.Equal(BootDeviceEmulation.HardDisk, fs.BootEmulation);
Assert.Equal(0x543, fs.BootLoadSegment);
}
public void CanWrite()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.False(fs.CanWrite);
}
private void RepackISO_Directory(CDBuilder cd, string rootFolder, string inputFolder)
{
var directories = Directory.GetDirectories(inputFolder);
foreach (var directory in directories)
{
var cd_directory = directory.Replace(rootFolder, string.Empty);
var directoryInfo = cd.AddDirectory(cd_directory);
RepackISO_Directory(cd, rootFolder, directory);
}
var files = Directory.GetFiles(inputFolder);
foreach (var file in files)
{
byte[] buffer = null;
using (var readStream = File.OpenRead(file))
{
buffer = new byte[readStream.Length];
var max_chunk = 1024;
for (var b = 0; b < readStream.Length; b += max_chunk)
{
var amount = (int)Math.Min(max_chunk, readStream.Length - b);
readStream.Read(buffer, b, amount);
}
}
var cd_file = file.Replace(rootFolder, string.Empty);
var fileInfo = cd.AddFile(cd_file, buffer);
}
}
public void GetDirectories()
{
CDBuilder builder = new CDBuilder();
builder.AddDirectory(@"SOMEDIR\CHILD\GCHILD");
builder.AddDirectory(@"A.DIR");
CDReader fs = new CDReader(builder.Build(), false);
Assert.Equal(2, fs.Root.GetDirectories().Length);
DiscDirectoryInfo someDir = fs.Root.GetDirectories(@"SoMeDir")[0];
Assert.Equal(1, fs.Root.GetDirectories("SOMEDIR").Length);
Assert.Equal("SOMEDIR", someDir.Name);
Assert.Equal(1, someDir.GetDirectories("*.*").Length);
Assert.Equal("CHILD", someDir.GetDirectories("*.*")[0].Name);
Assert.Equal(2, someDir.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.Equal(4, fs.Root.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.Equal(2, fs.Root.GetDirectories("*.*", SearchOption.TopDirectoryOnly).Length);
Assert.Equal(1, fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories).Length);
Assert.Equal(@"A.DIR\", fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories)[0].FullName);
Assert.Equal(1, fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories).Length);
Assert.Equal(@"SOMEDIR\CHILD\GCHILD\", fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories)[0].FullName);
}
private int BuildIso(DirectoryInfo sourceDirectory, string targetFile)
{
CDBuilder builder = new CDBuilder();
Dictionary <string, string> resultList = new Dictionary <string, string>();
try
{
// Get main folder and put it into results.
getFileList(sourceDirectory, sourceDirectory).ToList().ForEach(file => resultList.Add(file.Key, file.Value));
// Now do it for all subfolders
/*foreach (DirectoryInfo directory in sourceDirectory.GetDirectories())
* {
* getFileList(directory, sourceDirectory).ToList().ForEach(file => resultList.Add(file.Key, file.Value));
* }*/
// Finally, add all files collected to the ISO.
foreach (KeyValuePair <string, string> pair in resultList.ToList())
{
builder.AddFile(pair.Key, pair.Value);
}
builder.Build(targetFile);
} catch (Exception e)
{
MessageBox.Show("Error Writing ISO. Check Permissions and Files. " + e.Message);
return(1);
}
return(0);
}
/**************************************************************************************************************
* Extract ISO 9660
*************************************************************************************************************/
public bool CreateISO9660(string in_sISOPathAndFilename
, string in_sISORootSourceRootDir)
{
try
{
CDBuilder oISOBuilder = new CDBuilder();
oISOBuilder.UseJoliet = true;
oISOBuilder.VolumeIdentifier = "A_SAMPLE_DISK";
string sISOPathAndFilename = in_sISOPathAndFilename;
// Add Files to ISO
bool bResultAddFiles = AddFilesToISO9660(in_sISORootSourceRootDir
, ""
, oISOBuilder
, false);
if (bResultAddFiles)
{
// Build the ISO
oISOBuilder.Build(sISOPathAndFilename);
return(true);
}
else
{
return(false);
}
}
catch (Exception oEx)
{
BootmanLog.LogError(LogTextBox, "Error Extracting ISO: " + oEx.Message);
return(false);
}
}
private bool CreateIso()
{
var success = true;
try
{
var files = Directory.GetFiles(SrcDir, "*.*", SearchOption.AllDirectories);
CDBuilder builder = new CDBuilder();
builder.UseJoliet = true;
builder.VolumeIdentifier = VolumeIdentifier;
foreach (var file in files)
{
var fileIsoPath = file.Replace(SrcDir, string.Empty).TrimStart('\\');
builder.AddFile(fileIsoPath, file);
}
var isoPath = Path.Combine(Workflow.WorkflowTempFolder, IsoFileName);
builder.Build(isoPath);
Files.Add(new FileInf(isoPath, Id));
InfoFormat("Iso {0} created with success.", isoPath);
success = true;
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception e)
{
ErrorFormat("An error occured while creating {0}: {1}", IsoFileName, e.Message);
}
return(success);
}
private void PopulateFromFolder(CDBuilder builder, DirectoryInfo di, string basePath, string bootBin)
{
FileInfo bootBinFile = null;
foreach (FileInfo file in di.GetFiles())
{
string filePath = file.FullName.Substring(basePath.Length);
if (bootBin != null && file.Name.Equals(bootBin, StringComparison.OrdinalIgnoreCase))
{
bootBinFile = file; //Ignore this for now, we want it last
}
else
{
builder.AddFile(filePath, file.FullName);
}
}
foreach (DirectoryInfo dir in di.GetDirectories())
{
PopulateFromFolder(builder, dir, basePath, null);
}
if (bootBinFile != null && bootBin != null)
{
builder.AddFile(bootBin, bootBinFile.FullName);
long sectorSize = RoundUp(bootBinFile.Length, DATA_SECTOR_SIZE);
builder.LastFileStartSector = (uint)(GD_END_LBA - 150 - (sectorSize / DATA_SECTOR_SIZE));
}
else if (bootBin != null)
{
//User doesn't know what they're doing and gave us bad data.
throw new FileNotFoundException("IP.BIN requires the boot file " + bootBin +
" which was not found in the data directory.");
}
}
public override void Build(string inputPath, string outputPath)
{
// Use CDBuilder
CDBuilder isoBuild = new CDBuilder();
isoBuild.UseJoliet = true;
isoBuild.VolumeIdentifier = ISO_Label;
DirectoryInfo di = new DirectoryInfo(inputPath);
HashSet <FileStream> files = new HashSet <FileStream>();
foreach (DirectoryInfo dir in di.GetDirectories())
{
ISO_Common.Recursive_AddDirs(isoBuild, dir, dir.Name + @"\", files, true);
}
foreach (FileInfo file in di.GetFiles())
{
ISO_Common.AddFile(isoBuild, file, string.Empty, files, true);
}
using (FileStream output = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
using (Stream input = isoBuild.Build())
{
ISO2PSX.Run(input, output);
}
//isoBuild.Build(outputPath);
foreach (FileStream file in files)
{
file.Close();
}
}
public void CreateIso(string inputPath, string outputPath, string volumeIdentifier)
{
_log.Verbose($"Creating ISO from directory {inputPath}");
var builder = new CDBuilder
{
UseJoliet = true,
VolumeIdentifier = volumeIdentifier ?? "CAKE_ISO"
};
foreach (var entry in Directory.GetFileSystemEntries(inputPath, "*", SearchOption.AllDirectories))
{
var fileInfo = new FileInfo(entry);
if ((fileInfo.Attributes & FileAttributes.Directory) != 0)
{
_log.Verbose($"Creating directory: {Path.GetFullPath(entry).Replace(inputPath, "")}");
builder.AddDirectory(Path.GetFullPath(entry).Replace(inputPath, ""));
}
else
{
_log.Verbose($"Creating file: {Path.GetFullPath(entry).Replace(inputPath, "")}");
builder.AddFile(Path.GetFullPath(entry).Replace(inputPath, ""), entry);
}
}
builder.Build(outputPath);
}
public void AddtoISO(string directory, string isoFile, string sourceName)
{
try
{
DirectoryInfo rootDirToAdd = new DirectoryInfo(sourceName);
DirectoryInfo currentDirToAdd = new DirectoryInfo(directory);
int itemsAdded = 0;
CDBuilder isoBuilder = new CDBuilder();
foreach (FileInfo file in currentDirToAdd.GetFiles())
{
string fileOnHdd = file.FullName;
string fileOnIso = fileOnHdd.Substring(fileOnHdd.IndexOf(rootDirToAdd.Name) + rootDirToAdd.Name.Length + 1);
MessageBox.Show(fileOnIso);
isoBuilder.AddFile(fileOnIso, fileOnHdd);
itemsAdded++;
}
foreach (DirectoryInfo subdir in currentDirToAdd.GetDirectories())
{
itemsAdded++;
AddtoISO(subdir.FullName, isoFile, sourceName);
}
isoBuilder.Build(isoFile);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
public async void RunExecute()
{
try
{
if (!ValidatePaths())
{
return;
}
IFilesLoader filesLoader = new FilesLoader();
CDBuilder cdBuilder = new CDBuilder();
foreach (var(nameInIso, fullName) in filesLoader.GetFiles(SourcePath))
{
cdBuilder.AddFile(nameInIso, fullName);
}
IsNotRunning = false;
await cdBuilder.BuildAsync(DestinationPath,
(current, max) => ProgressValue = current / (double)max * 100);
ProgressValue = 100;
IsNotRunning = true;
MessageBox.Show("Operation complete");
}
catch (Exception exception)
{
MessageBox.Show(
$"Problem has occurred during processing. Details below:{Environment.NewLine}{exception.Message}");
IsNotRunning = true;
ProgressValue = 0;
}
}
public void DirectoryInfo()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
DiscDirectoryInfo fi = fs.GetDirectoryInfo(@"SOMEDIR");
Assert.NotNull(fi);
}
public void FileSystemInfo()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
DiscFileSystemInfo fi = fs.GetFileSystemInfo(@"SOMEDIR\SOMEFILE");
Assert.NotNull(fi);
}
public void Extension()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.Equal("dir", fs.GetDirectoryInfo("fred.dir").Extension);
Assert.Equal("", fs.GetDirectoryInfo("fred").Extension);
}
public void Name()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.Equal("foo.txt", fs.GetFileInfo("foo.txt").Name);
Assert.Equal("foo.txt", fs.GetFileInfo(@"path\foo.txt").Name);
Assert.Equal("foo.txt", fs.GetFileInfo(@"\foo.txt").Name);
}
public void AddFileStream()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"ADIR\AFILE.TXT", new MemoryStream());
CDReader fs = new CDReader(builder.Build(), false);
Assert.True(fs.Exists(@"ADIR\AFILE.TXT"));
}
public void AddFileBytes()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"ADIR\AFILE.TXT", new byte[] {});
CDReader fs = new CDReader(builder.Build(), false);
Assert.True(fs.Exists(@"ADIR\AFILE.TXT"));
}
public void Parent()
{
CDBuilder builder = new CDBuilder();
builder.AddDirectory(@"SOMEDIR");
CDReader fs = new CDReader(builder.Build(), false);
Assert.Equal(fs.Root, fs.Root.GetDirectories("SOMEDIR")[0].Parent);
}
public void CreateISO()
{
CDBuilder builder = new CDBuilder();
builder.UseJoliet = true;
builder.VolumeIdentifier = "A_SAMPLE_DISK";
builder.AddFile(@"Folder\Hello.txt", Encoding.ASCII.GetBytes("Hello World!"));
builder.Build(@"C:\sample.iso");
}
public void FullName()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.Equal(@"\", fs.Root.FullName);
Assert.Equal(@"SOMEDIR\", fs.GetDirectoryInfo(@"SOMEDIR").FullName);
Assert.Equal(@"SOMEDIR\CHILDDIR\", fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR").FullName);
}
public void Root()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.NotNull(fs.Root);
Assert.True(fs.Root.Exists);
Assert.Empty(fs.Root.Name);
Assert.Null(fs.Root.Parent);
}
public void CreationTimeUtc()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"foo.txt", new byte[] { 1 });
CDReader fs = new CDReader(builder.Build(), false);
Assert.True(DateTime.UtcNow >= fs.GetFileInfo("foo.txt").CreationTimeUtc);
Assert.True(DateTime.UtcNow.Subtract(TimeSpan.FromSeconds(10)) <= fs.GetFileInfo("foo.txt").CreationTimeUtc);
}
public void Exists()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"dir\foo.txt", new byte[] { 1 });
CDReader fs = new CDReader(builder.Build(), false);
Assert.False(fs.GetFileInfo("unknown.txt").Exists);
Assert.True(fs.GetFileInfo(@"dir\foo.txt").Exists);
Assert.False(fs.GetFileInfo(@"dir").Exists);
}
public void SimpleSearch()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"SOMEDIR\CHILDDIR\GCHILDIR\FILE.TXT", new byte[0]);
CDReader fs = new CDReader(builder.Build(), false);
DiscDirectoryInfo di = fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR");
DiscFileInfo[] fis = di.GetFiles("*.*", SearchOption.AllDirectories);
}
private static void AddFile(CDBuilder isoBuilder, string name, VirtualFile file)
{
if (file.StoredInMemory)
{
isoBuilder.AddFile(name, file.Open());
}
else
{
isoBuilder.AddFile(name, file.HostPath);
}
}
