public void Inject(string gamepath, RedistFile.UpdateDelegate upd)
{
BFF bff = new BFF();
foreach (string key in this.Files.Keys)
{
string str = (gamepath + "\\" + key).Replace("\\\\", "\\");
List <string> fileList = bff.GetFileList(str);
FileStream fs = new FileStream(str, FileMode.Open);
try
{
foreach (string filename in this.Files[key])
{
if (filename.IndexOf("|") != -1)
{
this._inject(str, fs, fileList, filename.Split('|'), upd);
}
else
{
this._inject(str, fs, fileList, filename, upd);
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
fs.Close();
}
}
}
public byte[] XDecompress(byte[] src, int srcLen, int usize)
{
IntPtr pContext = IntPtr.Zero;
BFF.My_XMemCreateDecompressionContext(1, IntPtr.Zero, (ushort)0, out pContext);
int pDestSize = usize;
byte[] pDestBuffer = new byte[pDestSize];
if (BFF.My_XMemDecompress(pContext, pDestBuffer, out pDestSize, src, srcLen) != 0)
{
throw new Exception("Can't decompress. Aborting processing.");
}
BFF.My_XMemDestroyDecompressionContext(pContext);
return(pDestBuffer);
}
private void _inject(
string archivePath,
FileStream fs_archive,
List <string> fs_list,
FileInfo fi,
string filename,
RedistFile.UpdateDelegate upd)
{
IntPtr pContext = IntPtr.Zero;
if (Compress.My_XMemCreateCompressionContext(1, IntPtr.Zero, (ushort)0, out pContext) != 0)
{
throw new Exception("Cannot create compression context. Aborted");
}
FileStream fileStream = fi.OpenRead();
int length = (int)fileStream.Length;
byte[] numArray1 = new byte[length];
fileStream.Read(numArray1, 0, length);
fileStream.Close();
int pDestSize = length * 3;
byte[] numArray2 = new byte[pDestSize];
if (Compress.My_XMemCompress(pContext, numArray2, out pDestSize, numArray1, length) != 0)
{
throw new Exception("Cannot compress data.");
}
BFF bff = new BFF();
if (pDestSize > length)
{
bff.Inject(archivePath, filename, numArray1, length, length, fs_archive, fs_list, upd);
}
else
{
bff.Inject(archivePath, filename, numArray2, pDestSize, length, fs_archive, fs_list, upd);
}
}
public void InstallRedist(
string gamepath,
string source,
RedistFile.UpdateDelegate upd,
bool uninstall,
List <string> ignoreList)
{
StreamReader streamReader = new StreamReader(source, Encoding.Default);
string path1 = !(streamReader.ReadLine() != "BFI") ? streamReader.ReadLine() : throw new Exception("Not a valid install script");
string str1 = string.Format("{0}\\PakFiles\\{1}", (object)gamepath, (object)path1);
string str2 = string.Format("{0}\\PakFiles\\{1}_Uninstall.bfi", (object)gamepath, (object)path1.Substring(0, path1.LastIndexOf(".") - 4));
if (File.Exists(str1) && File.Exists(str2))
{
if (!uninstall)
{
throw new PackageAlreadyInstalledException();
}
this.UnInstall(gamepath, str2, str1, upd);
}
else
{
if (upd != null)
{
upd("Preparing install. Please wait...");
}
else
{
Console.WriteLine("Preparing install. Please wait...");
}
FileStream fileStream1 = new FileStream(path1, FileMode.Open, FileAccess.Read);
Dictionary <string, int> dictionary1 = new Dictionary <string, int>();
Dictionary <string, RedistFileEntry> dictionary2 = new Dictionary <string, RedistFileEntry>();
byte[] numArray1 = new byte[4];
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
if (Encoding.Default.GetString(numArray1) == "BFFZ")
{
fileStream1.Seek(8L, SeekOrigin.Begin);
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int int32_1 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int int32_2 = BitConverter.ToInt32(numArray1, 0);
byte[] numArray2 = new byte[256];
fileStream1.Seek(16L, SeekOrigin.Begin);
for (int index = 0; index < int32_2; ++index)
{
this.Assert(fileStream1.Read(numArray2, 0, 256), 256);
string str3 = Encoding.Default.GetString(numArray2);
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int int32_3 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int int32_4 = BitConverter.ToInt32(numArray1, 0);
dictionary1.Add(str3.Replace(char.MinValue, '?').Replace("?", ""), int32_3);
fileStream1.Seek((long)int32_4, SeekOrigin.Begin);
}
fileStream1.Seek((long)int32_1, SeekOrigin.Begin);
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int result = BitConverter.ToInt32(numArray1, 0);
List <string> stringList1 = new List <string>();
for (int i = 0; i < result; ++i)
{
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int int32_3 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int int32_4 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream1.Read(numArray1, 0, 4), 4);
int int32_5 = BitConverter.ToInt32(numArray1, 0);
byte[] buffer = new byte[1];
this.Assert(fileStream1.Read(buffer, 0, 1), 1);
int length = (int)buffer[0];
byte[] numArray3 = new byte[length];
this.Assert(fileStream1.Read(numArray3, 0, length), length);
int position = (int)fileStream1.Position;
RedistFileEntry redistFileEntry = new RedistFileEntry(i, Encoding.Default.GetString(numArray3), int32_4, int32_5, position);
dictionary2.Add(redistFileEntry.Name, redistFileEntry);
stringList1.Add(redistFileEntry.Name);
fileStream1.Seek((long)int32_3, SeekOrigin.Begin);
}
byte[] buffer1 = new byte[4];
RedistHeader redistHeader = new RedistHeader(str1.Substring(0, str1.LastIndexOf("\\")));
File.Copy(new FileInfo(source).FullName, str2);
FileStream fileStream2 = new FileStream(str1, FileMode.Create, FileAccess.ReadWrite);
fileStream2.Write(redistHeader.Magic, 0, 4);
int position1 = (int)fileStream2.Position;
fileStream2.Write(BitConverter.GetBytes(redistHeader.FileSize), 0, 4);
int position2 = (int)fileStream2.Position;
fileStream2.Write(BitConverter.GetBytes(0), 0, 4);
fileStream2.Write(BitConverter.GetBytes(int32_2), 0, 4);
fileStream2.Seek(16L, SeekOrigin.Begin);
foreach (string key in dictionary1.Keys)
{
int num1 = dictionary1[key];
for (int index = 0; index < numArray2.Length; ++index)
{
numArray2[index] = (byte)0;
}
Encoding.Default.GetBytes(key).CopyTo((Array)numArray2, 0);
fileStream2.Write(numArray2, 0, numArray2.Length);
fileStream2.Write(BitConverter.GetBytes(num1), 0, 4);
int position3 = (int)fileStream2.Position;
fileStream2.Write(buffer1, 0, 4);
foreach (string str3 in stringList1)
{
str3.Replace("\\-", "\\").Replace("\\+", "\\");
fileStream2.Write(BitConverter.GetBytes(stringList1.IndexOf(str3)), 0, 4);
}
int position4 = (int)fileStream2.Position;
int num2 = position4 + (16 - position4 % 16);
fileStream2.Seek((long)position3, SeekOrigin.Begin);
fileStream2.Write(BitConverter.GetBytes(num2), 0, 4);
fileStream2.Seek((long)num2, SeekOrigin.Begin);
}
int position5 = (int)fileStream2.Position;
int num3 = position5 + (16 - position5 % 16);
fileStream2.Seek((long)position2, SeekOrigin.Begin);
fileStream2.Write(BitConverter.GetBytes(num3), 0, 4);
fileStream2.Seek((long)num3, SeekOrigin.Begin);
int num4 = num3;
fileStream2.Write(buffer1, 0, 4);
Dictionary <string, RedistFileEntry> dictionary3 = new Dictionary <string, RedistFileEntry>();
List <string> stringList2 = new List <string>();
BFF bff = new BFF();
label_30:
string str4 = streamReader.ReadLine();
if (str4 != null)
{
string[] strArray = str4.Split('=');
string str3 = strArray[0];
if (!int.TryParse(strArray[1], out result))
{
throw new Exception("BFI script is corrupt. Not valid number of files");
}
string str5 = (gamepath + "\\" + str3).Replace("\\\\", "\\");
if (!File.Exists(str5))
{
for (int index = 0; index < result; ++index)
{
streamReader.ReadLine();
}
goto label_30;
}
else
{
string str6 = str5 + ".bkp";
if (!File.Exists(str6))
{
if (!stringList2.Contains(str6))
{
stringList2.Add(str6);
}
File.Copy(str5, str6);
}
string msg = string.Format("Updating {0} file(s) in {1}...", (object)result, (object)str3);
if (upd != null)
{
upd(msg);
}
else
{
Console.WriteLine(msg);
}
List <string> fileList = bff.GetFileList(str5);
FileStream fs = new FileStream(str5, FileMode.Open);
try
{
for (int index = 0; index < result; ++index)
{
string str7 = streamReader.ReadLine();
string str8 = str7.Replace("\\-", "\\").Replace("\\+", "\\");
if (dictionary2.ContainsKey(str7))
{
RedistFileEntry redistFileEntry1 = dictionary2[str7];
if (!dictionary3.ContainsKey(str8))
{
int num1 = 304 + 42 * fileList.IndexOf(str8);
fs.Seek((long)(num1 + 8), SeekOrigin.Begin);
fs.Read(numArray1, 0, 4);
int int32_3 = BitConverter.ToInt32(numArray1, 0);
fs.Read(numArray1, 0, 4);
fs.Read(numArray1, 0, 4);
int int32_4 = BitConverter.ToInt32(numArray1, 0);
fs.Read(numArray1, 0, 4);
int int32_5 = BitConverter.ToInt32(numArray1, 0);
RedistFileEntry redistFileEntry2 = new RedistFileEntry(redistFileEntry1.Index, redistFileEntry1.Name, int32_4, int32_5, int32_3);
dictionary3.Add(str7, redistFileEntry2);
byte[] buffer2 = new byte[int32_4];
fs.Seek((long)int32_3, SeekOrigin.Begin);
fs.Read(buffer2, 0, int32_4);
int position3 = (int)fileStream2.Position;
fileStream2.Write(buffer1, 0, 4);
fileStream2.Write(BitConverter.GetBytes(int32_4), 0, 4);
fileStream2.Write(BitConverter.GetBytes(int32_5), 0, 4);
byte[] buffer3 = new byte[1]
{
(byte)str8.Length
};
fileStream2.Write(buffer3, 0, 1);
fileStream2.Write(Encoding.Default.GetBytes(str8), 0, str8.Length);
fileStream2.Write(buffer2, 0, int32_4);
int position4 = (int)fileStream2.Position;
int num2 = position4 + (16 - position4 % 16);
fileStream2.Seek((long)position3, SeekOrigin.Begin);
fileStream2.Write(BitConverter.GetBytes(num2), 0, 4);
fileStream2.Seek((long)num2, SeekOrigin.Begin);
}
if (ignoreList == null || ignoreList != null && !ignoreList.Contains(str8))
{
byte[] numArray3 = new byte[redistFileEntry1.Size];
fileStream1.Seek((long)redistFileEntry1.Offset, SeekOrigin.Begin);
this.Assert(fileStream1.Read(numArray3, 0, redistFileEntry1.Size), redistFileEntry1.Size);
if (!str3.StartsWith("PakFiles\\"))
{
str3 = "PakFiles\\" + str3;
}
bff.Inject(str5, str7, numArray3, redistFileEntry1.Size, redistFileEntry1.USize, fs, fileList, (RedistFile.UpdateDelegate)null);
if (upd != null && !bff.Result.StartsWith("OK"))
{
upd(bff.Result);
}
}
else if (upd != null)
{
upd(string.Format("Ignoring file {0}", (object)str8));
}
}
}
goto label_30;
}
finally
{
fs.Close();
}
}
}
else
{
int position3 = (int)fileStream2.Position;
fileStream2.Seek((long)num4, SeekOrigin.Begin);
fileStream2.Write(BitConverter.GetBytes(dictionary3.Count), 0, 4);
fileStream2.Seek((long)position1, SeekOrigin.Begin);
fileStream2.Write(BitConverter.GetBytes(position3), 0, 4);
fileStream2.Close();
foreach (string path2 in stringList2)
{
File.Delete(path2);
}
}
}
fileStream1.Close();
streamReader.Close();
if (upd != null)
{
upd("Install finished");
}
else
{
Console.WriteLine("Install finished");
}
}
}
public void UnInstall(
string gamepath,
string source,
string unpath,
RedistFile.UpdateDelegate upd)
{
StreamReader streamReader = new StreamReader(source, Encoding.Default);
if (upd != null)
{
upd("Starting MOD uninstall, please wait...");
}
if (streamReader.ReadLine() != "BFI")
{
throw new Exception("Not a valid install script");
}
streamReader.ReadLine();
FileStream fileStream = new FileStream(unpath, FileMode.Open, FileAccess.Read);
Dictionary <string, int> dictionary1 = new Dictionary <string, int>();
Dictionary <string, RedistFileEntry> dictionary2 = new Dictionary <string, RedistFileEntry>();
byte[] numArray1 = new byte[4];
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
if (Encoding.Default.GetString(numArray1) == "BFFZ")
{
fileStream.Seek(8L, SeekOrigin.Begin);
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int int32_1 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int int32_2 = BitConverter.ToInt32(numArray1, 0);
fileStream.Seek(16L, SeekOrigin.Begin);
for (int index = 0; index < int32_2; ++index)
{
byte[] numArray2 = new byte[256];
this.Assert(fileStream.Read(numArray2, 0, 256), 256);
string key = Encoding.Default.GetString(numArray2);
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int int32_3 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int int32_4 = BitConverter.ToInt32(numArray1, 0);
dictionary1.Add(key, int32_3);
fileStream.Seek((long)int32_4, SeekOrigin.Begin);
}
fileStream.Seek((long)int32_1, SeekOrigin.Begin);
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int result = BitConverter.ToInt32(numArray1, 0);
for (int i = 0; i < result; ++i)
{
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int int32_3 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int int32_4 = BitConverter.ToInt32(numArray1, 0);
this.Assert(fileStream.Read(numArray1, 0, 4), 4);
int int32_5 = BitConverter.ToInt32(numArray1, 0);
byte[] buffer = new byte[1];
this.Assert(fileStream.Read(buffer, 0, 1), 1);
int length = (int)buffer[0];
byte[] numArray2 = new byte[length];
this.Assert(fileStream.Read(numArray2, 0, length), length);
int position = (int)fileStream.Position;
RedistFileEntry redistFileEntry = new RedistFileEntry(i, Encoding.Default.GetString(numArray2), int32_4, int32_5, position);
dictionary2.Add(redistFileEntry.Name, redistFileEntry);
fileStream.Seek((long)int32_3, SeekOrigin.Begin);
}
List <string> stringList = new List <string>();
BFF bff = new BFF();
label_12:
string str1 = streamReader.ReadLine();
if (str1 != null)
{
string[] strArray = str1.Split('=');
string str2 = strArray[0];
if (!int.TryParse(strArray[1], out result))
{
throw new Exception("BFI script is corrupt. Not valid number of files");
}
string str3 = (gamepath + "\\" + str2).Replace("\\\\", "\\");
if (!File.Exists(str3))
{
for (int index = 0; index < result; ++index)
{
streamReader.ReadLine();
}
goto label_12;
}
else
{
string path = str3 + ".bkp";
if (!File.Exists(path))
{
if (!stringList.Contains(path))
{
stringList.Add(path);
}
File.Copy(str3, str3 + ".bkp");
}
string msg = string.Format("Restoring {0} file(s) in {1}...", (object)result, (object)str2);
if (upd != null)
{
upd(msg);
}
else
{
Console.WriteLine(msg);
}
List <string> fileList = bff.GetFileList(str3);
FileStream fs = new FileStream(str3, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
try
{
for (int index = 0; index < result; ++index)
{
string str4 = streamReader.ReadLine().Replace("\\-", "\\").Replace("\\+", "\\");
if (dictionary2.ContainsKey(str4))
{
RedistFileEntry redistFileEntry = dictionary2[str4];
byte[] numArray2 = new byte[redistFileEntry.Size];
fileStream.Seek((long)redistFileEntry.Offset, SeekOrigin.Begin);
this.Assert(fileStream.Read(numArray2, 0, redistFileEntry.Size), redistFileEntry.Size);
if (!str2.StartsWith("PakFiles\\"))
{
str2 = "PakFiles\\" + str2;
}
bff.Inject(str3, str4, numArray2, redistFileEntry.Size, redistFileEntry.USize, fs, fileList, (RedistFile.UpdateDelegate)null);
if (upd != null && !bff.Result.StartsWith("OK"))
{
upd(bff.Result);
}
}
}
goto label_12;
}
catch (Exception ex)
{
if (upd != null)
{
return;
}
Console.WriteLine(ex.Message + "\r\nPress ENTER: ");
Console.ReadLine();
return;
}
finally
{
fs.Close();
}
}
}
else
{
foreach (string path in stringList)
{
File.Delete(path);
}
}
}
fileStream.Close();
streamReader.Close();
if (upd != null)
{
upd("Deleting uninstall files");
}
File.Delete(source);
File.Delete(unpath);
if (upd == null)
{
return;
}
upd("Uninstall finished");
}
public void Build()
{
this.StopProcessing.Reset();
EventData eventData = new EventData();
List <string> fileList = this.getFileList();
if (this.RebuildStarted != null)
{
eventData.TotalFiles = fileList.Count;
this.RebuildStarted((object)eventData, EventArgs.Empty);
}
Header header = new Header();
header.sign = new byte[4]
{
(byte)32,
(byte)75,
(byte)65,
(byte)80
};
header.sign2 = new byte[4]
{
(byte)3,
(byte)0,
(byte)64,
(byte)16
};
header.sign3 = new byte[5]
{
(byte)32,
(byte)84,
(byte)88,
(byte)69,
(byte)84
};
header.filename = new byte[256];
header.gecko = new byte[256];
header.filepath = new byte[256];
header.pc = new byte[256];
int[] fromOriginalArchive = this.getStaticDataFromOriginalArchive();
header.align = fromOriginalArchive[0];
header.field_offset = fromOriginalArchive[1];
header.field_size = fromOriginalArchive[2];
header.offset = header.align;
List <BFF.StaticData> staticData1 = this.getStaticData(fileList);
header.files = fileList.Count;
string name = new FileInfo(this._files.OutputArchive).Name;
Encoding.Default.GetBytes(name.Substring(0, name.Length - 4)).CopyTo((Array)header.filename, 0);
Encoding.Default.GetBytes("Gecko.xml").CopyTo((Array)header.gecko, 0);
Encoding.Default.GetBytes(this._files.SourceFolder).CopyTo((Array)header.filepath, 0);
Encoding.Default.GetBytes("PC").CopyTo((Array)header.pc, 0);
InfoTable[] infoTableArray = new InfoTable[fileList.Count];
for (int index = 0; index < fileList.Count; ++index)
{
BFF.StaticData staticData2 = staticData1[index];
infoTableArray[index].dummy1 = staticData2.dummy1;
infoTableArray[index].dummy2 = staticData2.dummy2;
infoTableArray[index].offset = header.align;
infoTableArray[index].type = (short)2;
infoTableArray[index].everzero = staticData2.everzero;
infoTableArray[index].everzero2 = staticData2.everzero2;
infoTableArray[index].everzero3 = staticData2.everzero3;
infoTableArray[index].size = staticData2.fileSize;
infoTableArray[index].zsize = staticData2.fileSize;
}
header.infotable = new byte[42 * fileList.Count];
header.x118_sizeof_infotable = 42 * fileList.Count;
FileStream fileStream1 = new FileStream(this._files.OriginalArchive, FileMode.Open);
fileStream1.Read(header.infotable, 0, header.x118_sizeof_infotable);
byte[] buffer1 = new byte[header.field_size];
fileStream1.Seek((long)header.field_offset, SeekOrigin.Begin);
fileStream1.Read(buffer1, 0, header.field_size);
fileStream1.Close();
for (int index = 0; index < fileList.Count; ++index)
{
string str = string.Format("{0}\\{1}", (object)this._files.SourceFolder, (object)fileList[index]);
string s = new FileInfo(str).Extension.Substring(1);
if (s.Length > 3)
{
s = s.Substring(0, 3);
}
byte[] bytes = Encoding.Default.GetBytes(s);
infoTableArray[index].extension = new byte[4];
bytes.CopyTo((Array)infoTableArray[index].extension, 0);
FileStream fileStream2 = new FileStream(str, FileMode.Open);
byte[] buffer2 = new byte[(int)fileStream2.Length];
fileStream2.Read(buffer2, 0, (int)fileStream2.Length);
fileStream2.Close();
infoTableArray[index].size = buffer2.Length;
infoTableArray[index].zsize = buffer2.Length;
}
IntPtr num1 = Marshal.AllocHGlobal(header.x118_sizeof_infotable);
for (int index = 0; index < fileList.Count; ++index)
{
Marshal.StructureToPtr((object)infoTableArray[index], new IntPtr(num1.ToInt64() + (long)(42 * index)), false);
}
Marshal.Copy(num1, header.infotable, 0, header.infotable.Length);
Marshal.FreeHGlobal(num1);
header.x120_sizeof_nametable_plus_308h = 16 * fileList.Count;
for (int index = 0; index < fileList.Count; ++index)
{
header.x120_sizeof_nametable_plus_308h += fileList[index].Length + 1;
}
byte[] buffer3 = new byte[4];
FileStream fileStream3 = new FileStream(this._files.OutputArchive, FileMode.Create);
fileStream3.Seek(0L, SeekOrigin.Begin);
fileStream3.Write(header.sign, 0, 4);
fileStream3.Write(header.sign2, 0, 4);
fileStream3.Write(BitConverter.GetBytes(header.files), 0, 4);
fileStream3.Write(BitConverter.GetBytes(header.align), 0, 4);
fileStream3.Seek(4L, SeekOrigin.Current);
fileStream3.Write(BitConverter.GetBytes(2048), 0, 4);
fileStream3.Write(header.filename, 0, header.filename.Length);
fileStream3.Write(BitConverter.GetBytes(header.x118_sizeof_infotable), 0, 4);
fileStream3.Seek(4L, SeekOrigin.Current);
fileStream3.Write(BitConverter.GetBytes(header.x120_sizeof_nametable_plus_308h + 776), 0, 4);
fileStream3.Write(BitConverter.GetBytes(header.field_offset), 0, 4);
fileStream3.Write(BitConverter.GetBytes(header.field_size), 0, 4);
fileStream3.Write(buffer3, 0, 1);
fileStream3.Write(buffer3, 0, 1);
fileStream3.Write(buffer3, 0, 1);
fileStream3.Write(buffer3, 0, 1);
int position1 = (int)fileStream3.Position;
fileStream3.Write(header.infotable, 0, header.infotable.Length);
fileStream3.Write(header.sign3, 0, 5);
fileStream3.Write(buffer3, 0, 3);
fileStream3.Write(header.gecko, 0, header.gecko.Length);
fileStream3.Write(header.filepath, 0, header.filepath.Length);
fileStream3.Write(header.pc, 0, header.pc.Length);
long position2 = fileStream3.Position;
int count = fileList.Count;
int nametablePlus308h = header.x120_sizeof_nametable_plus_308h;
byte[] buffer4 = new byte[nametablePlus308h];
FileStream fileStream4 = new FileStream(this._files.OriginalArchive, FileMode.Open);
fileStream4.Seek(fileStream3.Position, SeekOrigin.Begin);
fileStream4.Read(buffer4, 0, nametablePlus308h);
fileStream4.Close();
fileStream3.Write(buffer4, 0, nametablePlus308h);
fileStream3.Write(buffer1, 0, buffer1.Length);
fileStream3.Seek((long)header.offset, SeekOrigin.Begin);
IntPtr pContext = IntPtr.Zero;
BFF.My_XMemCreateCompressionContext(1, IntPtr.Zero, (ushort)0, out pContext);
for (int index = 0; index < fileList.Count && !this.StopProcessing.WaitOne(1); ++index)
{
if (this.FileProcessing != null)
{
eventData.CurrentFile = index;
eventData.Filename = fileList[index];
eventData.FileSize = infoTableArray[index].size;
this.FileProcessing((object)eventData, EventArgs.Empty);
}
FileStream fileStream2 = new FileStream(string.Format("{0}\\{1}", (object)this._files.SourceFolder, (object)fileList[index]), FileMode.Open);
int length = (int)fileStream2.Length;
byte[] numArray1 = new byte[length];
fileStream2.Read(numArray1, 0, length);
fileStream2.Close();
int position3 = (int)fileStream3.Position;
int pDestSize = length;
byte[] numArray2 = new byte[pDestSize];
bool flag = false;
byte[] buffer2 = new byte[1];
switch (BFF.My_XMemCompress(pContext, numArray2, out pDestSize, numArray1, length))
{
case -2116149247:
if (!flag)
{
fileStream3.Write(numArray1, 0, length);
pDestSize = length;
buffer2[0] = (byte)0;
}
else
{
buffer2[0] = (byte)2;
fileStream3.Write(numArray2, 0, pDestSize);
}
int position4 = (int)fileStream3.Position;
fileStream3.Seek((long)(position1 + 16 + 42 * index), SeekOrigin.Begin);
fileStream3.Write(BitConverter.GetBytes(pDestSize), 0, 4);
uint num2 = !flag?this._getCRC(numArray1, length) : this._getCRC(numArray2, pDestSize);
fileStream3.Seek(14L, SeekOrigin.Current);
fileStream3.Write(BitConverter.GetBytes(num2), 0, 4);
fileStream3.Seek(-6L, SeekOrigin.Current);
byte[] buffer5 = new byte[1];
this.Assert(fileStream3.Read(buffer5, 0, 1), 1);
fileStream3.Seek(-1L, SeekOrigin.Current);
fileStream3.Write(buffer2, 0, 1);
if (index >= 0)
{
fileStream3.Seek((long)(position1 + 8 + 42 * index), SeekOrigin.Begin);
fileStream3.Write(BitConverter.GetBytes(position3), 0, 4);
fileStream3.Seek((long)position4, SeekOrigin.Begin);
}
int position5 = (int)fileStream3.Position;
int num3 = 2048 - position5 % 2048;
if (num3 == 0)
{
num3 = 2048;
}
int num4 = position5 + num3;
fileStream3.Seek((long)num4, SeekOrigin.Begin);
continue;
case 0:
flag = true;
goto case -2116149247;
default:
throw new Exception("Cannot compress file. Aborting");
}
}
fileStream3.Close();
this.Result = !this.StopProcessing.WaitOne(1) ? string.Format("{0} file(s) added to {1}", (object)fileList.Count, (object)this._files.OutputArchive) : "Aborted by user";
if (this.RebuildEnded == null)
{
return;
}
this.RebuildEnded((object)null, EventArgs.Empty);
}
private void doInject(List <FileInfo> files, bool alwaysUpdate)
{
DateTime lastWriteTime1 = File.GetLastWriteTime(this._files.OriginalArchive);
EventData eventData = new EventData();
List <string> fileList = this.getFileList();
int startIndex = this._files.SourceFolder.Length + 1;
foreach (FileSystemInfo file in files)
{
string str = file.FullName.Substring(startIndex);
if (fileList.Contains(str))
{
++eventData.TotalFiles;
}
}
if (this.RebuildStarted != null)
{
this.RebuildStarted((object)eventData, EventArgs.Empty);
}
File.Copy(this._files.OriginalArchive, this._files.OriginalArchive + ".tmp", true);
IntPtr pContext = IntPtr.Zero;
BFF.My_XMemCreateCompressionContext(1, IntPtr.Zero, (ushort)0, out pContext);
int num1 = 304;
byte[] buffer1 = new byte[4];
FileStream fileStream1 = new FileStream(this._files.OriginalArchive + ".tmp", FileMode.Open);
fileStream1.Seek(280L, SeekOrigin.Begin);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
BitConverter.ToInt32(buffer1, 0);
int num2 = 0;
try
{
int index1 = 0;
foreach (FileInfo file in files)
{
if (!this.StopProcessing.WaitOne(1))
{
string str = file.FullName.Substring(startIndex);
DateTime lastWriteTime2 = file.LastWriteTime;
if (alwaysUpdate || lastWriteTime2.CompareTo(lastWriteTime1) >= 0)
{
int num3 = fileList.IndexOf(str);
if (num3 != -1)
{
int num4 = num1 + 42 * num3;
fileStream1.Seek((long)(num4 + 8), SeekOrigin.Begin);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
int int32_1 = BitConverter.ToInt32(buffer1, 0);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
int position = (int)fileStream1.Position;
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
int int32_2 = BitConverter.ToInt32(buffer1, 0);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
BitConverter.ToInt32(buffer1, 0);
int num5 = position + 18;
fileStream1.Seek((long)num5, SeekOrigin.Begin);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
BitConverter.ToInt32(buffer1, 0);
FileStream fileStream2 = new FileStream(file.FullName, FileMode.Open);
int length = (int)fileStream2.Length;
byte[] numArray1 = new byte[length];
fileStream2.Read(numArray1, 0, length);
fileStream2.Close();
int pDestSize = length * 3;
byte[] numArray2 = new byte[pDestSize];
switch (BFF.My_XMemCompress(pContext, numArray2, out pDestSize, numArray1, length))
{
case -2116149247:
case 0:
if (pDestSize > length)
{
pDestSize = length;
}
if (pDestSize - int32_2 >= int32_2 % 2048 && num3 < fileList.Count - 1)
{
fileStream1.Seek((long)(num1 + 42 * (num3 + 1) + 8), SeekOrigin.Begin);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
if (BitConverter.ToInt32(buffer1, 0) - num4 < pDestSize)
{
FileStream fileStream3 = new FileStream(this._files.OriginalArchive, FileMode.Open);
int num6 = pDestSize - int32_2;
for (int index2 = fileList.Count - 1; index2 > num3; ++index2)
{
fileStream1.Seek((long)(num1 + 42 * index2 + 8), SeekOrigin.Begin);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
int int32_3 = BitConverter.ToInt32(buffer1, 0);
fileStream1.Seek(4L, SeekOrigin.Current);
this.Assert(fileStream1.Read(buffer1, 0, 4), 4);
int int32_4 = BitConverter.ToInt32(buffer1, 0);
int num7 = int32_3 + num6 + 2048 - (int32_3 + num6) % 2048;
fileStream1.Seek((long)(num1 + 42 * index2 + 8), SeekOrigin.Begin);
fileStream1.Write(BitConverter.GetBytes(num7), 0, 4);
fileStream3.Seek((long)int32_3, SeekOrigin.Begin);
byte[] buffer2 = new byte[int32_4];
fileStream3.Read(buffer2, 0, int32_4);
fileStream1.Seek((long)num7, SeekOrigin.Begin);
fileStream1.Write(buffer2, 0, int32_4);
}
fileStream3.Close();
}
}
fileStream1.Seek((long)int32_1, SeekOrigin.Begin);
if (pDestSize == length)
{
fileStream1.Write(numArray1, 0, length);
}
else
{
fileStream1.Write(numArray2, 0, pDestSize);
}
fileStream1.Seek((long)position, SeekOrigin.Begin);
fileStream1.Write(BitConverter.GetBytes(pDestSize), 0, 4);
fileStream1.Write(BitConverter.GetBytes(length), 0, 4);
if (pDestSize == length)
{
fileStream1.Seek(8L, SeekOrigin.Current);
byte[] buffer2 = new byte[1];
this.Assert(fileStream1.Read(buffer2, 0, 1), 1);
fileStream1.Seek(-1L, SeekOrigin.Current);
buffer2[0] = (byte)0;
fileStream1.Write(buffer2, 0, 1);
}
fileStream1.Seek((long)num5, SeekOrigin.Begin);
fileStream1.Write(BitConverter.GetBytes(this._getCRC(numArray2, pDestSize)), 0, 4);
++num2;
if (this.FileProcessing != null)
{
eventData.CurrentFile = index1;
eventData.Filename = files[index1].FullName.Substring(startIndex);
eventData.Message = string.Format("(O:{0} KB - C:{1} KB)", (object)Decimal.Round((Decimal)length / 1024M, 2).ToString("f2"), (object)Decimal.Round((Decimal)pDestSize / 1024M, 2).ToString("f0"));
this.FileProcessing((object)eventData, EventArgs.Empty);
break;
}
break;
default:
throw new Exception("Can't compress. Aborting processing.");
}
}
else
{
eventData.CurrentFile = -1;
eventData.Filename = str;
eventData.Message = string.Format("File {0} not found in original archive, ignored.", (object)str);
this.FileProcessing((object)eventData, EventArgs.Empty);
}
}
else
{
eventData.CurrentFile = -1;
eventData.Filename = str;
eventData.Message = string.Format("File {0} is older than archive, ignored.", (object)str);
this.FileProcessing((object)eventData, EventArgs.Empty);
}
++index1;
}
else
{
break;
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
fileStream1.Close();
try
{
File.Delete(this._files.OriginalArchive);
File.Move(this._files.OriginalArchive + ".tmp", this._files.OriginalArchive);
}
catch (Exception ex)
{
Console.WriteLine("Can't rename working archive.");
}
}
this.Result = string.Format("{0} file(s) injected", (object)num2);
if (this.RebuildEnded == null)
{
return;
}
this.RebuildEnded((object)null, EventArgs.Empty);
}
