public void OnReceivePacket(IPEndPoint ipEndpoint, PacketType packetType, Stream stream)
{
switch (packetType)
{
case PacketType.ConnectionRequest: {
ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket();
connectionRequestPacket.Deserialize(stream);
CheckAndSendChallengeRequest(ipEndpoint, connectionRequestPacket.payload);
} break;
case PacketType.ChallengeRequest: {
ChallengeRequestPacket challengeRequestPacket = new ChallengeRequestPacket();
challengeRequestPacket.Deserialize(stream);
CheckAndSendChallengeResponse(ipEndpoint, challengeRequestPacket.payload);
} break;
case PacketType.ChallengeResponse: {
ChallengeResponsePacket challengeResponsePacket = new ChallengeResponsePacket();
challengeResponsePacket.Deserialize(stream);
CheckResult(ipEndpoint, challengeResponsePacket.payload);
} break;
case PacketType.Connected: {
FinishHandShake();
} break;
}
}
public void OnReceivePacket(IPEndPoint ipEndpoint, PacketType packetType, Stream stream)
{
switch (packetType)
{
case PacketType.ConnectionRequest:
ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket();
connectionRequestPacket.Deserialize(stream);
CheckAndSendChallengeRequest(ipEndpoint, connectionRequestPacket.payload);
break;
case PacketType.ChallengeRequest:
ChallengeRequestPacket challengeRequestPacket = new ChallengeRequestPacket();
challengeRequestPacket.Deserialize(stream);
CheckAndSendChallengeResponse(ipEndpoint, challengeRequestPacket.payload);
break;
case PacketType.ChallengeResponse:
ChallengeResponsePacket challengeResponsePacket = new ChallengeResponsePacket();
challengeResponsePacket.Deserialize(stream);
CheckResult(ipEndpoint, challengeResponsePacket.payload);
break;
case PacketType.Connected:
if (!isServer && currentState == State.RespondingChallenge)
{
currentState = State.Connected;
}
break;
}
}
private void OnChallengeResponse(IPEndPoint iPEndPoint, Stream stream)
{
Debug.Log("OnChallengeResponse");
ChallengeResponsePacket challengeResponsePacket = new ChallengeResponsePacket();
challengeResponsePacket.Deserialize(stream);
CheckResultForConnection(iPEndPoint, challengeResponsePacket.payload);
}
public void ReceivingChallengeResponse(Stream stream, IPEndPoint iPEnd)
{
if (NetworkManager.Instance.isServer)
{
ChallengeResponsePacket responsePacket = new ChallengeResponsePacket();
responsePacket.Deserialize(stream);
if (NetworkManager.Instance.ipToId.ContainsKey(iPEnd))
{
Client client = NetworkManager.Instance.clients[NetworkManager.Instance.ipToId[iPEnd]];
challengeResult = client._clientSalt ^ client._serverSalt;
if (responsePacket.payload.result == challengeResult)
{
client.state = Client.ClientConnection.Connected;
SendConnected(client._id, iPEnd);
}
}
}
}
void OnChallengeResponse(Stream stream, IPEndPoint iPEndPoint)
{
if (NetworkManager.Instance.isServer)
{
ChallengeResponsePacket packet = new ChallengeResponsePacket();
packet.Deserialize(stream);
if (ipToId.ContainsKey(iPEndPoint))
{
Client client = clients[ipToId[iPEndPoint]];
long result = client.clientSalt ^ client.serverSalt;
if (result == packet.payload.result)
{
client.state = Client.ClientState.Connected;
SendConnected(client.id, iPEndPoint);
}
}
}
}
void OnRecieve(ushort type, Stream stream, IPEndPoint ip)
{
switch (type)
{
case (ushort)PacketType.ConnectionRequest:
{
ConnectionRequestPacket packet = new ConnectionRequestPacket();
packet.Deserialize(stream);
AddNewClient(ip, packet.payload);
break;
}
case (ushort)PacketType.ChallengeRequest:
{
onConectionRequest = false;
ChallengeRequestPacket packet = new ChallengeRequestPacket();
packet.Deserialize(stream);
serverDirt = packet.payload;
DoChallenge();
break;
}
case (ushort)PacketType.ChallengeResponse:
{
ChallengeResponsePacket packet = new ChallengeResponsePacket();
packet.Deserialize(stream);
CheckChallengeRecieved(ip, packet.payload);
break;
}
case (ushort)PacketType.Conected:
OnConected();
break;
}
}
void ReceiveConnectionData(ushort packetTypeIndex, IPEndPoint ipEndPoint, Stream stream)
{
switch ((PacketType)packetTypeIndex)
{
case PacketType.ChallengeRequest:
if (!UdpNetworkManager.Instance.IsServer && clientConnectionState == ClientConnectionState.RequestingConnection)
{
ChallengeRequestPacket challengeRequestPacket = new ChallengeRequestPacket();
challengeRequestPacket.Deserialize(stream);
challengeResultGeneratedByClient = saltGeneratedByClient ^ challengeRequestPacket.Payload.serverSalt;
clientConnectionState = ClientConnectionState.SendingChallengeResponse;
}
break;
case PacketType.ConnectionAccepted:
if (!UdpNetworkManager.Instance.IsServer && clientConnectionState == ClientConnectionState.SendingChallengeResponse)
{
ConnectionAcceptedPacket connectionAcceptedPacket = new ConnectionAcceptedPacket();
connectionAcceptedPacket.Deserialize(stream);
UdpNetworkManager.Instance.SetClientID(connectionAcceptedPacket.Payload.clientID);
onClientConnectedCallback?.Invoke(connectionAcceptedPacket.Payload.clientsInSession);
onClientConnectedCallback = null;
clientConnectionState = ClientConnectionState.Connected;
}
break;
case PacketType.ClientJoined:
if (!UdpNetworkManager.Instance.IsServer && clientConnectionState == ClientConnectionState.Connected)
{
ClientJoinedPacket clientJoinedPacket = new ClientJoinedPacket();
clientJoinedPacket.Deserialize(stream);
OnOtherClientJoined.Invoke(clientJoinedPacket.Payload.clientID);
}
break;
case PacketType.ConnectionRequest:
if (UdpNetworkManager.Instance.IsServer && !udpClientsIDs.ContainsKey(ipEndPoint))
{
if (!udpPendingClientsData.ContainsKey(ipEndPoint))
{
ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket();
connectionRequestPacket.Deserialize(stream);
AddPendingClient(ipEndPoint, connectionRequestPacket.Payload.clientSalt);
}
UdpPendingClientData udpPendingClientData = udpPendingClientsData[ipEndPoint];
SendChallengeRequest(udpPendingClientData);
}
break;
case PacketType.ChallengeResponse:
if (UdpNetworkManager.Instance.IsServer)
{
if (udpPendingClientsData.ContainsKey(ipEndPoint))
{
ChallengeResponsePacket challengeResponsePacket = new ChallengeResponsePacket();
UdpPendingClientData udpPendingClientData = udpPendingClientsData[ipEndPoint];
challengeResponsePacket.Deserialize(stream);
long serverResult = udpPendingClientData.clientSalt ^ udpPendingClientData.serverSalt;
if (challengeResponsePacket.Payload.result == serverResult)
{
ClientJoinedPacket clientJoinedPacket = new ClientJoinedPacket();
ClientJoinedData clientJoinedData;
clientJoinedData.clientID = ClientID;
clientJoinedPacket.Payload = clientJoinedData;
PacketsManager.Instance.SendPacket(clientJoinedPacket, null, 0, 0, reliable: true);
AddClient(ipEndPoint);
RemovePendingClient(ipEndPoint);
OnClientAddedByServer?.Invoke(udpClientsIDs[ipEndPoint]);
}
}
if (udpClientsIDs.ContainsKey(ipEndPoint))
{
SendConnectionAccepted(udpClientsData[udpClientsIDs[ipEndPoint]]);
}
}
break;
}
}