private Dictionary <string, PhysicalVolumeInfo> ScanForPhysicalVolumes()
{
Dictionary <string, PhysicalVolumeInfo> result = new Dictionary <string, PhysicalVolumeInfo>();
// First scan physical volumes
for (int i = 0; i < _disks.Count; ++i)
{
VirtualDisk disk = _disks[i];
string diskId = GetDiskId(i);
if (PartitionTable.IsPartitioned(disk.Content))
{
foreach (var table in PartitionTable.GetPartitionTables(disk.Content))
{
foreach (var part in table.Partitions)
{
PhysicalVolumeInfo pvi = new PhysicalVolumeInfo(diskId, disk, part);
result.Add(pvi.Identity, pvi);
}
}
}
else
{
PhysicalVolumeInfo pvi = new PhysicalVolumeInfo(diskId, disk);
result.Add(pvi.Identity, pvi);
}
}
return(result);
}
public void PartitionTableTest()
{
var originClientId = Guid.NewGuid();
var map = new Dictionary <int, Guid>
{
{ 1, Guid.NewGuid() },
{ 2, Guid.NewGuid() },
{ 3, Guid.NewGuid() },
};
var table = new PartitionTable(originClientId, 0, map);
Assert.That(table.OriginClientId, Is.EqualTo(originClientId));
Assert.That(table.Version, Is.EqualTo(0));
Assert.That(table.Count, Is.EqualTo(3));
Assert.That(table.MapPartitionId(2), Is.EqualTo(map[2]));
Assert.That(table.MapPartitionId(3), Is.EqualTo(map[3]));
Assert.That(table.MapPartitionId(4), Is.EqualTo(Guid.Empty));
Assert.That(table.IsSupersededBy(originClientId, 0, map), Is.False);
Assert.That(table.IsSupersededBy(Guid.NewGuid(), 0, map), Is.True);
Assert.That(table.IsSupersededBy(originClientId, 1, map), Is.True);
Assert.That(table.IsSupersededBy(originClientId, 1, new Dictionary <int, Guid>()), Is.False);
}
internal static PrivateHeader GetPrivateHeader(VirtualDisk disk)
{
if (disk.IsPartitioned)
{
long headerPos = 0;
PartitionTable pt = disk.Partitions;
if (pt is BiosPartitionTable)
{
headerPos = 0xc00;
}
else
{
foreach (var part in pt.Partitions)
{
if (part.GuidType == GuidPartitionTypes.WindowsLdmMetadata)
{
headerPos = part.LastSector * Sizes.Sector;
}
}
}
if (headerPos != 0)
{
disk.Content.Position = headerPos;
byte[] buffer = new byte[Sizes.Sector];
disk.Content.Read(buffer, 0, buffer.Length);
PrivateHeader hdr = new PrivateHeader();
hdr.ReadFrom(buffer, 0);
return(hdr);
}
}
return(null);
}
public static PartitionTable FindPartitionTable(Stream stream)
{
PartitionTable partitionTable = null;
// Always check GPT first as it as an MBR-encapsulated partition scheme
if (GuidPartitionTable.Detect(stream))
{
partitionTable = new GuidPartitionTable(
stream,
GuidPartitionTable.DetectGeometry(stream));
Logger.Info("Detected partition table: GPT");
}
else if (BiosPartitionTable.IsValid(stream))
{
partitionTable = new BiosPartitionTable(
stream,
BiosPartitionTable.DetectGeometry(stream));
Logger.Info("Detected partition table: MBR");
}
if (partitionTable == null)
{
Logger.Info("Could not find valid partition table");
return(null);
}
return(partitionTable);
}
internal void HandlePartitionsViewEvent(Connection connection, ICollection <KeyValuePair <Guid, IList <int> > > partitions,
int partitionStateVersion)
{
if (Logger.IsFinestEnabled)
{
Logger.Finest($"Handling new partition table with partitionStateVersion: {partitionStateVersion}");
}
while (true)
{
var current = _partitionTable.Get();
if (!ShouldBeApplied(connection, partitions, partitionStateVersion, current))
{
return;
}
var newPartitions = ConvertToMap(partitions);
var newMetaData = new PartitionTable
{
Connection = connection, PartitionSateVersion = partitionStateVersion, Partitions = newPartitions
};
if (_partitionTable.CompareAndSet(current, newMetaData))
{
if (Logger.IsFinestEnabled)
{
Logger.Finest("Applied partition table with partitionStateVersion : " + partitionStateVersion);
}
return;
}
}
}
private bool ShouldBeApplied(Connection connection, ICollection <KeyValuePair <Guid, IList <int> > > partitions,
int partitionStateVersion, PartitionTable current)
{
if (partitions.Count == 0)
{
if (Logger.IsFinestEnabled)
{
LogFailure(connection, partitionStateVersion, current, "response is empty");
}
return(false);
}
if (!connection.Equals(current?.Connection))
{
if (Logger.IsFinestEnabled)
{
Logger.Finest(
$"Event coming from a new connection. Old connection: {current?.Connection} , new connection {connection}");
}
return(true);
}
if (partitionStateVersion <= current?.PartitionSateVersion)
{
if (Logger.IsFinestEnabled)
{
LogFailure(connection, partitionStateVersion, current, "response state version is old");
}
return(false);
}
return(true);
}
public void FormatSecondFatPartition()
{
MemoryStream ms = new MemoryStream();
VirtualDisk disk = Disk.InitializeDynamic(ms, Ownership.Dispose, 30 * 1024 * 1204);
PartitionTable pt = BiosPartitionTable.Initialize(disk);
pt.Create(15 * 1024 * 1024, WellKnownPartitionType.WindowsFat, false);
pt.Create(5 * 1024 * 1024, WellKnownPartitionType.WindowsFat, false);
FatFileSystem fileSystem = FatFileSystem.FormatPartition(disk, 1, null);
long fileSystemSize = fileSystem.TotalSectors * fileSystem.BytesPerSector;
Assert.IsTrue(fileSystemSize > (5 * 1024 * 1024) * 0.9);
}
IEnumerable <DiscUtils.DiscFileInfo> IterateFilesystem(int partitionNumber)
{
IEnumerable <DiscUtils.DiscFileInfo> IterateSubdir(DiscUtils.DiscDirectoryInfo subdir)
{
foreach (var dir in subdir.GetDirectories())
{
foreach (var subfile in IterateSubdir(dir))
{
yield return(subfile);
}
}
var files = subdir.GetFiles();
foreach (var f in files)
{
yield return(f);
}
}
PartitionTable disk = OpenDisk();
if (disk == null)
{
Debug.WriteLine("IterateFilesystem: Failed to open disk");
yield break;
}
else if (disk.Partitions.Count - 1 < partitionNumber)
{
Debug.WriteLine($"IterateFilesystem: Partition {partitionNumber} does not exist");
yield break;
}
using (var fsStream = disk.Partitions[partitionNumber].Open())
{
var partitionStream = GetPatchedNtfsPartitionStream(fsStream);
NtfsFileSystem fs = new DiscUtils.Ntfs.NtfsFileSystem(partitionStream);
foreach (var file in IterateSubdir(fs.Root))
{
yield return(file);
}
fs.Dispose();
partitionStream.Dispose();
}
}
private void LoadToolStripMenuItem_Click(object sender, EventArgs e)
{
Console.WriteLine("Opening new project");
fileLoaded = true;
string fname = Interaction.InputBox("Enter project name.", "Dreamcaster", "project.bin");
disk = new Disk(fname);
PartitionTable partitions = disk.Partitions;
PartitionInfo fs_pi = partitions[0];
fs = new FatFileSystem(fs_pi.Open());
PartitionInfo mfs_pi = partitions[1];
mfs = new FatFileSystem(mfs_pi.Open());
UpdateListbox();
Text = "Dreamcaster -- " + fname;
Console.WriteLine("Done");
}
static void Main(string[] args)
{
//starts VDisk
vd = VDisk.Create(1024);
pt = new PartitionTable(vd);
//initializes partition
part = Partitioner.Create(pt, 1024);
PraxisFormatter.format(part, "system");
//formats
praxpart = new PraxisPartition(part);
PraxisPartitionTable.Add(praxpart);
//creates file
Praxis.IO.File.Create("/system/test1.txt", Encoding.UTF8.GetBytes("Hello, World. This is test 1.".PadLeft(1976, 'x')));
Praxis.IO.File.Create("/system/test2.txt", Encoding.UTF8.GetBytes("Hello, World. This is test 2."));
Praxis.IO.File.Create("/system/test3.txt", Encoding.UTF8.GetBytes("Hello, World. This is test 3."));
//writes contents to console
Console.Write(Encoding.UTF8.GetString(Praxis.IO.File.Read("/system/test1.txt")));//Encoding.UTF8.GetString(Praxis.IO.File.get("system", 0)).Replace(((char)0).ToString(), ""));
Console.ReadKey();
}
private void LoadHDI(string filename, bool isOriginal)
{
var disk = new Disk(filename);
var pt = PartitionTable.GetPartitionTables(disk);
var p = pt[0].Partitions[0];
var fs = new FatFileSystem(p.Open());
ListView loader;
var checkedFiles = new Dictionary <string, bool>();
if (isOriginal)
{
originalDisk = disk;
_patchBuilder.originalFs = fs;
loader = lvItems;
}
else
{
translatedDisk = disk;
_patchBuilder.translatedFs = fs;
loader = lvTranslatedItems;
foreach (ListViewItem item in lvItems.CheckedItems)
{
checkedFiles.Add(item.Name, true);
}
}
var files = fs.GetFiles(@"\");
var dirs = fs.GetDirectories(@"\");
foreach (var dir in dirs)
{
var item = new ListViewItem {
Name = dir,
Text = dir.Replace("\\", ""),
ImageIndex = 0
};
if (checkedFiles.ContainsKey(dir))
{
item.Checked = true;
}
loader.Items.Add(item);
}
foreach (var file in files)
{
var item = new ListViewItem {
Name = file,
Text = file.TrimStart('\\'),
ImageIndex = 1
};
if (checkedFiles.ContainsKey(file))
{
item.Checked = true;
}
if (_patchBuilder.IsSysFile(item.Text))
{
item.Tag = "sys";
item.BackColor = Color.LightGray;
item.ForeColor = Color.Gray;
}
else if (item.Text == "AUTOEXEC.BAT" || item.Text == "CONFIG.SYS")
{
item.Tag = "always";
item.Checked = true;
item.BackColor = Color.LightGray;
item.ForeColor = Color.Gray;
}
else
{
item.Tag = "ord";
}
loader.Items.Add(item);
}
loader.Refresh();
}
private static void LogFailure(Connection connection, int partitionStateVersion, PartitionTable current, string cause)
{
Logger.Finest($" We will not apply the response, because {cause} . " + $"Response is from {connection}. " +
$"Current connection {current?.Connection} response state version:{partitionStateVersion}. " +
$"Current state version: {current?.PartitionSateVersion}");
}
protected override void ProcessRecord()
{
PSObject diskObject = null;
VirtualDisk disk = null;
if (InputObject != null)
{
diskObject = InputObject;
disk = diskObject.BaseObject as VirtualDisk;
}
if (disk == null && string.IsNullOrEmpty(LiteralPath))
{
WriteError(new ErrorRecord(
new ArgumentException("No disk specified"),
"NoDiskSpecified",
ErrorCategory.InvalidArgument,
null));
return;
}
if (disk == null)
{
diskObject = SessionState.InvokeProvider.Item.Get(LiteralPath)[0];
VirtualDisk vdisk = diskObject.BaseObject as VirtualDisk;
if (vdisk == null)
{
WriteError(new ErrorRecord(
new ArgumentException("Path specified is not a virtual disk"),
"BadDiskSpecified",
ErrorCategory.InvalidArgument,
null));
return;
}
disk = vdisk;
}
PartitionTable pt = null;
if (VolumeManager == VolumeManagerType.Bios)
{
pt = BiosPartitionTable.Initialize(disk);
}
else
{
pt = GuidPartitionTable.Initialize(disk);
}
if (Signature != 0)
{
disk.Signature = Signature;
}
else
{
disk.Signature = new Random().Next();
}
// Changed volume layout, force a rescan
var drive = diskObject.Properties["PSDrive"].Value as VirtualDiskPSDriveInfo;
if (drive != null)
{
drive.RescanVolumes();
}
WriteObject(disk);
}
void MainC(string[] args)
{
Disk disk = new Disk("server.bin");
PartitionTable partitions = disk.Partitions;
PartitionInfo fs_pi = partitions[0];
FatFileSystem fs = new FatFileSystem(fs_pi.Open());
PartitionInfo mfs_pi = partitions[1];
FatFileSystem mfs = new FatFileSystem(mfs_pi.Open());
svtime = DateTime.Now.Ticks;
Console.WriteLine("Starting...");
netListener = new EventBasedNetListener();
client = new NetManager(netListener, new XorEncryptLayer("dreamscape"));
inetListener = new EventBasedNetListener();
iclient = new NetManager(inetListener);
lua = new Lua();
gameInstance = new Instance("DataModel");
Factory factoryContainer = new Factory("Factories");
factoryContainer.Parent = gameInstance;
CharacterFactory characterFactory = new CharacterFactory("CharacterFactory");
characterFactory.Parent = factoryContainer;
GameLibrary gameLibrary = new GameLibrary("GameLibrary");
gameLibrary.Parent = factoryContainer;
lua.LoadCLRPackage();
lua.DebugHook += Lua_DebugHook;
SparseStream stream = fs.OpenFile("lua\\main.lua", FileMode.Open, FileAccess.Read);
byte[] data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
string code = Encoding.ASCII.GetString(data);
stream.Close();
lua["netwriter"] = new NetDataWriter();
lua["netserver"] = client;
lua["DataModel"] = gameInstance;
lua.DoString("import('dreamhost','dreamscape','System','NLua','LiteNetLib','LiteNetLib.Utils','dreamhost.lua')\n" + code, svtime.ToString());
this.characterFactory = characterFactory;
client.Start(6698);
Console.WriteLine("Server ready! Hosting on UDP port 6698.");
client.AutoRecycle = true;
netListener.ConnectionRequestEvent += (request) =>
{
Console.WriteLine("Connection");
LuaFunction func = lua["peerhandle"] as LuaFunction;
try
{
func.Call(request);
} catch (Exception e)
{
request.Accept();
Console.WriteLine(e);
}
};
netListener.PeerDisconnectedEvent += (peer, info) =>
{
Player plr = null;
foreach (Player i in characterFactory.Children)
{
if (i.peer == peer)
{
plr = i;
}
}
Console.WriteLine("Disconnect");
LuaFunction func = lua["peerdisconnect"] as LuaFunction;
try
{
func.Call(peer, info, plr);
} catch (Exception e)
{
Console.WriteLine(e);
}
};
netListener.PeerConnectedEvent += (peer) =>
{
Player player = new Player(gameLibrary.FindEntropy().ToString(), peer);
player.Parent = characterFactory;
Console.WriteLine("Successful Connect");
LuaFunction func = lua["peerconnect"] as LuaFunction;
try
{
func.Call(peer, player);
} catch (Exception e)
{
Console.WriteLine(e);
}
};
netListener.NetworkReceiveEvent += NetworkReceive;
Console.WriteLine("Starting info server...");
inetListener.PeerConnectedEvent += (peer) =>
{
Console.WriteLine("Sending peer info");
NetDataWriter writer = new NetDataWriter();
LuaFunction func = lua["getinfo"] as LuaFunction;
try
{
writer.Put(func.Call(peer).First() as string);
}
catch (Exception e)
{
Console.WriteLine(e);
writer.Put("Please contact the <b>SYSOP</b> for this server.\n" + e);
}
peer.Send(writer, DeliveryMethod.ReliableSequenced);
};
inetListener.ConnectionRequestEvent += (request) =>
{
Console.WriteLine("Connected to info");
request.Accept();
};
iclient.Start(6699);
iclient.AutoRecycle = true;
Console.WriteLine("Info server ready! Hosting on UDP port 6699.");
while (true)
{
client.PollEvents();
Thread.Sleep(15);
}
}
public LogicalDevice(PhysicalDevice owner, PartitionTable partition)
{
this.physicalDevice = owner;
this.partition = partition;
Refresh();
}
