public bool OverWriteFile(File FileToOverwrite, string FilePath, ref int Progress, ref int BlocksToWrite)
{
FATX_Browser.FATX.IOReader br = null;
//Do a try...
try
{
//Create our new fatstuff to get our free blocks
FATStuff fs = new FATStuff(FileToOverwrite);
//Get our blocks needed
int BlocksNeeded = (int)(m.UpToNearestCluster(new System.IO.FileInfo(FilePath).Length, FileToOverwrite.PartInfo.ClusterSize) / FileToOverwrite.PartInfo.ClusterSize);
//Create our block array for the blocks we do have
uint[] BlocksWeHave = FileToOverwrite.BlocksOccupied;
//If we have more blocks than we need already...
if ((int)FileToOverwrite.BlocksOccupied.Length > BlocksNeeded)
{
//Get our blocks that we're going to clear...
List<uint> BlocksList = FileToOverwrite.BlocksOccupied.ToList<uint>();
//Remove the blocks we need from the list of blocks to overwrite
BlocksList.RemoveRange(0x0, (int)((int)FileToOverwrite.BlocksOccupied.Length - BlocksNeeded));
//Finalize
uint[] BlocksToFree = BlocksList.ToArray();
//Clears the blocks.
ClearFATChain(BlocksToFree, FileToOverwrite);
//Make the final block in the series the ending block by writing 0xFFFF to it
uint EndBlock = FileToOverwrite.BlocksOccupied[(FileToOverwrite.BlocksOccupied.Length - 1) - BlocksNeeded];
if (FileToOverwrite.PartInfo.EntrySize == Info.PartitionBit.FATX16)
{
WriteBlock(EndBlock, new byte[] { 0xFF, 0xFF }, FileToOverwrite);
}
else
{
WriteBlock(EndBlock, new byte[] { 0xFF, 0xFF, 0xFF, 0xFF }, FileToOverwrite);
}
BlocksList = FileToOverwrite.BlocksOccupied.ToList<uint>();
BlocksList.RemoveRange(0x0, (FileToOverwrite.BlocksOccupied.Length - 1) - BlocksNeeded);
BlocksWeHave = BlocksList.ToArray();
}
else if ((int)FileToOverwrite.BlocksOccupied.Length < BlocksNeeded)
{
//Get the number of blocks we REALLY need
int RealBlocksNeeded = BlocksNeeded - FileToOverwrite.BlocksOccupied.Length;
//Write out the FAT chain from that last block
List<uint> bl = new List<uint>();
bl.Add(FileToOverwrite.BlocksOccupied[FileToOverwrite.BlocksOccupied.Length - 1]);
uint[] newBlocks = new FATStuff(FileToOverwrite).GetFreeBlocks(RealBlocksNeeded, bl[0], 0, false);
bl.AddRange(newBlocks);
//Set the BlocksWeHave
BlocksWeHave = bl.ToArray();
}
//Create our binary reader to read our file
br = new FATX_Browser.FATX.IOReader(new System.IO.FileStream(FilePath, System.IO.FileMode.Open));
for (int i = 0; i < BlocksWeHave.Length; i++)
{
WriteToCluster(m.GetBlockOffset(BlocksWeHave[i], FileToOverwrite), br.ReadBytes(0x200));
}
br.Close();
return true;
}
catch (Exception e)
{
try
{
br.Close();
}
catch { }
throw e;
}
}
public bool WriteNewFile(Folder Root, string FilePath, ref int Progress, ref int BlocksToWrite)
{
FATX_Browser.FATX.IOReader br = null;
//Do a try...
try
{
//Get our entry
EntryData EData = GetNewEntryData(Root, new System.IO.FileInfo(FilePath).Name);
//Create our entry in the folder
CreateNewEntry(EData);
//Create our new fatstuff to get our free blocks
FATStuff fs = new FATStuff(Root);
//Get our free blocks
uint[] blocks = fs.GetFreeBlocks((int)(m.UpToNearestCluster(new System.IO.FileInfo(FilePath).Length, Root.PartInfo.ClusterSize) / Root.PartInfo.ClusterSize), EData.StartingCluster, 0, false);
//Make a new list for the blocks...
List<uint> COCKS = blocks.ToList<uint>();
//Insert the beginning block at the 0 index
COCKS.Insert(0, EData.StartingCluster);
//Make the cocks an array
blocks = COCKS.ToArray();
//Write the FAT chain
WriteFATChain(blocks, Root);
//Create our binary reader to read our file
br = new FATX_Browser.FATX.IOReader(new System.IO.FileStream(FilePath, System.IO.FileMode.Open));
for (int i = 0; i < blocks.Length; i++)
{
WriteToCluster(m.GetBlockOffset(blocks[i], Root), br.ReadBytes(0x200));
}
br.Close();
return true;
}
catch(Exception e)
{
try
{
br.Close();
}
catch { }
throw e;
}
}
/// <summary>
/// Returns an array of free blocks based off of the number of blocks needed
/// </summary>
public uint[] GetFreeBlocks(int blocksNeeded, uint StartBlock, long end, bool SecondLoop)
{
int Clustersize = 0x1000;
uint Block = StartBlock;
if (end == 0)
{
end = DataOffset();
}
List<uint> BlockList = new List<uint>();
Misc m = new Misc();
for (long i = m.DownToNearest200(m.BlockToFATOffset(StartBlock, Partition)); i < end; i += Clustersize)
{
//Create our reader
FATX_Browser.FATX.IOReader br = ourDrive.GetIO();
//Set our position to i
br.BaseStream.Position = i;
//Read our buffer
byte[] buffer = br.ReadBytes(Clustersize);
br.Close();
//Re-open our binary reader using the buffer/memory stream
for (int j = 0; j < Clustersize; j+= (int)Partition.EntrySize, Block += (uint)Partition.EntrySize)
{
br = new FATX_Browser.FATX.IOReader(new System.IO.MemoryStream(buffer));
br.BaseStream.Position = j;
//If we've gotten all of our requested blocks...
if (BlockList.ToArray().Length == blocksNeeded)
{
//Close our reader -> break the loop
br.Close();
break;
}
//Read the next block entry
byte[] reading = br.ReadBytes((int)Partition.EntrySize);
//Close our reader - it's no longer needed
br.Close();
//For each byte in our reading
for (int k = 0; k < reading.Length; k++)
{
//If the byte isn't null (if the block isn't open)
if (reading[k] != 0x00)
{
//Break
break;
}
//If we've reached the end of the array, and the last byte
//is 0x00, then the block is free
if (k == reading.Length - 1 && reading[k] == 0x00)
{
//Do some maths to get the block numbah
long fOff = FATOffset;
long blockPosition = (long)i + j;
uint block = (uint)(blockPosition - fOff) / (uint)EntrySize;
BlockList.Add(block);
}
}
}
//We're putting in one last check so that we don't loop more than we need to
if (BlockList.ToArray().Length == blocksNeeded)
{
break;
}
}
//If we found the required amount of free blocks - return our list
if (BlockList.Count == blocksNeeded)
{
return BlockList.ToArray();
}
//If we didn't find the amount of blocks required, but we started from a
//block other than the first one...
if (BlockList.Count < blocksNeeded && SecondLoop == false)
{
BlockList.AddRange(GetFreeBlocks(blocksNeeded - BlockList.ToArray().Length, 1, m.DownToNearest200(m.BlockToFATOffset(StartBlock, Partition)), true));
}
//We didn't find the amount of free blocks required, meaning we're out of
//disk space
throw new Exception("Out of Xbox 360 hard disk space");
}
/// <summary>
/// Partition ID
/// </summary>
public uint PartitionID()
{
uint rVal = 0;
Misc m = new Misc();
//Open our binary reader
FATX_Browser.FATX.IOReader br = ourDrive.GetIO();
//Seek to the data partition offset
br.BaseStream.Position = Partition.Offset;
//Read our buffer
FATX_Browser.FATX.IOReader mem = new FATX_Browser.FATX.IOReader(new System.IO.MemoryStream(br.ReadBytes(0x200)));
br.Close();
mem.BaseStream.Position = 0x4;
rVal = m.ReadUInt32(ref mem);
mem.Close();
return rVal;
}
/// <summary>
/// Number of File Allocation Tables
/// </summary>
public uint FATCopies()
{
uint rVal = 0;
Misc m = new Misc();
//Open our binary reader
FATX_Browser.FATX.IOReader br = ourDrive.GetIO();
//Seek to the data partition offset + 0xC (where the FATCopies int is)
br.BaseStream.Position = Partition.Offset;
//Create our mem reader / buffer
FATX_Browser.FATX.IOReader mem = new FATX_Browser.FATX.IOReader(new System.IO.MemoryStream(br.ReadBytes(0x200)));
br.Close();
mem.BaseStream.Position = 0xC;
//Get our value (uses outside class for bigendian)
rVal = m.ReadUInt32(ref mem);
mem.Close();
return rVal;
}
//For reading a single block
private byte[] GetOccupiedBlock(uint baseBlock)
{
//Create our list of our
Misc m = new Misc();
//Create our binary reader
FATX_Browser.FATX.IOReader br = xDrive.GetIO();
//Read our buffer to load in to the memory stream
long BufferOffset = m.BlockToFATOffset(baseBlock, Holder);
BufferOffset = BufferOffset - (BufferOffset % 0x200);
long BlockOffsetInBuffer = m.BlockToFATOffset(baseBlock, Holder) - BufferOffset;
//Go to the buffer we're reading's offset
br.BaseStream.Position = BufferOffset;
//Read our buffer
byte[] buffer = br.ReadBytes(0x200);
br.Close();
//Re-open our reader using the memorystream this time
FATX_Browser.FATX.IOReader mem = new FATX_Browser.FATX.IOReader(new System.IO.MemoryStream(buffer));
//Close our reader
mem.BaseStream.Position = BlockOffsetInBuffer;
byte[] rVal = mem.ReadBytes(EntrySize);
//The following checks to see if the next block in the sequence is
uint nextBlock;
if (EntrySize == 4)
{
byte[] blockCopy = rVal;
nextBlock = BitConverter.ToUInt32(blockCopy, 0x0);
}
else
{
byte[] blockCopy = rVal;
nextBlock = BitConverter.ToUInt16(blockCopy, 0x0);
}
mem.Close();
return rVal;
}
private bool CheckBlock(ref byte[] buffer, byte[] nextVal, long bufferOff, ref List<uint> blocks)
{
//Create our byte array for our reading (value will be set, but throws an error
//if we don't set it to anything now
byte[] reading = { 0x00 };
//For determining if we've reached the end of our fileszzz
bool EOOF = true;
//Our uint for the next valu
uint NextVal = 0;
//Get our position in buffer
int positionInBuff;
object[] ReturnObject = new Object[] { EOOF, blocks };
//If the previous value wasn't EOF
if (!EOF(nextVal, false))
{
EOOF = false;
Array.Reverse(nextVal);
if (Holder.PartInfo.EntrySize == Info.PartitionBit.FATX16)
{
NextVal = BitConverter.ToUInt16(nextVal, 0x0);
}
else
{
NextVal = BitConverter.ToUInt32(nextVal, 0x0);
}
//Get our position in buffer (actually assigning value now)
positionInBuff = (int)(new Misc().BlockToFATOffset(NextVal, Holder) - bufferOff);
//Open our binary reader
FATX_Browser.FATX.IOReader br = new FATX_Browser.FATX.IOReader(new System.IO.MemoryStream(buffer));
//Set our position of our reader
br.BaseStream.Position = positionInBuff;
//Sort of silly to loop, but i'm lazy to revise code
for (int i = positionInBuff; i < buffer.Length; i += EntrySize)
{
//Read our number (if possible)
reading = br.ReadBytes(EntrySize);
//If what we just read is the same as what we're expecting, and not EOF
if (!EOF(reading, false))
{
//Reverse our array (bitconverter reverses the array, causing it to be
//little endian when we convert)
Array.Reverse(reading);
//Create our bloccstyle value
uint blockAddVal;
//If we're in a uint32 partition
if (EntrySize == 4)
{
//Convert our shit to a uint32
blockAddVal = BitConverter.ToUInt32(reading, 0x0);
}
//We're in an uint16 partition
else
{
//Let's convert this shit to a uint16 val
blockAddVal = BitConverter.ToUInt16(reading, 0x0);
}
//Add it to our blocklist
blocks.Add(blockAddVal);
//Reverse the array again so that it's bigendian
Array.Reverse(reading);
//Get the next block if possible...
if (bufferOff == new Misc().DownToNearest200(new Misc().BlockToFATOffset(blockAddVal, Holder)))
{
EOOF = CheckBlock(ref buffer, reading, bufferOff, ref blocks);
}
return EOOF;
}
if (EOF(reading, false))
{
EOOF = true;
return EOOF;
}
}
}
EOOF = true;
return EOOF;
}
/// <summary>
/// Returns an array of EntryData for a specified block
/// </summary>
/// <param name="block">The block to read from</param>
public EntryData[] GetEntries(uint block)
{
FATX_Browser.FATX.IOReader br = xDrive.GetIO();
//Get the block offset
Misc r = new Misc();
br.BaseStream.Position = r.GetBlockOffset(block, Holder.PartInfo);
long position = br.BaseStream.Position;
//Create another binary reader that will hold our 0x200 bytes to read
//(we can not seek to something that's not a multiple of 0x200)
long OOFFSET = br.BaseStream.Position;
byte[] buffer = br.ReadBytes(0x200);
//Our placeholder for the bytes in the buffer read
int bufferRead = 0;
List<EntryData> l = new List<EntryData>();
for (uint i = 1; i <= 100; i++)
{
//If we've reached the end of the buffer
if (bufferRead == 0x200)
{
OOFFSET = br.BaseStream.Position;
//Read the next 0x200 bytes
buffer = br.ReadBytes(0x200);
bufferRead = 0;
}
//Create our stream for the reader
FATX_Browser.FATX.IOReader mem = new FATX_Browser.FATX.IOReader(new System.IO.MemoryStream(buffer));
mem.BaseStream.Position = bufferRead;
//Make sure that we're not at the end of the block
byte[] end = mem.ReadBytes(2);
if (EOF(end, true))
{
break;
}
//We have to reset the reader back to the beginning of the block
mem.BaseStream.Position -= 0x2;
l.Add(GetEData(OOFFSET, mem, i, block));
position += 0x40;
bufferRead += 0x40;
br.BaseStream.Position = position;
mem.Close();
}
br.Close();
return l.ToArray();
}
//For getting an array of blocks occupied
/// <summary>
/// Returns an array of blocks that a file/folder entry occupies
/// </summary>
/// <param name="baseBlock">The base block to read from the FAT chain (the root)</param>
public uint[] GetBlocksOccupied(uint baseBlock)
{
//Create our list to hold the uints
List<uint> l = new List<uint>();
l.Add(baseBlock);
//Create a new byte array with random input
byte[] ourReturn = { 0xAA, 0xAA };
//Increase the number of blocks - keep the loop going until we've
//reached the end of the blocks (0xFFFF or equal)
for (int i = 0; !EOF(ourReturn, false); i++)
{
uint CurrentBlock = l.ToArray()[i];
//Get our next block in the series
//Create our list of our
Misc m = new Misc();
//Create our binary reader
FATX_Browser.FATX.IOReader br = xDrive.GetIO();
//Read our buffer to load in to the memory stream
long BufferOffset = m.BlockToFATOffset(CurrentBlock, Holder);
BufferOffset = BufferOffset - (BufferOffset % 0x200);
long BlockOffsetInBuffer = m.BlockToFATOffset(CurrentBlock, Holder) - BufferOffset;
//Go to the buffer we're reading's offset
br.BaseStream.Position = BufferOffset;
//Read our buffer
byte[] buffer = br.ReadBytes(0x200);
br.Close();
//Re-open our reader using the memorystream this time
FATX_Browser.FATX.IOReader mem = new FATX_Browser.FATX.IOReader(new System.IO.MemoryStream(buffer));
//Close our reader
mem.BaseStream.Position = BlockOffsetInBuffer;
ourReturn = mem.ReadBytes(EntrySize);
mem.Close();
//If the block is the ending block
if (EOF(ourReturn, false))
{
//Break
break;
}
//The block isn't the ending block, reverse the array so we can
//convert it to big endian uintxx
Array.Reverse(ourReturn);
//Create our value to add to the list
uint addVal;
if (bit == Info.PartitionBit.FATX32)
{
addVal = BitConverter.ToUInt32(ourReturn, 0);
}
else { addVal = BitConverter.ToUInt16(ourReturn, 0); }
//Add our value to the list
l.Add(addVal);
Array.Reverse(ourReturn);
if (BufferOffset == (long)(m.DownToNearest200(m.BlockToFATOffset(addVal, Holder))))
{
object[] stuff = CheckBlock(ref buffer, ourReturn, BufferOffset);
l.AddRange(((List<uint>)stuff[1]).ToArray());
i += ((List<uint>)stuff[1]).Count;
if ((bool)stuff[0] == true)
{
break;
}
}
}
return l.ToArray();
}