public Packet TCPRead()
{
try
{
int numberOfBytes;
if ((numberOfBytes = _reader.ReadInt32()) != -1)
{
byte[] buffer = _reader.ReadBytes(numberOfBytes);
MemoryStream memoryStream = new MemoryStream(buffer);
Packet packet = _binaryFormatter.Deserialize(memoryStream) as Packet;
switch (packet.EPacketType)
{
case PacketType.CHATMESSAGE:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)packet;
return(new ChatMessagePacket(Decrypt(chatMessagePacket.OriginClient), Decrypt(chatMessagePacket.Message)));
case PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessagePacket = (ServerMessagePacket)packet;
return(new ServerMessagePacket(Decrypt(serverMessagePacket.Message)));
case PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privateMessagePacket = (PrivateMessagePacket)packet;
return(new PrivateMessagePacket(Decrypt(privateMessagePacket.OriginClient), Decrypt(privateMessagePacket.PrivateMessage)));
case PacketType.ANNOUNCEMESSAGE:
AnnouncementMessagePacket announcementMessagePacket = (AnnouncementMessagePacket)packet;
return(new AnnouncementMessagePacket(Decrypt(announcementMessagePacket.Message)));
}
return(packet);
}
else
{
return(null);
}
}
catch (Exception e)
{
Console.WriteLine("[Error] " + e.Message + e.StackTrace);
return(null);
}
}
public void TCPSend(Packet packet)
{
lock (_writeLock)
{
try
{
//encrypt relevant packets
switch (packet.EPacketType)
{
case PacketType.CHATMESSAGE:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)packet;
Serialize(new ChatMessagePacket(Encrypt(chatMessagePacket.OriginClient), Encrypt(chatMessagePacket.Message)));
break;
case PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessagePacket = (ServerMessagePacket)packet;
Serialize(new ServerMessagePacket(Encrypt(serverMessagePacket.Message)));
break;
case PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privateMessagePacket = (PrivateMessagePacket)packet;
Serialize(new PrivateMessagePacket(Encrypt(privateMessagePacket.OriginClient), Encrypt(privateMessagePacket.PrivateMessage)));
break;
case PacketType.ANNOUNCEMESSAGE:
AnnouncementMessagePacket announcementMessagePacket = (AnnouncementMessagePacket)packet;
Serialize(new AnnouncementMessagePacket(Encrypt(announcementMessagePacket.Message)));
break;
default:
Serialize(packet);
break;
}
}
catch (Exception e)
{
Console.WriteLine("[Error] " + e.Message + e.StackTrace);
}
}
}
private void ProcessCommand(Client client, string command)
{
try
{
ServerMessagePacket serverMessagePacket;
ChatMessagePacket chatMessagePacket;
string[] parameters = SplitCommandIntoParameters(command);
//////////////////////////////////
switch ((parameters[0].ToUpper()).TrimStart('/'))
{
case "HELLO":
//send server reponse
serverMessagePacket = new ServerMessagePacket(UTF8.GetBytes("Hello!"));
client.TCPSend(serverMessagePacket);
break;
case "PM":
int clientDestination = -1;
for(int i = 0; i < _clients.Count; i++)
{
if(parameters[1] == _clients[i].clientData.clientNickname)
{
//check if the destination is the same as the sender
if(_clients[i] == client)
{
clientDestination = -2;
break;
}
else
{
clientDestination = i;
break;
}
}
}
//check if there is a message
if(parameters[2] == null)
{
ServerMessagePacket serverMessagePacket1 = new ServerMessagePacket(UTF8.GetBytes("Please put a message after the nickname!"));
client.TCPSend(serverMessagePacket1);
}
//check if client was found with name
else if(clientDestination > -1)
{
//send private message to destination client
PrivateMessagePacket privateMessagePacket = new PrivateMessagePacket(UTF8.GetBytes(client.clientData.clientNickname), UTF8.GetBytes(parameters[2].ToString()));
_clients[clientDestination].TCPSend(privateMessagePacket);
//send confirmation to user that their private message has been sent and has arrived
PrivateMessagePacket privateMessagePacket1 = new PrivateMessagePacket(UTF8.GetBytes(parameters[2].ToString()), UTF8.GetBytes(_clients[clientDestination].clientData.clientNickname));
client.TCPSend(privateMessagePacket1);
//log pm to server console
OutputLog(privateMessagePacket.Time + " [PM] " + UTF8.GetString(privateMessagePacket.OriginClient) + " -> " + _clients[clientDestination].clientData.clientNickname + ": " + UTF8.GetString(privateMessagePacket.PrivateMessage));
}
else if (clientDestination == -1)
{
ServerMessagePacket serverMessagePacket2 = new ServerMessagePacket(UTF8.GetBytes("Sorry that client does not exist. Please try again with a real nickname!"));
client.TCPSend(serverMessagePacket2);
}
else if (clientDestination == -2)
{
ServerMessagePacket serverMessagePacket3 = new ServerMessagePacket(UTF8.GetBytes("You can't send private messages to yourself silly!"));
client.TCPSend(serverMessagePacket3);
}
break;
case "HELP":
ServerMessagePacket serverMessagePacket4 = new ServerMessagePacket(UTF8.GetBytes("\nCommands: \n/HELLO - Hello! \n/PM [NAME] [MSG] - Send private messages! \n/ROLLDICE [NumOfDices] [NumOfFaces] - Roll dice! \n/ANNOUNCE [MSG] - Send an announcement message to everyone on the server!"));
client.TCPSend(serverMessagePacket4);
break;
case "ROLLDICE":
ServerMessagePacket serverMessagePacket5;
if (!(String.IsNullOrEmpty(parameters[1]) || String.IsNullOrEmpty(parameters[2])))
{
serverMessagePacket5 = new ServerMessagePacket(UTF8.GetBytes(RollDice(Int32.Parse(parameters[1]), Int32.Parse(parameters[2]))));
}
else
{
serverMessagePacket5 = new ServerMessagePacket(UTF8.GetBytes("Please input a value for all parameters!"));
OutputLog(client.clientData.clientNickname + " has tried to roll dice without the correct number of parameters! (" + command + ")");
}
client.TCPSend(serverMessagePacket5);
break;
case "ANNOUNCE":
//get full announcement message
int start = command.IndexOf(" ");
string msg = command.Substring(start + 1, command.Length - (start + 1));
//send announcement message to all clients and server logs
AnnouncementMessagePacket announcementMessagePacket = new AnnouncementMessagePacket(UTF8.GetBytes(msg));
TCPSendPacketToAll(announcementMessagePacket);
OutputLog(msg);
break;
default:
//send client chat message
chatMessagePacket = new ChatMessagePacket(UTF8.GetBytes(client.clientData.clientNickname + ": "), UTF8.GetBytes(command));
client.TCPSend(chatMessagePacket);
//send server reponse
serverMessagePacket = new ServerMessagePacket(UTF8.GetBytes("Sorry that is not a command! For a list of commands type '/help'."));
client.TCPSend(serverMessagePacket);
break;
}
}
catch (Exception e)
{
OutputLog("[Error] " + e.Message + e.StackTrace);
}
}
private void TCPProcessServerResponse()
{
Packet receivedPacket;
while ((receivedPacket = TCPRead()) != null)
{
try
{
switch (receivedPacket.EPacketType)
{
case PacketType.EMPTY:
EmptyPacket emptyPacket = (EmptyPacket)receivedPacket;
break;
case PacketType.CHATMESSAGE:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)receivedPacket;
//Write message to client console
Console.WriteLine(chatMessagePacket.Time + " " + UTF8.GetString(chatMessagePacket.OriginClient) + ": " + UTF8.GetString(chatMessagePacket.Message));
//Write message to client form
_clientForm.UpdateChatWindow(chatMessagePacket.Time + " " + UTF8.GetString(chatMessagePacket.OriginClient) + ": " + UTF8.GetString(chatMessagePacket.Message));
break;
case PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privateMessagePacket = (PrivateMessagePacket)receivedPacket;
//Write pm to client console
Console.WriteLine(privateMessagePacket.Time + " [PM] " + UTF8.GetString(privateMessagePacket.OriginClient) + " -> " + UTF8.GetString(privateMessagePacket.PrivateMessage));
//Write message to client form
_clientForm.UpdateChatWindow(privateMessagePacket.Time + " [PM] " + UTF8.GetString(privateMessagePacket.OriginClient) + " -> " + UTF8.GetString(privateMessagePacket.PrivateMessage));
break;
case PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessagePacket = (ServerMessagePacket)receivedPacket;
//Write server response to client console
Console.WriteLine(serverMessagePacket.Time + " [Server] -> " + UTF8.GetString(serverMessagePacket.Message));
//Write server response to client form
_clientForm.UpdateChatWindow(serverMessagePacket.Time + " [Server] -> " + UTF8.GetString(serverMessagePacket.Message));
break;
case PacketType.ANNOUNCEMESSAGE:
AnnouncementMessagePacket announcementMessagePacket = (AnnouncementMessagePacket)receivedPacket;
//Write announcement to client console
Console.WriteLine(announcementMessagePacket.Time + " " + "[Announcement] -> " + UTF8.GetString(announcementMessagePacket.Message));
//Write announcement to client form
_clientForm.UpdateChatWindow(announcementMessagePacket.Time + " " + "[Announcement] -> " + UTF8.GetString(announcementMessagePacket.Message));
break;
case PacketType.SERVERKEY:
ServerKeyPacket serverKeyPacket = (ServerKeyPacket)receivedPacket;
_serverKey = serverKeyPacket.ServerKey;
successfulLogin = serverKeyPacket.Successful;
Console.WriteLine("Server Key Packet Received!");
break;
case PacketType.CLIENTLIST:
ClientListPacket clientListPacket = (ClientListPacket)receivedPacket;
_clientForm.RefreshClientList(clientListPacket.ClientList, clientListPacket.ClientIPS);
break;
}
}
catch (SocketException e)
{
Console.WriteLine("[Error] " + e.Message + e.StackTrace);
break;
}
}
}
