/// <summary> /// Handles the packet. /// </summary> /// <param name='packet'> /// Packet. /// </param> /// <param name='client'> /// Client. /// </param> public void HandlePacket(SchumixPacket packet, TcpClient client) { var hst = client.Client.RemoteEndPoint.ToString().Split(SchumixBase.Colon)[0]; int packetid = 0; try { packetid = packet.Read <int>(); } catch (Exception) { var packet2 = new SchumixPacket(); packet2.Write <int>((int)Opcode.SCMSG_PACKET_NULL); packet2.Write <string>(sLConsole.GetString("Wrong packetid, aborting connection!")); ClientSocket.SendPacketToSCS(packet); Log.Warning("ClientPacketHandler", sLConsole.GetString("Wrong packetid, aborting connection!")); return; } Log.Debug("ClientPacketHandler", sLConsole.GetString("Got packet with ID: {0} from: {1}"), packetid, client.Client.RemoteEndPoint); if (PacketMethodMap.ContainsKey((Opcode)packetid)) { PacketMethodMap[(Opcode)packetid].Method.Invoke(packet, hst); return; } else { Log.Notice("ClientPacketHandler", sLConsole.GetString("Received unhandled packetid: {0}"), packetid); } }
/// <summary> /// The SCS Random number handler. (SMSG_SEND_SCS_RANDOM) /// </summary> /// <param name='pck'> /// Packet. /// </param> /// <param name='hst'> /// Host. /// </param> public void ScsRandHandler(SchumixPacket pck, string hst) { // read random value. var rand = pck.Read <int>(); Log.Notice("Random", sLConsole.GetString("SCS sent random: {0}"), rand); }
/// <summary> /// The auth denied packet handler. (SMSG_AUTH_DENIED) /// </summary> /// <param name='pck'> /// Packet. /// </param> /// <param name='hst'> /// Host. /// </param> public void AuthDeniedHandler(SchumixPacket pck, string hst) { Log.Error("SchumixServer", sLConsole.GetString("Authentication denied to SCS server!")); Log.Warning("CloseHandler", sLConsole.GetString("Connection closed!")); Log.Warning("CloseHandler", sLConsole.GetString("Program shutting down!")); Thread.Sleep(1000); Environment.Exit(1); }
/// <summary> /// Start listening. /// </summary> public void Socket() { Log.Notice("ClientSocket", sLConsole.GetString("Successfully started the ClientSocket.")); Log.Notice("ClientSocket", sLConsole.GetString("Client connection from: {0}"), client.Client.RemoteEndPoint); var client_thread = new Thread(new ParameterizedThreadStart(ClientHandler)); client_thread.Start(client); Thread.Sleep(50); var packet = new SchumixPacket(); packet.Write <int>((int)Opcode.CMSG_REQUEST_AUTH); packet.Write <string>(SchumixBase.GetGuid().ToString()); packet.Write <string>(sUtilities.Md5(_password)); packet.Write <string>(SchumixBase.ServerIdentify); SendPacketToSCS(packet); }
/// <summary> /// Client handler procedure. /// </summary> /// <param name='ob'> /// The object passed with ParameterizedThreadStart (a TcpClient) /// </param> public void ClientHandler(object ob) { client = (ob as TcpClient); stream = client.GetStream(); byte[] message_buffer = new byte[262144]; int bytes_read; Log.Notice("ClientHandler", sLConsole.GetString("Handling client...")); while (true) { bytes_read = 0; // read if (stream.DataAvailable && stream.CanRead) { Log.Debug("ClientHandler", sLConsole.GetString("Stream data available, reading.")); bytes_read = stream.Read(message_buffer, 0, message_buffer.Length); if (SchumixBase.ExitStatus) { return; } if (bytes_read == 0) { Log.Warning("ClientHandler", sLConsole.GetString("Lost connection!")); break; } var encoding = new UTF8Encoding(); var msg = encoding.GetString(message_buffer, 0, bytes_read); var packet = new SchumixPacket(msg); sClientPacketHandler.HandlePacket(packet, client); } Thread.Sleep(100); } Log.Warning("ClientHandler", sLConsole.GetString("Program shutting down!")); Environment.Exit(1); }
private void CloseHandler(SchumixPacket pck, string hst) { if (SchumixBase.ExitStatus) { return; } Log.Warning("CloseHandler", sLConsole.GetString("Connection closed!")); Log.Warning("CloseHandler", sLConsole.GetString("Program shutting down!")); SchumixBase.Quit(); foreach (var nw in INetwork.WriterList) { if (!nw.Value.IsNull()) { nw.Value.WriteLine("QUIT :Server killed."); } } Thread.Sleep(1000); sRuntime.Exit(); }
/// <summary> /// Sends the packet to SCS. /// </summary> /// <param name='packet'> /// Packet. /// </param> public static void SendPacketToSCS(SchumixPacket packet) { if (!ServerConfig.Enabled) { return; } try { if (client.Connected) { Log.Debug("SchumixServer", sLConsole.GetString("Connected. Sending packet.")); var encoder = new UTF8Encoding(); byte[] buffer = encoder.GetBytes(packet.GetNetMessage()); stream.Write(buffer, 0, buffer.Length); stream.Flush(); Log.Debug("SchumixServer", sLConsole.GetString("Packet sent.")); } } catch { Log.Error("SchumixServer", sLConsole.GetString("Couldn't send SCS packet!")); } }
/// <summary> /// The auth approved packet handler. (SMSG_AUTH_APPROVED) /// </summary> /// <param name='pck'> /// Packet. /// </param> /// <param name='hst'> /// Host. /// </param> public void AuthApprovedHandler(SchumixPacket pck, string hst) { Log.Success("SchumixServer", sLConsole.GetString("Successfully authed to SCS server.")); SchumixBase.ThreadStop = false; }