public void FileSystemInfo()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
DiscFileSystemInfo fi = fs.GetFileSystemInfo(@"SOMEDIR\SOMEFILE");
Assert.IsNotNull(fi);
}
public List<string> LoadCVM(Stream iso_file, string cvmOpen)
{
List<string> files = new List<string>();
try
{
using (MemoryStream mt = new MemoryStream())
{
CDReader cr = new CDReader(iso_file, true);
MemoryStream mem = new MemoryStream((int)iso_file.Length);
cr.OpenFile(cvmOpen, FileMode.Open).CopyTo(mem);
mem.Seek(0x1800, SeekOrigin.Begin);
mem.CopyTo(mt);
mem.Dispose();
mem.Close();
CDReader cvmRead = new CDReader(mt, true);
DiscUtils.DiscFileInfo[] filescvm = cvmRead.Root.GetFiles("*.*", SearchOption.AllDirectories);
foreach (DiscUtils.DiscFileInfo file in filescvm)
{
files.Add(file.FullName.ToString());
}
mt.Dispose();
mt.Close();
return files;
}
}
catch (OutOfMemoryException)
{
return null;
}
}
public void DirectoryInfo()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
DiscDirectoryInfo fi = fs.GetDirectoryInfo(@"SOMEDIR");
Assert.IsNotNull(fi);
}
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.IsTrue(fs.HasBootImage);
using (Stream bootImg = fs.OpenBootImage())
{
Assert.AreEqual(memoryStream.Length, bootImg.Length);
for (int i = 0; i < bootImg.Length; ++i)
{
if (memoryStream[i] != bootImg.ReadByte())
{
Assert.Fail("Boot image corrupted");
}
}
}
Assert.AreEqual(BootDeviceEmulation.HardDisk, fs.BootEmulation);
Assert.AreEqual(0x543, fs.BootLoadSegment);
}
public void Equals()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.AreEqual(fs.GetFileInfo("foo.txt"), fs.GetFileInfo("foo.txt"));
}
public void ExtractFile(String FileSource, String FileTarget)
{
FileStream FileISO = File.Open(FileName, FileMode.Open, FileAccess.Read);
try
{
CDReader ReaderISO = new CDReader(FileISO, true);
SparseStream _SourceStream = ReaderISO.OpenFile(FileSource, FileMode.Open, FileAccess.Read);
Byte[] _ReadAllByte = new Byte[_SourceStream.Length];
_SourceStream.Read(_ReadAllByte, 0, _ReadAllByte.Length);
_SourceStream.Close();
FileStream _FileCreated = new FileStream(FileTarget, FileMode.CreateNew);
_FileCreated.Position = 0;
_FileCreated.Write(_ReadAllByte, 0, _ReadAllByte.Length);
_FileCreated.Close();
}
catch (IOException ex)
{
if (ex.Message != "No such file")
{
Console.WriteLine("-----------------------------------------------------");
Console.WriteLine("ExtractFile(" + FileSource + ", " + FileTarget + ")");
Console.WriteLine(ex.Message);
Console.WriteLine("-----------------------------------------------------");
}
else
{
Console.WriteLine("ExtractFile(" + FileSource + ") --> " + Path.GetFileName(FileName));
}
}
FileISO.Close();
}
public bool TryReadRom(FileStream rom, out string RomId, out string RomType)
{
RomId = null;
RomType = null;
byte[] magicNumberArray = new byte[11];
rom.Position = 65881;
rom.Read(magicNumberArray, 0, 11);
String magicNumberString = Encoding.ASCII.GetString(magicNumberArray);
rom.Position = 0;
if(magicNumberString == "PLAYSTATION")
{
// PS2 games use a standard .iso image. One of the filenames is the id (also known as the SLUS file if you're running a US game)
// Use DiskUtils to find it
var regex = new Regex(@"[A-Z]{4}_[0-9]+.[0-9]+"); // the regex matches a string of the form "<4 characters>_<some number>.<some number>"
CDReader reader = new CDReader(rom, true);
var id = reader.Root.GetFiles()
.Select(file => file.FullName) // Get the full name of all files in the root directory
.Where(file => regex.IsMatch(file)) // Check the filename against the regex
.First();
RomId = id;
RomType = "Playstation 2";
return true;
}
return false;
}
public void Extension()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.AreEqual("dir", fs.GetDirectoryInfo("fred.dir").Extension);
Assert.AreEqual("", fs.GetDirectoryInfo("fred").Extension);
}
public void AddFileStream()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"ADIR\AFILE.TXT", new MemoryStream());
CDReader fs = new CDReader(builder.Build(), false);
Assert.IsTrue(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.IsTrue(fs.Exists(@"ADIR\AFILE.TXT"));
}
public void CreationTimeUtc()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"foo.txt", new byte[] { 1 });
CDReader fs = new CDReader(builder.Build(), false);
Assert.GreaterOrEqual(DateTime.UtcNow, fs.GetFileInfo("foo.txt").CreationTimeUtc);
Assert.LessOrEqual(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.IsFalse(fs.GetFileInfo("unknown.txt").Exists);
Assert.IsTrue(fs.GetFileInfo(@"dir\foo.txt").Exists);
Assert.IsFalse(fs.GetFileInfo(@"dir").Exists);
}
public GangsISODriver(string isoPath, string mountPoint)
: base(mountPoint, "ISO")
{
if (!File.Exists(isoPath))
throw new FileNotFoundException();
this.isoPath = isoPath;
this.isoFileStream = null;
this.isoReader = null;
}
public void Attributes()
{
CDBuilder builder = new CDBuilder();
builder.AddFile("foo.txt", new byte[] { 1 });
CDReader fs = new CDReader(builder.Build(), false);
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
// Check default attributes
Assert.AreEqual(FileAttributes.ReadOnly, fi.Attributes);
}
public void ExtractISO(string toExtract, string folderName)
{
// reads the ISO
CDReader Reader = new CDReader(File.Open(toExtract, FileMode.Open), true);
// passes the root directory the folder name and the folder to extract
ExtractDirectory(Reader.Root, folderName /*+ Path.GetFileNameWithoutExtension(toExtract)*/ + "\\", "");
// clears reader and frees memory
Reader.Dispose();
docvmextract = true;
}
public void BuildCVM(Stream CVM, List<string> filesToReplace, List<string>names)
{
CDReader cd = new CDReader(CVM, true);
CDBuilder cb = new CDBuilder();
foreach (DiscFileInfo file in cd.Root.GetFiles("*.*", SearchOption.AllDirectories))
{
foreach (DiscDirectoryInfo dir in cd.Root.GetDirectories("*.*", SearchOption.AllDirectories))
{
}
}
}
public void Exists()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"SOMEDIR\CHILDDIR\FILE.TXT", new byte[0]);
CDReader fs = new CDReader(builder.Build(), false);
Assert.IsTrue(fs.GetDirectoryInfo(@"\").Exists);
Assert.IsTrue(fs.GetDirectoryInfo(@"SOMEDIR").Exists);
Assert.IsTrue(fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR").Exists);
Assert.IsTrue(fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR\").Exists);
Assert.IsFalse(fs.GetDirectoryInfo(@"NONDIR").Exists);
Assert.IsFalse(fs.GetDirectoryInfo(@"SOMEDIR\NONDIR").Exists);
}
public void BuildISO(Stream ISOOpen, string pathSave)
{
CDReader cd = new CDReader(ISOOpen, true);
CDBuilder cb = new CDBuilder(); cb.UseJoliet = true;
foreach (DiscFileInfo file in cd.Root.GetFiles("*.*", SearchOption.AllDirectories))
{
foreach (DiscDirectoryInfo dir in cd.Root.GetDirectories("*.*", SearchOption.AllDirectories))
{
cb.AddDirectory(dir.Name);
cb.AddFile(file.FullName, cd.OpenFile(file.FullName, FileMode.Open));
}
}
cb.Build(pathSave);
}
public void HideVersions()
{
CDBuilder builder = new CDBuilder();
builder.UseJoliet = true;
builder.AddFile("FILE.TXT;1", new byte[] { });
MemoryStream ms = new MemoryStream();
SparseStream.Pump(builder.Build(), ms);
CDReader reader = new CDReader(ms, true, false);
Assert.AreEqual("\\FILE.TXT;1", reader.GetFiles("")[0]);
Assert.AreEqual("\\FILE.TXT;1", reader.GetFileSystemEntries("")[0]);
reader = new CDReader(ms, true, true);
Assert.AreEqual("\\FILE.TXT", reader.GetFiles("")[0]);
Assert.AreEqual("\\FILE.TXT", reader.GetFileSystemEntries("")[0]);
}
public void GetFiles()
{
CDBuilder builder = new CDBuilder();
builder.AddDirectory(@"SOMEDIR\CHILD\GCHILD");
builder.AddDirectory(@"AAA.DIR");
builder.AddFile(@"FOO.TXT", new byte[10]);
builder.AddFile(@"SOMEDIR\CHILD.TXT", new byte[10]);
builder.AddFile(@"SOMEDIR\FOO.TXT", new byte[10]);
builder.AddFile(@"SOMEDIR\CHILD\GCHILD\BAR.TXT", new byte[10]);
CDReader fs = new CDReader(builder.Build(), false);
Assert.AreEqual(1, fs.Root.GetFiles().Length);
Assert.AreEqual("FOO.TXT", fs.Root.GetFiles()[0].FullName);
Assert.AreEqual(2, fs.Root.GetDirectories("SOMEDIR")[0].GetFiles("*.TXT").Length);
Assert.AreEqual(4, fs.Root.GetFiles("*.TXT", SearchOption.AllDirectories).Length);
Assert.AreEqual(0, fs.Root.GetFiles("*.DIR", SearchOption.AllDirectories).Length);
}
public void HideVersions()
{
CDBuilder builder = new CDBuilder();
builder.UseJoliet = true;
builder.AddFile("FILE.TXT;1", new byte[] { });
MemoryStream ms = new MemoryStream();
SparseStream.Pump(builder.Build(), ms);
CDReader reader = new CDReader(ms, true, false);
Assert.AreEqual("\\FILE.TXT;1", reader.GetFiles("")[0]);
Assert.AreEqual("\\FILE.TXT;1", reader.GetFileSystemEntries("")[0]);
reader = new CDReader(ms, true, true);
Assert.AreEqual("\\FILE.TXT", reader.GetFiles("")[0]);
Assert.AreEqual("\\FILE.TXT", reader.GetFileSystemEntries("")[0]);
}
public void Attributes()
{
// Start time rounded down to whole seconds
DateTime start = DateTime.UtcNow;
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second);
CDBuilder builder = new CDBuilder();
builder.AddDirectory("Foo");
CDReader fs = new CDReader(builder.Build(), false);
DateTime end = DateTime.UtcNow;
DiscDirectoryInfo di = fs.GetDirectoryInfo("Foo");
Assert.AreEqual(FileAttributes.Directory | FileAttributes.ReadOnly, di.Attributes);
Assert.GreaterOrEqual(di.CreationTimeUtc, start);
Assert.LessOrEqual(di.CreationTimeUtc, end);
Assert.GreaterOrEqual(di.LastAccessTimeUtc, start);
Assert.LessOrEqual(di.LastAccessTimeUtc, end);
Assert.GreaterOrEqual(di.LastWriteTimeUtc, start);
Assert.LessOrEqual(di.LastWriteTimeUtc, end);
}
public PSPGame(String iso)
{
Readable = true;
try
{
FileStream FileISO = File.Open(iso, FileMode.Open, FileAccess.Read);
CDReader ReaderISO = new CDReader(FileISO, true);
FileName = iso;
FileSize = FileISO.Length;
if (!ReaderISO.FileExists("PSP_GAME\\PARAM.SFO")) throw new NotImplementedException();
FileISO.Close();
}
catch (Exception ex)
{
Readable = false;
Console.WriteLine("-----------------------------------------------------");
Console.WriteLine("PSPGame(" + iso + ")");
Console.WriteLine(ex.Message);
Console.WriteLine("-----------------------------------------------------");
}
}
public Byte[] ReadAllByte(String FileSource)
{
Byte[] result = { 0x0 };
FileStream FileISO = File.Open(FileName, FileMode.Open, FileAccess.Read);
try
{
CDReader ReaderISO = new CDReader(FileISO, true);
SparseStream _SourceStream = ReaderISO.OpenFile(FileSource, FileMode.Open, FileAccess.Read);
Byte[] _ReadAllByte = new Byte[_SourceStream.Length];
_SourceStream.Read(_ReadAllByte, 0, _ReadAllByte.Length);
result = _ReadAllByte;
_SourceStream.Close();
}
catch (Exception ex)
{
Console.WriteLine("-----------------------------------------------------");
Console.WriteLine("ReadAllByte(" + FileSource + ")");
Console.WriteLine(ex.Message);
Console.WriteLine("-----------------------------------------------------");
}
FileISO.Close();
return result;
}
public void Attributes()
{
// Start time rounded down to whole seconds
DateTime start = DateTime.UtcNow;
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second);
CDBuilder builder = new CDBuilder();
builder.AddDirectory("Foo");
CDReader fs = new CDReader(builder.Build(), false);
DateTime end = DateTime.UtcNow;
DiscDirectoryInfo di = fs.GetDirectoryInfo("Foo");
Assert.AreEqual(FileAttributes.Directory | FileAttributes.ReadOnly, di.Attributes);
Assert.GreaterOrEqual(di.CreationTimeUtc, start);
Assert.LessOrEqual(di.CreationTimeUtc, end);
Assert.GreaterOrEqual(di.LastAccessTimeUtc, start);
Assert.LessOrEqual(di.LastAccessTimeUtc, end);
Assert.GreaterOrEqual(di.LastWriteTimeUtc, start);
Assert.LessOrEqual(di.LastWriteTimeUtc, end);
}
public void Open_FileNotFound()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Open)) { }
}
public void Open_Read()
{
CDBuilder builder = new CDBuilder();
builder.AddFile("foo.txt", new byte[] { 1 });
CDReader fs = new CDReader(builder.Build(), false);
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Open, FileAccess.Read))
{
Assert.IsFalse(s.CanWrite);
Assert.IsTrue(s.CanRead);
Assert.AreEqual(1, s.ReadByte());
}
}
public void Name()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
Assert.AreEqual("foo.txt", fs.GetFileInfo("foo.txt").Name);
Assert.AreEqual("foo.txt", fs.GetFileInfo(@"path\foo.txt").Name);
Assert.AreEqual("foo.txt", fs.GetFileInfo(@"\foo.txt").Name);
}
public override void Mount()
{
if (IsMounted)
return;
if (!File.Exists(this.isoPath))
throw new FileNotFoundException();
this.isoFileStream = File.Open(isoPath, FileMode.Open, System.IO.FileAccess.Read, FileShare.None);
this.isoReader = new CDReader(this.isoFileStream, true);
base.Mount();
}
public void Parent()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"SOMEDIR\ADIR\FILE.TXT", new byte[] { 1 });
CDReader fs = new CDReader(builder.Build(), false);
DiscFileInfo fi = fs.GetFileInfo(@"SOMEDIR\ADIR\FILE.TXT");
Assert.AreEqual(fs.GetDirectoryInfo(@"SOMEDIR\ADIR"), fi.Parent);
Assert.AreEqual(fs.GetDirectoryInfo(@"SOMEDIR\ADIR"), fi.Directory);
}
public void Length()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"FILE.TXT", new byte[0]);
builder.AddFile(@"FILE2.TXT", new byte[1]);
builder.AddFile(@"FILE3.TXT", new byte[10032]);
builder.AddFile(@"FILE3.TXT;2", new byte[132]);
CDReader fs = new CDReader(builder.Build(), false);
Assert.AreEqual(0, fs.GetFileInfo("FILE.txt").Length);
Assert.AreEqual(1, fs.GetFileInfo("FILE2.txt").Length);
Assert.AreEqual(10032, fs.GetFileInfo("FILE3.txt;1").Length);
Assert.AreEqual(132, fs.GetFileInfo("FILE3.txt;2").Length);
Assert.AreEqual(132, fs.GetFileInfo("FILE3.txt").Length);
}
private string Run(int revision, string additionalFilePath, bool autoStartChecked)
{
string filename = string.Format("bootcd-{0}-dbg", revision);
string filename7z = filename + ".7z";
string filenameIso = filename + ".iso";
if (!File.Exists(filenameIso))
{
string filename7zTemp = filename7z + ".temp";
string filenameIsoTemp = filenameIso + ".temp";
if (!File.Exists(filename7z))
{
File.Delete(filename7zTemp);
WebClient wc = new WebClient();
try
{
wc.DownloadFile(revToUrl[revision], filename7zTemp);
}
catch (WebException)
{
return "File download failed:\n '" + revToUrl[revision] + "'";
}
File.Move(filename7zTemp, filename7z);
}
File.Delete(filenameIsoTemp);
FileStream isotmpfs = File.Create(filenameIsoTemp);
FileStream szfs = File.Open(filename7z, FileMode.Open, FileAccess.Read);
SevenZipExtractor sze = new SevenZipExtractor(szfs);
sze.ExtractFile(filenameIso, isotmpfs);
isotmpfs.Close();
szfs.Close();
File.Move(filenameIsoTemp, filenameIso);
File.Delete(filename7z);
}
string vmName = string.Format("ReactOS_r{0}", revision);
string diskName = Environment.CurrentDirectory + "\\" + vmName + "\\" + vmName + ".vdi";
if (File.Exists(diskName))
{
FileStream fs = null;
try
{
fs = File.Open(diskName, FileMode.Open, FileAccess.Read, FileShare.None);
}
catch (IOException)
{
return "Virtual machine '" + vmName + "' is already running";
}
finally
{
if (fs != null)
fs.Close();
}
}
string filenameIsoUnatt = filename + "_unatt.iso";
string filenameIsoUnattTemp = filenameIsoUnatt + ".temp";
File.Delete(filenameIsoUnattTemp);
File.Delete(filenameIsoUnatt);
FileStream isofs = File.Open(filenameIso, FileMode.Open, FileAccess.Read);
CDReader cdr = new CDReader(isofs, true);
CDBuilder cdb = new CDBuilder();
cdb.VolumeIdentifier = cdr.VolumeLabel;
CloneCdDirectory("", cdr, cdb);
if (!File.Exists("unattend.inf"))
File.WriteAllText("unattend.inf", RosRegTest.Resources.unattend, Encoding.ASCII);
string additionalFileName = null;
if (additionalFilePath != null)
additionalFileName = Path.GetFileName(additionalFilePath);
string unattText = File.ReadAllText("unattend.inf", Encoding.ASCII);
if (autoStartChecked && (additionalFileName != null))
unattText = unattText + "[GuiRunOnce]\n" + "cmd.exe /c start d:\\" + additionalFileName + "\n\n";
cdb.AddFile("reactos\\unattend.inf", Encoding.ASCII.GetBytes(unattText));
if (additionalFileName != null)
cdb.AddFile(additionalFileName, additionalFilePath);
Stream bootImgStr = cdr.OpenBootImage();
cdb.SetBootImage(bootImgStr, cdr.BootEmulation, cdr.BootLoadSegment);
bootImgStr.Close();
cdb.Build(filenameIsoUnattTemp);
isofs.Close();
File.Move(filenameIsoUnattTemp, filenameIsoUnatt);
string fullIsoName = Environment.CurrentDirectory + "\\" + filenameIsoUnatt;
string deleteVmCmd = string.Format("unregistervm --name {0}", vmName);
string createVmCmd = string.Format(
"createvm --name {0} --basefolder {1} --ostype WindowsXP --register",
vmName, Environment.CurrentDirectory);
string modifyVmCmd = string.Format("modifyvm {0} --memory 256 --vram 16 --nictype1 Am79C973 --audio none --boot1 disk --boot2 dvd", vmName);
string storageCtlCmd = string.Format("storagectl {0} --name \"IDE Controller\" --add ide", vmName);
string createMediumCmd = string.Format("createmedium disk --filename {0} --size 2048", diskName);
string storageAttachCmd1 = string.Format("storageattach {0} --port 0 --device 0 --storagectl \"IDE Controller\" --type hdd --medium {1}", vmName, diskName);
string storageAttachCmd2 = string.Format("storageattach {0} --port 1 --device 0 --storagectl \"IDE Controller\" --type dvddrive --medium {1}", vmName, fullIsoName);
string startCmd = string.Format("startvm {0}", vmName);
Exec(vboxManagePath, deleteVmCmd);
Exec(vboxManagePath, createVmCmd);
Exec(vboxManagePath, modifyVmCmd);
Exec(vboxManagePath, storageCtlCmd);
Exec(vboxManagePath, createMediumCmd);
Exec(vboxManagePath, storageAttachCmd1);
Exec(vboxManagePath, storageAttachCmd2);
Exec(vboxManagePath, startCmd);
return null;
}
private void CloneCdDirectory(string dir, CDReader cdr, CDBuilder cdb)
{
foreach (string fileName in cdr.GetFiles(dir))
{
if (fileName == "\\reactos\\unattend.inf")
continue;
var stream = cdr.OpenFile(fileName, FileMode.Open);
cdb.AddFile(fileName.Remove(0, 1), stream);
stream.Close();
}
foreach (string dirName in cdr.GetDirectories(dir))
{
CloneCdDirectory(dirName, cdr, cdb);
}
}
