private static void HandleConnection(ConnectionRequest request)
{
NetDataWriter rejectData = new NetDataWriter();
try
{
byte result1;
byte result2;
if (!request.Data.TryGetByte(out result1) || !request.Data.TryGetByte(out result2) || result1 != CustomNetworkManager.Major || result2 != CustomNetworkManager.Minor)
{
rejectData.Reset();
rejectData.Put(3);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimit.Contains(request.RemoteEndPoint.Address.ToString()))
{
ServerConsole.AddLog(string.Format("Incoming connection from endpoint {0} rejected due to exceeding the rate limit.", request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Incoming connection from endpoint {0} rejected due to exceeding the rate limit.", request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.IpRateLimit.Add(request.RemoteEndPoint.Address.ToString());
}
if (!CharacterClassManager.OnlineMode)
{
KeyValuePair <BanDetails, BanDetails> keyValuePair = BanHandler.QueryBan(null, request.RemoteEndPoint.Address.ToString());
if (keyValuePair.Value != null)
{
ServerConsole.AddLog(string.Format("Player tried to connect from banned endpoint {0}.", request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(6);
rejectData.Put(keyValuePair.Value.Expires);
rejectData.Put(keyValuePair.Value?.Reason ?? string.Empty);
request.Reject(rejectData);
}
else
{
request.Accept();
}
}
else
{
string result3;
if (!request.Data.TryGetString(out result3) || result3 == string.Empty)
{
rejectData.Reset();
rejectData.Put(5);
request.Reject(rejectData);
}
else
{
ulong result4;
byte result5;
string result6;
byte[] result7;
if (!request.Data.TryGetULong(out result4) || !request.Data.TryGetByte(out result5) || !request.Data.TryGetString(out result6) || !request.Data.TryGetBytesWithLength(out result7))
{
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
else
{
CentralAuthPreauthFlags flags = (CentralAuthPreauthFlags)result5;
try
{
if (!ECDSA.VerifyBytes(string.Format("{0};{1};{2};{3}", result3, result5, result6, result4), result7, ServerConsole.PublicKey))
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} sent preauthentication token with invalid digital signature.", request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
else if (TimeBehaviour.CurrentUnixTimestamp > result4)
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} sent expired preauthentication token.", request.RemoteEndPoint));
ServerConsole.AddLog("Make sure that time and timezone set on server is correct. We recommend synchronizing the time.");
rejectData.Reset();
rejectData.Put(11);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimit.Contains(result3))
{
ServerConsole.AddLog(string.Format("Incoming connection from {0} ({1}) rejected due to exceeding the rate limit.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Incoming connection from endpoint {0} ({1}) rejected due to exceeding the rate limit.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.UserRateLimit.Add(result3);
}
if (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreBans) || !ServerStatic.GetPermissionsHandler().IsVerified)
{
KeyValuePair <BanDetails, BanDetails> keyValuePair = BanHandler.QueryBan(result3, request.RemoteEndPoint.Address.ToString());
if (keyValuePair.Key != null || keyValuePair.Value != null)
{
ServerConsole.AddLog(string.Format("{0} {1} tried to connect from {2} endpoint {3}.", keyValuePair.Key == null ? "Player" : "Banned player", result3, keyValuePair.Value == null ? "" : "banned ", request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("{0} {1} tried to connect from {2} endpoint {3}.", keyValuePair.Key == null ? "Player" : "Banned player", result3, keyValuePair.Value == null ? "" : "banned ", request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
rejectData.Reset();
rejectData.Put(6);
NetDataWriter netDataWriter1 = rejectData;
BanDetails key = keyValuePair.Key;
netDataWriter1.Put(key != null ? key.Expires : keyValuePair.Value.Expires);
NetDataWriter netDataWriter2 = rejectData;
string str;
if ((str = keyValuePair.Key?.Reason) == null)
{
str = keyValuePair.Value?.Reason ?? string.Empty;
}
netDataWriter2.Put(str);
request.Reject(rejectData);
return;
}
}
if (flags.HasFlagFast(CentralAuthPreauthFlags.GloballyBanned) && !ServerStatic.GetPermissionsHandler().IsVerified)
{
bool useGlobalBans = CustomLiteNetLib4MirrorTransport.UseGlobalBans;
}
if ((!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreWhitelist) || !ServerStatic.GetPermissionsHandler().IsVerified) && !WhiteList.IsWhitelisted(result3))
{
ServerConsole.AddLog(string.Format("Player {0} tried joined from endpoint {1}, but is not whitelisted.", result3, request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(7);
request.Reject(rejectData);
}
else if (CustomLiteNetLib4MirrorTransport.Geoblocking != GeoblockingMode.None && (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreGeoblock) || !ServerStatic.GetPermissionsHandler().BanTeamBypassGeo) && (!CustomLiteNetLib4MirrorTransport.GeoblockIgnoreWhitelisted || !WhiteList.IsOnWhitelist(result3)) && (CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Whitelist && !CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper()) || CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Blacklist && CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper())))
{
ServerConsole.AddLog(string.Format("Player {0} ({1}) tried joined from blocked country {2}.", result3, request.RemoteEndPoint, result6.ToUpper()));
rejectData.Reset();
rejectData.Put(9);
request.Reject(rejectData);
}
else
{
int num = CustomNetworkManager.slots;
if (flags.HasFlagFast(CentralAuthPreauthFlags.ReservedSlot) && ServerStatic.GetPermissionsHandler().BanTeamSlots)
{
num = LiteNetLib4MirrorNetworkManager.singleton.maxConnections;
}
else if (ConfigFile.ServerConfig.GetBool("use_reserved_slots", true) && ReservedSlot.HasReservedSlot(result3))
{
num += CustomNetworkManager.reservedSlots;
}
if (LiteNetLib4MirrorCore.Host.PeersCount < num)
{
if (CustomLiteNetLib4MirrorTransport.UserIds.ContainsKey(request.RemoteEndPoint))
{
CustomLiteNetLib4MirrorTransport.UserIds[request.RemoteEndPoint].SetUserId(result3);
}
else
{
CustomLiteNetLib4MirrorTransport.UserIds.Add(request.RemoteEndPoint, new PreauthItem(result3));
}
bool allow = true;
Events.InvokePreAuth(ref result3, request, ref allow);
if (allow)
{
request.Accept();
ServerConsole.AddLog(string.Format("Player {0} preauthenticated from endpoint {1}.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("{0} preauthenticated from endpoint {1}.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
}
}
else
{
rejectData.Reset();
rejectData.Put(1);
request.Reject(rejectData);
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} sent an invalid preauthentication token. {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
}
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} failed to preauthenticate: {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
}
/// <summary> /// Sends a raw log message to the game console. /// </summary> /// <param name="message">The message to be sent.</param> /// <param name="color">The message color.</param> public static void SendRaw(object message, System.ConsoleColor color) => ServerConsole.AddLog(message.ToString(), color);
//Used to Exiled2Multiadmin
internal static void ToMultiAdmin(string message)
{
ServerConsole.AddLog($"[EXILED2Multiadmin] {message} LOGTYPE02");
}
public void LogReport(GameConsoleTransmission reporter, string reporterUserId, string reportedUserId, ref string reason, int reportedId, bool notifyGm)
{
if (string.IsNullOrEmpty(_serverAddress) && !_hasLoaded)
{
reportedPlayers = typeof(CheaterReport).GetField("reportedPlayers",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(PlayerManager.localPlayer.GetComponent <CheaterReport>()) as HashSet <int> ?? new HashSet <int>();
_serverAddress = $"{ServerConsole.Ip}:{ServerConsole.Port}";
_hasLoaded = true;
}
try
{
GameObject reporterGO = PlayerManager.players.Find(p => p.GetComponent <CharacterClassManager>().UserId == reporterUserId);
GameObject reportedGO = PlayerManager.players.Find(p => p.GetComponent <CharacterClassManager>().UserId == reportedUserId);
if (reportedGO != null && reporterGO != null)
{
string json = JsonSerializer.ToJsonString(new DiscordWebhook($"{PMConfigFile.webhookMessage}", PMConfigFile.webhookName, PMConfigFile.webhookAvatar, tts: false, new DiscordEmbed[1]
{
new DiscordEmbed("Ingame player report", "rich", "Player has just been reported.", PMConfigFile.webhookColour, new DiscordEmbedField[5]
{
new DiscordEmbedField("Reported User", $"{reportedGO.GetComponent<NicknameSync>().MyNick} ({reportedUserId})", inline: false),
new DiscordEmbedField("Reporter", $"{reporterGO.GetComponent<NicknameSync>().MyNick} ({reporterUserId})", inline: false),
new DiscordEmbedField("Reason", reason, inline: false),
new DiscordEmbedField("Server", _serverAddress, inline: false),
new DiscordEmbedField("Reported ID", reportedId.ToString(), inline: false)
})
}));
HttpClient _client;
_client = new HttpClient();
_client.DefaultRequestHeaders.Add("User-Agent", "SCP SL");
_client.DefaultRequestHeaders.Add("Game-Version", CustomNetworkManager.CompatibleVersions[0]);
_client.Timeout = TimeSpan.FromSeconds(20.0);
_client.PostAsync(PMConfigFile.webhookUrl, new StringContent(json, Encoding.UTF8, "application/json"));
try
{
Base.Debug("Triggering PlayerReportEvent");
PluginManager.TriggerEvent <IEventHandlerPlayerReport>(new PlayerReportEvent(new PheggPlayer(reporterGO), new PheggPlayer(reportedGO), reason));
}
catch (Exception e)
{
Base.Error($"Error triggering PlayerReportEvent {e.InnerException.ToString()}");
}
if (!notifyGm)
{
reportedPlayers.Add(reportedId);
reporter.SendToClient(base.connectionToClient, "[REPORTING] Player report successfully sent to local administrators by webhooks.", "green");
}
}
}
catch (Exception ex)
{
ServerConsole.AddLog("Failed to send report by webhook: " + ex.Message);
Debug.LogException(ex);
reporter.SendToClient(base.connectionToClient, "[REPORTING] Failed to send report to local administrators by webhooks.", "red");
}
}
public static void OnServerStarted()
{
ServerConsole.DebugLine("global Event OnServerStarted called :O");
}
public static List <MapleMovementFragment> Parse(PacketReader pr)
{
List <MapleMovementFragment> movementList = new List <MapleMovementFragment>();
byte movements = pr.ReadByte();
for (int i = 0; i < movements; i++)
{
byte type = pr.ReadByte();
switch (type)//completely changed by alonevampire
{
case 0x00:
case 0x08:
case 0x0F:
case 0x12:
case 0x17:
case 0x3A:
case 0x3B:
case 0x3C:
{
Point position = pr.ReadPoint();
Point wobble = pr.ReadPoint();
short fh = pr.ReadShort();
short fhFallStart = 0;
Point offset = new Point();
if (type == 0xF)
{
fhFallStart = pr.ReadShort();
}
if (type != 0x3A)
{
offset = pr.ReadPoint();
}
byte state = pr.ReadByte();
short duration = pr.ReadShort();
AbsoluteLifeMovement alm = new AbsoluteLifeMovement(type, position, state, duration, wobble, offset, fh, fhFallStart);
movementList.Add(alm);
break;
}
case 0x01:
case 0x02:
case 0x10:
case 0x13:
case 0x14:
case 0x16:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
{
Point position = pr.ReadPoint();
short fhFallStart = 0;
if (type == 19 || type == 20)
{
fhFallStart = pr.ReadShort();
}
byte state = pr.ReadByte();
short duration = pr.ReadShort();
RelativeLifeMovement rlm = new RelativeLifeMovement(type, position, state, duration, fhFallStart);
movementList.Add(rlm);
break;
}
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x09:
case 0x0A:
case 0x0B:
case 0x0D:
case 0x18:
case 0x19:
case 0x31:
case 0x32:
case 0x33:
case 0x35:
{
Point position = pr.ReadPoint();
short fh = pr.ReadShort();
byte state = pr.ReadByte();
short duration = pr.ReadShort();
TeleportMovement tm = new TeleportMovement(type, position, state, duration, fh);
movementList.Add(tm);
break;
}
case 0x1B:
case 0x1C:
case 0x1D:
case 0x1E:
case 0x1F:
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x34:
{
byte state = pr.ReadByte();
short duration = pr.ReadShort();
GroundMovement gm = new GroundMovement(type, new Point(), state, duration);
movementList.Add(gm);
break;
}
case 0x0E:
{
Point wobble = pr.ReadPoint();
short fhFallStart = pr.ReadShort();
byte state = pr.ReadByte();
short duration = pr.ReadShort();
WobbleMovement m = new WobbleMovement(type, wobble, fhFallStart, state, duration);
movementList.Add(m);
}
break;
case 0x0C:
{
byte wui = pr.ReadByte();
ChangeEquipMovement cem = new ChangeEquipMovement(type, wui);
movementList.Add(cem);
break;
}
default:
ServerConsole.Warning("Unknown movement type: {0} - Data:\r\n{1}", type, pr.ToString(true));
FileLogging.Log("MovementLog.txt", String.Format("Unknown movement type: {0} - Position: {1} - Data:\r\n{2}", type, pr.Position, pr.ToString()));
return(null);
}
}
if (movements != movementList.Count) //probably hack
{
string packet = pr.ToString();
FileLogging.Log("MovementLog.txt", String.Format("Movement count mismatch in packet {0} Data:\r\n{1}", packet.Substring(0, 5), packet));
return(null);
}
return(movementList);
}
public void MyTestInitialize()
{
_engineMock = new Mock <IFSEngine>(MockBehavior.Loose);
_userContext = CommandHelper.CreateCommandContext().User;
_serverConsole = new ServerConsole(_engineMock.Object);
}
public static void UseEquipEnhancementScroll(MapleEquip equip, MapleItem scroll, MapleCharacter chr)
{
if (equip == null || scroll == null)
{
return;
}
WzItemEnhancer wzScrollInfo = DataBuffer.GetItemById(scroll.ItemId) as WzItemEnhancer;
WzEquip equipInfo = DataBuffer.GetEquipById(equip.ItemId);
if (wzScrollInfo == null || equipInfo == null)
{
return;
}
int maxEnhancements;
if (wzScrollInfo == null || equipInfo == null || (maxEnhancements = equipInfo.MaxStarEnhance) - equip.Enhancements < 1 || equip.RemainingUpgradeCount > 0)
{
chr.SendPopUpMessage("You cannot use that on this item.");
chr.EnableActions();
return;
}
int chance;
bool diminishChance = false;
int enhancements;
int curseChance = 100;
switch (scroll.ItemId)
{
case 2049323: //advanced equip enhancement scroll
curseChance = 0;
goto case 2049300;
case 2049300:
case 2049303:
case 2049306:
case 2049325:
{
chance = 100;
diminishChance = true;
enhancements = 1;
break;
}
case 2049301: //equip enhancement scroll
case 2049307:
{
chance = 80;
diminishChance = true;
enhancements = 1;
break;
}
default:
{
if (wzScrollInfo.StatEnhancements.TryGetValue("forceUpgrade", out enhancements) && //multiple star enhances
wzScrollInfo.StatEnhancements.TryGetValue("success", out chance))
{
if (!wzScrollInfo.StatEnhancements.TryGetValue("cursed", out curseChance))
{
curseChance = 100;
}
break;
}
chr.SendPopUpMessage("This item is not coded, please report it on the forums. ItemId " + scroll.ItemId);
ServerConsole.Debug("ItemID {0} is unhandled in UseEnhancementScroll", scroll.ItemId);
return;
}
}
bool scrollProtection = equip.CheckAndRemoveFlag(MapleItemFlags.ScrollProtection);
bool curseProtection = equip.CheckAndRemoveFlag(MapleItemFlags.CurseProtection) && equip.Enhancements < 12;
bool success = EnhanceEquip(equip, chance, diminishChance, enhancements, maxEnhancements);
bool destroyed = false;
byte scrollResult = 1;
bool removeScroll = success || !scrollProtection;
if (!success)
{
scrollResult = 0;
if (!curseProtection && Functions.MakeChance(curseChance))
{
scrollResult = 2;
destroyed = true;
}
}
if (removeScroll)
{
chr.Inventory.RemoveItemsFromSlot(scroll.InventoryType, scroll.Position, 1);
}
if (destroyed)
{
chr.Inventory.RemoveItem(equip.InventoryType, equip.Position);
}
else
{
chr.Client.SendPacket(MapleInventory.Packets.AddItem(equip, equip.InventoryType, equip.Position)); //Update item
}
chr.Map.BroadcastPacket(Packets.ShowScrollEffect(chr.Id, scrollResult, scroll.ItemId, equip.ItemId), chr, true);
}
public bool LoadPacketDefintions()
{
if (File.Exists(mFilepath) == false)
{
ServerConsole.WriteLine(GodLesZ.Library.EConsoleColor.Error, "failed, file not found!");
return(false);
}
var xml = new XmlSerializer(typeof(PacketList));
using (Stream fs = File.OpenRead(mFilepath)) {
mPackets = (PacketList)xml.Deserialize(fs);
}
// TODO: Make a defaul packet version, holding base definitions
// and let them be overritten from higher versions
// Load all types from script assemblies
//List<Type> scriptTypes = new List<Type>();
/*
* foreach (Assembly asm in Scripting.ScriptCompiler.Assemblies) {
* scriptTypes.AddRange(asm.GetTypes());
* }
*/
Assembly lookupAsm = Assembly.GetExecutingAssembly();
// Attach all packet handlers
foreach (PacketVersion packets in mPackets)
{
foreach (PacketDefinition p in packets.Packets)
{
string asmName = string.Format("GodLesZ.Library.Network.Packets.{0}", p.HandlerType);
/*
* foreach (Type type in scriptTypes) {
* if (type.FullName == asmName) {
* MethodInfo info = type.GetMethod(p.HandlerName, BindingFlags.Public | BindingFlags.Static);
* Delegate dele = Delegate.CreateDelegate(typeof(OnPacketReceive), info);
* PacketHandlers.Register(p.ID, p.Length, (OnPacketReceive)dele);
*
* found = true;
* break;
* }
* }
*/
var t = lookupAsm.GetType(asmName);
if (t != null)
{
var info = t.GetMethod(p.HandlerName, BindingFlags.Public | BindingFlags.Static);
if (info == null)
{
ServerConsole.ErrorLine("Unable to find Packet handler for definition: {0}.{1}", p.HandlerType, p.HandlerName);
continue;
}
var dele = Delegate.CreateDelegate(typeof(OnPacketReceive), info);
PacketHandlers.Register(p.HandlerName, p.ID, p.Length, (OnPacketReceive)dele);
}
else
{
ServerConsole.ErrorLine("Unable to find Packet handler for definition: {0}.{1}", p.HandlerType, p.HandlerName);
}
}
}
return(true);
}
public static void Handle(MapleClient c, PacketReader pr)
{
MapleCharacter chr = c.Account.Character;
try
{
if (c.NpcEngine == null || c.NpcEngine.ScriptInstance == null)
{
if (chr.ActionState == ActionState.NpcTalking)
{
chr.EnableActions();
}
return;
}
int objectId = c.NpcEngine.ScriptInstance.ObjectId;
if (objectId != -1) //objectId == -1 when npc conversation was started by the server, so players can talk to NPCs that are not on their map (with commands etc)
{
WzMap.Npc npc = chr.Map.GetNpc(objectId);
if (npc == null)
{
c.NpcEngine.ScriptInstance = null;
return;
}
}
byte type = pr.ReadByte();
byte next = pr.ReadByte();
if (next == 0xFF) //End Chat
{
c.NpcEngine.Dispose();
return;
}
if (next == 0 && (type != 2))
{
c.NpcEngine.ScriptInstance.State -= 1;
}
else
{
c.NpcEngine.ScriptInstance.State += 1;
}
bool execute = false;
switch (type)
{
case 0: //SendOk, SendPrev, SendNext
execute = true;
break;
case 2: //SendYesNo
execute = true;
c.NpcEngine.ScriptInstance.Selection = next == 0 ? 0 : 1;
break;
case 3: //SendAskText
if (next == 0)
{
execute = false;
}
else
{
execute = true;
string text = pr.ReadMapleString();
c.NpcEngine.ScriptInstance.InText = text;
}
break;
case 4: //SendGetNumber
//Player.GetNpcStatus().Num = pr.ReadInt();
execute = true;
break;
case 5: //SendSimple
if (next == 0)
{
execute = false;
}
else
{
if (pr.Available >= 4)
{
c.NpcEngine.ScriptInstance.Selection = pr.ReadInt(); //This can be int as well, decided by the client
}
else if (pr.Available >= 1)
{
c.NpcEngine.ScriptInstance.Selection = pr.ReadSByte();
}
execute = true;
}
break;
case 23: //Choose Job
int choice = pr.ReadInt();
break;
default:
string msg = "Unknown Npc chat type: " + pr.ToString();
ServerConsole.Error(msg);
FileLogging.Log("NPC chat type", msg);
c.NpcEngine.ScriptInstance = null;
break;
}
if (execute)
{
NpcEngine engine = c.NpcEngine;
if (engine == null)
{
if (c.Account.Character.ActionState == ActionState.NpcTalking)
{
c.Account.Character.EnableActions();
}
return;
}
engine.ExecuteScriptForNpc();
}
else
{
c.NpcEngine.ScriptInstance = null;
if (chr.ActionState == ActionState.NpcTalking)
{
chr.EnableActions();
}
}
}
catch (Exception ex)
{
ServerConsole.Error("NpcChatMoreHandler.Handle : " + ex.ToString());
if (c.NpcEngine != null)
{
c.NpcEngine.ScriptInstance = null;
}
if (chr.ActionState == ActionState.NpcTalking)
{
chr.EnableActions();
}
}
}
public static void Info(string message)
{
Assembly assembly = Assembly.GetCallingAssembly();
ServerConsole.AddLog($"[INFO] [{assembly.GetName().Name}] {message}");
}
//Used to send ERROR level messages to the game console. This should be used to send errors only. It's recommended to send any messages in the catch block of a try/catch as errors with the exception string.
public static void Error(string message)
{
Assembly assembly = Assembly.GetCallingAssembly();
ServerConsole.AddLog($"[ERROR] [{assembly.GetName().Name}] {message} LOGTYPE-8");
}
public static void Warn(string message)
{
Assembly assembly = Assembly.GetCallingAssembly();
ServerConsole.AddLog($"[WARN] [{assembly.GetName().Name}] {message} LOGTYPE14");
}
public static void Handle(MapleClient c, PacketReader pr)
{
if (c.Account.Character.Map != null)
{
int objectId = pr.ReadInt();
MapleMonster Mob = c.Account.Character.Map.GetMob(objectId);
if (Mob == null)
{
return;
}
lock (Mob.MobLock)
{
if (!Mob.Alive)
{
return;
}
if (Mob.GetController() != c.Account.Character)
{
c.SendPacket(MapleMonster.RemoveMobControl(objectId));
return;
}
pr.Skip(1);
short moveID = pr.ReadShort();
bool useSkill = pr.ReadBool();
byte skill = pr.ReadByte();
int unk = pr.ReadInt();
Point startPos = Mob.Position;
int skillid = 0;
int skilllevel = 0;
if (useSkill)
{
if (Mob.WzInfo.Skills.Count > 0)
{
if (skill >= 0 && skill < Mob.WzInfo.Skills.Count)
{
MobSkill mobSkill = Mob.WzInfo.Skills[skill];
if ((DateTime.UtcNow - Mob.SkillTimes[mobSkill]).TotalMilliseconds > mobSkill.interval)// && mobSkill.summonOnce
{
Mob.SkillTimes[mobSkill] = DateTime.UtcNow;
if (mobSkill.hp <= Mob.HpPercent)
{
//supposed to apply efffect here :/
//todo $$
//mobSkill.applyEffect(chr, monster, true);
skillid = mobSkill.Skill;
skilllevel = mobSkill.Level;
}
}
}
else
{
return;//hacking?
}
}
}
List <int> unkList = new List <int>();
List <short> unkList2 = new List <short>();
byte count = pr.ReadByte();
for (int i = 0; i < count; i++)
{
unkList.Add(pr.ReadInt());
}
count = pr.ReadByte();
for (int i = 0; i < count; i++)
{
unkList.Add(pr.ReadShort());
}
pr.Skip(30);
List <MapleMovementFragment> Res = ParseMovement.Parse(pr);
if (Res != null && Res.Count > 0)
{
updatePosition(Res, Mob, -1);
if (Mob.Alive)
{
MoveResponse(c, objectId, moveID, Mob.ControllerHasAggro, (short)Mob.WzInfo.MP, 0, 0);
MoveMob(c, objectId, useSkill, skill, unk, startPos, Res, unkList, unkList2);
}
}
else
{
ServerConsole.Warning("Monster Res == null or empty!");
}
}
}
}
private static bool Prefix(RespawnManager __instance)
{
try
{
if (!RespawnWaveGenerator.SpawnableTeams.TryGetValue(__instance.NextKnownTeam, out SpawnableTeam spawnableTeam) ||
__instance.NextKnownTeam == SpawnableTeamType.None)
{
ServerConsole.AddLog("Fatal error. Team '" + __instance.NextKnownTeam + "' is undefined.", ConsoleColor.Red);
}
else
{
List <API.Features.Player> list = API.Features.Player.List
.Where(p => p.IsDead && !p.IsOverwatchEnabled).ToList();
if (__instance._prioritySpawn)
{
list = list.OrderBy(item => item.ReferenceHub.characterClassManager.DeathTime).ToList();
}
else
{
list.ShuffleList();
}
RespawnTickets singleton = RespawnTickets.Singleton;
int a = singleton.GetAvailableTickets(__instance.NextKnownTeam);
if (a == 0)
{
a = singleton.DefaultTeamAmount;
RespawnTickets.Singleton.GrantTickets(singleton.DefaultTeam, singleton.DefaultTeamAmount, true);
}
int num = Mathf.Min(a, spawnableTeam.MaxWaveSize);
List <ReferenceHub> referenceHubList = ListPool <ReferenceHub> .Shared.Rent();
var ev = new RespawningTeamEventArgs(list, num, __instance.NextKnownTeam);
Handlers.Server.OnRespawningTeam(ev);
while (list.Count > num)
{
list.RemoveAt(list.Count - 1);
}
list.ShuffleList();
foreach (API.Features.Player me in list)
{
try
{
RoleType classid =
spawnableTeam.ClassQueue[
Mathf.Min(referenceHubList.Count, spawnableTeam.ClassQueue.Length - 1)];
me.ReferenceHub.characterClassManager.SetPlayersClass(classid, me.ReferenceHub.gameObject);
referenceHubList.Add(me.ReferenceHub);
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Player " + me.ReferenceHub.LoggedNameFromRefHub() + " respawned as " + classid + ".", ServerLogs.ServerLogType.GameEvent);
}
catch (Exception ex)
{
if (me != null)
{
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Player " + me.ReferenceHub.LoggedNameFromRefHub() + " couldn't be spawned. Err msg: " + ex.Message, ServerLogs.ServerLogType.GameEvent);
}
else
{
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, "Couldn't spawn a player - target's ReferenceHub is null.", ServerLogs.ServerLogType.GameEvent);
}
}
}
if (referenceHubList.Count > 0)
{
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, $"RespawnManager has successfully spawned {referenceHubList.Count} players as {__instance.NextKnownTeam}!", ServerLogs.ServerLogType.GameEvent);
RespawnTickets.Singleton.GrantTickets(__instance.NextKnownTeam, -referenceHubList.Count * spawnableTeam.TicketRespawnCost);
if (UnitNamingRules.TryGetNamingRule(__instance.NextKnownTeam, out UnitNamingRule rule))
{
rule.GenerateNew(__instance.NextKnownTeam, out string regular);
foreach (ReferenceHub referenceHub in referenceHubList)
{
referenceHub.characterClassManager.NetworkCurSpawnableTeamType =
(byte)__instance.NextKnownTeam;
referenceHub.characterClassManager.NetworkCurUnitName = regular;
}
rule.PlayEntranceAnnouncement(regular);
}
RespawnEffectsController.ExecuteAllEffects(RespawnEffectsController.EffectType.UponRespawn, __instance.NextKnownTeam);
}
__instance.NextKnownTeam = SpawnableTeamType.None;
}
return(false);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Server.RespawningTeam: {e}\n{e.StackTrace}");
return(true);
}
}
private void conexion_StateChange(ServerConsole src, ServerConsole.EstadoConexion anterior, ServerConsole.EstadoConexion nuevo)
{
Text = String.Format("Explorador de Servidores: {0} ({1})", conexion.Destino.UDP, nuevo);
}
public bool HandleReceive(NetState ns)
{
if (ns == null || ns.Running == false)
{
return(false);
}
ByteQueue buffer = ns.Buffer;
if (buffer == null || buffer.Length <= 0)
{
return(true);
}
ServerConsole.DebugLine("{0}: Incoming data, {1} bytes", ns, buffer.Length);
/*
* Packet Analyse/verify && Parsing
*/
lock (buffer) {
int turns = 0;
int length = buffer.Length;
while (length > 0 && ns != null && ns.Running)
{
short packetID = buffer.GetPacketID();
#if DEBUG_PACKETS
// debug log
using (TextWriter writer = File.CreateText(AppDomain.CurrentDomain.BaseDirectory + @"\packet_" + DateTime.Now.UnixTimestamp() + ".log")) {
using (MemoryStream ms = new MemoryStream(buffer.ByteBuffer))
Tools.FormatBuffer(writer, ms, (int)ms.Length);
}
#endif
PacketHandler handler = PacketHandlers.GetHandler(packetID);
if (handler == null)
{
byte[] data = new byte[length];
length = buffer.Dequeue(data, 0, length);
// Log unknown packets
string unknownPacketPath = AppDomain.CurrentDomain.BaseDirectory + @"\packet_" + packetID.ToString("X4") + ".log";
if (File.Exists(unknownPacketPath) == false)
{
using (TextWriter writer = File.CreateText(unknownPacketPath)) {
writer.WriteLine("Unknown packet 0x" + packetID.ToString("X4") + ", length " + length);
using (MemoryStream ms = new MemoryStream(data)) {
Tools.FormatBuffer(writer, ms, (int)ms.Length);
}
}
}
ServerConsole.WarningLine("{0}: P {1:X4}, {2} bytes, no Handler found!", ns, packetID, length);
break;
}
ServerConsole.StatusLine("{0}: [{1}] P {2:X4}, {3} bytes, handled {4}", ns, handler.Name, packetID, length, handler.Length);
byte[] packetBuffer;
// If we set the length to -1 (dynamic packet length), read the full buffer
int bufferLength = (handler.Length > 0 ? handler.Length : length);
if (bufferLength < mBufferSize)
{
packetBuffer = mBuffers.AcquireBuffer();
}
else
{
packetBuffer = new byte[bufferLength];
}
buffer.Dequeue(packetBuffer, 0, bufferLength);
PacketReader r = new PacketReader(packetBuffer, bufferLength, 0, true);
handler.OnReceive(ns, r);
length -= bufferLength;
if (bufferLength < mBufferSize)
{
mBuffers.ReleaseBuffer(packetBuffer);
}
else
{
packetBuffer = null;
}
turns++;
} // end while()*/
} // end Lock()
// Clear internal byte buffer for receive data
if (ns != null && ns.Buffer != null)
{
ns.Buffer.Clear();
}
return(true);
}
public static void HandleCommand(JObject o)
{
try
{
string type = (string)o["type"];
if (type == "IDENT")
{
if ((string)o["data"] == "PASS")
{
Log.Debug($"Server {ServerConsole.Port} passed identification.");
}
else if ((string)o["data"] == "FAIL")
{
Log.Warn($"Server {ServerConsole.Port} failed identification.");
}
}
else if (type == "UPDATE")
{
EventHandlers.tcp.SendData(new Update());
}
else if (type == "ROLESYNC")
{
Log.Warn(o);
string userid = (string)o["userid"];
if (o["group"] == null)
{
Log.Debug($"No role sync found for {userid}");
SCPDiscord.VerifyReservedSlot(userid);
return;
}
string group = (string)o["group"];
UserGroup userGroup = ServerStatic.PermissionsHandler.GetGroup(group);
if (userGroup == null)
{
Log.Error($"Attempted to assign invalid user group {group} to {userid}");
return;
}
Player player = Player.Get(userid);
if (player == null)
{
Log.Error($"Error assigning user group to {userid}, player not found.");
return;
}
if (SCPDiscord.setRoleGroups.Contains(group))
{
Log.Debug($"Assigning role: {userGroup} to {userid}.");
player.Group = userGroup;
}
string tag = (string)o["tag"];
if (SCPDiscord.setTagGroups.Contains(group) && tag != null)
{
Log.Debug($"Changing tag of {userid} to {tag}.");
player.RankName = tag;
}
if (SCPDiscord.reservedSlotGroups.Contains(group))
{
// grant reserved slot
Log.Debug("Player has necessary rank for reserved slot, checking...");
List <string> lines = File.ReadAllLines(SCPDiscord.reservedSlots).ToList();
if (!lines.Contains(userid))
{
Log.Debug("Reserved slot not found, adding player...");
lines.Add(userid);
File.WriteAllLines(SCPDiscord.reservedSlots, lines);
// This only reloads the slots on the current server, change this to reload on every server?
// Might not work
ReservedSlot.Reload();
}
}
else
{
SCPDiscord.VerifyReservedSlot(userid);
}
}
else if (type == "COMMAND")
{
GameCore.Console.singleton.TypeCommand((string)o["command"]);
}
else if (type == "BAN")
{
bool isuid = false;
string uid = (string)o["user"];
if (!uid.Contains("@steam") && !uid.Contains("@discord"))
{
if (!uid.Contains("."))
{
isuid = true;
uid += "@steam";
}
}
else
{
isuid = true;
}
Player player = Player.Get(uid);
int min = (int)o["min"];
string reason = (string)o["reason"];
Ban ban = new Ban
{
player = null,
duration = min,
success = true,
offline = false
};
if (player != null)
{
PlayerManager.localPlayer.GetComponent <BanPlayer>().BanUser(player.GameObject, min, reason, "Server");
ban.player = new User
{
name = player.Nickname,
userid = player.UserId
};
}
else
{
if (isuid)
{
ban.offline = true;
ban.player = new User
{
name = "Offline Player",
userid = uid
};
if (SCPDiscord.instance.Config.SteamApiKey != string.Empty)
{
string data = null;
try
{
data = webclient.DownloadString($"https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v2/?key={SCPDiscord.instance.Config.SteamApiKey}&format=json&steamids={uid.Replace("@steam", "")}");
}
catch
{
Log.Debug("Failed to get profile data from SteamAPI.");
}
JObject o2 = JObject.Parse(data);
if (o2 != null)
{
ban.player.name = (string)o2["response"]["players"][0]["personaname"];
}
}
BanHandler.IssueBan(new BanDetails()
{
OriginalName = ban.player.name,
Id = uid,
IssuanceTime = TimeBehaviour.CurrentTimestamp(),
Expires = DateTime.UtcNow.AddMinutes((double)min).Ticks,
Reason = reason,
Issuer = "Server"
}, BanHandler.BanType.UserId);
}
else if (uid.Contains("."))
{
ban.offline = true;
BanHandler.IssueBan(new BanDetails()
{
OriginalName = "IP Address",
Id = uid,
IssuanceTime = TimeBehaviour.CurrentTimestamp(),
Expires = DateTime.UtcNow.AddMinutes((double)min).Ticks,
Reason = reason,
Issuer = "Server"
}, BanHandler.BanType.IP);
}
else
{
ban.success = false;
}
}
EventHandlers.tcp.SendData(ban);
}
else if (type == "KICK")
{
string uid = (string)o["user"];
if (!uid.Contains("@steam") && !uid.Contains("@discord"))
{
uid += "@steam";
}
Player player = Player.Get(uid);
Kick kick = new Kick
{
player = null
};
if (player != null)
{
kick.player = new User
{
name = player.Nickname,
userid = player.UserId
};
ServerConsole.Disconnect(player.GameObject, (string)o["reason"]);
}
EventHandlers.tcp.SendData(kick);
}
else if (type == "UNBAN")
{
Unban unban = new Unban();
List <string> ipBans = File.ReadAllLines(SCPDiscord.ipBans).ToList();
List <string> userIDBans = File.ReadAllLines(SCPDiscord.useridBans).ToList();
string id = (string)o["user"];
if (!id.Contains("."))
{
if (!id.Contains("@steam") && !id.Contains("@discord"))
{
id += "@steam";
}
}
List <string> matchingIPBans = ipBans.FindAll(s => s.Contains(id));
List <string> matchingSteamIDBans = userIDBans.FindAll(s => s.Contains(id));
if (matchingIPBans.Count == 0 && matchingSteamIDBans.Count == 0)
{
unban.success = false;
EventHandlers.tcp.SendData(unban);
return;
}
ipBans.RemoveAll(s => s.Contains(id));
userIDBans.RemoveAll(s => s.Contains(id));
foreach (var row in matchingIPBans)
{
userIDBans.RemoveAll(s => s.Contains(row.Split(';').Last()));
}
foreach (var row in matchingSteamIDBans)
{
ipBans.RemoveAll(s => s.Contains(row.Split(';').Last()));
}
File.WriteAllLines(SCPDiscord.ipBans, ipBans);
File.WriteAllLines(SCPDiscord.useridBans, userIDBans);
EventHandlers.tcp.SendData(unban);
}
}
catch (Exception x)
{
Log.Error("SCPDiscord handle command error: " + x.Message);
}
}
public static void Handle(MapleClient c, PacketReader pr)
{
byte operation = pr.ReadByte();
MapleCharacter chr = c.Account.Character;
switch (operation)
{
case 0x01: //Create party
if (chr.Party == null)
{
bool privateParty = !pr.ReadBool();
string partyName = pr.ReadMapleString();
chr.Party = MapleParty.CreateParty(chr, partyName, privateParty);
}
break;
case 0x02: //Leave party
if (chr.Party != null)
{
chr.Party.RemovePlayer(chr.Id, false);
}
break;
case 0x04: //Invite to party
string targetName = pr.ReadMapleString();
MapleCharacter target = Program.GetCharacterByName(targetName);
if (target != null && !target.Hidden)
{
if (target.Party != null)
{
chr.SendWhiteMessage("'" + targetName + "' is already in a party.");
return;
}
Invite inv;
if (target.Invites.TryGetValue(InviteType.Party, out inv))
{
if (inv.SenderId == chr.Id)
{
chr.SendWhiteMessage("You have already invited '" + targetName + "' to your party.");
}
else
{
chr.SendWhiteMessage("'" + targetName + "' currently has a party invite pending.");
}
}
else
{
if (chr.Party != null && chr.Party.LeaderId != chr.Id)
{
chr.SendWhiteMessage("You are not the leader of your party.");
}
else
{
target.Invites.Add(InviteType.Party, new Invite(chr.Id, InviteType.Party));
target.Client.SendPacket(MapleParty.Packets.GenerateInvite(chr));
}
}
}
else
{
chr.SendWhiteMessage("'" + targetName + "' could not be found.");
}
break;
case 0x07: //Set leader
{
if (!chr.Map.PartyLeaderChangeLimit)
{
MapleParty party = chr.Party;
if (party != null && party.LeaderId == chr.Id)
{
party.SetLeader(pr.ReadInt());
}
}
}
break;
case 0x0D: //Rename
{
MapleParty party = chr.Party;
if (party != null && party.LeaderId == chr.Id)
{
party.Private = !pr.ReadBool();
party.Name = pr.ReadMapleString();
party.BroadcastPacket(MapleParty.Packets.UpdatePartyName(party));
}
break;
}
/*
* case 0x22://deny invite
* {
* int id = pr.ReadInt();
* Invite inv;
* if (chr.Invites.TryGetValue(InviteType.Party, out inv))
* {
* if (inv.SenderId == id)
* {
* chr.Invites.Remove(InviteType.Party);
* MapleCharacter from = Program.GetCharacterById(id);
* if (from != null)
* from.SendWhiteMessage(chr.Name + " has denied the party request.");//should be a white message.
* }
* }
* }
* break;
* case 0x23://accept invite
* {
* int id = pr.ReadInt();
* Invite inv;
* if (chr.Invites.TryGetValue(InviteType.Party, out inv))
* {
* if (inv.SenderId == id)
* {
* chr.Invites.Remove(InviteType.Party);
* if (chr.Party == null)
* {
* MapleClient victim = Program.GetClientByCharacterId(id);
* MapleParty p = victim.Account.Character.Party;
* if (p != null)
* {
* chr.Party = p;
* p.AddPlayer(chr);
* }
* }
* else
* {
* }
* }
* }
* }
* break;*/
default:
ServerConsole.Warning("Unknown PartyHandler operation: 0x" + operation.ToString("X"));
break;
}
}
public static void OnWorldLoadFinish()
{
ServerConsole.DebugLine("global Event OnWorldLoadFinish called :O");
}
private bool OnPlayerChat(ConsoleSystem.Arg arg, Chat.ChatChannel channel)
{
var player = arg.Player();
var text = arg.GetString(0, "text").Replace("\n", "").Replace("\r", "").Trim().EscapeRichText();
if (Chat.serverlog)
{
ServerConsole.PrintColoured(ConsoleColor.DarkYellow, string.Concat("[", channel.ToString(), "] ", player.displayName, ": "), ConsoleColor.DarkGreen, text);
DebugEx.Log(channel == Chat.ChatChannel.Team
? $"[TEAM CHAT] {player} : {text}"
: $"[CHAT] {player} : {text}");
}
var color = "#5af";
var displayName = player.displayName.EscapeRichText();
player.NextChatTime = Time.realtimeSinceStartup + 1.5f;
var chatEntry = new Chat.ChatEntry
{
Channel = channel,
Message = text,
UserId = player.UserIDString,
Username = player.displayName,
Color = color,
Time = Epoch.Current
};
RCon.Broadcast(RCon.LogType.Chat, chatEntry);
if (channel != Chat.ChatChannel.Global)
{
if (channel == Chat.ChatChannel.Team)
{
var team = arg.Player().Team;
var list = team?.GetOnlineMemberConnections();
if (list == null)
{
return(false);
}
ConsoleNetwork.SendClientCommand(list, "chat.add2", new object[]
{
1,
player.userID,
text,
displayName,
color,
1f
});
return(false);
}
}
else if (ConVar.Server.globalchat)
{
ConsoleNetwork.BroadcastToAllClients("chat.add2", 0, player.userID, text, displayName, color, 1f);
return(false);
}
var radius = 2500f;
foreach (var basePlayer2 in BasePlayer.activePlayerList)
{
var sqrMagnitude = (basePlayer2.transform.position - player.transform.position).sqrMagnitude;
if (sqrMagnitude <= radius)
{
ConsoleNetwork.SendClientCommand(basePlayer2.net.connection, "chat.add2", 0, player.userID, text, displayName, color, Mathf.Clamp01(radius - sqrMagnitude + 0.2f));
}
}
return(false);
}
private static void HandleConnection(ConnectionRequest request)
{
NetDataWriter rejectData = new NetDataWriter();
try
{
byte result1;
byte result2;
if (!request.Data.TryGetByte(out result1) || !request.Data.TryGetByte(out result2) || result1 != CustomNetworkManager.Major || result2 != CustomNetworkManager.Minor)
{
rejectData.Reset();
rejectData.Put(3);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimit.Contains(request.RemoteEndPoint.Address.ToString()))
{
ServerConsole.AddLog(string.Format("Connexion entrante à partir de l'IP {0} rejetée en raison d'un dépassement du taux limite.", request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Connexion entrante à partir de l'IP {0} rejetée en raison d'un dépassement du taux limite.", request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.IpRateLimit.Add(request.RemoteEndPoint.Address.ToString());
}
string result3;
if (!request.Data.TryGetString(out result3) || result3 == string.Empty)
{
rejectData.Reset();
rejectData.Put(5);
request.Reject(rejectData);
}
else
{
ulong result4;
byte result5;
string result6;
byte[] result7;
if (!request.Data.TryGetULong(out result4) || !request.Data.TryGetByte(out result5) || !request.Data.TryGetString(out result6) || !request.Data.TryGetBytesWithLength(out result7))
{
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
else
{
CentralAuthPreauthFlags flags = (CentralAuthPreauthFlags)result5;
try
{
String steamID = result3;
Login LoginJSON = new Login();
LoginJSON.Steamid64 = steamID;
LoginJSON.Ip = request.RemoteEndPoint.Address.ToString();
String JSON = Serialize.ToJson(LoginJSON);
String JsonResponse = Methods.Post(Plugin.LoginURL, JSON);
try
{
JSON.Success.SuccessResponseJSON APIResponse = AtlasUserAPI.JSON.Success.SuccessResponseJSON.FromJson(JsonResponse);
if (!ECDSA.VerifyBytes(string.Format("{0};{1};{2};{3}", result3, result5, result6, result4), result7, ServerConsole.PublicKey))
{
ServerConsole.AddLog(string.Format("Joueur avec l'IP {0} a envoyé un jeton de préauthentification avec une signature numérique non valide.", request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
else if (TimeBehaviour.CurrentUnixTimestamp > result4)
{
ServerConsole.AddLog(string.Format("Joueur avec l'IP {0} a envoyé un jeton de préauthentification périmé.", request.RemoteEndPoint));
ServerConsole.AddLog("Assurez-vous que l'heure et le fuseau horaire définis sur le serveur sont corrects. Nous recommandons de synchroniser l'heure.");
rejectData.Reset();
rejectData.Put(11);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimit.Contains(result3))
{
ServerConsole.AddLog(string.Format("Connexion entrante de {0} ({1}) rejetée en raison d'un dépassement du taux limite.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Connexion entrante à partir de l'IP {0} ({1}) rejetée en raison d'un dépassement du taux limite.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.UserRateLimit.Add(result3);
}
if (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreBans) || !ServerStatic.GetPermissionsHandler().IsVerified)
{
// API Check BAN.
if (APIResponse.IsBanned)
{
ServerConsole.AddLog(string.Format("Le joueur {0} a essayé de se connecter avec l'IP {1}, mais l'API répond qu'il est banni.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Le joueur {0} a essayé de se connecter avec l'IP {1}, mais l'API répond qu'il est banni.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
rejectData.Reset();
rejectData.Put(6);
request.Reject(rejectData);
return;
}
}
if (flags.HasFlagFast(CentralAuthPreauthFlags.GloballyBanned) && !ServerStatic.GetPermissionsHandler().IsVerified)
{
bool useGlobalBans = CustomLiteNetLib4MirrorTransport.UseGlobalBans;
}
if ((!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreWhitelist) || !ServerStatic.GetPermissionsHandler().IsVerified) && !WhiteList.IsWhitelisted(result3))
{
ServerConsole.AddLog(string.Format("Le joueur {0} a essayé de joindre à partir de l'IP {1}, mais n'est pas sur la liste blanche.", result3, request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(7);
request.Reject(rejectData);
}
else if (CustomLiteNetLib4MirrorTransport.Geoblocking != GeoblockingMode.None && (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreGeoblock) || !ServerStatic.GetPermissionsHandler().BanTeamBypassGeo) && (!CustomLiteNetLib4MirrorTransport.GeoblockIgnoreWhitelisted || !WhiteList.IsOnWhitelist(result3)) && (CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Whitelist && !CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper()) || CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Blacklist && CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper())))
{
ServerConsole.AddLog(string.Format("Le joueur {0} ({1}) a tenté de rejoindre depuis le pays bloqué {2}.", result3, request.RemoteEndPoint, result6.ToUpper()));
rejectData.Reset();
rejectData.Put(9);
request.Reject(rejectData);
}
else
{
// API Role & Slots
string role;
if (Plugin.role.TryGetValue(steamID, out role))
{
Plugin.role.Remove(steamID);
}
if (!String.IsNullOrEmpty(APIResponse.Role))
{
Plugin.role.Add(steamID, APIResponse.Role);
}
else
{
if (ServerStatic.GetPermissionsHandler()._members.ContainsKey(steamID))
{
ServerStatic.GetPermissionsHandler()._members.Remove(steamID);
}
}
int num = CustomNetworkManager.slots;
if (flags.HasFlagFast(CentralAuthPreauthFlags.ReservedSlot) && ServerStatic.GetPermissionsHandler().BanTeamSlots)
{
num = LiteNetLib4MirrorNetworkManager.singleton.maxConnections;
}
else if (ConfigFile.ServerConfig.GetBool("use_reserved_slots", true))
{
// API Slots
if (!String.IsNullOrEmpty(APIResponse.Role))
{
List <string> RoleRSRead = File.ReadAllLines(Plugin.RoleRSFilePath).ToList();
if (RoleRSRead.Contains(APIResponse.Role))
{
num = CustomNetworkManager.singleton.maxConnections;
}
}
}
if (LiteNetLib4MirrorCore.Host.PeersCount < num)
{
if (CustomLiteNetLib4MirrorTransport.UserIds.ContainsKey(request.RemoteEndPoint))
{
CustomLiteNetLib4MirrorTransport.UserIds[request.RemoteEndPoint].SetUserId(result3);
}
else
{
CustomLiteNetLib4MirrorTransport.UserIds.Add(request.RemoteEndPoint, new PreauthItem(result3));
}
bool allow = true;
Events.InvokePreAuth(ref result3, request, ref allow);
if (allow)
{
request.Accept();
ServerConsole.AddLog(string.Format("Le joueur {0} est préauthentifié à partir de l'IP {1}.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("{0} préauthentifié à partir de l'IP {1}.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
}
}
else
{
ServerConsole.AddLog(string.Format("Le joueur {0} ({1}) a essayé de se connecter, mais le serveur est plein.", result3, request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(1);
request.Reject(rejectData);
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Le joueur avec l'IP {0} a envoyé un jeton de préauthentification non valable. {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Le joueur avec l'IP {0} a subi une erreur avec l'API. {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Joueur avec l'IP {0} n'a pas réussi à se préauthentifier : {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
}
public void Kick(string message) => ServerConsole.Disconnect(gameObject, message);
/// <summary>
/// Gets the reference hub belonging to the player who's name most closely matches the string given, if any.
/// </summary>
/// <param name="args">Player's Name</param>
/// <returns>ReferenceHub or null</returns>
public static ReferenceHub GetPlayer(string args)
{
try
{
if (StrHubs.ContainsKey(args))
{
return(StrHubs[args]);
}
GameObject ply = null;
if (short.TryParse(args, out short pID))
{
return(GetPlayer(pID));
}
if (args.EndsWith("@steam") || args.EndsWith("@discord") || args.EndsWith("@northwood") ||
args.EndsWith("@patreon"))
{
Log.Debug("Trying to find by SID..");
foreach (GameObject pl in PlayerManager.players)
{
if (pl.GetComponent <ReferenceHub>()?.characterClassManager.UserId == args)
{
ply = pl;
Log.Debug("Found SID match.");
}
}
}
else
{
Log.Debug($"Trying to find by name.. {args}");
if (args == "WORLD" || args == "SCP-018" || args == "SCP-575" || args == "SCP-207")
{
return(null);
}
int maxNameLength = 31, lastnameDifference = 31;
string str1 = args.ToLower();
foreach (GameObject pl in PlayerManager.players)
{
ReferenceHub rh;
try
{
rh = pl.GetComponent <ReferenceHub>();
}
catch (Exception e)
{
ServerConsole.AddLog(e.ToString());
continue;
}
if (!rh.nicknameSync.MyNick.ToLower().Contains(args.ToLower()))
{
continue;
}
if (str1.Length < maxNameLength)
{
int x = maxNameLength - str1.Length;
int y = maxNameLength - rh.nicknameSync.MyNick.Length;
string str2 = rh.nicknameSync.MyNick;
for (int i = 0; i < x; i++)
{
str1 += "z";
}
for (int i = 0; i < y; i++)
{
str2 += "z";
}
int nameDifference = LevenshteinDistance.Compute(str1, str2);
if (nameDifference < lastnameDifference)
{
lastnameDifference = nameDifference;
ply = pl;
Log.Debug("Found name match.");
}
}
}
}
ReferenceHub hub = ReferenceHub.GetHub(ply);
if (hub != null)
{
StrHubs.Add(args, hub);
}
return(hub);
}
catch (Exception)
{
return(null);
}
}
public void ServerOn(bool UseSecurityMode)
{
ServerConsole.ServerOn(UseSecurityMode);
ServerReady = true;
}
/// <summary>
/// Internally called loading method.
/// </summary>
public static void Load()
{
if (IsLoaded)
{
ServerConsole.AddLog("[Exiled.Bootstrap] Exiled has already been loaded!", ConsoleColor.DarkRed);
return;
}
try
{
ServerConsole.AddLog("[Exiled.Bootstrap] Exiled is loading...", ConsoleColor.DarkRed);
string rootPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "EXILED");
if (Environment.CurrentDirectory.Contains("testing", StringComparison.OrdinalIgnoreCase))
{
rootPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "EXILED-Testing");
}
string dependenciesPath = Path.Combine(rootPath, "Plugins", "dependencies");
if (!Directory.Exists(rootPath))
{
Directory.CreateDirectory(rootPath);
}
if (!File.Exists(Path.Combine(rootPath, "Exiled.Loader.dll")))
{
ServerConsole.AddLog($"[Exiled.Bootstrap] Exiled.Loader.dll was not found, Exiled won't be loaded!", ConsoleColor.DarkRed);
return;
}
if (!File.Exists(Path.Combine(dependenciesPath, "Exiled.API.dll")))
{
ServerConsole.AddLog($"[Exiled.Bootstrap] Exiled.API.dll was not found, Exiled won't be loaded!", ConsoleColor.DarkRed);
return;
}
if (!File.Exists(Path.Combine(dependenciesPath, "YamlDotNet.dll")))
{
ServerConsole.AddLog($"[Exiled.Bootstrap] YamlDotNet.dll was not found, Exiled won't be loaded!", ConsoleColor.DarkRed);
return;
}
Assembly.Load(File.ReadAllBytes(Path.Combine(rootPath, "Exiled.Loader.dll")))
.GetType("Exiled.Loader.Loader")
.GetMethod("Run")
?.Invoke(
null,
new object[]
{
new[]
{
Assembly.Load(File.ReadAllBytes(Path.Combine(dependenciesPath, "Exiled.API.dll"))),
Assembly.Load(File.ReadAllBytes(Path.Combine(dependenciesPath, "YamlDotNet.dll"))),
},
});
IsLoaded = true;
}
catch (Exception exception)
{
ServerConsole.AddLog($"[Exiled.Bootstrap] Exiled loading error: {exception}", ConsoleColor.DarkRed);
}
}
public void ServerOFF()
{
ServerConsole.ServerOFF();
ServerReady = false;
}
public bool RunServer(string serverName, MemorySize min, MemorySize max, ServerConsole outputControl, bool gui)
{
int index = ServerNames.IndexOf(serverName);
MinecraftServerJson runningServer = ServerData.MinecraftServers[index];
string directory = runningServer.Directory;
string serverjar = directory + @"\server.jar";
bool signed = false;
try
{
Process runServer = new Process();
runServer.StartInfo.FileName = @"java.exe";
runServer.StartInfo.Arguments = @"-jar " + serverjar + " nogui";
runServer.StartInfo.UseShellExecute = false;
runServer.StartInfo.CreateNoWindow = true;
runServer.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
runServer.StartInfo.RedirectStandardOutput = true;
runServer.StartInfo.RedirectStandardError = true;
runServer.StartInfo.RedirectStandardInput = true;
runServer.StartInfo.WorkingDirectory = directory;
runServer.ErrorDataReceived += new DataReceivedEventHandler((sender, e) =>
{
if (!runningServer.Signed)
{
if (!runServer.HasExited)
{
runServer.Kill();
}
}
else
{
string reader = runServer.StandardError.ReadToEnd();
Console.WriteLine(reader);
}
});
runServer.OutputDataReceived += SortOutputHandler;
runServer.Start();
serverRunner.AddProcess(runServer);
if (!runningServer.Signed)
{
runServer.WaitForExit();
runServer.Close();
}
else
{
runningServers.Add(runServer);
runningServer.Signed = true;
outputControl.SetID(runningServers.IndexOf(runServer));
serverOutputs.Add(outputControl);
signed = true;
runServer.BeginOutputReadLine();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(signed);
}
public static void WalkToXY_Tick(WorldObjectUnit obj)
{
if (obj.Walkpath == null)
{
return;
}
else if (obj.Walkpath.path_pos >= obj.Walkpath.path_len)
{
return;
}
else if (obj.Walkpath.path[obj.Walkpath.path_pos] == EDirection.None)
{
return;
}
else if ((int)obj.Walkpath.path[obj.Walkpath.path_pos] > 8)
{
return;
}
else
{
}
// TODO: this is the point there the client seems to look laggy
// eAthena sends before any movement the WalkOk() packet
// and the client animates the move to the target location.
// But if we attacked by a skill or w00tever,
// eAthena updates the position (i think)
// AND THIS is the all-known movement/position-reset.
//
// In future, we may test to send a WalkOk() Packet in every single step
// So the client maybe display it more accurate..
EDirection dir = obj.Walkpath.path[obj.Walkpath.path_pos];
Point2D targetLoc = obj.Location.Point + dir.ToPoint2D();
ServerConsole.DebugLine("{0}: walk from {1} to {2} ({3})", obj, obj.Location.Point, targetLoc, dir);
//obj.Map.DrawGat();
//Mapcache.Maps[obj.Map.Name].DrawGat();
if (obj.Map.CheckCell(targetLoc, ECollisionType.Walkable) == false)
{
// Target location is not walkable - recalc path!
ServerConsole.DebugLine("WalkToXY_Tick: location {0} not walkable, recalc path..", targetLoc);
WalkToXY(obj, obj.TargetLocation);
return;
}
obj.Move(dir);
obj.Walkpath.path_pos++;
int speed = CalcWalkspeed(obj);
// Next step?
if (speed > 0)
{
obj.WalkTimer = Timer.DelayCall(TimeSpan.FromMilliseconds(speed), TimeSpan.Zero, 1, new TimerStateCallback <WorldObjectUnit>(WalkToXY_Tick), obj);
}
else
{
// No next step, target location reached, update target location
// just to be sure..
obj.TargetLocation = obj.Location.Point;
obj.Walkpath = null;
ServerConsole.DebugLine("WalkToXY_Tick: finished moving to location {0}", obj.Location.Point);
}
}
private object IOnEnableServerConsole(ServerConsole serverConsole)
{
if (!Interface.Oxide.CheckConsole(true)) return null;
serverConsole.enabled = false;
UnityEngine.Object.Destroy(serverConsole);
typeof(SingletonComponent<ServerConsole>).GetField("instance", BindingFlags.NonPublic | BindingFlags.Static)?.SetValue(null, null);
RustExtension.EnableConsole();
return false;
}
private static bool Prefix(GameObject user, long duration, string reason, string issuer, bool isGlobalBan)
{
try
{
if (isGlobalBan && ConfigFile.ServerConfig.GetBool("gban_ban_ip", false))
{
duration = int.MaxValue;
}
string userId = null;
string address = user.GetComponent <NetworkIdentity>().connectionToClient.address;
API.Features.Player targetPlayer = API.Features.Player.Get(user);
API.Features.Player issuerPlayer;
if (issuer.Contains("("))
{
issuerPlayer = API.Features.Player.Get(issuer.Substring(issuer.LastIndexOf('(') + 1).TrimEnd(')')) ?? Server.Host;
}
else
{
issuerPlayer = Server.Host;
}
try
{
if (ConfigFile.ServerConfig.GetBool("online_mode", false))
{
userId = targetPlayer.UserId;
}
}
catch
{
ServerConsole.AddLog("Failed during issue of User ID ban (1)!");
return(false);
}
string message = $"You have been {((duration > 0) ? "banned" : "kicked")}. ";
if (!string.IsNullOrEmpty(reason))
{
message = message + "Reason: " + reason;
}
if (!ServerStatic.PermissionsHandler.IsVerified || !targetPlayer.IsStaffBypassEnabled)
{
if (duration > 0)
{
BanningEventArgs ev = new(targetPlayer, issuerPlayer, duration, reason, message);
Handlers.Player.OnBanning(ev);
if (!ev.IsAllowed)
{
return(false);
}
duration = ev.Duration;
reason = ev.Reason;
message = ev.FullMessage;
string originalName = string.IsNullOrEmpty(targetPlayer.Nickname)
? "(no nick)"
: targetPlayer.Nickname;
long issuanceTime = TimeBehaviour.CurrentTimestamp();
long banExpieryTime = TimeBehaviour.GetBanExpirationTime((uint)duration);
try
{
if (userId is not null && !isGlobalBan)
{
BanHandler.IssueBan(
new BanDetails
{
OriginalName = originalName,
Id = userId,
IssuanceTime = issuanceTime,
Expires = banExpieryTime,
Reason = reason,
Issuer = issuer,
}, BanHandler.BanType.UserId);
if (!string.IsNullOrEmpty(targetPlayer.CustomUserId))
{
BanHandler.IssueBan(
new BanDetails
{
OriginalName = originalName,
Id = targetPlayer.CustomUserId,
IssuanceTime = issuanceTime,
Expires = banExpieryTime,
Reason = reason,
Issuer = issuer,
}, BanHandler.BanType.UserId);
}
}
}
catch
{
ServerConsole.AddLog("Failed during issue of User ID ban (2)!");
return(false);
}
try
{
if (ConfigFile.ServerConfig.GetBool("ip_banning", false) || isGlobalBan)
{
BanHandler.IssueBan(
new BanDetails
{
OriginalName = originalName,
Id = address,
IssuanceTime = issuanceTime,
Expires = banExpieryTime,
Reason = reason,
Issuer = issuer,
}, BanHandler.BanType.IP);
}
}
catch
{
ServerConsole.AddLog("Failed during issue of IP ban!");
return(false);
}
}
else if (duration == 0)
{
KickingEventArgs ev = new(targetPlayer, issuerPlayer, reason, message);
Handlers.Player.OnKicking(ev);
if (!ev.IsAllowed)
{
return(false);
}
reason = ev.Reason;
message = ev.FullMessage;
}
}
ServerConsole.Disconnect(targetPlayer.ReferenceHub.gameObject, message);
return(false);
}
catch (Exception e)
{
API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.BanningAndKicking: {e}\n{e.StackTrace}");
return(true);
}
}
