bool xExtract(string xOut, bool Sub)
{
if (!VariousFunctions.xCheckDirectory(xOut))
{
return(false);
}
FATXReadContents xread = xRead();
if (xread == null)
{
return(false);
}
foreach (FATXFileEntry x in xread.Files)
{
DJsIO xIOOut = new DJsIO(xOut + "/" + x.Name, DJFileMode.Create, true);
if (!xIOOut.Accessed)
{
continue;
}
x.xExtract(ref xIOOut);
xIOOut.Dispose();
}
if (!Sub)
{
return(true);
}
foreach (FATXFolderEntry x in xread.Folders)
{
x.xExtract(xOut + "/" + x.Name, Sub);
}
return(true);
}
/* Note: Have plans for safer and better manipulation to prevent
* minimal block loss to human error */
/// <summary>
/// Adds a folder
/// </summary>
/// <param name="FolderName"></param>
/// <returns></returns>
public bool AddFolder(string FolderName)
{
FolderName.IsValidXboxName();
if (xDrive.ActiveCheck())
{
return(false);
}
try
{
FATXReadContents xconts = xRead();
foreach (FATXFolderEntry x in xconts.xfolds)
{
if (x.Name == FolderName)
{
return(xDrive.xActive = false);
}
}
DJsIO xIOIn = new DJsIO(new byte[Partition.xBlockSize], true);
uint xnew = 0;
long xpos = GetNewEntryPos(out xnew);
if (xpos == -1)
{
return(xDrive.xActive = false);
}
uint[] blocks = Partition.xTable.GetNewBlockChain(xIOIn.BlockCountFATX(Partition), xnew + 1);
if (blocks.Length == 0)
{
return(xDrive.xActive = false);
}
if (!Partition.WriteFile(blocks, ref xIOIn))
{
return(xDrive.xActive = false);
}
FATXEntry y = new FATXEntry(FolderName, blocks[0], (int)xIOIn.Length, xpos, true, ref xDrive);
if (!y.xWriteEntry())
{
return(xDrive.xActive = false);
}
if (xnew > 0)
{
List <uint> fileblocks = new List <uint>(Partition.xTable.GetBlocks(xStartBlock));
fileblocks.Add(xnew);
uint[] xtemp = fileblocks.ToArray();
if (!Partition.xTable.WriteChain(ref xtemp))
{
return(xDrive.xActive = false);
}
}
if (!Partition.xTable.WriteChain(ref blocks))
{
return(xDrive.xActive = false);
}
if (Partition.WriteAllocTable())
{
return(!(xDrive.xActive = false));
}
return(xDrive.xActive = false);
}
catch { return(xDrive.xActive = false); }
}
public FATXEntry GetSubEntry(string fileName, FATXReadContents parent)
{
FATXEntry ret = GetSubFolder(fileName, parent);
if (ret == null)
{
ret = GetSubFile(fileName, parent);
}
return(ret);
}
/// <summary>
/// Reads the contents
/// </summary>
/// <returns></returns>
public FATXReadContents Read()
{
if (xDrive.ActiveCheck())
{
return(null);
}
FATXReadContents xReturn = xRead();
xDrive.xActive = false;
return(xReturn);
}
/// <summary>
/// Attempts to read to a specified location
/// </summary>
/// <param name="Path">Path to read to</param>
/// <param name="xFolderOut">FATXFolder of result</param>
/// <returns></returns>
public FATXReadContents ReadToFolder(string Path, out FATXFolderEntry xFolderOut)
{
if (ActiveCheck())
{
xFolderOut = null;
return(null);
}
FATXReadContents xreturn = xReadToFolder(Path, out xFolderOut);
xactive = false;
return(xreturn);
}
public FATXEntry GetSubFile(string fileName, FATXReadContents parent)
{
FATXEntry ret = null;
for (int x = 0; x < parent.Files.Length; x++)
{
var subFile = parent.Files[x];
if (string.Compare(subFile.Name, fileName, true) == 0)
{
ret = subFile;
break;
}
}
return(ret);
}
internal FATXReadContents xRead()
{
FATXReadContents xreturn = new FATXReadContents();
try
{
xDrive.GetIO();
List <FATXEntry> xEntries = new List <FATXEntry>();
uint[] xBlocks = Partition.xTable.GetBlocks(xStartBlock);
for (int i = 0; i < xBlocks.Length; i++)
{
long xCurrent = Partition.BlockToOffset(xBlocks[i]);
if (xCurrent == -1)
{
break;
}
for (int x = 0; x < Partition.xEntryCount; x++)
{
xDrive.xIO.Position = xCurrent + (0x40 * x);
FATXEntry z = new FATXEntry((xCurrent + (0x40 * x)), xDrive.xIO.ReadBytes(0x40), ref xDrive);
z.SetAtts(Partition);
if (z.xIsValid)
{
xEntries.Add(z);
}
else if (z.xNLen != 0xE5)
{
break;
}
}
}
xreturn.xfolds = new List <FATXFolderEntry>();
xreturn.xfiles = new List <FATXFileEntry>();
for (int i = 0; i < xEntries.Count; i++)
{
if (xEntries[i].IsFolder)
{
xreturn.xfolds.Add(new FATXFolderEntry(xEntries[i], ref xDrive));
}
else
{
xreturn.xfiles.Add(new FATXFileEntry(xEntries[i], ref xDrive));
}
}
return(xreturn);
}
catch { return(xreturn = null); }
}
public FATXReadContents GetPartitionContents(int partition)
{
FATXReadContents xread = new FATXReadContents();
xread.xfiles = new List <FATXFileEntry>();
xread.xfolds = new List <FATXFolderEntry>();
foreach (FATXFolderEntry xz in Partitions[partition].Folders)
{
xread.xfolds.Add(xz);
}
foreach (FATXPartition xz in Partitions[partition].SubPartitions)
{
xread.xsubparts.Add(xz);
}
return(xread);
}
public FATXEntry GetSubFolder(string folderName, FATXReadContents parent)
{
FATXEntry ret = null;
for (int x = 0; x < parent.Folders.Length; x++)
{
var subFolder = parent.Folders[x];
if (string.Compare(subFolder.Name, folderName, true) == 0)
{
ret = subFolder;
break;
}
}
return(ret);
}
internal FATXReadContents xRead()
{
FATXReadContents xreturn = new FATXReadContents();
try
{
xDrive.GetIO();
List<FATXEntry> xEntries = new List<FATXEntry>();
uint[] xBlocks = Partition.xTable.GetBlocks(xStartBlock);
for (int i = 0; i < xBlocks.Length; i++)
{
long xCurrent = Partition.BlockToOffset(xBlocks[i]);
if (xCurrent == -1)
break;
for (int x = 0; x < Partition.xEntryCount; x++)
{
xDrive.xIO.Position = xCurrent + (0x40 * x);
FATXEntry z = new FATXEntry((xCurrent + (0x40 * x)), xDrive.xIO.ReadBytes(0x40), ref xDrive);
z.SetAtts(Partition);
if (z.xIsValid)
xEntries.Add(z);
else if (z.xNLen != 0xE5)
break;
}
}
xreturn.xfolds = new List<FATXFolderEntry>();
xreturn.xfiles = new List<FATXFileEntry>();
for (int i = 0; i < xEntries.Count; i++)
{
if (xEntries[i].IsFolder)
xreturn.xfolds.Add(new FATXFolderEntry(xEntries[i], ref xDrive));
else xreturn.xfiles.Add(new FATXFileEntry(xEntries[i], ref xDrive));
}
return xreturn;
}
catch { return (xreturn = null); }
}
public USBDriveEntry(string name, FATXReadContents contents, FATXFolderEntry entry)
{
this.entry = entry;
this.name = name;
this.contents = contents;
}
public FATXReadContents xRead()
{
FATXReadContents xreturn = new FATXReadContents();
try
{
xDrive.GetIO();
if (!Partition.xTable.xAllocTable.Accessed)
{
return null;
}
List<FATXEntry> xEntries = new List<FATXEntry>();
uint[] xBlocks = Partition.xTable.GetBlocks(xStartBlock);
for (int i = 0; i < xBlocks.Length; i++)
{
long xCurrent = Partition.BlockToOffset(xBlocks[i]);
if (xCurrent == -1)
break;
for (int x = 0; x < Partition.xEntryCount; x++)
{
xDrive.xIO.Position = xCurrent + (0x40 * x);
FATXEntry z = new FATXEntry(Partition.FatType,
(xCurrent + (0x40 * x)),
xDrive.xIO.ReadBytes(0x40),
ref xDrive);
z.SetAtts(Partition);
if (z.xIsValid)
{
xEntries.Add(z);
}
else
{
if (z.xNLen != 0xE5)
break;
}
}
}
xreturn.xfolds = new List<FATXFolderEntry>();
xreturn.xfiles = new List<FATXFileEntry>();
for (int i = 0; i < xEntries.Count; i++)
{
if (xEntries[i].IsFolder)
{
if (string.Compare(xEntries[i].Name, this.Name, true) != 0)
{
var f = new FATXFolderEntry(this, xEntries[i], Path + "/" + xEntries[i].Name);
xreturn.xfolds.Add(f);
}
}
else
{
var f = new FATXFileEntry(this, xEntries[i]);
xreturn.xfiles.Add(f);
}
}
return xreturn;
}
catch { return (xreturn = null); }
}
public FATXReadContents xReadToFolder(string Path, out FATXFolderEntry xFolderOut)
{
xFolderOut = null;
List<string> findFolders = GetPathFromString(Path);
if (findFolders == null || findFolders.Count == 0)
return null;
string findPartition = findFolders[0];
var partition = GetPartition(findPartition);
if (partition == null)
return null;
int partIndex = GetPartitionIndex(partition);
if (partIndex == -1)
return null;
var contents = GetPartitionContents(partIndex);
if (contents == null)
return null;
if (findFolders.Count == 1)
{
xFolderOut = new FATXFolderEntry(contents.Folders[0].Parent, contents.Folders[0], Path);
return contents;
}
findFolders.RemoveAt(0);
while (findFolders.Count > 0)
{
var entry = GetSubEntry(findFolders[0], contents);
if (entry != null)
{
if (entry.xIsValid)
{
if (entry.IsFolder)
{
var fe = entry as FATXFolderEntry;
if (fe != null)
{
xFolderOut = fe;
contents = fe.xRead();
}
else
{
xFolderOut = null;
contents = null;
}
}
else
{
var fe = entry as FATXFileEntry;
if (fe != null)
{
xFolderOut = null;
contents = new FATXReadContents();
contents.xfiles = new List<FATXFileEntry>();
contents.xfolds = new List<FATXFolderEntry>();
contents.xfiles.Add(fe);
}
else
{
xFolderOut = null;
contents = null;
}
}
}
}
findFolders.RemoveAt(0);
if (contents == null)
return null;
}
return contents;
/*
if (Folders.Length == 1)
{
return partContents;
}
int curFolder=1;
FATXPartition xcurpart = xPartitions[PartitionIndex];
int idx = 1;
for (int i = 0; i < xcurpart.SubPartitions.Length; i++)
{
if (xcurpart.SubPartitions[i].PartitionName.ToLower() != Folders[1].ToLower())
continue;
xcurpart = xcurpart.SubPartitions[i];
idx++;
if (Folders.Length == 2)
{
FATXReadContents xread = new FATXReadContents();
xread.xfiles = new List<FATXFileEntry>();
xread.xfolds = new List<FATXFolderEntry>();
foreach (FATXFolderEntry xz in xcurpart.Folders)
xread.xfolds.Add(xz);
return xread;
}
break;
}
FATXFolderEntry xFold = null;
foreach (FATXFolderEntry x in xcurpart.Folders)
{
if (x.Name.ToLower() != Folders[idx].ToLower())
continue;
xFold = x;
break;
}
if (xFold == null)
return null;
idx++;
FATXReadContents xreadct;
for (int i = idx; i < Folders.Length; i++)
{
bool found = false;
xreadct = xFold.xRead();
foreach (FATXFolderEntry x in xreadct.Folders)
{
if (x.Name.ToLower() != Folders[i].ToLower())
continue;
found = true;
xFold = x;
break;
}
if (!found)
return null;
}
xFolderOut = xFold;
return xFold.xRead();*/
}
public FATXEntry GetSubFolder(string folderName, FATXReadContents parent)
{
FATXEntry ret = null;
for (int x = 0; x < parent.Folders.Length; x++)
{
var subFolder = parent.Folders[x];
if (string.Compare(subFolder.Name, folderName, true) == 0)
{
ret = subFolder;
break;
}
}
return ret;
}
public FATXEntry GetSubFile(string fileName, FATXReadContents parent)
{
FATXEntry ret = null;
for (int x = 0; x < parent.Files.Length; x++)
{
var subFile = parent.Files[x];
if (string.Compare(subFile.Name, fileName, true) == 0)
{
ret = subFile;
break;
}
}
return ret;
}
public FATXEntry GetSubEntry(string fileName, FATXReadContents parent)
{
FATXEntry ret = GetSubFolder(fileName, parent);
if (ret == null)
ret = GetSubFile(fileName, parent);
return ret;
}
public FATXReadContents GetPartitionContents(int partition)
{
FATXReadContents xread = new FATXReadContents();
xread.xfiles = new List<FATXFileEntry>();
xread.xfolds = new List<FATXFolderEntry>();
foreach (FATXFolderEntry xz in Partitions[partition].Folders)
xread.xfolds.Add(xz);
foreach (FATXPartition xz in Partitions[partition].SubPartitions)
xread.xsubparts.Add(xz);
return xread;
}
public FATXReadContents xReadToFolder(string Path, out FATXFolderEntry xFolderOut)
{
xFolderOut = null;
List <string> findFolders = GetPathFromString(Path);
if (findFolders == null || findFolders.Count == 0)
{
return(null);
}
string findPartition = findFolders[0];
var partition = GetPartition(findPartition);
if (partition == null)
{
return(null);
}
int partIndex = GetPartitionIndex(partition);
if (partIndex == -1)
{
return(null);
}
var contents = GetPartitionContents(partIndex);
if (contents == null)
{
return(null);
}
if (findFolders.Count == 1)
{
xFolderOut = new FATXFolderEntry(contents.Folders[0].Parent, contents.Folders[0], Path);
return(contents);
}
findFolders.RemoveAt(0);
while (findFolders.Count > 0)
{
var entry = GetSubEntry(findFolders[0], contents);
if (entry != null)
{
if (entry.xIsValid)
{
if (entry.IsFolder)
{
var fe = entry as FATXFolderEntry;
if (fe != null)
{
xFolderOut = fe;
contents = fe.xRead();
}
else
{
xFolderOut = null;
contents = null;
}
}
else
{
var fe = entry as FATXFileEntry;
if (fe != null)
{
xFolderOut = null;
contents = new FATXReadContents();
contents.xfiles = new List <FATXFileEntry>();
contents.xfolds = new List <FATXFolderEntry>();
contents.xfiles.Add(fe);
}
else
{
xFolderOut = null;
contents = null;
}
}
}
}
findFolders.RemoveAt(0);
if (contents == null)
{
return(null);
}
}
return(contents);
/*
* if (Folders.Length == 1)
* {
* return partContents;
* }
*
* int curFolder=1;
*
*
*
* FATXPartition xcurpart = xPartitions[PartitionIndex];
* int idx = 1;
* for (int i = 0; i < xcurpart.SubPartitions.Length; i++)
* {
* if (xcurpart.SubPartitions[i].PartitionName.ToLower() != Folders[1].ToLower())
* continue;
* xcurpart = xcurpart.SubPartitions[i];
* idx++;
* if (Folders.Length == 2)
* {
* FATXReadContents xread = new FATXReadContents();
* xread.xfiles = new List<FATXFileEntry>();
* xread.xfolds = new List<FATXFolderEntry>();
* foreach (FATXFolderEntry xz in xcurpart.Folders)
* xread.xfolds.Add(xz);
* return xread;
* }
* break;
* }
* FATXFolderEntry xFold = null;
* foreach (FATXFolderEntry x in xcurpart.Folders)
* {
* if (x.Name.ToLower() != Folders[idx].ToLower())
* continue;
* xFold = x;
* break;
* }
* if (xFold == null)
* return null;
* idx++;
* FATXReadContents xreadct;
* for (int i = idx; i < Folders.Length; i++)
* {
* bool found = false;
* xreadct = xFold.xRead();
* foreach (FATXFolderEntry x in xreadct.Folders)
* {
* if (x.Name.ToLower() != Folders[i].ToLower())
* continue;
* found = true;
* xFold = x;
* break;
* }
* if (!found)
* return null;
* }
* xFolderOut = xFold;
* return xFold.xRead();*/
}
/// <summary>
/// Adds a file
/// </summary>
/// <param name="FileName"></param>
/// <param name="FileLocation"></param>
/// <param name="xType"></param>
/// <returns></returns>
public bool AddFile(string FileName, string FileLocation, AddType xType)
{
FileName.IsValidXboxName();
if (xDrive.ActiveCheck())
{
return(false);
}
DJsIO xIOIn = null;
try { xIOIn = new DJsIO(FileLocation, DJFileMode.Open, true); }
catch { return(xDrive.xActive = false); }
try
{
FATXReadContents xconts = xRead();
foreach (FATXFileEntry x in xconts.xfiles)
{
if (x.Name == FileName)
{
bool xreturn = false;
if (xType == AddType.NoOverWrite)
{
return(xDrive.xActive = false);
}
else if (xType == AddType.Inject)
{
xreturn = x.xInject(xIOIn);
}
else
{
xreturn = x.xReplace(xIOIn);
}
return(xreturn & !(xDrive.xActive = false));
}
}
uint xnew = 0;
long xpos = GetNewEntryPos(out xnew);
if (xpos == -1)
{
return(xDrive.xActive = false);
}
uint[] blocks = Partition.xTable.GetNewBlockChain(xIOIn.BlockCountFATX(Partition), xnew + 1);
if (blocks.Length == 0)
{
return(xDrive.xActive = false);
}
if (!Partition.WriteFile(blocks, ref xIOIn))
{
return(xDrive.xActive = false);
}
FATXEntry y = new FATXEntry(FileName, blocks[0], (int)xIOIn.Length, xpos, false, ref xDrive);
if (!y.xWriteEntry())
{
return(xDrive.xActive = false);
}
if (xnew > 0)
{
List <uint> fileblocks = new List <uint>(Partition.xTable.GetBlocks(xStartBlock));
fileblocks.Add(xnew);
uint[] xtemp = fileblocks.ToArray();
if (!Partition.xTable.WriteChain(ref xtemp))
{
return(xDrive.xActive = false);
}
}
if (!Partition.xTable.WriteChain(ref blocks))
{
return(xDrive.xActive = false);
}
if (Partition.WriteAllocTable())
{
return(!(xDrive.xActive = false));
}
return(xDrive.xActive = false);
}
catch { xIOIn.Close(); return(xDrive.xActive = false); }
}
internal FATXReadContents xReadToFolder(string Path, out FATXFolderEntry xFolderOut)
{
xFolderOut = null;
if (Path == null || Path == "")
return null;
Path = Path.Replace("\\", "/");
if (Path[0] == '/')
Path = Path.Substring(1, Path.Length - 1);
if (Path[Path.Length - 1] == '/')
Path = Path.Substring(0, Path.Length - 1);
string[] Folders = Path.Split(new char[] { '/' });
sbyte PartitionIndex = -1;
for (int i = 0; i < xPartitions.Count; i++)
{
if (xPartitions[i].PartitionName.ToLower() != Folders[0].ToLower())
continue;
PartitionIndex = (sbyte)i;
break;
}
if (PartitionIndex == -1)
return null;
if (Folders.Length == 1)
{
FATXReadContents xread = new FATXReadContents();
xread.xfiles = new List<FATXFileEntry>();
xread.xfolds = new List<FATXFolderEntry>();
foreach (FATXFolderEntry xz in Partitions[PartitionIndex].Folders)
xread.xfolds.Add(xz);
foreach (FATXPartition xz in Partitions[PartitionIndex].SubPartitions)
xread.xsubparts.Add(xz);
return xread;
}
FATXPartition xcurpart = xPartitions[PartitionIndex];
int idx = 1;
for (int i = 0; i < xcurpart.SubPartitions.Length; i++)
{
if (xcurpart.SubPartitions[i].PartitionName.ToLower() != Folders[1].ToLower())
continue;
xcurpart = xcurpart.SubPartitions[i];
idx++;
if (Folders.Length == 2)
{
FATXReadContents xread = new FATXReadContents();
xread.xfiles = new List<FATXFileEntry>();
xread.xfolds = new List<FATXFolderEntry>();
foreach (FATXFolderEntry xz in xcurpart.Folders)
xread.xfolds.Add(xz);
return xread;
}
break;
}
FATXFolderEntry xFold = null;
foreach (FATXFolderEntry x in xcurpart.Folders)
{
if (x.Name.ToLower() != Folders[idx].ToLower())
continue;
xFold = x;
break;
}
if (xFold == null)
return null;
idx++;
FATXReadContents xreadct;
for (int i = idx; i < Folders.Length; i++)
{
bool found = false;
xreadct = xFold.xRead();
foreach (FATXFolderEntry x in xreadct.Folders)
{
if (x.Name.ToLower() != Folders[i].ToLower())
continue;
found = true;
xFold = x;
break;
}
if (!found)
return null;
}
xFolderOut = xFold;
return xFold.xRead();
}
internal FATXReadContents xReadToFolder(string Path, out FATXFolderEntry xFolderOut)
{
xFolderOut = null;
if (Path == null || Path == "")
{
return(null);
}
Path = Path.Replace("\\", "/");
if (Path[0] == '/')
{
Path = Path.Substring(1, Path.Length - 1);
}
if (Path[Path.Length - 1] == '/')
{
Path = Path.Substring(0, Path.Length - 1);
}
string[] Folders = Path.Split(new char[] { '/' });
sbyte PartitionIndex = -1;
for (int i = 0; i < xPartitions.Count; i++)
{
if (xPartitions[i].PartitionName.ToLower() != Folders[0].ToLower())
{
continue;
}
PartitionIndex = (sbyte)i;
break;
}
if (PartitionIndex == -1)
{
return(null);
}
if (Folders.Length == 1)
{
FATXReadContents xread = new FATXReadContents();
xread.xfiles = new List <FATXFileEntry>();
xread.xfolds = new List <FATXFolderEntry>();
foreach (FATXFolderEntry xz in Partitions[PartitionIndex].Folders)
{
xread.xfolds.Add(xz);
}
foreach (FATXPartition xz in Partitions[PartitionIndex].SubPartitions)
{
xread.xsubparts.Add(xz);
}
return(xread);
}
FATXPartition xcurpart = xPartitions[PartitionIndex];
int idx = 1;
for (int i = 0; i < xcurpart.SubPartitions.Length; i++)
{
if (xcurpart.SubPartitions[i].PartitionName.ToLower() != Folders[1].ToLower())
{
continue;
}
xcurpart = xcurpart.SubPartitions[i];
idx++;
if (Folders.Length == 2)
{
FATXReadContents xread = new FATXReadContents();
xread.xfiles = new List <FATXFileEntry>();
xread.xfolds = new List <FATXFolderEntry>();
foreach (FATXFolderEntry xz in xcurpart.Folders)
{
xread.xfolds.Add(xz);
}
return(xread);
}
break;
}
FATXFolderEntry xFold = null;
foreach (FATXFolderEntry x in xcurpart.Folders)
{
if (x.Name.ToLower() != Folders[idx].ToLower())
{
continue;
}
xFold = x;
break;
}
if (xFold == null)
{
return(null);
}
idx++;
FATXReadContents xreadct;
for (int i = idx; i < Folders.Length; i++)
{
bool found = false;
xreadct = xFold.xRead();
foreach (FATXFolderEntry x in xreadct.Folders)
{
if (x.Name.ToLower() != Folders[i].ToLower())
{
continue;
}
found = true;
xFold = x;
break;
}
if (!found)
{
return(null);
}
}
xFolderOut = xFold;
return(xFold.xRead());
}
