public async Task <bool> BanAsync(IUser user, IUser bannedBy = null, string reason = null, TimeSpan?duration = null)
{
UserBanEvent @event = new UserBanEvent(user, bannedBy, reason, duration, true);
eventManager.Emit(host, @event);
if (@event.IsCancelled)
{
return(false);
}
var callerId = (bannedBy is UnturnedUser up) ? up.CSteamID : CSteamID.Nil;
//if (user.IsOnline)
//{
// SteamBlacklist.ban(player.CSteamID, 0, callerId, reason, (uint)(duration?.TotalSeconds ?? uint.MaxValue));
// return true;
//}
var steamId = new CSteamID(ulong.Parse(user.Id));
SteamBlacklist.ban(steamId, 0, callerId, reason, (uint)(duration?.TotalSeconds ?? uint.MaxValue));
var target = ((UnturnedUser)user).Player;
if (target.IsOnline)
{
Provider.kick(steamId, reason);
}
return(true);
}
public bool Ban(IUserInfo target, IUser bannedBy = null, string reason = null, TimeSpan?duration = null)
{
//todo: this is wrong
var player = ((UnturnedUser)target).Player;
PlayerBanEvent @event = new PlayerBanEvent(player.User, bannedBy, reason, duration, true);
eventManager.Emit(host, @event);
if (@event.IsCancelled)
{
return(false);
}
if (target is IUser u && u.IsOnline)
{
var uPlayer = ((UnturnedUser)target).Player;
Provider.ban(uPlayer.CSteamID, reason, (uint)(duration?.TotalSeconds ?? uint.MaxValue));
return(true);
}
var steamId = new CSteamID(ulong.Parse(target.Id));
var callerId = (bannedBy is UnturnedUser up) ? up.Player.CSteamID : CSteamID.Nil;
SteamBlacklist.ban(steamId, 0, callerId, reason, (uint)(duration?.TotalSeconds ?? uint.MaxValue));
return(true);
}
public static void checkBanStatus(SteamPlayerID playerID, uint remoteIP, out bool isBanned, out string banReason, out uint banRemainingDuration)
{
isBanned = false;
banReason = string.Empty;
banRemainingDuration = 0U;
if (SteamBlacklist.checkBanned(playerID.steamID, remoteIP, out SteamBlacklistID steamBlacklistID))
{
isBanned = true;
banReason = steamBlacklistID.reason;
banRemainingDuration = steamBlacklistID.getTime();
}
try
{
Provider.onCheckBanStatusWithHWID?.Invoke(playerID, remoteIP, ref isBanned, ref banReason, ref banRemainingDuration);
#pragma warning disable CS0612 // Type or member is obsolete
Provider.onCheckBanStatus?.Invoke(playerID.steamID, remoteIP, ref isBanned, ref banReason, ref banRemainingDuration);
#pragma warning restore CS0612 // Type or member is obsolete
}
catch (Exception e)
{
UnturnedLog.warn("Plugin raised an exception from onCheckBanStatus:");
UnturnedLog.exception(e);
}
}
private void OnPlayerDisconnected(UnturnedPlayer player)
{
int playerPoints;
bool playerExists = dicPoints.TryGetValue(player.CSteamID, out playerPoints);
if (playerExists)
{
dicPoints.Remove(player.CSteamID);
}
if (Instance.Configuration.Instance.LogIDonjoin)
{
CSteamID judge = (CSteamID)0;
if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Contains(player.CSteamID))
{
return;
}
if (FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Contains(player.CSteamID))
{
if (Instance.Database.IsBanned(player.CSteamID.ToString()))
{
return;
}
Instance.Database.BanPlayer(player.CharacterName, player.CSteamID.ToString(), "[TourneyCore]", "[TourneyCore Filter]", 2147483647);
SteamBlacklist.ban(player.CSteamID, GetIP(player.CSteamID), judge, Translate("Filter_Reason"), SteamBlacklist.PERMANENT);
}
}
else
{
return;
}
}
public void FixedUpdate()
{
//When player connects, run through iteration.
if (banPlayer)
{
//Keep trying to ban player once ping had reached threshold.
try
{
ping = playerData.Ping;
if (ping == 0)
{
ping = 1;
}
//Debug.
//Logger.Log("Player's ping: " + ping);
//Logger.Log("Time Now: " + startTime);
//Logger.Log("Total Seconds: " +(DateTime.Now - startTime).TotalSeconds);
//Logger.Log("Config Set Grace: " + JailTime.Instance.Configuration.Instance.GracePeriod);
//Logger.Log("Grace: " + (JailTime.Instance.Configuration.Instance.GracePeriod + (ping * 10)));
if ((DateTime.Now - startTime).TotalSeconds >= JailTime.Instance.Configuration.Instance.GracePeriod + (ping * 10))
{
//Debug
//Logger.Log("Attempt to ban " + playerData.SteamName);
//Temp ban.
if (JailTime.Instance.Configuration.Instance.BanOnReconnectTime > 0)
{
SteamBlacklist.ban(playerData.CSteamID, (CSteamID)0UL, JailTime.Instance.Translate("jailtime_ban_time"), JailTime.Instance.Configuration.Instance.BanOnReconnectTime);
SteamBlacklist.save();
//Debug
//Logger.Log("Banned player " + playerData.SteamName + " temporarily. Ban-On-Reconnect.");
}
//Perma ban.
else
{
SteamBlacklist.ban(playerData.CSteamID, (CSteamID)0L, JailTime.Instance.Translate("jailtime_ban"), 1000000000);
SteamBlacklist.save();
//Debug
//Logger.Log("Banned player " + playerData.SteamName + " permanently. Ban-On-Reconnect.");
}
banPlayer = false;
}
}
catch
{
//Nothing to catch, run on next interval
}
}
}
/// <summary>
/// Unbans the player
/// </summary>
public void Unban()
{
// Check if unbanned already
if (!IsBanned)
{
return;
}
// Set to unbanned
SteamBlacklist.unban(cSteamId);
}
/// <summary>
/// Unbans the user
/// </summary>
public void Unban()
{
// Check not banned
if (!IsBanned)
{
return;
}
// Set to unbanned
SteamBlacklist.unban(cSteamId);
}
/// <summary>
/// Unbans the player
/// </summary>
/// <param name="id"></param>
public void Unban(string id)
{
// Check if unbanned already
if (!IsBanned(id))
{
return;
}
// Set to unbanned
SteamBlacklist.unban(new CSteamID(ulong.Parse(id)));
}
public void BanPlayer(UnturnedPlayer player, string reason, int warnings, uint banDuration, IRocketPlayer caller)
{
CSteamID judge = (CSteamID)0;
if (!(caller is ConsolePlayer))
{
judge = ((UnturnedPlayer)caller).CSteamID;
}
SteamBlacklist.ban(player.CSteamID, GetIP(player.CSteamID), judge, WarningsPlugin.Instance.Translate("warning_ban_reason", warnings, reason, banDuration),
banDuration);
}
private void DeathBan(UnturnedPlayer player)
{
if (!player.HasPermission("banondeath.ignore"))
{
SteamBlacklist.ban(player.CSteamID, CSteamID.Nil, Configuration.Instance.BanReason, Configuration.Instance.BanLengthSeconds);
player.Ban(Configuration.Instance.BanReason, Configuration.Instance.BanLengthSeconds);
Logger.LogWarning($"{player.DisplayName} [{player.Id}] has been banned for {Configuration.Instance.BanLengthSeconds} seconds for dying!");
}
else
{
Logger.LogWarning("Ignoring Death...");
}
}
public async Task <bool> UnbanAsync(IUser target, IUser bannedBy = null)
{
UserUnbanEvent @event = new UserUnbanEvent(target, bannedBy);
eventManager.Emit(host, @event);
if (@event.IsCancelled)
{
return(false);
}
var steamId = new CSteamID(ulong.Parse(target.Id));
return(SteamBlacklist.unban(steamId));
}
public override void Execute(PointBlankPlayer executor, string[] args)
{
if (!UnturnedPlayer.TryGetPlayer(args[0], out UnturnedPlayer ply))
{
UnturnedChat.SendMessage(executor, Translations["Base_InvalidPlayer"], ConsoleColor.Red);
return;
}
SteamBlacklist.ban(ply.SteamID, ply.SteamIP, ((UnturnedPlayer)executor)?.SteamID ?? CSteamID.Nil, (args.Length > 1 ? args[1] : "Undefined"), SteamBlacklist.PERMANENT);
if (ply.SteamPlayer.player != null)
{
ply.Player.life.askDamage(255, Vector3.up * 101f, EDeathCause.KILL, ELimb.SKULL, ((UnturnedPlayer)executor)?.SteamID ?? CSteamID.Nil, out EPlayerKill ePlayerKill);
}
UnturnedChat.SendMessage(executor, string.Format(Translations["Slay_Slay"], ply.PlayerName), ConsoleColor.Red);
}
public override void Execute(PointBlankPlayer executor, string[] args)
{
if (!PlayerTool.tryGetSteamID(args[0], out CSteamID id))
{
UnturnedChat.SendMessage(executor, Translations["Base_InvalidPlayer"], ConsoleColor.Red);
return;
}
if (!SteamBlacklist.unban(id))
{
UnturnedChat.SendMessage(executor, string.Format(Translations["Unban_NotBanned"], id), ConsoleColor.Red);
return;
}
UnturnedChat.SendMessage(executor, string.Format(Translations["Unban_Unban"], id), ConsoleColor.Green);
}
public bool Unban(IUserInfo target, IUser bannedBy = null)
{
var player = ((UnturnedUser)target).Player;
PlayerUnbanEvent @event = new PlayerUnbanEvent(player.User, bannedBy);
eventManager.Emit(host, @event);
if (@event.IsCancelled)
{
return(false);
}
var steamId = new CSteamID(ulong.Parse(target.Id));
return(SteamBlacklist.unban(steamId));
}
public override void Execute(PointBlankPlayer executor, string[] args)
{
uint ip;
if (!PlayerTool.tryGetSteamID(args[0], out CSteamID player) || (executor != null && ((UnturnedPlayer)executor).SteamID == player))
{
UnturnedChat.SendMessage(executor, Translations["Base_InvalidPlayer"], ConsoleColor.Red);
return;
}
ip = SteamGameServerNetworking.GetP2PSessionState(player, out P2PSessionState_t p2PSessionState_t) ? p2PSessionState_t.m_nRemoteIP : 0u;
if (args.Length < 2 || uint.TryParse(args[1], out uint duration))
{
duration = SteamBlacklist.PERMANENT;
}
string reason = args.Length < 3 ? Translations["Ban_Reason"] : args[2];
SteamBlacklist.ban(player, ip, ((UnturnedPlayer)executor)?.SteamID ?? CSteamID.Nil, reason, duration);
UnturnedChat.SendMessage(executor, string.Format(Translations["Ban_Success"], player), ConsoleColor.Green);
}
public void Execute(IRocketPlayer caller, params string[] command)
{
if (command.Length != 1)
{
UnturnedChat.Say(caller, GlobalBan.Instance.Translate("command_generic_invalid_parameter"));
return;
}
fr34kyn01535.GlobalBan.DatabaseManager.UnbanResult name = GlobalBan.Instance.Database.UnbanPlayer(command[0]);
if (!SteamBlacklist.unban(new CSteamID(name.Id)) && String.IsNullOrEmpty(name.Name))
{
UnturnedChat.Say(caller, GlobalBan.Instance.Translate("command_generic_player_not_found"));
return;
}
else
{
UnturnedChat.Say("The player " + name.Name + " was unbanned");
}
}
public static void IShit(CSteamID steamID, byte[] packet, int offset, int size, int channel)
{
Provider._bytesReceived += (uint)size;
Provider._packetsReceived++;
if (Dedicator.isDedicated)
{
ESteamPacket packet2 = (ESteamPacket)packet[offset];
if (Provider.isUpdate(packet2))
{
if (steamID == Provider.server)
{
for (int i = 0; i < Provider.receivers.Count; i++)
{
if (Provider.receivers[i].id == channel)
{
Provider.receivers[i].receive(steamID, packet, offset, size);
return;
}
}
}
else
{
for (int j = 0; j < Provider.clients.Count; j++)
{
if (Provider.clients[j].playerID.steamID == steamID)
{
for (int k = 0; k < Provider.receivers.Count; k++)
{
if (Provider.receivers[k].id == channel)
{
Provider.receivers[k].receive(steamID, packet, offset, size);
return;
}
}
return;
}
}
}
}
else
{
SteamPending pending;
switch (packet2)
{
case ESteamPacket.WORKSHOP:
{
ulong num8;
List <ulong> list = new List <ulong>();
string[] strArray = ReadWrite.getFolders("/Bundles/Workshop/Content");
for (int m = 0; m < strArray.Length; m++)
{
ulong num5;
if (ulong.TryParse(ReadWrite.folderName(strArray[m]), out num5))
{
list.Add(num5);
}
}
string[] strArray2 = ReadWrite.getFolders(ServerSavedata.directory + "/" + Provider.serverID + "/Workshop/Content");
for (int n = 0; n < strArray2.Length; n++)
{
ulong num7;
if (ulong.TryParse(ReadWrite.folderName(strArray2[n]), out num7))
{
list.Add(num7);
}
}
if (ulong.TryParse(new DirectoryInfo(Level.info.path).Parent.Name, out num8))
{
list.Add(num8);
}
byte[] array = new byte[2 + (list.Count * 8)];
array[0] = 1;
array[1] = (byte)list.Count;
for (byte num9 = 0; num9 < list.Count; num9 = (byte)(num9 + 1))
{
BitConverter.GetBytes(list[num9]).CopyTo(array, (int)(2 + (num9 * 8)));
}
Provider.send(steamID, ESteamPacket.WORKSHOP, array, array.Length, 0);
return;
}
case ESteamPacket.TICK:
{
int num10;
object[] objects = new object[] { (byte)14, Provider.net };
byte[] buffer2 = SteamPacker.getBytes(0, out num10, objects);
Provider.send(steamID, ESteamPacket.TIME, buffer2, num10, 0);
return;
}
case ESteamPacket.TIME:
for (int num11 = 0; num11 < Provider.clients.Count; num11++)
{
if (Provider.clients[num11].playerID.steamID == steamID)
{
if (Provider.clients[num11].lastPing > 0f)
{
Provider.clients[num11].lastNet = Time.realtimeSinceStartup;
Provider.clients[num11].lag(Time.realtimeSinceStartup - Provider.clients[num11].lastPing);
Provider.clients[num11].lastPing = -1f;
}
return;
}
}
return;
case ESteamPacket.CONNECT:
{
long num14;
double num15;
long num16;
double num17;
SteamBlacklistID tid;
for (int num12 = 0; num12 < Provider.pending.Count; num12++)
{
if (Provider.pending[num12].playerID.steamID == steamID)
{
Provider.Reject(steamID, ESteamRejection.ALREADY_PENDING);
return;
}
}
for (int num13 = 0; num13 < Provider.clients.Count; num13++)
{
if (Provider.clients[num13].playerID.steamID == steamID)
{
Provider.Reject(steamID, ESteamRejection.ALREADY_CONNECTED);
return;
}
}
Type[] types = new Type[] {
Types.BYTE_TYPE, Types.BYTE_TYPE, Types.STRING_TYPE, Types.STRING_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_TYPE, Types.STRING_TYPE, Types.BOOLEAN_TYPE, Types.SINGLE_TYPE, Types.STRING_TYPE, Types.STEAM_ID_TYPE, Types.BYTE_TYPE, Types.BYTE_TYPE, Types.BYTE_TYPE,
Types.COLOR_TYPE, Types.COLOR_TYPE, Types.BOOLEAN_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_ARRAY_TYPE, Types.BYTE_TYPE
};
object[] objArray = SteamPacker.getObjects(steamID, offset, 0, packet, types);
SteamPlayerID newPlayerID = new SteamPlayerID(steamID, (byte)objArray[1], (string)objArray[2], (string)objArray[3], (string)objArray[11], (CSteamID)objArray[12]);
if (((string)objArray[8]) != Provider.Version)
{
Provider.Reject(steamID, ESteamRejection.WRONG_VERSION);
return;
}
if (newPlayerID.SteamName.Length < 2)
{
Provider.Reject(steamID, ESteamRejection.NAME_PLAYER_SHORT);
return;
}
if (newPlayerID.CharacterName.Length < 2)
{
Provider.Reject(steamID, ESteamRejection.NAME_CHARACTER_SHORT);
return;
}
if (newPlayerID.SteamName.Length > 0x20)
{
Provider.Reject(steamID, ESteamRejection.NAME_PLAYER_LONG);
return;
}
if (newPlayerID.CharacterName.Length > 0x20)
{
Provider.Reject(steamID, ESteamRejection.NAME_CHARACTER_LONG);
return;
}
if (long.TryParse(newPlayerID.SteamName, out num14) || double.TryParse(newPlayerID.SteamName, out num15))
{
Provider.Reject(steamID, ESteamRejection.NAME_PLAYER_NUMBER);
return;
}
if (long.TryParse(newPlayerID.CharacterName, out num16) || double.TryParse(newPlayerID.CharacterName, out num17))
{
Provider.Reject(steamID, ESteamRejection.NAME_CHARACTER_NUMBER);
return;
}
if (Provider.filterName)
{
if (!NameTool.isValid(newPlayerID.SteamName))
{
Provider.Reject(steamID, ESteamRejection.NAME_PLAYER_INVALID);
return;
}
if (!NameTool.isValid(newPlayerID.CharacterName))
{
Provider.Reject(steamID, ESteamRejection.NAME_CHARACTER_INVALID);
return;
}
}
if (SteamBlacklist.checkBanned(steamID, out tid))
{
int num18;
object[] objArray2 = new object[] { (byte)9, tid.reason, tid.getTime() };
byte[] buffer3 = SteamPacker.getBytes(0, out num18, objArray2);
Provider.send(steamID, ESteamPacket.BANNED, buffer3, num18, 0);
return;
}
if (!SteamWhitelist.checkWhitelisted(steamID))
{
Provider.Reject(steamID, ESteamRejection.WHITELISTED);
return;
}
if ((Provider.clients.Count + 1) > Provider.maxPlayers)
{
Provider.Reject(steamID, ESteamRejection.SERVER_FULL);
return;
}
byte[] buffer4 = (byte[])objArray[4];
if (buffer4.Length != 20)
{
Provider.Reject(steamID, ESteamRejection.WRONG_HASH);
return;
}
byte[] buffer5 = (byte[])objArray[5];
if (buffer5.Length != 20)
{
Provider.Reject(steamID, ESteamRejection.WRONG_HASH);
return;
}
byte[] h = (byte[])objArray[6];
if (h.Length != 20)
{
Provider.Reject(steamID, ESteamRejection.WRONG_HASH);
return;
}
if ((Provider.serverPassword == string.Empty) || Hash.verifyHash(buffer4, Provider._serverPasswordHash))
{
if (Hash.verifyHash(buffer5, Level.hash))
{
if (ReadWrite.appIn(h, (byte)objArray[7]))
{
if (((float)objArray[10]) < Provider.timeout)
{
Provider.pending.Add(new SteamPending(newPlayerID, (bool)objArray[9], (byte)objArray[13], (byte)objArray[14], (byte)objArray[15], (Color)objArray[0x10], (Color)objArray[0x11], (bool)objArray[0x12], (ulong)objArray[0x13], (ulong)objArray[20], (ulong)objArray[0x15], (ulong)objArray[0x16], (ulong)objArray[0x17], (ulong)objArray[0x18], (ulong)objArray[0x19], (ulong[])objArray[0x1a], (EPlayerSpeciality)((byte)objArray[0x1b])));
byte[] buffer1 = new byte[] { 3 };
Provider.send(steamID, ESteamPacket.VERIFY, buffer1, 1, 0);
return;
}
Provider.Reject(steamID, ESteamRejection.PING);
return;
}
Provider.Reject(steamID, ESteamRejection.WRONG_HASH);
return;
}
Provider.Reject(steamID, ESteamRejection.WRONG_HASH);
return;
}
Provider.Reject(steamID, ESteamRejection.WRONG_PASSWORD);
return;
}
default:
if (packet2 != ESteamPacket.AUTHENTICATE)
{
Debug.LogError("Failed to handle message: " + packet2);
return;
}
pending = null;
for (int num19 = 0; num19 < Provider.pending.Count; num19++)
{
if (Provider.pending[num19].playerID.steamID == steamID)
{
pending = Provider.pending[num19];
break;
}
}
break;
}
if (pending == null)
{
Provider.Reject(steamID, ESteamRejection.NOT_PENDING);
}
else if ((Provider.clients.Count + 1) > Provider.maxPlayers)
{
Provider.Reject(steamID, ESteamRejection.SERVER_FULL);
}
else
{
ushort count = BitConverter.ToUInt16(packet, 1);
byte[] dst = new byte[count];
Buffer.BlockCopy(packet, 3, dst, 0, count);
ushort num21 = BitConverter.ToUInt16(packet, 3 + count);
byte[] buffer8 = new byte[num21];
Buffer.BlockCopy(packet, 5 + count, buffer8, 0, num21);
if (!Provider.verifyTicket(steamID, dst))
{
Provider.Reject(steamID, ESteamRejection.AUTH_VERIFICATION);
}
else if (num21 > 0)
{
if (!SteamGameServerInventory.DeserializeResult(out pending.inventoryResult, buffer8, num21, false))
{
Provider.Reject(steamID, ESteamRejection.AUTH_ECON);
}
}
else
{
pending.shirtItem = 0;
pending.pantsItem = 0;
pending.hatItem = 0;
pending.backpackItem = 0;
pending.vestItem = 0;
pending.maskItem = 0;
pending.glassesItem = 0;
pending.skinItems = new int[0];
pending.packageShirt = 0L;
pending.packagePants = 0L;
pending.packageHat = 0L;
pending.packageBackpack = 0L;
pending.packageVest = 0L;
pending.packageMask = 0L;
pending.packageGlasses = 0L;
pending.packageSkins = new ulong[0];
pending.inventoryResult = SteamInventoryResult_t.Invalid;
pending.inventoryDetails = new SteamItemDetails_t[0];
pending.hasProof = true;
}
}
}
}
}
public static bool Prefix(CSteamID steamID, byte[] packet, int offset, int size, int channel)
{
if (!Dedicator.isDedicated)
{
return(true);
}
byte index1 = packet[offset];
if (!(index1 < (byte)26))
{
UnityEngine.Debug.LogWarning((object)("Received invalid packet index from " + (object)steamID + ", so we're refusing them"));
SDG.Unturned.Provider.refuseGarbageConnection(steamID, "sv invalid packet index");
}
else
{
ESteamPacket packet1 = (ESteamPacket)index1;
if (packet1 == ESteamPacket.AUTHENTICATE || packet1 == ESteamPacket.CONNECT)
{
Console.WriteLine(packet1);
}
if (packet1 == ESteamPacket.CONNECT)
{
RocketPlayer player = new RocketPlayer(steamID.ToString());
bool result = player.HasPermission("QueueBypasser.Skip");
Console.WriteLine(result);
if (!result)
{
return(true); //We don't need to do jack shit because he doesn't have the right permission.
}
for (int index2 = 0; index2 < SDG.Unturned.Provider.pending.Count; ++index2)
{
if (SDG.Unturned.Provider.pending[index2].playerID.steamID == steamID)
{
Console.WriteLine("line 1");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.ALREADY_PENDING);
return(true);
}
}
for (int index2 = 0; index2 < SDG.Unturned.Provider.clients.Count; ++index2)
{
if (SDG.Unturned.Provider.clients[index2].playerID.steamID == steamID)
{
Console.WriteLine("line 2");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.ALREADY_CONNECTED);
return(true);
}
}
object[] objects = SteamPacker.getObjects(steamID, offset, 0, packet, Types.BYTE_TYPE, Types.BYTE_TYPE, Types.STRING_TYPE, Types.STRING_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_TYPE, Types.UINT32_TYPE, Types.BOOLEAN_TYPE, Types.SINGLE_TYPE, Types.STRING_TYPE, Types.STEAM_ID_TYPE, Types.BYTE_TYPE, Types.BYTE_TYPE, Types.BYTE_TYPE, Types.COLOR_TYPE, Types.COLOR_TYPE, Types.COLOR_TYPE, Types.BOOLEAN_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_ARRAY_TYPE, Types.BYTE_TYPE, Types.STRING_TYPE, Types.STRING_TYPE, Types.STEAM_ID_TYPE, Types.UINT32_TYPE);
SteamPlayerID newPlayerID = new SteamPlayerID(steamID, (byte)objects[1], (string)objects[2], (string)objects[3], (string)objects[11], (CSteamID)objects[12]);
if (objects[8].ToString() != SDG.Unturned.Provider.APP_VERSION && (int)(uint)objects[8] != Parser.getUInt32FromIP(SDG.Unturned.Provider.APP_VERSION))
{
Console.WriteLine("line 3");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_VERSION);
return(true);
}
if (newPlayerID.playerName.Length < 2)
{
Console.WriteLine("line 4");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_SHORT);
return(true);
}
if (newPlayerID.characterName.Length < 2)
{
Console.WriteLine("line 5");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_SHORT);
return(true);
}
if (newPlayerID.playerName.Length > 32)
{
Console.WriteLine("line 6");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_LONG);
return(true);
}
if (newPlayerID.characterName.Length > 32)
{
Console.WriteLine("line 7");
//Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_LONG);
return(true);
}
long result1;
double result2;
if (long.TryParse(newPlayerID.playerName, out result1) || double.TryParse(newPlayerID.playerName, out result2))
{
Console.WriteLine("line 8");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_NUMBER);
return(true);
}
long result3;
double result4;
if (long.TryParse(newPlayerID.characterName, out result3) || double.TryParse(newPlayerID.characterName, out result4))
{
Console.WriteLine("line 9");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_NUMBER);
return(true);
}
if (SDG.Unturned.Provider.filterName)
{
if (!NameTool.isValid(newPlayerID.playerName))
{
Console.WriteLine("line 10");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_INVALID);
return(true);
}
if (!NameTool.isValid(newPlayerID.characterName))
{
Console.WriteLine("line 11");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_INVALID);
return(true);
}
}
if (NameTool.containsRichText(newPlayerID.playerName))
{
Console.WriteLine("line 12");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_INVALID);
return(true);
}
if (NameTool.containsRichText(newPlayerID.characterName))
{
Console.WriteLine("line 13");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_INVALID);
return(true);
}
P2PSessionState_t pConnectionState;
uint ip = !SteamGameServerNetworking.GetP2PSessionState(steamID, out pConnectionState) ? 0U : pConnectionState.m_nRemoteIP;
SteamBlacklistID blacklistID;
if (SteamBlacklist.checkBanned(steamID, ip, out blacklistID))
{
//int size1;
//byte[] bytes = SteamPacker.getBytes(0, out size1, (object)(byte)9, (object)blacklistID.reason, (object)blacklistID.getTime());
//SDG.Unturned.Provider.send(steamID, ESteamPacket.BANNED, bytes, size1, 0);
Console.WriteLine("line 15");
return(true);
}
bool flag3 = SteamWhitelist.checkWhitelisted(steamID);
if (SDG.Unturned.Provider.isWhitelisted && !flag3)
{
Console.WriteLine("line 16");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WHITELISTED);
return(true);
}
byte[] hash_0_1 = (byte[])objects[4];
if (hash_0_1.Length != 20)
{
Console.WriteLine("line 17");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_PASSWORD);
return(true);
}
byte[] hash_0_2 = (byte[])objects[5];
if (hash_0_2.Length != 20)
{
Console.WriteLine("line 18");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_LEVEL);
return(true);
}
byte[] h = (byte[])objects[6];
if (h.Length != 20)
{
Console.WriteLine("line 19");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_ASSEMBLY);
return(true);
}
string str1 = (string)objects[29];
ModuleDependency[] moduleDependencyArray;
if (string.IsNullOrEmpty(str1))
{
moduleDependencyArray = new ModuleDependency[0];
}
else
{
string[] strArray1 = str1.Split(';');
moduleDependencyArray = new ModuleDependency[strArray1.Length];
for (int index2 = 0; index2 < moduleDependencyArray.Length; ++index2)
{
string[] strArray2 = strArray1[index2].Split(',');
if (strArray2.Length == 2)
{
moduleDependencyArray[index2] = new ModuleDependency();
moduleDependencyArray[index2].Name = strArray2[0];
uint.TryParse(strArray2[1], out moduleDependencyArray[index2].Version_Internal);
}
}
}
critMods.Clear();
ModuleHook.getRequiredModules(critMods);
bool flag4 = true;
for (int index2 = 0; index2 < moduleDependencyArray.Length; ++index2)
{
bool flag2 = false;
if (moduleDependencyArray[index2] != null)
{
for (int index3 = 0; index3 < critMods.Count; ++index3)
{
if (critMods[index3] != null && critMods[index3].config != null && (critMods[index3].config.Name == moduleDependencyArray[index2].Name && critMods[index3].config.Version_Internal >= moduleDependencyArray[index2].Version_Internal))
{
flag2 = true;
return(true);
}
}
}
if (!flag2)
{
flag4 = false;
return(true);
}
}
if (!flag4)
{
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.CLIENT_MODULE_DESYNC);
Console.WriteLine("line 20");
return(true);
}
bool flag5 = true;
for (int index2 = 0; index2 < critMods.Count; ++index2)
{
bool flag2 = false;
if (critMods[index2] != null && critMods[index2].config != null)
{
for (int index3 = 0; index3 < moduleDependencyArray.Length; ++index3)
{
if (moduleDependencyArray[index3] != null && moduleDependencyArray[index3].Name == critMods[index2].config.Name && moduleDependencyArray[index3].Version_Internal >= critMods[index2].config.Version_Internal)
{
flag2 = true;
return(true);
}
}
}
if (!flag2)
{
flag5 = false;
return(true);
}
}
if (!flag5)
{
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.SERVER_MODULE_DESYNC);
Console.WriteLine("line 21");
return(true);
}
Console.WriteLine("section 1");
if (SDG.Unturned.Provider.serverPassword == string.Empty || Hash.verifyHash(hash_0_1, _serverPasswordHash))
{
Console.WriteLine("section 2");
if (Hash.verifyHash(hash_0_2, Level.hash))
{
Console.WriteLine("section 3");
if (ReadWrite.appIn(h, (byte)objects[7]))
{
Console.WriteLine("section 4");
if ((double)(float)objects[10] < (double)SDG.Unturned.Provider.configData.Server.Max_Ping_Milliseconds / 1000.0)
{
Console.WriteLine("section 5");
//var pending = new SteamPending(newPlayerID, (bool)objects[9], (byte)objects[13], (byte)objects[14], (byte)objects[15], (Color)objects[16], (Color)objects[17], (Color)objects[18], (bool)objects[19], (ulong)objects[20], (ulong)objects[21], (ulong)objects[22], (ulong)objects[23], (ulong)objects[24], (ulong)objects[25], (ulong)objects[26], (ulong[])objects[27], (EPlayerSkillset)(byte)objects[28], (string)objects[30], (CSteamID)objects[31]);
//Provider.pending.Insert(0, pending);
//pending.sendVerifyPacket();
//Console.WriteLine($"Accepting {pending.playerID.steamID}.");
return(false);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.PING);
Console.WriteLine("line 22");
return(true);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_ASSEMBLY);
Console.WriteLine("line 23");
return(true);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_LEVEL);
Console.WriteLine("line 24");
return(true);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_PASSWORD);
Console.WriteLine("line 25");
return(true);
}
}
return(true);
}
public void Execute(IRocketPlayer caller, params string[] param)
{
CSteamID judge = (CSteamID)0;
if (!(caller is ConsolePlayer))
{
judge = ((UnturnedPlayer)caller).CSteamID;
}
if (param.Length == 0)
{
if (Init.Instance.Configuration.Instance.LogIDonjoin)
{
Init.Instance.Configuration.Save();
UnturnedChat.Say(caller, "Players already logged when they joined");
return;
}
else
{
//if logindonjoin false
if (Provider.clients.Count == 0)
{
UnturnedChat.Say(caller, "No one available");
return;
}
else
{
List <CSteamID> ids = Provider.clients.Select(x => x.playerID.steamID).ToList();
if (!ids.Any())
{
return;
}
foreach (var player in ids)
{
FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted = ids.Except(FilterData.FilterData.Instance.Configuration.Instance.Whitelists).ToList();
FilterData.FilterData.Instance.Configuration.Save();
foreach (var playerid in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted)
{
UnturnedChat.Say(caller, playerid.ToString());
}
UnturnedChat.Say(caller, "IDs saved locally");
}
}
}
return;
}
if (param.Length > 0)
{
if (param.Length == 1)
{
switch (param[0])
{
case "debug":
if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
{
UnturnedChat.Say(caller, "Tban list is empty");
return;
}
foreach (var player in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted)
{
UnturnedChat.Say(caller, player.ToString());
}
break;
case "unban":
if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
{
UnturnedChat.Say(caller, "Tban list is empty");
return;
}
foreach (var player in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.ToList())
{
Init.Instance.Database.UnbanPlayer(player.ToString());
SteamBlacklist.unban(player);
//CommandWindow.input.onInputText("unban " + player.ToString());
UnturnedChat.Say(caller, "Unbanned " + player + " and relieved from Globalban");
}
break;
case "ban":
if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
{
UnturnedChat.Say(caller, "Tban list is empty");
return;
}
else
{
foreach (var player in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted)
{
/*ulong? otherPlayerID = player.GetCSteamID;
* UnturnedPlayer playern = UnturnedPlayer.FromCSteamID(player);*/
Init.Instance.Database.BanPlayer("Tourneybanned", player.ToString(), "Tourneyban", "[TourneyCore Filter]", 2147483647);
Provider.kick(player, Init.Instance.Translate("Filter_Reason"));
SteamBlacklist.ban(player, Init.Instance.GetIP(player), judge, Init.Instance.Translate("Filter_Reason"), 2147483647);
UnturnedChat.Say("Kicked " + player);
//UnturnedChat.Say(caller, "" + player + " Tourneyban");
}
}
//EArenaState.SPAWN.
break;
case "enable":
if (Init.Instance.Configuration.Instance.LogIDonjoin == true)
{
UnturnedChat.Say(caller, "Logging on join is already enabled");
return;
}
UnturnedChat.Say(caller, "Enabling logging on join");
Init.Instance.Configuration.Instance.LogIDonjoin = true;
Init.Instance.Configuration.Save();
break;
case "disable":
if (Init.Instance.Configuration.Instance.LogIDonjoin == false)
{
UnturnedChat.Say(caller, "Logging on join is already disabled");
return;
}
UnturnedChat.Say(caller, "Disabling logging on join");
Init.Instance.Configuration.Instance.LogIDonjoin = false;
Init.Instance.Configuration.Save();
break;
case "clear":
if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
{
UnturnedChat.Say(caller, "List already empty");
return;
}
FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Clear();
FilterData.FilterData.Instance.Configuration.Save();
UnturnedChat.Say(caller, "Successfully cleared Tban list");
break;
}
}
else
{
UnturnedChat.Say(caller, "Wrong syntax!");
}
}
if (param.Length != 1 && param.Length != 0)
{
UnturnedChat.Say(caller, "Wrong syntax");
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
if (caller.DisplayName != "Console")
{
UnturnedPlayer pCaller = (UnturnedPlayer)caller;
if (command.Count() == 3)
{
string playerName = command[0];
string reason = command[1];
uint duration = (uint)Convert.ToInt32(command[2]);
//Find player
foreach (SteamPlayer plr in Provider.Players)
{
//So let's convert each SteamPlayer into an UnturnedPlayer
UnturnedPlayer unturnedPlayer = UnturnedPlayer.FromSteamPlayer(plr);
if (unturnedPlayer.DisplayName.ToLower().IndexOf(playerName.ToLower()) != -1 || unturnedPlayer.CharacterName.ToLower().IndexOf(playerName.ToLower()) != -1 || unturnedPlayer.SteamName.ToLower().IndexOf(playerName.ToLower()) != -1 || unturnedPlayer.CSteamID.ToString().Equals(playerName))
{
if (CommandModerator.isMod(pCaller))
{
if (duration > DatasEssentialsManager.Instance.Configuration.Instance.maxBanLength)
{
UnturnedChat.Say(caller, "Can't ban longer than " + DatasEssentialsManager.Instance.Configuration.Instance.maxBanLength + " seconds as a moderator.");
return;
}
DateTime time = DateTime.Now;
DatasEssentialsManager.Instance.Configuration.Instance.modKickBanList.Add("[" + time.ToString("M/d/yyyy h:mm:ss tt") + "] Banned " + unturnedPlayer.CharacterName + "(" + unturnedPlayer.CSteamID.ToString() + ") for " + duration + " seconds because " + reason + " by " + pCaller.CharacterName + ".");
}
SteamBlacklist.ban(unturnedPlayer.CSteamID, pCaller.CSteamID, reason, duration);
// Provider.ban(unturnedPlayer.CSteamID, reason, duration);
UnturnedChat.Say(unturnedPlayer.DisplayName + " has been banned for " + reason + " for " + duration + " seconds.", Color.cyan);
return;
}
}
UnturnedChat.Say(caller, "Did not find anyone with the name \"" + playerName + "\".", Color.red);
}
else
{
UnturnedChat.Say(caller, "Used that wrong, syntax is /ban (player) (reason) (duration seconds)", Color.red);
}
}
else
{
if (command.Count() == 3)
{
string playerName = command[0];
string reason = command[1];
uint duration = (uint)Convert.ToInt32(command[2]);
//Find player
foreach (SteamPlayer plr in Provider.Players)
{
//So let's convert each SteamPlayer into an UnturnedPlayer
UnturnedPlayer unturnedPlayer = UnturnedPlayer.FromSteamPlayer(plr);
if (unturnedPlayer.DisplayName.ToLower().IndexOf(playerName.ToLower()) != -1 || unturnedPlayer.CharacterName.ToLower().IndexOf(playerName.ToLower()) != -1 || unturnedPlayer.SteamName.ToLower().IndexOf(playerName.ToLower()) != -1 || unturnedPlayer.CSteamID.ToString().Equals(playerName))
{
CSteamID consoleID = new CSteamID(Convert.ToUInt64(0));
SteamBlacklist.ban(unturnedPlayer.CSteamID, consoleID, reason, duration);
// Provider.ban(unturnedPlayer.CSteamID, reason, duration);
UnturnedChat.Say(unturnedPlayer.DisplayName + " has been banned for " + reason + " for " + duration + " seconds.", Color.cyan);
Logger.Log(unturnedPlayer.DisplayName + " (" + unturnedPlayer.CSteamID + ") has been banned for " + reason + " for " + duration + " seconds.");
return;
}
}
UnturnedChat.Say(caller, "Did not find anyone with the name \"" + playerName + "\".", Color.red);
}
else
{
UnturnedChat.Say(caller, "Used that wrong, syntax is /ban (player) (reason) (duration seconds)", Color.red);
}
}
}
/// <summary>
/// Gets if the player is banned
/// </summary>
/// <param name="id"></param>
public bool IsBanned(string id)
{
SteamBlacklistID steamBlacklistId;
return(SteamBlacklist.checkBanned(new CSteamID(ulong.Parse(id)), 0, out steamBlacklistId)); // TODO: Might need actual player IP
}
