using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("TimeoutLimit")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("TimeoutLimit")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("FE8B42E3-7082-4DFF-A5CC-6B62B0315ACA")]
[assembly: AssemblyFileVersion("0.2.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.0.0")]
[module: UnverifiableCode]
namespace TimeoutLimit;
public static class CodeMatcherExtensions
{
public static CodeMatcher GetPosition(this CodeMatcher codeMatcher, out int position)
{
position = codeMatcher.Pos;
return codeMatcher;
}
public static CodeMatcher AddLabel(this CodeMatcher codeMatcher, out Label label)
{
label = default(Label);
codeMatcher.AddLabels((IEnumerable<Label>)new Label[1] { label });
return codeMatcher;
}
public static CodeMatcher GetLabels(this CodeMatcher codeMatcher, out List<Label> label)
{
label = codeMatcher.Labels;
return codeMatcher;
}
public static CodeMatcher GetOperand(this CodeMatcher codeMatcher, out object operand)
{
operand = codeMatcher.Operand;
return codeMatcher;
}
internal static CodeMatcher Print(this CodeMatcher codeMatcher, string message)
{
Debug.Log((object)message);
return codeMatcher;
}
internal static CodeMatcher Print(this CodeMatcher codeMatcher, int before, int after)
{
for (int i = -before; i <= after; i++)
{
int num = i;
int num2 = codeMatcher.Pos + num;
if (num2 > 0)
{
if (num2 >= codeMatcher.Length)
{
break;
}
try
{
CodeInstruction val = codeMatcher.InstructionAt(num);
Debug.Log((object)($"[{num}] " + ((object)val).ToString()));
}
catch (Exception ex)
{
Debug.Log((object)ex.Message);
}
}
}
return codeMatcher;
}
public static bool IsVirtCall(this CodeInstruction i, string declaringType, string name)
{
return i.opcode == OpCodes.Callvirt && i.operand is MethodInfo methodInfo && methodInfo.DeclaringType?.Name == declaringType && methodInfo.Name == name;
}
}
[BepInPlugin("com.maxsch.valheim.TimeoutLimit", "TimeoutLimit", "0.2.0")]
[HarmonyPatch]
public class Plugin : BaseUnityPlugin
{
public const string ModName = "TimeoutLimit";
public const string ModGuid = "com.maxsch.valheim.TimeoutLimit";
public const string ModVersion = "0.2.0";
public static Harmony harmony;
public static HashSet<Assembly> patchedAssemblies = new HashSet<Assembly>();
public static CodeInstruction[] loadTimeout = (CodeInstruction[])(object)new CodeInstruction[2]
{
new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Plugin), "Timeout")),
new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<float>), "Value"))
};
public static MethodInfo getTime = AccessTools.PropertyGetter(typeof(Time), "time");
public static ConfigEntry<float> Timeout { get; set; }
public void Awake()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
Timeout = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Timeout", 90f, "Timeout in seconds");
Timeout.SettingChanged += delegate
{
if (Chainloader.PluginInfos.TryGetValue("com.jotunn.jotunn", out var value))
{
SetJotunnTimeout(value);
}
};
harmony = new Harmony("com.maxsch.valheim.TimeoutLimit");
harmony.PatchAll();
}
public void Start()
{
//IL_0467: Unknown result type (might be due to invalid IL or missing references)
//IL_0473: Expected O, but got Unknown
//IL_0439: Unknown result type (might be due to invalid IL or missing references)
//IL_0445: Expected O, but got Unknown
foreach (PluginInfo value in Chainloader.PluginInfos.Values)
{
if (value == null || !Object.op_Implicit((Object)(object)value.Instance) || value.Metadata.GUID == "com.maxsch.valheim.TimeoutLimit")
{
continue;
}
if (value.Metadata.GUID == "com.jotunn.jotunn")
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Patching " + value.Metadata.Name + " [" + value.Metadata.GUID + "]"));
SetJotunnTimeout(value);
continue;
}
Assembly assembly = ((object)value.Instance).GetType().Assembly;
if (!patchedAssemblies.Add(assembly))
{
continue;
}
List<Type> source = (from t in assembly.GetTypes()
where t.IsClass && (t.Name == "ConfigSync" || t.Name == "ServerSync")
select t).ToList();
List<Type> list = (from t in source.SelectMany((Type t) => t.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic)).SelectMany((Type t) => t.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic))
where t.IsClass && t.Name.Contains("waitForQueue")
select t).ToList();
bool flag = false;
if (value.Metadata.GUID == "Azumatt.AzuAntiCheat" && list.Count == 0)
{
list = (from m in assembly.GetTypes().SelectMany((Type t) => t.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic)).SelectMany((Type t) => t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic))
where m.Name.Contains("waitForQueue")
select m).SelectMany((MethodInfo m) => m.DeclaringType?.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic)).ToList();
flag = list.Count == 1;
}
List<MethodInfo> list2 = (from m in list.SelectMany((Type t) => t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic))
where m.Name == "MoveNext"
select m).ToList();
if (list2.Count > 0)
{
if (value.Metadata.GUID == "Azumatt.AzuAntiCheat")
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Patching " + value.Metadata.Name + " [" + value.Metadata.GUID + "] (special case: " + (flag ? "yes" : "no") + ")"));
}
else
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Patching " + value.Metadata.Name + " [" + value.Metadata.GUID + "]"));
}
}
else
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Skipping " + value.Metadata.Name + " [" + value.Metadata.GUID + "]"));
}
foreach (MethodInfo item in list2)
{
try
{
if (flag)
{
harmony.Patch((MethodBase)item, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin).GetMethod("AzuAntiCheatTranspiler")), (HarmonyMethod)null, (HarmonyMethod)null);
}
else
{
harmony.Patch((MethodBase)item, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin).GetMethod("ServerSyncTranspiler")), (HarmonyMethod)null, (HarmonyMethod)null);
}
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogError((object)$"Failed to patch {item?.DeclaringType?.FullName}.{item?.Name}: {arg}");
}
}
}
}
public void SetJotunnTimeout(PluginInfo plugin)
{
if (plugin != null && (Object)(object)plugin.Instance != (Object)null && plugin.Metadata.GUID == "com.jotunn.jotunn" && plugin.Metadata.Version >= new Version("2.24.0"))
{
Type type = AccessTools.TypeByName("Jotunn.Entities.CustomRPC, Jotunn");
AccessTools.Field(type, "Timeout").SetValue(null, Timeout.Value);
}
}
[HarmonyPatch(typeof(ZRpc), "SetLongTimeout")]
[HarmonyTranspiler]
public static IEnumerable<CodeInstruction> SetLongTimeoutTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[2]
{
new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Stsfld, (object)null, (string)null)
};
List<Label> label;
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, array).RemoveInstructions(1).InsertAndAdvance(loadTimeout)
.MatchForward(false, array)
.GetLabels(out label)
.RemoveInstructions(1)
.Insert(loadTimeout)
.AddLabels((IEnumerable<Label>)label)
.InstructionEnumeration();
}
[HarmonyPatch(typeof(Debug), "Log", new Type[] { typeof(object) })]
[HarmonyPrefix]
public static bool DebugContext(object message)
{
if (message is string text && text.Contains("seconds config sending timeout") && !text.StartsWith("["))
{
Assembly assembly;
try
{
assembly = (new StackTrace().GetFrames() ?? Array.Empty<StackFrame>()).First((StackFrame x) => x.GetMethod().ReflectedType?.Assembly != typeof(Plugin).Assembly && x.GetMethod().ReflectedType?.Assembly != typeof(Debug).Assembly).GetMethod().ReflectedType?.Assembly;
}
catch (Exception)
{
return true;
}
if (assembly != null)
{
Debug.Log((object)$"[{assembly.GetName().Name}] {message}");
return false;
}
}
return true;
}
public static IEnumerable<CodeInstruction> ServerSyncTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Expected O, but got Unknown
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Expected O, but got Unknown
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Expected O, but got Unknown
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Expected O, but got Unknown
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Expected O, but got Unknown
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_01a9: Expected O, but got Unknown
return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.Calls(i, getTime)), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Add, (object)null, (string)null)
}).ThrowIfNotMatch("Failed to match timeout calculation", Array.Empty<CodeMatch>()).Advance(1)
.RemoveInstructions(1)
.InsertAndAdvance(loadTimeout)
.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"Disconnecting {0} after 30 seconds config sending timeout", (string)null)
})
.ThrowIfNotMatch("Failed to match disconnect message", Array.Empty<CodeMatch>())
.RemoveInstructions(1)
.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Ldstr, (object)"Disconnecting {0} after {1} seconds config sending timeout")
})
.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Call && i.operand is MethodInfo methodInfo && methodInfo.Name == "Format"), (string)null)
})
.ThrowIfNotMatch("Failed to match string.Format", Array.Empty<CodeMatch>())
.RemoveInstructions(1)
.InsertAndAdvance(loadTimeout)
.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Box, (object)typeof(float))
})
.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(string), "Format", new Type[3]
{
typeof(string),
typeof(object),
typeof(object)
}, (Type[])null))
})
.InstructionEnumeration();
}
public static IEnumerable<CodeInstruction> AzuAntiCheatTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Expected O, but got Unknown
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Expected O, but got Unknown
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Expected O, but got Unknown
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Expected O, but got Unknown
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Expected O, but got Unknown
//IL_0197: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Expected O, but got Unknown
return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.Calls(i, getTime)), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Add, (object)null, (string)null)
}).ThrowIfNotMatch("Failed to match timeout calculation", Array.Empty<CodeMatch>())
.Advance(1)
.RemoveInstructions(1)
.InsertAndAdvance(loadTimeout)
.Start()
.MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Call && i.operand is MethodInfo methodInfo && methodInfo.Name == "Format"), (string)null)
})
.ThrowIfNotMatch("Failed to match string.Format", Array.Empty<CodeMatch>())
.Advance(1)
.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
{
new CodeInstruction(OpCodes.Pop, (object)null),
new CodeInstruction(OpCodes.Ldstr, (object)"Disconnecting peer after {0} seconds config sending timeout"),
new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(Plugin), "Timeout")),
new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(ConfigEntry<float>), "Value")),
new CodeInstruction(OpCodes.Box, (object)typeof(float)),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(string), "Format", new Type[2]
{
typeof(string),
typeof(object)
}, (Type[])null))
})
.InstructionEnumeration();
}
}
