public void Clear()
{
CDNIndex?.Clear();
CDNIndex = null;
foreach (var stream in DataStreams)
{
stream.Value.Dispose();
}
DataStreams.Clear();
EncodingHandler?.Clear();
EncodingHandler = null;
InstallHandler?.Clear();
InstallHandler = null;
LocalIndex?.Clear();
LocalIndex = null;
RootHandler?.Clear();
RootHandler = null;
DownloadHandler?.Clear();
DownloadHandler = null;
}
private CASCHandler(CASCConfig config) : base(config)
{
using (var fs = OpenEncodingFile(this))
Encoding = new EncodingHandler(fs);
if ((CASCConfig.LoadFlags & LoadFlags.Download) != 0)
{
using (var fs = OpenDownloadFile(Encoding, this))
Download = new DownloadHandler(fs);
}
KeyService.LoadKeys();
using (var fs = OpenRootFile(Encoding, this))
{
if (config.GameType == CASCGameType.WoW)
{
Root = new WowRootHandler(fs);
}
else
{
using (var ufs = new FileStream("unk_root", FileMode.Create))
fs.BaseStream.CopyTo(ufs);
throw new Exception("Unsupported game " + config.BuildUID);
}
}
if ((CASCConfig.LoadFlags & LoadFlags.Install) != 0)
{
using (var fs = OpenInstallFile(Encoding, this))
Install = new InstallHandler(fs);
}
}
private CASCHandler(CASCConfig config) : base(config)
{
Debug.Log("CASCHandler: Loading Encoding Handler...");
using (var fs = OpenEncodingFile(this))
EncodingHandler = new EncodingHandler(fs);
if ((CASCConfig.LoadFlags & LoadFlags.Download) != 0)
{
Debug.Log("CASCHandler: Loading Download Handler...");
using (var fs = OpenDownloadFile(EncodingHandler, this))
DownloadHandler = new DownloadHandler(fs);
}
Debug.Log("CASCHandler: Loading WoW Root Handler...");
using (var fs = OpenRootFile(EncodingHandler, this))
RootHandler = new WowRootHandler(fs);
if ((CASCConfig.LoadFlags & LoadFlags.Install) != 0)
{
Debug.Log("CASCHandler: Loading Install Handler...");
using (var fs = OpenInstallFile(EncodingHandler, this))
InstallHandler = new InstallHandler(fs);
}
Debug.Log("CASCHandler: Initialized CASC...");
}
private CASCHandlerLite(CASCConfig config, LocaleFlags locale, BackgroundWorkerEx worker) : base(config, worker)
{
if (config.GameType != CASCGameType.WoW)
{
throw new Exception("Unsupported game " + config.BuildUID);
}
Logger.WriteLine("CASCHandlerLite: loading encoding data...");
EncodingHandler EncodingHandler;
using (var _ = new PerfCounter("new EncodingHandler()"))
{
using (var fs = OpenEncodingFile(this))
EncodingHandler = new EncodingHandler(fs, worker);
}
Logger.WriteLine("CASCHandlerLite: loaded {0} encoding data", EncodingHandler.Count);
Logger.WriteLine("CASCHandlerLite: loading root data...");
WowRootHandler RootHandler;
using (var _ = new PerfCounter("new RootHandler()"))
{
using (var fs = OpenRootFile(EncodingHandler, this))
RootHandler = new WowRootHandler(fs, worker);
}
Logger.WriteLine("CASCHandlerLite: loaded {0} root data", RootHandler.Count);
RootHandler.SetFlags(locale, false, false);
RootEntry rootEntry;
foreach (var entry in RootHandler.GetAllEntries())
{
rootEntry = entry.Value;
if ((rootEntry.LocaleFlags == locale || (rootEntry.LocaleFlags & locale) != LocaleFlags.None) && (rootEntry.ContentFlags & ContentFlags.Alternate) == ContentFlags.None)
{
if (EncodingHandler.GetEntry(rootEntry.cKey, out EncodingEntry enc))
{
if (!HashToEKey.ContainsKey(entry.Key))
{
HashToEKey.Add(entry.Key, enc.Keys[0]);
FileDataIdToHash.Add(RootHandler.GetFileDataIdByHash(entry.Key), entry.Key);
}
}
}
}
RootHandler.Clear();
RootHandler = null;
EncodingHandler.Clear();
EncodingHandler = null;
GC.Collect();
Logger.WriteLine("CASCHandlerLite: loaded {0} files", HashToEKey.Count);
}
protected BinaryReader OpenRootFile(EncodingHandler enc, CASCHandlerBase casc)
{
if (!enc.GetEntry(casc.Config.RootMD5, out EncodingEntry encInfo))
{
throw new FileNotFoundException("encoding info for root file missing!");
}
//ExtractFile(encInfo.Key, ".", "root");
return(new BinaryReader(casc.OpenFile(encInfo.Key)));
}
public override void Dump(EncodingHandler encodingHandler = null)
{
Logger.WriteLine("WowRootHandler Dump:");
foreach (var fd in RootData.OrderBy(r => r.Key))
{
string name;
if (FileDataStore.TryGetValue(fd.Key, out ulong hash) && CASCFile.Files.TryGetValue(hash, out CASCFile file))
{
name = file.FullName;
}
else
{
name = $"FILEDATA_{fd.Key}";
}
Logger.WriteLine($"FileData: {fd.Key:D7} Hash: {hash:X16} Locales: {fd.Value.Aggregate(LocaleFlags.None, (a, b) => a | b.LocaleFlags)} Name: {name}");
foreach (var entry in fd.Value)
{
Logger.WriteLine($"\tcKey: {entry.cKey.ToHexString()} Locale: {entry.LocaleFlags} CF: {entry.ContentFlags}");
if (encodingHandler != null)
{
if (encodingHandler.GetEntry(entry.cKey, out var encodingEntry))
{
foreach (var eKey in encodingEntry.Keys)
{
var keys = encodingHandler.GetEncryptionKeys(eKey);
if (keys != null)
{
Logger.WriteLine($"\teKey: {eKey.ToHexString()} TactKeys: {string.Join(",", keys.Select(k => $"{k:X16}"))} Size: {encodingEntry.Size}");
}
else
{
Logger.WriteLine($"\teKey: {eKey.ToHexString()} TactKeys: NA Size: {encodingEntry.Size}");
}
}
}
}
}
}
}
public override void Dump(EncodingHandler encodingHandler = null)
{
}
private CASCHandler(CASCConfig config, BackgroundWorkerEx worker) : base(config, worker)
{
Logger.WriteLine("CASCHandler: loading encoding data...");
using (var _ = new PerfCounter("new EncodingHandler()"))
{
using (var fs = OpenEncodingFile(this))
EncodingHandler = new EncodingHandler(fs, worker);
}
Logger.WriteLine("CASCHandler: loaded {0} encoding data", EncodingHandler.Count);
if ((CASCConfig.LoadFlags & LoadFlags.Download) != 0)
{
Logger.WriteLine("CASCHandler: loading download data...");
using (var _ = new PerfCounter("new DownloadHandler()"))
{
using (var fs = OpenDownloadFile(EncodingHandler, this))
DownloadHandler = new DownloadHandler(fs, worker);
}
Logger.WriteLine("CASCHandler: loaded {0} download data", EncodingHandler.Count);
}
Logger.WriteLine("CASCHandler: loading root data...");
using (var _ = new PerfCounter("new RootHandler()"))
{
using (var fs = OpenRootFile(EncodingHandler, this))
{
if (config.GameType == CASCGameType.S2 || config.GameType == CASCGameType.HotS)
{
RootHandler = new MNDXRootHandler(fs, worker);
}
else if (config.GameType == CASCGameType.D3)
{
RootHandler = new D3RootHandler(fs, worker, this);
}
else if (config.GameType == CASCGameType.WoW)
{
RootHandler = new WowRootHandler(fs, worker);
}
else if (config.GameType == CASCGameType.Agent || config.GameType == CASCGameType.Bna || config.GameType == CASCGameType.Client)
{
RootHandler = new AgentRootHandler(fs, worker);
}
else if (config.GameType == CASCGameType.S1)
{
RootHandler = new S1RootHandler(fs, worker);
}
else if (config.GameType == CASCGameType.WC3)
{
RootHandler = new WC3RootHandler(fs, worker);
}
else if (config.GameType == CASCGameType.Hearthstone)
{
RootHandler = new HSRootHandler(fs, worker);
}
else if (config.GameType == CASCGameType.Overwatch)
{
RootHandler = new OwRootHandler(fs, worker, this);
}
else if (config.GameType == CASCGameType.Destiny2)
{
RootHandler = new Destiny2RootHandler(fs, worker);
}
else
{
using (var ufs = new FileStream("unk_root", FileMode.Create))
fs.BaseStream.CopyTo(ufs);
throw new Exception("Unsupported game " + config.BuildUID);
}
}
}
Logger.WriteLine("CASCHandler: loaded {0} root data", RootHandler.Count);
if ((CASCConfig.LoadFlags & LoadFlags.Install) != 0)
{
Logger.WriteLine("CASCHandler: loading install data...");
using (var _ = new PerfCounter("new InstallHandler()"))
{
using (var fs = OpenInstallFile(EncodingHandler, this))
InstallHandler = new InstallHandler(fs, worker);
InstallHandler.Print();
}
Logger.WriteLine("CASCHandler: loaded {0} install data", InstallHandler.Count);
}
}
public abstract void Dump(EncodingHandler encodingHandler = null);
private CASCHandlerLite(CASCConfig config, LocaleFlags locale, BackgroundWorkerEx worker) : base(config, worker)
{
if (config.GameType != CASCGameType.WoW)
{
throw new Exception("Unsupported game " + config.BuildUID);
}
Logger.WriteLine("CASCHandlerLite: loading encoding data...");
EncodingHandler EncodingHandler;
using (var _ = new PerfCounter("new EncodingHandler()"))
{
using (var fs = OpenEncodingFile(this))
EncodingHandler = new EncodingHandler(fs, worker);
}
Logger.WriteLine("CASCHandlerLite: loaded {0} encoding data", EncodingHandler.Count);
Logger.WriteLine("CASCHandlerLite: loading root data...");
WowRootHandler RootHandler;
using (var _ = new PerfCounter("new RootHandler()"))
{
using (var fs = OpenRootFile(EncodingHandler, this))
RootHandler = new WowRootHandler(fs, worker);
}
Logger.WriteLine("CASCHandlerLite: loaded {0} root data", RootHandler.Count);
RootHandler.SetFlags(locale, ContentFlags.None, false);
CDNIndexData = new Dictionary <MD5Hash, IndexEntry>(comparer);
if (LocalIndex != null)
{
LocalIndexData = new Dictionary <MD5Hash, IndexEntry>(comparer);
}
RootEntry rootEntry;
foreach (var entry in RootHandler.GetAllEntries())
{
rootEntry = entry.Value;
if ((rootEntry.LocaleFlags == locale || (rootEntry.LocaleFlags & locale) != LocaleFlags.None) && (rootEntry.ContentFlags & ContentFlags.LowViolence) == ContentFlags.None)
{
if (EncodingHandler.GetEntry(rootEntry.MD5, out EncodingEntry enc))
{
if (!HashToKey.ContainsKey(entry.Key))
{
HashToKey.Add(entry.Key, enc.Key);
FileDataIdToHash.Add(RootHandler.GetFileDataIdByHash(entry.Key), entry.Key);
if (LocalIndex != null)
{
IndexEntry iLocal = LocalIndex.GetIndexInfo(enc.Key);
if (iLocal != null && !LocalIndexData.ContainsKey(enc.Key))
{
LocalIndexData.Add(enc.Key, iLocal);
}
}
IndexEntry iCDN = CDNIndex.GetIndexInfo(enc.Key);
if (iCDN != null && !CDNIndexData.ContainsKey(enc.Key))
{
CDNIndexData.Add(enc.Key, iCDN);
}
}
}
}
}
CDNIndex.Clear();
//CDNIndex = null;
LocalIndex?.Clear();
LocalIndex = null;
RootHandler.Clear();
RootHandler = null;
EncodingHandler.Clear();
EncodingHandler = null;
GC.Collect();
Logger.WriteLine("CASCHandlerLite: loaded {0} files", HashToKey.Count);
}
private CASCHandler(CASCConfig config, BackgroundWorkerEx worker) : base(config, worker)
{
Logger.WriteLine("CASCHandler: loading encoding data...");
using (var _ = new PerfCounter("new EncodingHandler()"))
{
using (var fs = OpenEncodingFile(this))
EncodingHandler = new EncodingHandler(fs, worker);
}
Logger.WriteLine("CASCHandler: loaded {0} encoding data", EncodingHandler.Count);
if ((CASCConfig.LoadFlags & LoadFlags.Download) != 0)
{
Logger.WriteLine("CASCHandler: loading download data...");
using (var _ = new PerfCounter("new DownloadHandler()"))
{
using (var fs = OpenDownloadFile(EncodingHandler, this))
DownloadHandler = new DownloadHandler(fs, worker);
}
Logger.WriteLine("CASCHandler: loaded {0} download data", EncodingHandler.Count);
}
KeyService.LoadKeys();
Logger.WriteLine("CASCHandler: loading root data...");
using (var _ = new PerfCounter("new RootHandler()"))
{
if (config.IsVfsRoot)
{
RootHandler = new TVFSRootHandler(worker, this);
}
else
{
using (var fs = OpenRootFile(EncodingHandler, this))
{
RootHandlerBase UnknownRootHandler()
{
using (var ufs = new FileStream("unk_root", FileMode.Create))
fs.BaseStream.CopyTo(ufs);
throw new Exception("Unsupported game " + config.BuildProduct);
}
RootHandler = config.GameType switch
{
CASCGameType.S2 => new MNDXRootHandler(fs, worker),
CASCGameType.HotS => new MNDXRootHandler(fs, worker),
CASCGameType.D3 => new D3RootHandler(fs, worker, this),
CASCGameType.WoW => new WowRootHandler(fs, worker),
CASCGameType.S1 => new S1RootHandler(fs, worker),
CASCGameType.Agent => new DummyRootHandler(fs, worker),
CASCGameType.Bna => new DummyRootHandler(fs, worker),
CASCGameType.Client => new DummyRootHandler(fs, worker),
CASCGameType.Hearthstone => new DummyRootHandler(fs, worker),
CASCGameType.Destiny2 => new DummyRootHandler(fs, worker),
CASCGameType.Wlby => new DummyRootHandler(fs, worker),
CASCGameType.Rtro => new DummyRootHandler(fs, worker),
_ => UnknownRootHandler()
};
}
}
}
Logger.WriteLine("CASCHandler: loaded {0} root data", RootHandler.Count);
if ((CASCConfig.LoadFlags & LoadFlags.Install) != 0)
{
Logger.WriteLine("CASCHandler: loading install data...");
using (var _ = new PerfCounter("new InstallHandler()"))
{
using (var fs = OpenInstallFile(EncodingHandler, this))
InstallHandler = new InstallHandler(fs, worker);
//InstallHandler.Print();
}
Logger.WriteLine("CASCHandler: loaded {0} install data", InstallHandler.Count);
}
}