void UdpSecureRespondToAll(SecurePacket secureChatMsg)
{
foreach (KeyValuePair <int, Client> pair in _clients)
{
pair.Value.UdpSend(secureChatMsg, ref _udpListener);
}
}
public void AddPacket(SecurePacket packet)
{
lock (this)
{
_receivedPackets.Enqueue(packet);
}
}
private void ProcessSendQueue()
{
lock (_aegisClient)
{
if (_queueSendPacket.Count() == 0)
{
return;
}
else if (_aegisClient.ConnectionStatus == ConnectionStatus.Closed)
{
_aegisClient.Connect();
}
else if (_aegisClient.ConnectionStatus == ConnectionStatus.Connected &&
_aegisClient.EnableSend == true)
{
SecurePacket packet = _queueSendPacket.Peek();
if (PacketSending == null ||
PacketSending(packet) == true)
{
_queueSendPacket.Dequeue();
packet.Encrypt(AESIV, AESKey);
_aegisClient.SendPacket(packet);
}
}
}
}
public bool UdpSendSecurePacket(string message, string src)
{
SecurePacket securePacket = new SecurePacket(_crypt.EncryptString(message))
{
_packetSrc = src
};
return(UdpSendPacket(securePacket));
}
void TcpSecureRespondToAll(string message, string src)
{
foreach (KeyValuePair <int, Client> pair in _clients)
{
// encrypt message
SecurePacket safePacket =
new SecurePacket(pair.Value.SetSecureMessage(message))
{
_packetSrc = src
};
pair.Value.TcpSend(safePacket);
}
}
private void OnReceive(AegisClient ac, StreamBuffer buffer)
{
SecurePacket packet = new SecurePacket(buffer);
packet.Decrypt(AESIV, AESKey);
packet.SkipHeader();
if (PacketPreprocessing != null &&
PacketPreprocessing(packet) == false)
{
_callbackQueue.AddPacket(packet);
}
}
public void SendPacket(SecurePacket packet, Action <SecurePacket> responseAction)
{
lock (_aegisClient)
{
packet.SeqNo = _nextSeqNo++;
if (_nextSeqNo == Int32.MaxValue)
{
_nextSeqNo = 0;
}
_queueSendPacket.Enqueue(packet);
_callbackQueue.AddCallback(packet.SeqNo, responseAction);
}
}
IEnumerator <UnityWebRequestAsyncOperation> SendRq(RequestPayload rq)
{
webRequest = new UnityWebRequest("https://ssl.dyko.eu/cgi-bin/webglHttpsTunel/BytesPost", UnityWebRequest.kHttpVerbPOST);
MessagePackSerializer.PrepareType <byte>();
MessagePackSerializer.PrepareType <byte[]>();
MessagePackSerializer.PrepareType <RequestPayload>();
var s = MessagePackSerializer.Get <RequestPayload>();
byte[] ss = s.PackSingleObject(rq);
SecurePacket p = new SecurePacket((UInt16)ServicePort, ss);
MessagePackSerializer.PrepareType <UInt16>();
MessagePackSerializer.PrepareType <SecurePacket.SecureFrame>();
var sd = MessagePackSerializer.Get <SecurePacket.SecureFrame>();
byte[] data = sd.PackSingleObject(p.GetSecuredPacket());
UploadHandlerRaw dataHandler = new UploadHandlerRaw(data);
dataHandler.contentType = "application/octet-stream"; // might work with 'multipart/form-data'
webRequest.uploadHandler = dataHandler;
DownloadHandlerBuffer downHand = new DownloadHandlerBuffer();
webRequest.downloadHandler = downHand;
yield return(webRequest.SendWebRequest());
List <byte> replyData = new List <byte>();
byte[] unsecuredData = SecurePacket.GetData(sd.UnpackSingleObject(downHand.data));
MessagePackSerializer.PrepareType <GeneralResponseState>();
MessagePackSerializer.PrepareType <GeneralRequestResponse>();
var sr = MessagePackSerializer.Get <GeneralRequestResponse>();
result = sr.UnpackSingleObject(unsecuredData);
webRequest.Dispose();
}
public void DoCallback()
{
lock (this)
{
while (_receivedPackets.Count() > 0)
{
SecurePacket packet = _receivedPackets.Dequeue();
Int32 key = packet.SeqNo;
Action <SecurePacket> callback;
packet.SkipHeader();
if (_callbacks.TryGetValue(key, out callback) == true)
{
if (callback != null)
{
callback(packet);
}
_callbacks.Remove(key);
}
}
}
}
void TcpClientMethod(int index)
{
Console.WriteLine("Socket opened. (" + _tcpListener.ToString() + ")");
Packet receivedPacket;
Client client = _clients[index];
try {
while ((receivedPacket = client.TcpRead()) != null)
{
Console.Write("TCP Receieved: ");
// act on packet type
switch (receivedPacket._packetType)
{
case Packet.PacketType.EMPTY:
Console.WriteLine("EMPTY");
/* do nothing */
break;
case Packet.PacketType.CHATMESSAGE:
Console.WriteLine("CHAT");
TcpRespondToAll((ChatMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.PRIVATEMESSAGE:
Console.WriteLine("PRIVATE");
TcpRespondTo((PrivateMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.SERVERMESSAGE:
Console.WriteLine("SERVER");
ServerMessagePacket servPacket = (ServerMessagePacket)receivedPacket;
servPacket._messageRecv = GetReturnMessage(servPacket._messageSent);
client.TcpSend(servPacket);
break;
case Packet.PacketType.CLIENTNAME:
Console.WriteLine("NAME");
ClientNamePacket namePacket = (ClientNamePacket)receivedPacket;
// create message
namePacket._message = client._name + " changed name to " + namePacket._name;
// change name
client._name = namePacket._name;
// update client
client.TcpSend(namePacket);
// notify all clients
TcpRespondToAll(new ChatMessagePacket(namePacket._message), client);
break;
case Packet.PacketType.LOGIN:
Console.WriteLine("LOGIN");
LoginPacket loginPacket = (LoginPacket)receivedPacket;
client._endPoint = loginPacket._endPoint;
loginPacket._serverKey = client.UpdateRSA(loginPacket);
client.TcpSend(loginPacket);
break;
case Packet.PacketType.SECUREMESSAGE:
Console.WriteLine("SECURE");
// receive packet
SecurePacket safePacket = (SecurePacket)receivedPacket;
// transmit packet
TcpSecureRespondToAll(
client.GetSecureMessage(safePacket),
safePacket._packetSrc
);
break;
case Packet.PacketType.ERROR:
//should be for other things, in another place
Console.WriteLine("ERROR");
ErrorMessagePacket errPacket = (ErrorMessagePacket)receivedPacket;
client.TcpSend(errPacket);
break;
case Packet.PacketType.ENDSESSION:
Console.Write("ENDING TCP SESSION: " + client._name);
// signal to client to close connections
// and end while loop
client.Close();
break;
case Packet.PacketType.JOINGAME:
Console.Write("JOIN GAME - ");
JoinGamePacket joinGame = (JoinGamePacket)receivedPacket;
Client host = null;
foreach (Client user in _clients.Values)
{
if (user._name == joinGame._targetHost)
{
host = user;
}
}
//ChatMessagePacket resultPacket = null;
if (GameSession.Instance.JoinSession(ref client, host))
{
Console.WriteLine("JOINED A GAME");
//success - msg client
PrivateMessagePacket resultPacket =
new PrivateMessagePacket(client._name, "Started Game Session")
{
_packetSrc = _serverName
};
TcpRespondTo(resultPacket, client);
//launch client's game
client.TcpSend(joinGame);
}
else
{
Console.WriteLine("FAILED TO JOIN A GAME");
//failed - msg client
};
break;
case Packet.PacketType.USERLIST:
Console.WriteLine("USERLIST");
UserListPacket userList = (UserListPacket)receivedPacket;
if (userList._users == null)
{
List <string> usernames = new List <string>();
// collect user names
foreach (KeyValuePair <int, Client> c in _clients)
{
usernames.Add(c.Value._name);
}
userList._users = usernames.ToArray();
TcpSendToAll(userList);
}
// if list is filled, why is it here?!
break;
case Packet.PacketType.LEAVEGAME:
LeaveGamePacket leaveGame = (LeaveGamePacket)receivedPacket;
// check game sessions
bool wasHost = GameSession.Instance.IsHosting(client);
// update game session
List <string> players = GameSession.Instance.LeaveSession(ref client);
ServerMessagePacket serverMessage = null;
if (!leaveGame._wasForced)
{
serverMessage = new ServerMessagePacket
(client._name + " has left the game.", null);
}
else
{
serverMessage = new ServerMessagePacket
("GAME ERROR: " + client._name + " was forced to leave the game.", null);
}
foreach (Client user in _clients.Values)
{
if (players.Contains(user._name))
{
user.TcpSend(serverMessage);
}
}
if (wasHost)
{
leaveGame._wasForced = true;
foreach (Client user in _clients.Values)
{
user.TcpSend(leaveGame);
}
}
break;
default:
break;
}
}
} catch (Exception e) {
Console.WriteLine("Error: " + e.Message);
if (client != null)
{
Console.WriteLine("Client: " + client._name);
}
}
client.Close();
_clients.TryRemove(index, out client);
}
public string GetSecureMessage(SecurePacket safePacket)
{
return(_crypt.DecryptString(safePacket._data));
}
private void TcpProcessServerPacket()
{
Packet packet = new Packet();
while (_net.IsTcpConnected)
{
packet = _net.TcpReadPacket();
Debug("TcpProcessServerPacket: packet = " + packet);
if (packet != null)
{
switch (packet._packetType)
{
case Packet.PacketType.EMPTY:
/* do nothing */
break;
case Packet.PacketType.CLIENTNAME:
ClientNamePacket namePacket = (ClientNamePacket)packet;
_win.name = namePacket._name;
_nick = namePacket._name;
break;
case Packet.PacketType.CHATMESSAGE:
ChatMessagePacket chatPacket = (ChatMessagePacket)packet;
_win.UpdateChat(chatPacket._message);
break;
case Packet.PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privPacket = (PrivateMessagePacket)packet;
_win.UpdateChat(privPacket._packetSrc + ": " + privPacket._message);
break;
case Packet.PacketType.LOGIN:
Console.WriteLine("Logged in to server.");
_net.TcpFinishLogin((LoginPacket)packet);
break;
case Packet.PacketType.SECUREMESSAGE:
SecurePacket safePacket = (SecurePacket)packet;
_win.UpdateChat(
"Secure Message Received [" + safePacket._packetSrc + "]: " +
_net.DecryptString(safePacket._data)
);
break;
case Packet.PacketType.ENDSESSION:
Console.WriteLine("Disconnecting from server.");
_net.Close();
break;
case Packet.PacketType.JOINGAME:
_win.StartGame(this);
break;
case Packet.PacketType.USERLIST:
UserListPacket userList = (UserListPacket)packet;
_win.UserList = userList._users;
break;
case Packet.PacketType.LEAVEGAME:
LeaveGamePacket leaveGame = (LeaveGamePacket)packet;
if (leaveGame._wasForced)
{
_win.StopGame();
}
break;
case Packet.PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessage = (ServerMessagePacket)packet;
_win.UpdateChat(serverMessage._messageSent);
break;
}
}
}
}
public Response(SecurePacket packet)
{
Packet = packet;
Packet.SkipHeader();
ResultCodeNo = packet.GetInt32();
}
