/// <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;
}
