using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: Guid("E74EB49A-461D-48EA-85BC-F462D60C98C4")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyProduct("WhitelistRemove")]
[assembly: AssemblyCompany("Radamanto")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("WhitelistRemove")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
[Microsoft.CodeAnalysis.Embedded]
[CompilerGenerated]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace WhitelistRemove
{
[BepInPlugin("radamanto.WhitelistRemove", "WhitelistRemove", "1.0.0")]
public sealed class WhitelistRemovePlugin : BaseUnityPlugin
{
private readonly struct ParsedLine
{
public readonly string Raw;
public readonly string Trimmed;
public readonly bool IsCommentOrEmpty;
public readonly string Token;
public readonly bool IsNumericToken;
public readonly ulong SteamId;
public ParsedLine(string raw, string trimmed, bool isCommentOrEmpty, string token, bool isNumericToken, ulong steamId)
{
Raw = raw;
Trimmed = trimmed;
IsCommentOrEmpty = isCommentOrEmpty;
Token = token;
IsNumericToken = isNumericToken;
SteamId = steamId;
}
}
[CompilerGenerated]
private sealed class <BootstrapWhenServerReady>d__17 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public WhitelistRemovePlugin <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <BootstrapWhenServerReady>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
goto IL_0044;
case 1:
<>1__state = -1;
goto IL_0044;
case 2:
{
<>1__state = -1;
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.ScanLoop());
return false;
}
IL_0044:
if ((Object)(object)ZNet.instance == (Object)null)
{
<>2__current = null;
<>1__state = 1;
return true;
}
if (!<>4__this.CE_Enable.Value)
{
return false;
}
if (!IsServer())
{
return false;
}
<>2__current = <>4__this.RunScanOnceCoroutine();
<>1__state = 2;
return true;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <RunScanOnceCoroutine>d__26 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public WhitelistRemovePlugin <>4__this;
private string <fileName>5__1;
private string <root>5__2;
private string <whitelistPath>5__3;
private long <now>5__4;
private long <threshold>5__5;
private HashSet<string> <online>5__6;
private bool <onlineSeenChanged>5__7;
private string[] <lines>5__8;
private bool <readOk>5__9;
private int <readAttempt>5__10;
private List<ParsedLine> <parsed>5__11;
private bool <lastSeenChanged>5__12;
private int <removedCount>5__13;
private HashSet<string> <keptIds>5__14;
private HashSet<ulong> <keptUlong>5__15;
private int <pruned>5__16;
private List<string> <rebuilt>5__17;
private bool <writeOk>5__18;
private int <writeAttempt>5__19;
private HashSet<string>.Enumerator <>s__20;
private string <s>5__21;
private ulong <osid>5__22;
private bool <delay>5__23;
private int <i>5__24;
private string <raw>5__25;
private string <t>5__26;
private string <tok>5__27;
private ulong <sid>5__28;
private int <i>5__29;
private ParsedLine <pl>5__30;
private string <idStr>5__31;
private ulong <sid>5__32;
private long <lastSeen>5__33;
private long <delta>5__34;
private int <i>5__35;
private ParsedLine <pl>5__36;
private bool <delay>5__37;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RunScanOnceCoroutine>d__26(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<fileName>5__1 = null;
<root>5__2 = null;
<whitelistPath>5__3 = null;
<online>5__6 = null;
<lines>5__8 = null;
<parsed>5__11 = null;
<keptIds>5__14 = null;
<keptUlong>5__15 = null;
<rebuilt>5__17 = null;
<>s__20 = default(HashSet<string>.Enumerator);
<s>5__21 = null;
<raw>5__25 = null;
<t>5__26 = null;
<tok>5__27 = null;
<pl>5__30 = default(ParsedLine);
<idStr>5__31 = null;
<pl>5__36 = default(ParsedLine);
<>1__state = -2;
}
private bool MoveNext()
{
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
//IL_0247: Expected O, but got Unknown
//IL_08c2: Unknown result type (might be due to invalid IL or missing references)
//IL_08cc: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>4__this.RefreshBypassCacheIfNeeded();
<fileName>5__1 = (<>4__this.CE_WhitelistFileName.Value ?? "permittedlist.txt").Trim();
if (string.IsNullOrWhiteSpace(<fileName>5__1))
{
return false;
}
<root>5__2 = GetVanillaListRootPath();
if (string.IsNullOrWhiteSpace(<root>5__2))
{
return false;
}
Directory.CreateDirectory(<root>5__2);
<whitelistPath>5__3 = Path.Combine(<root>5__2, <fileName>5__1);
if (!File.Exists(<whitelistPath>5__3))
{
return false;
}
<now>5__4 = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
<threshold>5__5 = (long)Mathf.Max(1f, <>4__this.CE_InactiveThresholdSeconds.Value);
<online>5__6 = OnlineSnapshot.GetOnlineSteamIdStrings();
<onlineSeenChanged>5__7 = false;
<>s__20 = <online>5__6.GetEnumerator();
try
{
while (<>s__20.MoveNext())
{
<s>5__21 = <>s__20.Current;
if (ulong.TryParse(<s>5__21, NumberStyles.None, CultureInfo.InvariantCulture, out <osid>5__22) && <osid>5__22 != 0)
{
SeenStore.SetLastSeen(<osid>5__22, <now>5__4);
<onlineSeenChanged>5__7 = true;
}
<s>5__21 = null;
}
}
finally
{
((IDisposable)<>s__20).Dispose();
}
<>s__20 = default(HashSet<string>.Enumerator);
<lines>5__8 = Array.Empty<string>();
<readOk>5__9 = false;
<readAttempt>5__10 = 0;
goto IL_0258;
case 1:
<>1__state = -1;
goto IL_0258;
case 2:
{
<>1__state = -1;
break;
}
IL_0258:
while (<readAttempt>5__10 < 3)
{
<delay>5__23 = false;
try
{
<lines>5__8 = File.ReadAllLines(<whitelistPath>5__3, Encoding.UTF8);
<readOk>5__9 = true;
}
catch (IOException)
{
<readAttempt>5__10++;
if (<readAttempt>5__10 >= 3)
{
break;
}
<delay>5__23 = true;
goto IL_022b;
}
catch
{
}
break;
IL_022b:
if (<delay>5__23)
{
<>2__current = (object)new WaitForSecondsRealtime(0.2f);
<>1__state = 1;
return true;
}
}
if (!<readOk>5__9)
{
return false;
}
<parsed>5__11 = new List<ParsedLine>(<lines>5__8.Length);
<i>5__24 = 0;
while (<i>5__24 < <lines>5__8.Length)
{
<raw>5__25 = <lines>5__8[<i>5__24] ?? string.Empty;
<t>5__26 = <raw>5__25.Trim();
if (<t>5__26.Length == 0 || <t>5__26.StartsWith("//", StringComparison.Ordinal) || <t>5__26.StartsWith("#", StringComparison.Ordinal) || <t>5__26.StartsWith(";", StringComparison.Ordinal))
{
<parsed>5__11.Add(new ParsedLine(<raw>5__25, <t>5__26, isCommentOrEmpty: true, string.Empty, isNumericToken: false, 0uL));
}
else
{
<tok>5__27 = FirstToken(<t>5__26);
if (<tok>5__27.Length == 0)
{
<parsed>5__11.Add(new ParsedLine(<raw>5__25, <t>5__26, isCommentOrEmpty: true, string.Empty, isNumericToken: false, 0uL));
}
else
{
if (ulong.TryParse(<tok>5__27, NumberStyles.None, CultureInfo.InvariantCulture, out <sid>5__28))
{
<parsed>5__11.Add(new ParsedLine(<raw>5__25, <t>5__26, isCommentOrEmpty: false, <tok>5__27, isNumericToken: true, <sid>5__28));
}
else
{
<parsed>5__11.Add(new ParsedLine(<raw>5__25, <t>5__26, isCommentOrEmpty: false, <tok>5__27, isNumericToken: false, 0uL));
}
<raw>5__25 = null;
<t>5__26 = null;
<tok>5__27 = null;
}
}
<i>5__24++;
}
if (<parsed>5__11.Count == 0)
{
return false;
}
<lastSeenChanged>5__12 = <onlineSeenChanged>5__7;
<removedCount>5__13 = 0;
<keptIds>5__14 = new HashSet<string>(StringComparer.Ordinal);
<keptUlong>5__15 = new HashSet<ulong>();
<i>5__29 = 0;
while (<i>5__29 < <parsed>5__11.Count)
{
<pl>5__30 = <parsed>5__11[<i>5__29];
if (!<pl>5__30.IsCommentOrEmpty && <pl>5__30.IsNumericToken)
{
<idStr>5__31 = <pl>5__30.Token;
<sid>5__32 = <pl>5__30.SteamId;
if (<online>5__6.Contains(<idStr>5__31))
{
<keptIds>5__14.Add(<idStr>5__31);
<keptUlong>5__15.Add(<sid>5__32);
}
else if (<>4__this.IsBypassed(<sid>5__32))
{
<keptIds>5__14.Add(<idStr>5__31);
<keptUlong>5__15.Add(<sid>5__32);
}
else if (!SeenStore.TryGetLastSeen(<sid>5__32, out <lastSeen>5__33))
{
SeenStore.SetLastSeen(<sid>5__32, <now>5__4);
<lastSeenChanged>5__12 = true;
<keptIds>5__14.Add(<idStr>5__31);
<keptUlong>5__15.Add(<sid>5__32);
}
else
{
<delta>5__34 = <now>5__4 - <lastSeen>5__33;
if (<delta>5__34 > <threshold>5__5)
{
<removedCount>5__13++;
AppendRemovedLog(<>4__this._removedLogPath, <sid>5__32, <lastSeen>5__33, <delta>5__34, "inactive", ((BaseUnityPlugin)<>4__this).Logger);
if (SeenStore.Remove(<sid>5__32))
{
<lastSeenChanged>5__12 = true;
}
}
else
{
<keptIds>5__14.Add(<idStr>5__31);
<keptUlong>5__15.Add(<sid>5__32);
<pl>5__30 = default(ParsedLine);
<idStr>5__31 = null;
}
}
}
<i>5__29++;
}
<pruned>5__16 = SeenStore.PruneTo(<keptUlong>5__15);
if (<pruned>5__16 > 0)
{
<lastSeenChanged>5__12 = true;
}
if (<removedCount>5__13 == 0)
{
if (<lastSeenChanged>5__12)
{
SeenStore.Save(<>4__this._lastSeenPath, ((BaseUnityPlugin)<>4__this).Logger);
}
return false;
}
<rebuilt>5__17 = new List<string>(<parsed>5__11.Count);
<i>5__35 = 0;
while (<i>5__35 < <parsed>5__11.Count)
{
<pl>5__36 = <parsed>5__11[<i>5__35];
if (<pl>5__36.IsCommentOrEmpty)
{
<rebuilt>5__17.Add(<pl>5__36.Raw);
}
else if (!<pl>5__36.IsNumericToken)
{
<rebuilt>5__17.Add(<pl>5__36.Raw);
}
else
{
if (<keptIds>5__14.Contains(<pl>5__36.Token))
{
<rebuilt>5__17.Add(<pl>5__36.Raw);
}
<pl>5__36 = default(ParsedLine);
}
<i>5__35++;
}
<writeOk>5__18 = false;
<writeAttempt>5__19 = 0;
break;
}
while (<writeAttempt>5__19 < 3)
{
<delay>5__37 = false;
try
{
FileIoRetry.AtomicWriteText(<whitelistPath>5__3, string.Join(Environment.NewLine, <rebuilt>5__17) + Environment.NewLine);
<writeOk>5__18 = true;
}
catch (IOException)
{
<writeAttempt>5__19++;
if (<writeAttempt>5__19 >= 3)
{
break;
}
<delay>5__37 = true;
goto IL_08b0;
}
catch
{
}
break;
IL_08b0:
if (<delay>5__37)
{
<>2__current = (object)new WaitForSecondsRealtime(0.2f);
<>1__state = 2;
return true;
}
}
if (!<writeOk>5__18)
{
return false;
}
SeenStore.Save(<>4__this._lastSeenPath, ((BaseUnityPlugin)<>4__this).Logger);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <ScanLoop>d__19 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public WhitelistRemovePlugin <>4__this;
private float <interval>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ScanLoop>d__19(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
if (!<>4__this.CE_Enable.Value || !IsServer())
{
break;
}
<>2__current = <>4__this.RunScanOnceCoroutine();
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
break;
}
<interval>5__1 = Mathf.Max(5f, <>4__this.CE_ScanIntervalSeconds.Value);
<>2__current = (object)new WaitForSecondsRealtime(<interval>5__1);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal const string ModName = "WhitelistRemove";
internal const string ModVersion = "1.0.0";
internal const string Author = "radamanto";
internal const string ModGUID = "radamanto.WhitelistRemove";
private readonly Harmony _harmony = new Harmony("radamanto.WhitelistRemove");
private ConfigEntry<bool> CE_Enable = null;
private ConfigEntry<string> CE_WhitelistFileName = null;
private ConfigEntry<float> CE_ScanIntervalSeconds = null;
private ConfigEntry<float> CE_InactiveThresholdSeconds = null;
private ConfigEntry<string> CE_BypassSteamIds = null;
private ConfigEntry<bool> CE_BypassAdmins = null;
private string _dataDir = string.Empty;
private string _lastSeenPath = string.Empty;
private string _removedLogPath = string.Empty;
private string _bypassRawLast = string.Empty;
private readonly HashSet<ulong> _bypassIds = new HashSet<ulong>();
private void Awake()
{
CE_Enable = ((BaseUnityPlugin)this).Config.Bind<bool>("01 - General", "Enable", true, "Enable the whitelist inactivity cleaner.");
CE_WhitelistFileName = ((BaseUnityPlugin)this).Config.Bind<string>("02 - Whitelist", "WhitelistFileName", "permittedlist.txt", "Whitelist file name.");
CE_ScanIntervalSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("03 - Scan", "ScanIntervalSeconds", 900f, "How often the mod scans the whitelist and removes inactive users.");
CE_InactiveThresholdSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("03 - Scan", "InactiveThresholdSeconds", 259200f, "If a whitelisted SteamID did not log in for more than this amount of seconds, it will be removed.");
CE_BypassSteamIds = ((BaseUnityPlugin)this).Config.Bind<string>("04 - Bypass", "BypassSteamIds", "", "SteamIDs that are NEVER removed (comma separated).");
CE_BypassAdmins = ((BaseUnityPlugin)this).Config.Bind<bool>("04 - Bypass", "BypassAdmins", true, "If true, SteamIDs that are admins on the server are NEVER removed.");
_dataDir = Path.Combine(Paths.ConfigPath, "WhitelistRemove");
_lastSeenPath = Path.Combine(_dataDir, "lastseen.json");
_removedLogPath = Path.Combine(_dataDir, "removed.log");
Directory.CreateDirectory(_dataDir);
SeenStore.Load(_lastSeenPath, ((BaseUnityPlugin)this).Logger);
_harmony.PatchAll(typeof(WhitelistRemovePlugin).Assembly);
((MonoBehaviour)this).StartCoroutine(BootstrapWhenServerReady());
}
[IteratorStateMachine(typeof(<BootstrapWhenServerReady>d__17))]
private IEnumerator BootstrapWhenServerReady()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <BootstrapWhenServerReady>d__17(0)
{
<>4__this = this
};
}
private static bool IsServer()
{
try
{
return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer();
}
catch
{
return false;
}
}
[IteratorStateMachine(typeof(<ScanLoop>d__19))]
private IEnumerator ScanLoop()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ScanLoop>d__19(0)
{
<>4__this = this
};
}
private void RefreshBypassCacheIfNeeded()
{
string text = CE_BypassSteamIds.Value ?? string.Empty;
if (string.Equals(text, _bypassRawLast, StringComparison.Ordinal))
{
return;
}
_bypassRawLast = text;
_bypassIds.Clear();
string[] array = text.Split(new char[5] { ',', ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < array.Length; i++)
{
string text2 = array[i].Trim();
if (text2.Length != 0 && !text2.StartsWith("//", StringComparison.Ordinal) && !text2.StartsWith("#", StringComparison.Ordinal) && !text2.StartsWith(";", StringComparison.Ordinal) && ulong.TryParse(text2, NumberStyles.None, CultureInfo.InvariantCulture, out var result))
{
_bypassIds.Add(result);
}
}
}
private bool IsBypassed(ulong steamId)
{
if (_bypassIds.Contains(steamId))
{
return true;
}
if (CE_BypassAdmins.Value)
{
try
{
if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsAdmin(steamId.ToString(CultureInfo.InvariantCulture)))
{
return true;
}
}
catch
{
}
}
return false;
}
private static string FirstToken(string trimmed)
{
int i;
for (i = 0; i < trimmed.Length && !char.IsWhiteSpace(trimmed[i]); i++)
{
}
return (i <= 0) ? string.Empty : trimmed.Substring(0, i);
}
private static string? TryGetSavedirFromCommandLine()
{
try
{
string[] commandLineArgs = Environment.GetCommandLineArgs();
for (int i = 0; i < commandLineArgs.Length; i++)
{
string text = commandLineArgs[i] ?? string.Empty;
if (string.Equals(text, "-savedir", StringComparison.OrdinalIgnoreCase))
{
if (i + 1 < commandLineArgs.Length)
{
string text2 = (commandLineArgs[i + 1] ?? string.Empty).Trim().Trim(new char[1] { '"' });
if (!string.IsNullOrWhiteSpace(text2))
{
return text2;
}
}
return null;
}
if (!text.StartsWith("-savedir", StringComparison.OrdinalIgnoreCase))
{
continue;
}
int num = text.IndexOf('=');
int num2 = text.IndexOf(':');
int num3 = -1;
if (num >= 0)
{
num3 = num;
}
else if (num2 >= 0)
{
num3 = num2;
}
if (num3 >= 0 && num3 + 1 < text.Length)
{
string text3 = text.Substring(num3 + 1).Trim().Trim(new char[1] { '"' });
if (!string.IsNullOrWhiteSpace(text3))
{
return text3;
}
}
}
}
catch
{
}
return null;
}
private static string GetVanillaListRootPath()
{
string text = TryGetSavedirFromCommandLine();
if (!string.IsNullOrWhiteSpace(text))
{
return text;
}
return Application.persistentDataPath;
}
[IteratorStateMachine(typeof(<RunScanOnceCoroutine>d__26))]
private IEnumerator RunScanOnceCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RunScanOnceCoroutine>d__26(0)
{
<>4__this = this
};
}
private static void AppendRemovedLog(string removedLogPath, ulong steamId, long lastSeen, long inactiveSeconds, string reason, ManualLogSource logger)
{
try
{
Directory.CreateDirectory(Path.GetDirectoryName(removedLogPath) ?? ".");
string text = DateTimeOffset.UtcNow.ToString("yyyy-MM-dd HH:mm:ss 'UTC'", CultureInfo.InvariantCulture);
string text2 = DateTimeOffset.FromUnixTimeSeconds(lastSeen).ToString("yyyy-MM-dd HH:mm:ss 'UTC'", CultureInfo.InvariantCulture);
string text3 = "[" + text + "] removed steamid=" + steamId.ToString(CultureInfo.InvariantCulture) + " reason=" + reason + " lastSeen=" + text2 + " inactiveSeconds=" + inactiveSeconds.ToString(CultureInfo.InvariantCulture);
File.AppendAllText(removedLogPath, text3 + Environment.NewLine, Encoding.UTF8);
}
catch
{
}
}
}
internal static class SeenStore
{
private static readonly object LockObj = new object();
private static readonly Dictionary<ulong, long> LastSeenUnixBySteamId = new Dictionary<ulong, long>();
private static bool _loaded;
internal static void Load(string path, ManualLogSource logger)
{
lock (LockObj)
{
if (_loaded)
{
return;
}
_loaded = true;
if (!File.Exists(path))
{
return;
}
try
{
string[] array = File.ReadAllLines(path, Encoding.UTF8);
foreach (string text in array)
{
string text2 = (text ?? string.Empty).Trim();
if (text2.Length == 0 || text2[0] != '"')
{
continue;
}
int num = text2.IndexOf('"', 1);
if (num <= 1)
{
continue;
}
string s = text2.Substring(1, num - 1);
int num2 = text2.IndexOf(':', num + 1);
if (num2 >= 0)
{
string s2 = text2.Substring(num2 + 1).Trim().TrimEnd(new char[1] { ',' });
if (ulong.TryParse(s, NumberStyles.None, CultureInfo.InvariantCulture, out var result) && long.TryParse(s2, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
{
LastSeenUnixBySteamId[result] = result2;
}
}
}
}
catch
{
}
}
}
internal static bool TryGetLastSeen(ulong steamId, out long lastSeen)
{
lock (LockObj)
{
return LastSeenUnixBySteamId.TryGetValue(steamId, out lastSeen);
}
}
internal static void SetLastSeen(ulong steamId, long unixSeconds)
{
lock (LockObj)
{
LastSeenUnixBySteamId[steamId] = unixSeconds;
}
}
internal static void MarkSeenNow(ulong steamId)
{
long unixSeconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
SetLastSeen(steamId, unixSeconds);
}
internal static bool Remove(ulong steamId)
{
lock (LockObj)
{
return LastSeenUnixBySteamId.Remove(steamId);
}
}
internal static int PruneTo(HashSet<ulong> keepSteamIds)
{
lock (LockObj)
{
if (LastSeenUnixBySteamId.Count == 0)
{
return 0;
}
int num = 0;
ulong[] array = LastSeenUnixBySteamId.Keys.ToArray();
foreach (ulong num2 in array)
{
if (!keepSteamIds.Contains(num2) && LastSeenUnixBySteamId.Remove(num2))
{
num++;
}
}
return num;
}
}
internal static void Save(string path, ManualLogSource logger)
{
lock (LockObj)
{
try
{
StringBuilder stringBuilder = new StringBuilder(4096);
stringBuilder.AppendLine("{");
foreach (KeyValuePair<ulong, long> item in LastSeenUnixBySteamId.OrderBy((KeyValuePair<ulong, long> k) => k.Key))
{
stringBuilder.Append(" \"");
stringBuilder.Append(item.Key.ToString(CultureInfo.InvariantCulture));
stringBuilder.Append("\": ");
stringBuilder.Append(item.Value.ToString(CultureInfo.InvariantCulture));
stringBuilder.AppendLine(",");
}
string text = stringBuilder.ToString();
if (LastSeenUnixBySteamId.Count > 0)
{
int num = text.LastIndexOf(",\n", StringComparison.Ordinal);
if (num >= 0)
{
text = text.Remove(num, 1);
}
}
text += "}\n";
FileIoRetry.AtomicWriteText(path, text);
}
catch
{
}
}
}
}
internal static class OnlineSnapshot
{
private static bool TryGetSteamIdString(ZNetPeer peer, out string steamIdStr)
{
steamIdStr = string.Empty;
try
{
if (peer == null)
{
return false;
}
ISocket socket = peer.m_socket;
if (socket == null)
{
return false;
}
string text = (socket.GetHostName() ?? string.Empty).Trim();
if (text.Length == 0)
{
return false;
}
int num = text.IndexOf(':');
if (num >= 0)
{
text = text.Substring(0, num).Trim();
}
if (text.Length == 0)
{
return false;
}
if (!ulong.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var _))
{
return false;
}
steamIdStr = text;
return true;
}
catch
{
return false;
}
}
internal static HashSet<string> GetOnlineSteamIdStrings()
{
HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
try
{
if ((Object)(object)ZNet.instance == (Object)null)
{
return hashSet;
}
List<ZNetPeer> peers = ZNet.instance.GetPeers();
for (int i = 0; i < peers.Count; i++)
{
ZNetPeer val = peers[i];
if (val != null && TryGetSteamIdString(val, out string steamIdStr))
{
hashSet.Add(steamIdStr);
}
}
}
catch
{
}
return hashSet;
}
}
internal static class FileIoRetry
{
internal const int MaxRetries = 3;
internal const float RetryDelaySeconds = 0.2f;
internal static void AtomicWriteText(string path, string content)
{
string path2 = Path.GetDirectoryName(path) ?? ".";
Directory.CreateDirectory(path2);
string text = path + ".tmp";
File.WriteAllText(text, content, Encoding.UTF8);
if (File.Exists(path))
{
try
{
string text2 = path + ".bak";
File.Replace(text, path, text2, ignoreMetadataErrors: true);
TryDelete(text2);
return;
}
catch
{
}
}
if (File.Exists(path))
{
File.Delete(path);
}
File.Move(text, path);
}
private static void TryDelete(string path)
{
try
{
if (File.Exists(path))
{
File.Delete(path);
}
}
catch
{
}
}
}
[HarmonyPatch]
internal static class PeerSeenPatches
{
[HarmonyPostfix]
[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
private static void ZNet_RPC_PeerInfo_Postfix(ZNet __instance, ZRpc rpc)
{
try
{
if ((Object)(object)__instance == (Object)null || !__instance.IsServer())
{
return;
}
List<ZNetPeer> peers = __instance.GetPeers();
for (int i = 0; i < peers.Count; i++)
{
ZNetPeer val = peers[i];
if (val == null || val.m_rpc != rpc)
{
continue;
}
ISocket socket = val.m_socket;
if (socket == null)
{
break;
}
string text = (socket.GetHostName() ?? string.Empty).Trim();
if (text.Length != 0)
{
int num = text.IndexOf(':');
if (num >= 0)
{
text = text.Substring(0, num).Trim();
}
if (ulong.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var result) && result != 0)
{
SeenStore.MarkSeenNow(result);
}
}
break;
}
}
catch
{
}
}
}
}
