private void ClientDisconnectHandler(NetworkClient senderClient)
{
this.m_connectedClients.Remove(senderClient);
Debug.Log("Current connected clients Count={0}.", this.m_connectedClients.Count);
ContactUpdate removeUpdate = new ContactUpdate();
removeUpdate.Remove.Add(senderClient.ClientId);
foreach (NetworkClient connectedClient in this.m_connectedClients) {
Debug.Log("Sending UpdateContact to remove Client from ClientId={0}.", connectedClient.ClientId);
connectedClient.SendMessage(MessageType.ContactUpdate, removeUpdate);
}
}
private void ServerMessageReceived(NetworkClient senderClient, int messageType, ByteString messageContent)
{
Debug.Log("Server message Type={0} Size={1}.", messageType, messageContent.Length);
switch (messageType) {
/* Handshake request. */
case MessageType.ClientHandshakeRequest: {
HandshakeRequest request = HandshakeRequest.Parser.ParseFrom(messageContent);
senderClient.UpdatePublicKey(request.Key);
PublicKey serverPublic = this.ServerKey;
if (serverPublic == null) {
Debug.Error("Server public key is invalid.");
return;
}
HandshakeResponse response = new HandshakeResponse();
response.Key = serverPublic;
senderClient.SendMessage(MessageType.ClientHandshakeResponse, response);
}
break;
/* Authorization request. */
case MessageType.AuthorizationRequest: {
AuthorizationRequest request = AuthorizationRequest.Parser.ParseFrom(messageContent);
senderClient.Profile.UpdateProfile(request);
AuthorizationResponse response = new AuthorizationResponse();
response.ServerName = this.m_serverConfig.ServerName;
senderClient.SendMessage(MessageType.AuthorizationResponse, response);
Task.Run(() => {
ContactUpdate contactUpdate = new ContactUpdate();
contactUpdate.Add.Add(senderClient.ContactClient);
foreach (NetworkClient connectedClient in this.m_connectedClients) {
if (connectedClient.ClientId == senderClient.ClientId) continue;
Debug.Log("Sending contact update to ClientId={0}.", connectedClient.ClientId);
connectedClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
}
});
}
break;
/* Contact list update. */
case MessageType.ContactUpdateRequest: {
ContactUpdateRequest request = ContactUpdateRequest.Parser.ParseFrom(messageContent);
ContactUpdate contactUpdate = new ContactUpdate();
List<long> clientList = request.Clients.ToList();
foreach (NetworkClient connectedClient in this.m_connectedClients) {
// if (connectedClient.ClientId == senderClient.ClientId) continue;
if (!connectedClient.Profile.Valid) continue;
if (clientList.Contains(connectedClient.ClientId)) {
Debug.Log("Client {0} has got ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
clientList.Remove(connectedClient.ClientId);
}
else {
Debug.Log("Client {0} requires ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
contactUpdate.Add.Add(connectedClient.ContactClient);
}
}
Debug.Log("Trash clients count={0}.", clientList.Count);
if (clientList.Count > 0) {
contactUpdate.Remove.Add(clientList);
}
senderClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
}
break;
case MessageType.ContactUpdateChangeRequest: {
ContactUpdateChangeRequest clientRequestedChange = ContactUpdateChangeRequest.Parser.ParseFrom(messageContent);
var senderProfile = senderClient.Profile;
if (senderProfile.Name != clientRequestedChange.Name || senderProfile.Surname != clientRequestedChange.Surname) {
Debug.Log("Updating client data. This is not implemented on the client side. ;)");
}
else if(senderProfile.Status != clientRequestedChange.Online) {
senderProfile.Status = clientRequestedChange.Online;
ContactUpdateStatus statusUpdate = new ContactUpdateStatus();
statusUpdate.Online = clientRequestedChange.Online;
statusUpdate.ClientId = senderClient.ClientId;
foreach (NetworkClient connectedClient in this.m_connectedClients) {
// if (connectedClient.ClientId == senderClient.ClientId) continue;
Debug.Log("Sending status update to ClientId={0}.", connectedClient.ClientId);
connectedClient.SendMessage(MessageType.ContactUpdateStatus, statusUpdate);
}
}
}
break;
/* Client Public Key request. */
case MessageType.MessageClientPublicRequest: {
MessageRequestClientPublic requestMessage = MessageRequestClientPublic.Parser.ParseFrom(messageContent);
PublicKey responseKey = null;
foreach (NetworkClient connectedClient in this.m_connectedClients) {
if (connectedClient.ClientId == requestMessage.ClientId) {
responseKey = connectedClient.ClientPublic;
}
}
if (responseKey != null) {
MessageResponseClientPublic responseMessage = new MessageResponseClientPublic();
responseMessage.ClientId = requestMessage.ClientId;
responseMessage.Key = responseKey;
senderClient.SendMessage(MessageType.MessageClientPublicResponse, responseMessage);
}
else
Debug.Warn("ClientId={0} has invalid public key.");
}
break;
}
}
private void ClientMessageReceived(NetworkClient senderClient, NetworkPacket receivedPacket)
{
NetworkClient requestedUser = this.GetClientFromId(receivedPacket.ClientId);
if (requestedUser == null) {
Debug.Warn("Invalid ClientId={0} requested from ClientId={1}.", receivedPacket.ClientId, senderClient.ClientId);
return;
}
Debug.Log("Forwarding message from ClientId={0} to ClientId={1}.", senderClient.ClientId, receivedPacket.ClientId);
requestedUser.ForwardNetworkPacket(senderClient.ClientId, receivedPacket);
}
private void ServerListener()
{
while (this.m_serverListener != null) {
TcpClient tcpClient = this.m_serverListener.AcceptTcpClient();
Debug.Log("New client connection.");
NetworkClient networkClient = new NetworkClient(tcpClient, this.ClientKeyRequester);
networkClient.onServerMessageRequest += this.ServerMessageReceived;
networkClient.onClientMessageRequest += this.ClientMessageReceived;
networkClient.onClientDisconnected += this.ClientDisconnectHandler;
this.m_connectedClients.Add(networkClient);
networkClient.Start();
}
}
