public RepositoryFile(Stream stream)
{
Stream = stream;
var buffer1 = new byte[256];
stream.Read(buffer1, 0, 256);
long offset = BitConverter.ToInt64(buffer1, 12);
files = new Dictionary <ulong, RepositoryFileInfo>(BitConverter.ToInt32(buffer1, 24));
var buffer2 = new byte[12];
while (offset != 0L)
{
stream.Seek(offset, SeekOrigin.Begin);
stream.Read(buffer2, 0, buffer2.Length);
int num1 = BitConverter.ToInt32(buffer2, 0);
long num4 = BitConverter.ToInt64(buffer2, 4);
var numArray = new byte[num1 * 34];
stream.Read(numArray, 0, numArray.Length);
for (int num2 = 0; num2 < num1; ++num2)
{
var repositoryFileInfo = new RepositoryFileInfo(numArray, num2);
repositoryFileInfo.File = this;
files[repositoryFileInfo.Hash] = repositoryFileInfo;
}
offset = num4;
}
}
/// <summary>
/// Enumerates the recursive.
/// </summary>
/// <param name="pathRootLength">Length of the path root.</param>
/// <param name="di">The di.</param>
/// <param name="category">The category.</param>
/// <param name="filter">The filter.</param>
/// <param name="recursive">if set to <c>true</c> [recursive].</param>
/// <returns></returns>
public static List <RepositoryFileInfo> EnumerateRecursive(int pathRootLength, DirectoryInfo di,
RepositoryCategory category, string filter,
bool recursive)
{
if (String.IsNullOrEmpty(filter))
{
filter = "*.*";
}
List <RepositoryFileInfo> results = new List <RepositoryFileInfo>();
if (di.Exists)
{
foreach (FileInfo fi in di.GetFiles(filter))
{
RepositoryFileInfo rfi = new RepositoryFileInfo();
rfi.FileName = fi.FullName.Substring(pathRootLength);
rfi.LastWriteTimeUtc = fi.LastWriteTimeUtc;
results.Add(rfi);
}
if (recursive)
{
foreach (DirectoryInfo childDi in di.GetDirectories())
{
results.AddRange(EnumerateRecursive(pathRootLength, childDi, category, filter, true));
}
}
}
return(results);
}
public Stream GetFile(string name)
{
RepositoryFileInfo fileInfo = this.GetFileInfo(name);
if (fileInfo != null)
{
return(fileInfo.File.GetFile(fileInfo));
}
return(null);
}
public RepositoryFileInfo GetFileInfo(ulong hash, string name)
{
if (!files.ContainsKey(hash))
{
return(null);
}
RepositoryFileInfo repositoryFileInfo = files[hash];
repositoryFileInfo.Name = name;
return(repositoryFileInfo);
}
public void ExtractAll(string basePath)
{
foreach (RepositoryFile file in this.repositoryFiles)
{
foreach (ulong num in file.Files.Keys)
{
RepositoryFileInfo info = file.Files[num];
this.ExtractFile(info);
}
}
}
public RepositoryFileInfo GetFileInfo(string name)
{
ulong hash = Hasher.Hash(name, 0xdeadbeef);
foreach (RepositoryFile file in this.repositoryFiles)
{
RepositoryFileInfo fileInfo = file.GetFileInfo(hash, name);
if (fileInfo != null)
{
return(fileInfo);
}
}
return(null);
}
public void ExtractFile(RepositoryFileInfo info)
{
string str;
Stream file = info.File.GetFile(info);
if (info.Name != null)
{
str = this.extractBasePath + info.Name;
}
else
{
str = string.Format("{0}/{1:X}.bin", this.extractBasePath, info.Hash);
}
str = str.Replace('/', '\\');
RepoDirectory rootDirectory = this.rootDirectory;
string[] strArray = info.Name.Split(new char[] { '/' });
string path = this.extractBasePath + @"\";
for (int i = 1; i < (strArray.Length - 1); i++)
{
if (rootDirectory.SubDirectories.ContainsKey(strArray[i]))
{
rootDirectory = rootDirectory.SubDirectories[strArray[i]];
}
else
{
RepoDirectory directory2 = new RepoDirectory {
Name = strArray[i]
};
rootDirectory.SubDirectories[strArray[i]] = directory2;
rootDirectory = directory2;
}
path = path + strArray[i] + @"\";
}
if (!rootDirectory.Files.Contains(strArray[strArray.Length - 1]))
{
rootDirectory.Files.Add(strArray[strArray.Length - 1]);
}
Directory.CreateDirectory(path);
Stream stream2 = File.Open(str, FileMode.Create, FileAccess.Write);
byte[] buffer = new byte[file.Length];
file.Read(buffer, 0, buffer.Length);
stream2.Write(buffer, 0, buffer.Length);
file.Close();
stream2.Close();
}
public void ExtractFile(RepositoryFileInfo info)
{
Stream file = info.File.GetFile(info);
string path1 =
(info.Name == null
? string.Format("{0}/{1:X}.bin", ExtractBasePath, info.Hash)
: ExtractBasePath + info.Name).Replace('/', '\\');
RepoDirectory repoDirectory1 = _rootDirectory;
string[] strArray = info.Name.Split(new char[1]
{
'/'
});
string path2 = ExtractBasePath + "\\";
for (int index = 1; index < strArray.Length - 1; ++index)
{
if (repoDirectory1.SubDirectories.ContainsKey(strArray[index]))
{
repoDirectory1 = repoDirectory1.SubDirectories[strArray[index]];
}
else
{
var repoDirectory2 = new RepoDirectory();
repoDirectory2.Name = strArray[index];
repoDirectory1.SubDirectories[strArray[index]] = repoDirectory2;
repoDirectory1 = repoDirectory2;
}
path2 = path2 + strArray[index] + "\\";
}
if (!repoDirectory1.Files.Contains(strArray[strArray.Length - 1]))
{
repoDirectory1.Files.Add(strArray[strArray.Length - 1]);
}
Directory.CreateDirectory(path2);
Stream stream = File.Open(path1, FileMode.Create, FileAccess.Write);
var buffer = new byte[file.Length];
file.Read(buffer, 0, buffer.Length);
stream.Write(buffer, 0, buffer.Length);
file.Close();
stream.Close();
}
public Stream GetFile(RepositoryFileInfo info)
{
var buffer1 = new byte[info.UncompressedSize];
switch (info.CompressionMethod)
{
case 0:
Stream.Seek(info.Offset + info.HeaderSize, SeekOrigin.Begin);
Stream.Read(buffer1, 0, buffer1.Length);
break;
case 1:
Stream.Seek(info.Offset + info.HeaderSize, SeekOrigin.Begin);
var buffer2 = new byte[info.CompressedSize];
Stream.Read(buffer2, 0, buffer2.Length);
var inflater = new Inflater();
inflater.SetInput(buffer2);
inflater.Inflate(buffer1);
break;
}
return(new MemoryStream(buffer1));
}
