public bool Process(MessageType type, byte[] data)
{
switch (type)
{
case MessageType.TypePlayerHealthOffsetDetected:
Logger.Info("Player health offset has been successfully detected");
return(true);
case MessageType.TypeErrorDetectingPlayerHealthOffset: {
Logger.Warn("Player health offset could not be detect, health graphs will be unavailable");
ExceptionReporter.ReportIssue("No health offset");
StringBuilder hex = new StringBuilder(data.Length * 2);
foreach (byte b in data)
{
hex.AppendFormat("{0:x2} ", b);
}
Logger.Debug(hex.ToString());
return(true);
}
case MessageType.TYPE_ErrorDetectingPrimaryPlayerIdOffset:
{
Logger.Warn("Player id offset could not be detect, player id may be unavailable");
ExceptionReporter.ReportIssue("No player id offset");
StringBuilder hex = new StringBuilder(data.Length * 2);
foreach (byte b in data)
{
hex.AppendFormat("{0:x2} ", b);
}
Logger.Debug(hex.ToString());
return(true);
}
case MessageType.TypeHitpointMonitor:
{
int entity = IOHelper.GetInt(data, 0);
float hp = IOHelper.GetFloat(data, 4);
bool isPrimary = data[8] != 0;
if (_appSettings.LogEntityHitpointEvent)
{
Logger.Info($"Entity {entity} has {hp} hitpoints, isPrimary: {isPrimary}.");
}
if (isPrimary)
{
_damageParsingService.SetPlayerInfo(entity, true);
}
_damageParsingService.SetHealth(entity, hp);
return(true);
}
}
return(false);
}
private AccessStatus Migrate()
{
try {
Logger.Info("Starting migration to new backup provider");
var httpClient = new HttpClient(new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
})
{
Timeout = TimeSpan.FromSeconds(15)
};
var url = Uris.MigrateUrl + "?token=" + _authenticationProvider.GetLegacyToken();
var result = httpClient.GetAsync(url).Result;
var status = result.StatusCode;
if (status == HttpStatusCode.OK)
{
Logger.Info($"Got Status {result} migrating authentication token");
var body = result.Content.ReadAsStringAsync().Result;
var accessToken = JsonConvert.DeserializeObject <MigrateResponseType>(body);
_authenticationProvider.SetToken(accessToken.Email, accessToken.Token);
return(AccessStatus.Authorized);
}
else if (status == HttpStatusCode.Unauthorized || status == HttpStatusCode.Forbidden)
{
Logger.Warn("Migration failed, unauthorized");
return(AccessStatus.Unauthorized);
}
else if (status == HttpStatusCode.InternalServerError)
{
ExceptionReporter.ReportIssue("Server response 500 migrating access token");
Logger.Warn("Server response 500 migrating access token towards backup service");
return(AccessStatus.Unknown);
}
else
{
Logger.Error($"Got Status {result} migrating authentication token");
ExceptionReporter.ReportIssue($"Server response {result} migrating access oken");
return(AccessStatus.Unknown);
}
}
catch (AggregateException ex) {
Logger.Warn(ex.Message, ex);
return(AccessStatus.Unknown);
}
catch (WebException ex) {
Logger.Warn(ex.Message, ex);
return(AccessStatus.Unknown);
}
}
private static AccessStatus IsTokenValid(string user, string token)
{
try {
using (var httpClient = new HttpClient {
Timeout = TimeSpan.FromSeconds(5)
}) {
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", token);
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("X-Api-User", user);
var result = httpClient.GetAsync(Uris.TokenVerificationUri).Result;
var status = result.StatusCode;
if (status == HttpStatusCode.OK)
{
Logger.Info($"Got Status {result} verifying authentication token");
return(AccessStatus.Authorized);
}
else if (status == HttpStatusCode.Unauthorized || status == HttpStatusCode.Forbidden)
{
Logger.Warn("Got unauthorized validating access token");
return(AccessStatus.Unauthorized);
}
else if (status == HttpStatusCode.InternalServerError)
{
ExceptionReporter.ReportIssue("Server response 500 verifying access token");
Logger.Warn("Server response 500 verifying access token towards backup service");
return(AccessStatus.Unknown);
}
else
{
Logger.Error($"Got Status {result} verifying authentication token");
ExceptionReporter.ReportIssue($"Server response {result} verifying access token");
return(AccessStatus.Unknown);
}
}
}
catch (AggregateException ex) {
Logger.Warn(ex.Message, ex);
return(AccessStatus.Unknown);
}
catch (WebException ex) {
Logger.Warn(ex.Message, ex);
return(AccessStatus.Unknown);
}
}
private AccessStatus IsTokenValid(string token)
{
try {
// TODO : This is being spammed to holy hell, probably incurring vast costs.
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Simple-Auth", token);
var result = httpClient.GetAsync(AzureUris.TokenVerificationUri).Result.StatusCode;
if (result == HttpStatusCode.OK)
{
Logger.Info($"Got Status {result} verifying authentication token");
return(AccessStatus.Authorized);
}
else if (result == HttpStatusCode.Unauthorized || result == HttpStatusCode.Forbidden)
{
return(AccessStatus.Unauthorized);
}
else if (result == HttpStatusCode.InternalServerError)
{
ExceptionReporter.ReportIssue("Server response 500 verifying access token");
return(AccessStatus.Unknown);
}
else
{
Logger.Error($"Got Status {result} verifying authentication token");
ExceptionReporter.ReportIssue($"Server response {result} verifying access token");
return(AccessStatus.Unknown);
}
}
catch (AggregateException ex) {
Logger.Warn(ex.Message, ex);
return(AccessStatus.Unknown);
}
catch (WebException ex) {
Logger.Warn(ex.Message, ex);
return(AccessStatus.Unknown);
}
}
public void Process(MessageType type, byte[] data)
{
if (Errors.Contains(type))
{
var error = Errors.FirstOrDefault(m => m == type);
logger.Fatal($"GD Hook reports error detecting {error}, unable to detect stash status");
ExceptionReporter.ReportIssue($"DLL Incompatability: {error}");
MessageBox.Show("Alert dev - Possible version incompatibility", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else if (Relevants.Contains(type))
{
if (data.Length != 1 && type == MessageType.TYPE_OPEN_CLOSE_TRANSFER_STASH)
{
logger.WarnFormat("Received a Open/Close stash message from hook, expected length 1, got length {0}", data.Length);
}
switch (type)
{
case MessageType.TYPE_OPEN_PRIVATE_STASH:
PrivateStashStatus = InternalStashStatus.Open;
logger.Debug("Private Stash opened");
break;
case MessageType.TYPE_DISPLAY_CRAFTER:
if (PrivateStashStatus != InternalStashStatus.Open)
{
PrivateStashStatus = InternalStashStatus.Crafting;
GlobalSettings.StashStatus = StashAvailability.CRAFTING;
}
break;
case MessageType.TYPE_OPEN_CLOSE_TRANSFER_STASH:
bool isOpen = ((int)data[0]) != 0;
TransferStashStatus = isOpen ? InternalStashStatus.Open : InternalStashStatus.Closed;
break;
case MessageType.TYPE_SAVE_TRANSFER_STASH:
PrivateStashStatus = InternalStashStatus.Closed;
TransferStashStatus = InternalStashStatus.Closed;
break;
}
switch (type)
{
case MessageType.TYPE_InventorySack_Sort:
GlobalSettings.StashStatus = StashAvailability.SORTED;
break;
case MessageType.TYPE_OPEN_PRIVATE_STASH:
case MessageType.TYPE_OPEN_CLOSE_TRANSFER_STASH:
case MessageType.TYPE_SAVE_TRANSFER_STASH:
// Sorted can still be open, but lets treat it as sorted since we can't transfer items without knowing position
if (GlobalSettings.StashStatus != StashAvailability.SORTED && !IsClosed)
{
GlobalSettings.StashStatus = StashAvailability.OPEN;
}
else if (IsClosed)
{
GlobalSettings.StashStatus = StashAvailability.CLOSED;
logger.Debug("Closed stash");
}
break;
}
}
}
private void process(BackgroundWorker worker, RunArguments arguments)
{
System.Threading.Thread.Sleep(1200);
HashSet <uint> pids = FindProcesses(arguments);
if (pids.Count == 0 && _previouslyInjected.Count == 0)
{
worker.ReportProgress(NO_PROCESS_FOUND_ON_STARTUP, null);
}
else if (pids.Count == 0)
{
worker.ReportProgress(NO_PROCESS_FOUND, null);
}
string dll = Path.Combine(Directory.GetCurrentDirectory(), arguments.DllName);
if (!File.Exists(dll))
{
Logger.FatalFormat("Could not find {1} at \"{0}\"", dll, arguments.DllName);
}
else
{
foreach (uint pid in pids)
{
if (!_previouslyInjected.Contains(pid))
{
//DllInjector.adjustDebugPriv(pid);
IntPtr remoteModuleHandle = DllInjector.NewInject(pid, dll);
if (remoteModuleHandle == IntPtr.Zero)
{
if (!_dontLog.Contains(pid))
{
Logger.WarnFormat("Could not inject dll into process {0}, if this is a recurring issue, try running as administrator.", pid);
worker.ReportProgress(INJECTION_ERROR, "Could not inject dll into process " + pid);
}
}
else
{
if (!_dontLog.Contains(pid))
{
Logger.Info("Injected dll into process " + pid);
}
if (!InjectionVerifier.VerifyInjection(pid, arguments.DllName))
{
if (!_dontLog.Contains(pid))
{
Logger.Warn("InjectionVerifier reports injection failed.");
ExceptionReporter.ReportIssue("InjectionVerifier reports injection failed into PID " + pid);
worker.ReportProgress(INJECTION_ERROR, string.Format("InjectionVerifier reports injection failed into PID {0}, try running as administrator.", pid));
}
_dontLog.Add(pid);
}
else
{
Logger.Info("InjectionVerifier reports injection succeeded.");
_previouslyInjected.Add(pid);
_pidModuleHandleMap[pid] = remoteModuleHandle;
}
}
}
}
}
}
public Form1(CefBrowserHandler browser, AppSettings appSettings, bool showDevtools)
{
InitializeComponent();
_browser = browser;
_appSettings = appSettings;
_generalStateService = new GeneralStateService(_appSettings);
_showDevtools = showDevtools;
_messageProcessorCore = new MessageProcessorCore(_damageParsingService, _positionTrackerService, _generalStateService, _appSettings);
_statisticsService = new StatisticsService(_damageParsingService);
_browser.JsPojo.OnSave += JsPojoOnOnSave;
_browser.JsPojo.OnSetLightMode += (sender, args) => {
bool isDarkMode = (args as LightModeArgument)?.IsDarkMode ?? false;
Properties.Settings.Default.DarkModeEnabled = isDarkMode;
Properties.Settings.Default.Save();
};
_browser.JsPojo.OnLog += (sender, args) => {
string data = (args as SaveParseArgument)?.Data;
Logger.Warn(data);
ExceptionReporter.ReportIssue(data);
};
_nameSuggestionService = new NameSuggestionService(GlobalSettings.BineroHost);
_cSharpJsStateMapper = new CSharpJsStateMapper(_browser, _statisticsService, _generalStateService, _positionTrackerService);
_browser.JsPojo.OnRequestData += (sender, _args) => {
RequestDataArgument args = _args as RequestDataArgument;
long start;
if (long.TryParse(args.TimestampStart, out start))
{
long end;
if (long.TryParse(args.TimestampEnd, out end))
{
_cSharpJsStateMapper.RequestData(args.Type, start, end, args.EntityId, args.Callback);
}
else
{
Logger.Warn($"Could not parse timestamp {args.TimestampEnd} received for {args.Type}");
}
}
else
{
Logger.Warn($"Could not parse timestamp {args.TimestampStart} received for {args.Type}");
}
};
#if !DEBUG
webViewPanel.Parent.Controls.Remove(webViewPanel);
Controls.Clear();
if (_showDevtools)
{
Controls.Add(btnShowDevtools);
}
Controls.Add(webViewPanel);
bool itemAssistantInstalled = Directory.Exists(GlobalSettings.ItemAssistantFolder) || new Random().Next(10) < 8;
if (itemAssistantInstalled)
{
webViewPanel.Location = new Point {
X = 0, Y = 0
};
webViewPanel.Width = this.ClientSize.Width;
webViewPanel.Height = this.ClientSize.Height;
}
else
{
var labels = new[] {
"Is your stash full? Try Item Assistant!",
"Need a larger stash? Try Item Assistant!",
"Having trouble finding space for all your loot? Try Item Assistant!",
"Having trouble finding space for all your items? Try Item Assistant!",
"Need extra item storage? Try Item Assistant!",
};
var idx = new Random().Next(0, labels.Length);
linkItemAssistant.Text = labels[idx];
const int margin = 5;
webViewPanel.Location = new Point {
X = 0, Y = linkItemAssistant.Height + margin * 2
};
webViewPanel.Width = this.ClientSize.Width;
webViewPanel.Height = this.ClientSize.Height - linkItemAssistant.Height - margin * 2;
Controls.Add(linkItemAssistant);
}
#else
linkItemAssistant.Hide();
#endif
_timerReportUsage = new System.Timers.Timer();
_timerReportUsage.Start();
_timerReportUsage.Elapsed += (a1, a2) => {
if (Thread.CurrentThread.Name == null)
{
Thread.CurrentThread.Name = "CleanupThread";
}
_damageParsingService.Cleanup();
};
_timerReportUsage.Interval = 60 * 1000 * 5;
_timerReportUsage.AutoReset = true;
_timerReportUsage.Start();
}
public static JsonItem GetJsonItem(PlayerHeldItem item)
{
// TODO: Modifiers
bool isCloudSynced = false;
object[] transferUrl = { "", "", "", "" };
string uniqueIdentifier;
if (item is PlayerItem pi)
{
transferUrl = new object[] { pi.BaseRecord, pi.PrefixRecord, pi.SuffixRecord, pi.MateriaRecord };
isCloudSynced = pi.IsCloudSynchronized;
uniqueIdentifier = $"PI/{pi.Id}/{pi.CloudId}";
}
else if (item is BuddyItem bi)
{
// TODO: Remove this, buddy items are never transferable. Gotta provide a better unique id.
uniqueIdentifier = $"BI/{bi.BuddyId}/{bi.RemoteItemId}";
}
else if (item is RecipeItem)
{
uniqueIdentifier = $"RI/{item.BaseRecord}";
}
else if (item is AugmentationItem)
{
uniqueIdentifier = $"AI/{item.BaseRecord}";
}
else
{
uniqueIdentifier = $"UK/{item.BaseRecord}";
}
ItemTypeDto type;
string extras = string.Empty;
if (item.IsRecipe)
{
type = ItemTypeDto.Recipe;
}
else if (!string.IsNullOrEmpty(item.Stash))
{
type = ItemTypeDto.Buddy;
}
else if (item is PlayerItem)
{
type = ItemTypeDto.Player;
}
else if (item is AugmentationItem augmentationItem)
{
type = ItemTypeDto.Augmentation;
extras = ItemOperationsUtility.TranslateFaction(
RuntimeSettings.Language,
augmentationItem.Tags.FirstOrDefault(m => m.Stat == "factionSource")?.TextValue ?? string.Empty
);
}
else
{
type = ItemTypeDto.Unknown;
}
var json = new JsonItem {
UniqueIdentifier = uniqueIdentifier,
BaseRecord = item.BaseRecord ?? string.Empty,
URL = transferUrl,
Icon = item.Bitmap ?? string.Empty,
Name = PureItemName(item.Name) ?? string.Empty,
Quality = item.Rarity ?? string.Empty,
Level = item.MinimumLevel,
Socket = GetSocketFromItem(item?.Name) ?? string.Empty,
NumItems = (uint)item.Count,
InitialNumItems = (uint)item.Count,
PetStats = item.PetStats.Select(ToJsonStat).ToHashSet().ToList(),
BodyStats = item.BodyStats.Select(ToJsonStat).ToHashSet().ToList(),
HeaderStats = item.HeaderStats.Select(ToJsonStat).ToHashSet().ToList(),
Type = type,
HasRecipe = item.HasRecipe,
Buddies = item.Buddies.ToArray(),
Skill = item.Skill != null?GetJsonSkill(item.Skill) : null,
GreenRarity = (int)item.PrefixRarity,
HasCloudBackup = isCloudSynced,
Slot = SlotTranslator.Translate(RuntimeSettings.Language, item.Slot ?? ""),
Extras = extras,
IsMonsterInfrequent = item.ModifiedSkills.Any(s => s.IsMonsterInfrequent),
};
var modifiedSkills = item.ModifiedSkills;
foreach (var modifiedSkill in modifiedSkills)
{
var translated = modifiedSkill.Translated;
foreach (var stat in translated.Select(ToJsonStat))
{
json.BodyStats.Add(stat);
}
if (translated.Count == 0 && !(modifiedSkill.Class == null || modifiedSkill.Tier == null))
{
string[] uri = json.URL.Select(o => o.ToString()).ToArray();
var error = $@"Could not translate skill-modifier on: '{item.Name}', {json.BaseRecord} - {string.Join(";", uri)}";
ExceptionReporter.ReportIssue(error);
Logger.Debug($"Could not translate skill-modifier stats for \"{item.Name}\"");
}
}
return(json);
}
