private void BigBytePropExport_Click(object sender, EventArgs e)
{
var arrayProp = checkArrayRow();
if (arrayProp == null || arrayProp.value == null)
{
return;
}
byte[] data = arrayProp.value;
String path = MiscFuncs.GenerateSaveDialog(arrayProp.name, ".raw");
if (path == "")
{
return;
}
DialogResult answer = MessageBox.Show("Remove Count bytes?", "TH", MessageBoxButtons.YesNo);
if (answer == DialogResult.Yes)
{
data = new byte[arrayProp.value.Length - 4];
Array.Copy(arrayProp.value, 4, data, 0, arrayProp.value.Length - 4);
}
DataTools.WriteExportDataFile(path, data);
}
public IDisposable GetFuncWrapper(
[CallerMemberName] string memberName = "",
[CallerLineNumber] int sourceLineNumber = 0,
#if DEBUG
[CallerFilePath]
#endif
string fp = ""
)
{
int fc = MiscFuncs.CheckStackFrameCount();
string methodId = string.Format(
"{0} {1} line {2} file {3}",
fc,
memberName,
sourceLineNumber,
fp
);
return(new FuncWrapperDisposable(
() => IncrementRunningFuncCounter(methodId),
() => DecrementRunningFuncCounter(methodId),
new FuncWrapperId()
{
MethodId = methodId,
StateHelperId = _stateHelperId
}
));
}
public async Task ChangePass(
byte[] oldPass,
byte[] newPass,
CryptConfigFileHelperScryptParameters
scryptParameters = null
)
{
if (!CheckPass(oldPass))
{
throw new ArgumentException(
MyNameof.GetLocalVarName(() => oldPass)
);
}
var originData = GetOriginData(
oldPass,
scryptParameters
);
Salt = new byte[32];
MiscFuncs.GetRandomBytes(Salt);
EncryptedData = CryptConfigFileHelper.Encrypt(
originData,
newPass,
Salt,
scryptParameters
);
}
/// <summary>
///
/// </summary>
/// <param name="changedNum"></param>
/// <param name="changedItemsEnumerable">index, old, new</param>
/// <returns></returns>
public static MyNotifyCollectionChangedArgs <TItem> CreateMultipleItemsChanged(
long changedNum,
IList <Tuple <int, TItem, TItem> > changedItemsEnumerable
)
{
Assert.NotNull(changedItemsEnumerable);
Assert.False(changedItemsEnumerable.Any(_ => _ == null));
var indices = changedItemsEnumerable.Select(_ => _.Item1).ToList();
Assert.False(indices.Any(_ => _ < 0));
Assert.Equal(indices, indices.Distinct());
var oldItemsIndices = new List <int>(changedItemsEnumerable.Count);
var newItemsIndices = new List <int>(changedItemsEnumerable.Count);
var oldItems = new List <TItem>(changedItemsEnumerable.Count);
var newItems = new List <TItem>(changedItemsEnumerable.Count);
foreach (Tuple <int, TItem, TItem> changedItemTuple in changedItemsEnumerable)
{
Assert.NotNull(changedItemTuple);
oldItemsIndices.Add(changedItemTuple.Item1);
newItemsIndices.Add(changedItemTuple.Item1);
oldItems.Add(MiscFuncs.GetDeepCopy(changedItemTuple.Item2));
newItems.Add(MiscFuncs.GetDeepCopy(changedItemTuple.Item3));
}
return(new MyNotifyCollectionChangedArgs <TItem>()
{
ChangesNum = changedNum,
ChangedAction = EMyCollectionChangedAction.ItemsChanged,
NewItems = newItems,
NewItemsIndices = newItemsIndices,
OldItemsIndices = oldItemsIndices,
OldItems = oldItems
});
}
public async Task Test1()
{
var data1 = new byte[1000000];
MiscFuncs.GetRandomBytes(data1);
var data2 = new byte[1000000];
MiscFuncs.GetRandomBytes(data2);
var xData1 = data1.ToArray();
var xData2 = data1.Concat(data2).ToArray();
_output.WriteLine("{0}", xData2.Length);
byte[] xDataDiff;
using (var sw = new StopWatchDisposable("GetPatch"))
{
xDataDiff = MyBinDiffHelper.GetPatch(
xData1,
xData2
);
}
_output.WriteLine("{0}", xDataDiff.Length);
byte[] xData2Copy;
using (var sw = new StopWatchDisposable("ApplyPatch"))
{
xData2Copy = MyBinDiffHelper.ApplyPatch(
xData1,
xDataDiff
);
}
_output.WriteLine("{0}", xData2Copy.Length);
Assert.Equal(xData2, xData2Copy);
}
private void BigBytePropImport_Click(object sender, EventArgs e)
{
var arrayProp = checkArrayRow();
if (arrayProp == null)
{
return;
}
String[] files = MiscFuncs.GenerateOpenDialog();
if (files.Length == 0)
{
return;
}
string path = files[0];
if (!File.Exists(path))
{
return;
}
byte[] data = File.ReadAllBytes(path);
DialogResult answer = MessageBox.Show("Add Count bytes?", "TH", MessageBoxButtons.YesNo);
if (answer == DialogResult.Yes)
{
byte[] tmp = new byte[data.Length + 4];
Array.Copy(BitConverter.GetBytes(data.Length), tmp, 4);
Array.Copy(data, 0, tmp, 4, data.Length);
data = tmp;
}
arrayProp.value = data;
DrawGrid(selectedPackage, selectedExport);
}
public void Dispose()
{
Destination = null;
MiscFuncs.GetRandomBytes(PrivateKey);
MiscFuncs.GetRandomBytes(SigningPrivateKey);
PrivateKey = null;
SigningPrivateKey = null;
}
public static AesKeyIvPair GenAesKeyIvPair()
{
var result = new AesKeyIvPair();
MiscFuncs.GetRandomBytes(result.Iv);
MiscFuncs.GetRandomBytes(result.Key);
return(result);
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
String[] files = MiscFuncs.GenerateOpenDialog();
if (files.Length == 0)
{
return;
}
DateTime start = DateTime.Now;
List <IProgress> runningReaders = new List <IProgress>();
List <Task> runningTasks = new List <Task>();
foreach (var path in files)
{
if (File.Exists(path))
{
Task newTask = new Task(delegate()
{
Reader reader = new Reader();
runningReaders.Add(reader);
GpkPackage tmpPack = reader.ReadGpk(path);
if (tmpPack != null)
{
if (Settings.Default.Debug)
{
tmpPack.Changes = true; //tmp, remove after tests
}
loadedGpkPackages.Add(tmpPack);
}
});
newTask.Start();
runningTasks.Add(newTask);
}
}
//display info while loading
while (!Task.WaitAll(runningTasks.ToArray(), 50))
{
Application.DoEvents();
DisplayStatus(runningReaders, "Loading", start);
//Thread.Sleep(50);
}
//Diplay end info
DisplayStatus(runningReaders, "Loading", start);
//for patchmode
Array.Resize(ref changedExports, loadedGpkPackages.Count);
for (int i = 0; i < changedExports.Length; i++)
{
changedExports[i] = new List <GpkExport>();
}
//gui stuff
DrawPackages();
}
public MainWindow()
{
try
{
InitializeComponent();
//Opcode Section
PacketTranslator.Init();
pp = new PacketProcessor(this);
cap = new Capture(this);
filter = new PacketFilter();
pp.Init();
//Serverlist
List <ServerInfo> servers = MiscFuncs.LoadServerlistFile(Directory.GetCurrentDirectory() + "\\serverlist.xml");
if (servers != null && servers.Count > 0)
{
//We got a custom serverlist.xml loaded....
boxServers.Items.Clear();
foreach (var server in servers)
{
ComboBoxItem item = new ComboBoxItem {
Tag = server, Content = server.ToString()
};
int index = boxServers.Items.Add(item);
if (server.Focus)
{
boxServers.SelectedIndex = index;
}
if (server.AutoStart)
{
btnStartStop_Click(null, null);
}
}
}
//Print Info
string info = String.Format("Loaded {0} Opcodes. \n" +
"Loaded {1} servers.\n" +
"Github of this Project: https://github.com/GoneUp/Tera_PacketViewer\n" +
"Released at Ragezone: http://forum.ragezone.com/f797/release-tera-live-packet-sniffer-1052922/\n" +
"Uses code of the TeraDamageMeter by gothos-folly: https://github.com/gothos-folly/TeraDamageMeter\n" +
"Have Fun ;)", PacketTranslator.PacketNames.Count, boxServers.Items.Count);
SetText(info);
}
catch (Exception ex)
{
string info = "Startup FAIL! Is WinPcap installed? \n " + ex;
SetText(info);
}
}
/**/
public int EncryptType
= (int)ELightCertificateEncryptType.None;
public int EncryptKeySize = 0;
public byte[] PublicEncryptParameters;
public PassEncryptedData PrivateEncryptParameters;
/**/
public static async Task CorruptByteArrays(
params byte[][] byteArrayArray
)
{
foreach (byte[] b in byteArrayArray)
{
if (b != null)
{
MiscFuncs.GetRandomBytes(b);
}
}
}
public void TestGuidGen()
{
var g1 = Guid.NewGuid();
_output.WriteLine($"{g1}");
var g1Bytes = g1.ToByteArray();
_output.WriteLine(MiscFuncs.ToBinaryString(g1Bytes));
g1Bytes[0] = 0;
g1Bytes[2] = 0;
var g2 = new Guid(g1Bytes);
_output.WriteLine($"{g2}");
}
public void TestEncryptDecrypt()
{
var passBytes = Encoding.UTF8.GetBytes("TestPassword");
var testCertificate =
LightCertificatesHelper.GenerateSelfSignedCertificate(
ELightCertificateSignType.Rsa,
2048,
ELightCertificateEncryptType.Rsa,
2048,
EPrivateKeysKeyDerivationFunction.ScryptDefault,
Guid.NewGuid(),
"TestCertificate",
passBytes
);
foreach (var n in new[] { 1, 2, 3, 5, 10, 16, 32, 48, 64, 63, 65, 191 })
{
var originData = new byte[n];
MiscFuncs.GetRandomBytes(originData);
var encryptedData = testCertificate.EncryptData(originData);
var originDataCopy = testCertificate.DecryptData(encryptedData, passBytes);
Assert.Equal(originData.Length, originDataCopy.Length);
Assert.Equal(originData, originDataCopy);
}
for (int i = 0; i < 10; i++)
{
var aesPair = AesKeyIvPair.GenAesKeyIvPair();
var encryptedPair = LightCertificatesHelper.EncryptAesKeyIvPair(
aesPair,
testCertificate
);
var decryptedPair = LightCertificatesHelper.DecryptAesKeyIvPair(
encryptedPair,
testCertificate,
passBytes
);
Assert.Equal(
aesPair.WriteObjectToJson(),
decryptedPair.WriteObjectToJson()
);
}
}
private void btnExtractOGG_Click(object sender, EventArgs e)
{
if (selectedExport != null && selectedExport.ClassName == "Core.SoundNodeWave")
{
var path = MiscFuncs.GenerateSaveDialog(selectedExport.ObjectName, ".ogg");
if (path != "")
{
SoundwaveTools.ExportOgg(selectedExport, path);
}
}
else if (selectedPackage != null && selectedClass == "Core.SoundNodeWave")
{
List <GpkExport> exports = selectedPackage.GetExportsByClass(selectedClass);
if (exports.Count == 0)
{
logger.Info("No oggs found for class {0}.", selectedClass);
return;
}
FolderBrowserDialog dialog = new FolderBrowserDialog();
dialog.SelectedPath = Path.GetDirectoryName(Settings.Default.SaveDir);
DialogResult result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
Settings.Default.SaveDir = dialog.SelectedPath;
foreach (GpkExport exp in exports)
{
SoundwaveTools.ExportOgg(exp, String.Format("{0}\\{1}.ogg", dialog.SelectedPath, exp.ObjectName));
logger.Trace("ogg save for " + exp.UID);
}
logger.Info("Mass export to {0} was successful.", dialog.SelectedPath);
}
}
}
public ScryptPassEncryptedData(
byte[] originData,
byte[] pass,
byte[] salt = null,
CryptConfigFileHelperScryptParameters scryptParameters = null
)
{
if (salt == null)
{
salt = new byte[32];
MiscFuncs.GetRandomBytes(salt);
}
if (salt.Length != 32)
{
throw new Exception("salt.Length != 32");
}
Salt = salt;
EncryptedData = CryptConfigFileHelper.Encrypt(
originData,
pass,
salt,
scryptParameters
);
}
public void Dispose()
{
MiscFuncs.GetRandomBytes(Key);
MiscFuncs.GetRandomBytes(Iv);
}
public void Dispose()
{
MiscFuncs.GetRandomBytes(_encryptedData);
_aesKeyIvPair.Dispose();
}
public async Task TestSendReceiveOneMessageImpl()
{
const string addressSend = "192.168.56.102"; //"192.168.1.132";
const int portSend = 7656;
const string addressRecv = addressSend; //"127.0.0.1";
const int portRecv = 7656;
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressSend,
SamServerPort = portSend
}, CancellationToken.None
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressRecv,
SamServerPort = portRecv
}, CancellationToken.None
).ConfigureAwait(false);
var reliableHelperSend = new ReliableSamHelper(
samHelperSend,
new ReliableSamHelperSettings()
);
var reliableHelperRecv = new ReliableSamHelper(
samHelperReceive,
new ReliableSamHelperSettings()
);
var data = new byte[1];
MiscFuncs.GetRandomBytes(data);
var waitRecvMessage = reliableHelperRecv.ReliableMessageReceived
.Where(x => x.Destination == samHelperSend.Session.Destination)
.FirstAsync()
.ToTask();
var sendProgress = new Progress <OutMessageProgressInfo>(
x => _logger.Trace(x.ToString())
);
try
{
var messageId = await reliableHelperSend.SendReliableMessage(
samHelperReceive.Session.Destination,
data,
sendProgress
).ConfigureAwait(false);
_logger.Trace("Message sent id {0}", messageId);
}
catch (EnumException <ReliableSamHelper.SendReliableMessageExcs> exc)
{
_logger.Trace("Send error {0}", exc.ExceptionCode);
throw;
}
try
{
var receivedMessage = await waitRecvMessage.ConfigureAwait(false);
_logger.Trace("Message received {0} bytes", receivedMessage.Data.Length);
Assert.Equal(data, receivedMessage.Data);
}
catch (OperationCanceledException exc)
{
_logger.Trace("Recv timeout {0}", exc);
throw;
}
catch (Exception exc)
{
_logger.Trace("Recv error {0}", exc);
throw;
}
_logger.Trace("End Total memory - {0} bytes", GC.GetTotalMemory(true));
await reliableHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperSend disposed");
await reliableHelperRecv.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperRecv disposed");
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperSend disposed");
await samHelperReceive.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperReceive disposed");
}
public PassEncryptedData()
{
Salt = new byte[32];
MiscFuncs.GetRandomBytes(Salt);
}
public async Task TestReconnectingReliable()
{
const string addressSend = "127.0.0.1";
const int portSend = 7656;
/**/
var proxyHostname = "127.0.0.1";
var proxyPort = 17000;
var proxyServer = await MyTcpProxyServer.CreateInstance(
new MyTcpProxyServerSettings()
{
DestinationHostname = addressSend,
DestinationPort = portSend,
ServerHostname = proxyHostname,
ServerPort = proxyPort
}
).ConfigureAwait(false);
/**/
const string addressRecv = addressSend;
const int portRecv = portSend;
string sendPrivKeys;
/**/
{
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressSend,
SamServerPort = portSend
}, CancellationToken.None
).ConfigureAwait(false);
sendPrivKeys = samHelperSend.Session.PrivateKey;
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
}
/**/
var reconnectingSamHelperSend = await ReconnectingSamHelper.CreateInstance(
new ReconnectingSamHelperSettings()
{
ImplementationHelperSettings =
new SamHelperSettings()
{
SamServerAddress = proxyHostname,
SamServerPort = proxyPort,
SessionPrivateKeys = sendPrivKeys
}
}, CancellationToken.None
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressRecv,
SamServerPort = portRecv
}, CancellationToken.None
).ConfigureAwait(false);
var reliableHelperSend = new ReliableSamHelper(
reconnectingSamHelperSend,
new ReliableSamHelperSettings()
);
var reliableHelperRecv = new ReliableSamHelper(
samHelperReceive,
new ReliableSamHelperSettings()
);
var data = new byte[200000];
MiscFuncs.GetRandomBytes(data);
/**/
await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false);
await proxyServer.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("###################################");
await Assert.ThrowsAsync <TimeoutException>(
async() => await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false)
).ConfigureAwait(false);
/**/
_logger.Trace("###################################");
proxyServer = await MyTcpProxyServer.CreateInstance(
new MyTcpProxyServerSettings()
{
DestinationHostname = addressSend,
DestinationPort = portSend,
ServerHostname = proxyHostname,
ServerPort = proxyPort
}
).ConfigureAwait(false);
reconnectingSamHelperSend.TryToReconnect(DateTime.UtcNow);
await Task.Delay(TimeSpan.FromSeconds(15.0d)).ConfigureAwait(false);
/**/
await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false);
/**/
await reliableHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperSend disposed");
await reliableHelperRecv.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperRecv disposed");
await reconnectingSamHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperSend disposed");
await samHelperReceive.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperReceive disposed");
await proxyServer.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("{0} disposed", MyNameof.GetLocalVarName(() => proxyServer));
}
private async void ProcessNewChangedArgs()
{
try
{
using (_stateHelper.GetFuncWrapper())
{
var lockSemCalledWrapper = _lockSem.GetCalledWrapper();
lockSemCalledWrapper.Called = true;
using (await _lockSem.GetDisposable(true).ConfigureAwait(false))
{
while (!_cts.IsCancellationRequested && lockSemCalledWrapper.Called)
{
lockSemCalledWrapper.Called = false;
var currentChangesNumInDictToRemove =
_changedArgsDict.Keys.Where(_ => _ <= _prevChangesCounter).ToList();
foreach (long key in currentChangesNumInDictToRemove)
{
MyNotifyCollectionChangedArgs <TItem> removedArgs;
_changedArgsDict.TryRemove(key, out removedArgs);
}
MyNotifyCollectionChangedArgs <TItem> nextArgs;
if (
_changedArgsDict.TryRemove(
_prevChangesCounter + 1,
out nextArgs
)
)
{
lockSemCalledWrapper.Called = true;
if (nextArgs.ChangedAction == EMyCollectionChangedAction.Reset)
{
await ResetActionAsync().ConfigureAwait(false);
}
else if (nextArgs.ChangedAction == EMyCollectionChangedAction.NewItemsRangeInserted)
{
var insertIndex = nextArgs.NewItemsIndices[0];
var insertCount = nextArgs.NewItems.Count;
if (insertCount > 0)
{
var insertArgs = new List <MutableTuple <int, TItem> >();
for (int i = 0; i < insertCount; i++)
{
insertArgs.Add(
MutableTuple.Create(
i + insertIndex,
nextArgs.NewItems[i]
)
);
}
await _resultCollection.InsertRangeAtAsync(
insertIndex,
insertArgs
).ConfigureAwait(false);
_originCollectionCopy.InsertRange(
insertIndex,
nextArgs.NewItems
);
/**/
var currentResultCount = _originCollectionCopy.Count;
var bulkUpdateArgs = new List <Tuple <int, MutableTuple <int, TItem> > >();
for (int i = insertIndex + insertCount; i < currentResultCount; i++)
{
bulkUpdateArgs.Add(
Tuple.Create(
i,
MutableTuple.Create(
i,
_originCollectionCopy[i]
)
)
);
}
if (bulkUpdateArgs.Any())
{
await _resultCollection.ReplaceBulkAsync(
bulkUpdateArgs
).ConfigureAwait(false);
}
}
_prevChangesCounter++;
}
else if (nextArgs.ChangedAction == EMyCollectionChangedAction.ItemsRangeRemoved)
{
var removeIndex = nextArgs.OldItemsIndices[0];
var removeCount = nextArgs.OldItems.Count;
if (removeCount > 0)
{
await _resultCollection.RemoveRangeAsync(
removeIndex,
removeCount
).ConfigureAwait(false);
_originCollectionCopy.RemoveRange(
removeIndex,
removeCount
);
/**/
var currentResultCount = _originCollectionCopy.Count;
var bulkUpdateArgs = new List <Tuple <int, MutableTuple <int, TItem> > >();
for (int i = removeIndex; i < currentResultCount; i++)
{
bulkUpdateArgs.Add(
Tuple.Create(
i,
MutableTuple.Create(
i,
_originCollectionCopy[i]
)
)
);
}
if (bulkUpdateArgs.Any())
{
await _resultCollection.ReplaceBulkAsync(
bulkUpdateArgs
).ConfigureAwait(false);
}
}
_prevChangesCounter++;
}
else if (nextArgs.ChangedAction == EMyCollectionChangedAction.ItemsChanged)
{
var count = nextArgs.NewItems.Count;
var bulkUpdateArgs = new List <Tuple <int, MutableTuple <int, TItem> > >();
for (int i = 0; i < count; i++)
{
_originCollectionCopy[nextArgs.NewItemsIndices[i]] = nextArgs.NewItems[i];
bulkUpdateArgs.Add(
Tuple.Create(
nextArgs.NewItemsIndices[i],
MutableTuple.Create(
nextArgs.NewItemsIndices[i],
nextArgs.NewItems[i]
)
)
);
}
if (bulkUpdateArgs.Any())
{
await _resultCollection.ReplaceBulkAsync(
bulkUpdateArgs
).ConfigureAwait(false);
}
_prevChangesCounter++;
}
else
{
throw new NotImplementedException();
}
}
}
}
}
}
catch (OperationCanceledException)
{
}
catch (WrongDisposableObjectStateException)
{
}
catch (Exception exc)
{
MiscFuncs.HandleUnexpectedError(exc, _log);
}
}
private void btnImportOgg_Click(object sender, EventArgs e)
{
try
{
if (selectedExport != null)
{
String[] files = MiscFuncs.GenerateOpenDialog();
if (files.Length == 0)
{
return;
}
if (File.Exists(files[0]))
{
SoundwaveTools.ImportOgg(selectedExport, files[0]);
treeMain_AfterSelect(treeMain, new TreeViewEventArgs(treeMain.SelectedNode));
logger.Info("Import successful.");
}
else
{
logger.Info("File not found.");
}
}
else if (selectedPackage != null && selectedClass == "Core.SoundNodeWave")
{
List <GpkExport> exports = selectedPackage.GetExportsByClass(selectedClass);
FolderBrowserDialog dialog = new FolderBrowserDialog();
dialog.SelectedPath = Path.GetDirectoryName(Settings.Default.SaveDir);
DialogResult result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
Settings.Default.SaveDir = dialog.SelectedPath;
string[] files = Directory.GetFiles(dialog.SelectedPath);
foreach (string file in files)
{
string filename = Path.GetFileName(file); //AttackL_02.ogg
string oggname = filename.Remove(filename.Length - 4);
if (oggname == "")
{
continue;
}
foreach (GpkExport exp in exports)
{
if (exp.ObjectName == oggname)
{
SoundwaveTools.ImportOgg(exp, file);
logger.Trace("Matched file {0} to export {1}!", filename, exp.ObjectName);
break;
}
}
}
logger.Info("Mass import to {0} was successful.", dialog.SelectedPath);
}
}
}
catch (Exception ex)
{
logger.FatalException("Import failure! " + ex, ex);
}
}
private void btnReplace_Click(object sender, EventArgs e)
{
if (selectedExport == null)
{
logger.Trace("no selected export");
return;
}
if (selectedExport.Data == null)
{
logger.Trace("no export data");
return;
}
String[] files = MiscFuncs.GenerateOpenDialog();
if (files.Length == 0)
{
return;
}
string path = files[0];
if (File.Exists(path))
{
byte[] buffer = File.ReadAllBytes(path);
if (Settings.Default.PatchMode)
{
if (treeMain.SelectedNode.Parent.Parent == null)
{
return;
}
int packageIndex = Convert.ToInt32(treeMain.SelectedNode.Parent.Parent.Name);
if (buffer.Length > selectedExport.Data.Length)
{
//Too long, not possible without rebuiling the gpk
logger.Info("File size too big for PatchMode. Size: " + buffer.Length + " Maximum Size: " +
selectedExport.Data.Length);
return;
}
//selectedExport.data = buffer;
Array.Copy(buffer, selectedExport.Data, buffer.Length);
changedExports[packageIndex].Add(selectedExport);
}
else
{
//Rebuild Mode
//We force the rebuilder to recalculate the size. (atm we dont know how big the propertys are)
logger.Trace(String.Format("rebuild mode old size {0} new size {1}", selectedExport.Data.Length,
buffer.Length));
selectedExport.Data = buffer;
selectedExport.GetDataSize();
selectedPackage.Changes = true;
}
logger.Info(String.Format("Replaced the data of {0} successfully! Dont forget to save.",
selectedExport.ObjectName));
}
}
private void btnExport_Click(object sender, EventArgs e)
{
if (selectedExport != null)
{
if (selectedExport.Data == null)
{
logger.Info("Length is zero. Nothing to export");
return;
}
var path = MiscFuncs.GenerateSaveDialog(selectedExport.ObjectName, ".raw");
if (path == "")
{
return;
}
DataTools.WriteExportDataFile(path, selectedExport);
}
else if (selectedPackage != null && selectedClass != "")
{
List <GpkExport> exports = selectedPackage.GetExportsByClass(selectedClass);
if (exports.Count == 0)
{
logger.Info("No exports found for class {0}.", selectedClass);
return;
}
FolderBrowserDialog dialog = new FolderBrowserDialog();
dialog.SelectedPath = Settings.Default.SaveDir;
DialogResult result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
Settings.Default.SaveDir = dialog.SelectedPath;
foreach (GpkExport exp in exports)
{
if (exp.Data != null)
{
DataTools.WriteExportDataFile(String.Format("{0}\\{1}.raw", dialog.SelectedPath, exp.ObjectName), exp);
logger.Trace("save for " + exp.UID);
}
}
}
}
else if (selectedPackage != null)
{
FolderBrowserDialog dialog = new FolderBrowserDialog();
dialog.SelectedPath = Settings.Default.SaveDir;
DialogResult result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
Settings.Default.SaveDir = dialog.SelectedPath;
foreach (GpkExport exp in selectedPackage.ExportList.Values)
{
if (exp.Data != null)
{
DataTools.WriteExportDataFile(String.Format("{0}\\{1}\\{2}.raw", dialog.SelectedPath, exp.ClassName, exp.ObjectName), exp);
logger.Trace("save for " + exp.UID);
}
}
}
}
logger.Info("Data was saved!");
}
public MainWindow()
{
try
{
InitializeComponent();
//Opcode Section
PacketTranslator.Init(this);
IEnumerable <string> sortDescendingQuery =
from w in PacketTranslator.PacketNames.Values
orderby w ascending
select w;
foreach (var packetName in sortDescendingQuery)
{
PacketNamesList.Items.Add(packetName);
}
PacketNamesList.SelectedIndex = 0;
//Serverlist
List <ServerInfo> servers = MiscFuncs.LoadServerlistFile(Directory.GetCurrentDirectory() + "\\serverlist.xml");
if (servers != null && servers.Count > 0)
{
//We got a custom serverlist.xml loaded....
BoxServers.Items.Clear();
foreach (var server in servers)
{
int index = BoxServers.Items.Add(server.GetDisplayString());
if (server.Focus)
{
BoxServers.SelectedIndex = index;
}
}
}
//Capture
pp = new PacketProcessor(this);
cap = new Capture.Capture(this);
var list = cap.GetDevices();
foreach (var nic in list)
{
BoxNic.Items.Add(nic);
}
pp.Init();
//Print Info
string info = String.Format("Loaded {0} Opcodes. \n" +
"Loaded {1} servers.\n" +
"{2} network devices available.\n" +
"Github of this Project: https://github.com/GoneUp/Tera_PacketViewer\n" +
"Released at Ragezone: http://forum.ragezone.com/f797/release-tera-live-packet-sniffer-1052922/\n" +
"Have Fun ;)", PacketNamesList.Items.Count, BoxServers.Items.Count,
BoxNic.Items.Count);
SetText(info);
}
catch (Exception ex)
{
string info = "Startup FAIL! Is WinPcap installed? \n " + ex;
SetText(info);
}
}
