public void SendClient(WorksPacket packet, Socket Client)
{
//send to client
byte[] seal = Converter.ObjectToByteArray(packet);
Client.BeginSend(seal, 0, seal.Length,
SocketFlags.None,
new AsyncCallback(OnSend), Client);
}
public void SendPacket(string clientname, string header, object payload)
{
WorksPacket packet = new WorksPacket()
{
ClientName = clientname, Header = header, Payload = payload
};
_service.SendClient(packet, _srvClients[clientname].ClientSocket);
SentPackets(this, packet);
}
public static byte[] Seal(WorksPacket wrapper)
{
BinaryFormatter bf = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
bf.Serialize(ms, wrapper);
return(ms.ToArray());
}
}
public static WorksPacket Release(byte[] stream)
{
BinaryFormatter binForm = new BinaryFormatter();
WorksPacket obj = null;
using (MemoryStream memStream = new MemoryStream())
{
memStream.Write(stream, 0, stream.Length);
memStream.Seek(0, SeekOrigin.Begin);
obj = (WorksPacket)binForm.Deserialize(memStream);
}
return(obj);
}
internal void Send(WorksPacket packet)
{
try
{
ByteData = Converter.ObjectToByteArray(packet);
if (ServerAuthMode)
{
if (UserAuthored)
{
ClientSocket.BeginSend(ByteData, 0, ByteData.Length, SocketFlags.None, OnSend, null);
}
}
else
{
//Send it to the server
ClientSocket.BeginSend(ByteData, 0, ByteData.Length, SocketFlags.None, OnSend, null);
}
}
catch (Exception)
{
MessageBox.Show("Unable to send message to the server.", "Client TCP", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void SendPacket(WorksPacket packet)
{
_service.Send(packet);
SentPackets(this, packet);
}
private void DefaultMethod(object sender, WorksPacket e)
{
//ignore
}
protected void OnReceive(IAsyncResult ar)
{
try
{
Socket clientSocket = (Socket)ar.AsyncState;
Console.WriteLine("SERVER --> RECEIVING...");
clientSocket.EndReceive(ar);
//Transform the array of bytes received from the user into an
//intelligent form of object Data
WorksPacket packet = (WorksPacket)Converter.ByteArrayToObject(_byteData);
_byteData = new byte[65535];
bool authResult = true;
if (packet.Header == "AUTHMODE")
{
SendClient(new WorksPacket()
{
ClientName = "REQUESTED", Header = "AUTHMODE", Payload = _authenticate ? "AUTHORIZED" : "UNAUTHORIZED"
}, clientSocket);
}
else if (_authenticate)
{
UserAuth client = (UserAuth)packet.Payload;
if (packet.Header == "AUTH")
{
bool result = _worksServer.AuthenticateClientConnection(true, client.Username, client.Password);
SendClient(
result
? new WorksPacket()
{
ClientName = packet.ClientName, Header = "AUTH", Payload = "TRUE"
}
: new WorksPacket()
{
ClientName = packet.ClientName, Header = "AUTH", Payload = "FALSE"
},
clientSocket);
if (result)
{
_worksServer.SetClientSocket(clientSocket, client.Username);
}
}
else if (packet.Header == "UPDT")
{
bool result = _worksServer.CheckCredentials(client.Username, client.Password);
if (result)
{
_worksServer.RegenerateToken(client.Username, client.NewPassword);
}
SendClient(
result
? new WorksPacket()
{
ClientName = packet.ClientName, Header = "UPDT", Payload = "TRUE"
}
: new WorksPacket()
{
ClientName = packet.ClientName, Header = "UPDT", Payload = "FALSE"
},
clientSocket);
}
else if (packet.Header == "DISC")
{
bool result = _worksServer.AuthenticateClientConnection(false, client.Username, client.Password);
authResult = result;
SendClient(
result
? new WorksPacket()
{
ClientName = packet.ClientName, Header = "DISC", Payload = "TRUE"
}
: new WorksPacket()
{
ClientName = packet.ClientName, Header = "DISC", Payload = "FALSE"
},
clientSocket);
}
else
{
if (_worksServer.IsAuthenticated(packet.ClientName))
{
_worksServer.ExReceivedPackets(clientSocket, packet);
}
}
}
else
{
_worksServer.ExReceivedPackets(clientSocket, packet);
}
if (packet.Header != "DISC" || packet.Header == "DISC" && authResult)
{
//Start listening to the message sent by the client
clientSocket.BeginReceive(_byteData, 0, _byteData.Length, SocketFlags.None,
new AsyncCallback(OnReceive), clientSocket);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, @"serverTCP", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
internal void OnReceive(IAsyncResult ar)
{
try
{
Console.WriteLine("CLIENT --> RECEIVING");
ClientSocket.EndReceive(ar);
WorksPacket msgReceived = (WorksPacket)Converter.ByteArrayToObject(ByteData);
Console.WriteLine("CLIENT --> {" + msgReceived.Header + "}");
ByteData = new byte[1024];
if (msgReceived.Header == "AUTHMODE")
{
ServerAuthMode = (string)msgReceived.Payload == "AUTHORIZED";
if (ServerAuthMode)
{
_worksClient.SendCredentials();
}
}
else
{
if (ServerAuthMode)
{
if (msgReceived.Header == "AUTH")
{
UserAuthored = (string)msgReceived.Payload == "TRUE";
}
else if (msgReceived.Header == "UPDT")
{
if ((string)msgReceived.Payload == "TRUE")
{
_worksClient.UpdatePassword();
}
}
else if (msgReceived.Header == "DISC")
{
UserAuthored = (string)msgReceived.Payload != "TRUE";
}
else
{
if (UserAuthored)
{
_worksClient.ReceivedPackets(_worksClient, msgReceived);
}
}
}
else
{
_worksClient.ReceivedPackets(_worksClient, msgReceived);
}
}
ClientSocket.BeginReceive(ByteData,
0,
ByteData.Length,
SocketFlags.None,
new AsyncCallback(OnReceive),
null);
}
catch (ObjectDisposedException)
{ }
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Client TCP: ", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
