public RemotePeer Connect(EndPoint remoteEndpoint)
{
RemotePeer remotePeer = new RemotePeer()
{
ConnectionState = ConnectState.WaitingForChallenge,
ChallengeSeed = RandomUtils.GetULong(Constants.USE_CRYPTO_RANDOM),
RemoteEndpoint = remoteEndpoint
};
PendingPeers.Add(new ConnectKey(remoteEndpoint, remotePeer.ChallengeSeed), remotePeer);
ConnectionRequestPacket packet = new ConnectionRequestPacket(remotePeer.ChallengeSeed);
SendPacket(packet, remotePeer);
for (int i = 0; i < Constants.CONNECTION_SEGMENT_RETRIES - 1; i++)
{
_network.PacketScheduler.Add(DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, Constants.CONNECTION_SEGMENT_RETRY_TIMEOUT * i)), new ScheduledPacket()
{
Packet = packet,
LocalPeer = this,
RemotePeer = remotePeer
});
}
return(remotePeer);
}
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 SendConnectionRequest()
{
ConnectionRequestPacket request = new ConnectionRequestPacket();
request.payload.clientSalt = UlongRandom.GetRandom();
SendToServer(request);
}
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;
}
}
void OnConnectionRequest(Stream stream, IPEndPoint ipEndPoint)
{
if (NetworkManager.Instance.isServer)
{
ConnectionRequestPacket packet = new ConnectionRequestPacket();
packet.Deserialize(stream);
long clientSalt = packet.payload.clientSalt;
long serverSalt = -1;
uint id = 0;
if (ipToId.ContainsKey(ipEndPoint))
{
id = ipToId[ipEndPoint];
serverSalt = clients[id].serverSalt;
}
else
{
serverSalt = (long)Random.Range(0, float.MaxValue);
id = AddClient(clientSalt, serverSalt, ipEndPoint);
}
if (id == DECLINED)
{
SendDeclinedRequest(ipEndPoint);
}
else
{
SendChallengeRequest(id, clientSalt, serverSalt, ipEndPoint);
}
}
}
void SendConnectionRequest()
{
ConnectionRequestPacket packet = new ConnectionRequestPacket();
packet.payload.clientSalt = clientSalt;
PacketManager.Instance.SendPacketToServer(packet);
}
private void SendConnectionRequest()
{
ConnectionRequestPacket requestPacket = new ConnectionRequestPacket();
requestPacket.payload.clientSalt = clientSalt;
Debug.Log("SendConnectionRequest");
SendToServer(requestPacket);
}
private void OnConnectionRequest(IPEndPoint iPEndPoint, Stream stream)
{
Debug.Log("OnConnectionRequest");
ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket();
connectionRequestPacket.Deserialize(stream);
SendChallengeRequest(iPEndPoint, connectionRequestPacket.payload);
}
void SendConnectionRequest()
{
Debug.Log("Enviando Connection Request");
ConnectionRequestPacket packet = new ConnectionRequestPacket();
packet.payload = clientDirt;
PacketsManager.Instance.SendPacket(packet, objectId);
}
void SendConnectionRequest()
{
ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket();
ConnectionRequestData connectionRequestData;
connectionRequestData.clientSalt = saltGeneratedByClient;
connectionRequestPacket.Payload = connectionRequestData;
PacketsManager.Instance.SendPacket(connectionRequestPacket);
}
private void SendConnectionRequest()
{
Debug.Log("Sending connection request");
ConnectionRequestPacket connectionRequestPacket = new ConnectionRequestPacket();
connectionRequestPacket.payload.clientSalt = (ulong)UnityEngine.Random.Range(0, ulong.MaxValue);
SendToServer(connectionRequestPacket);
}
public void TestConnectionRequestPacket()
{
Random rnd = new Random(0);
ulong val = (ulong)rnd.Next(int.MaxValue);
ConnectionRequestPacket packet1 = new ConnectionRequestPacket(val);
byte[] output = new byte[1024];
int written = packet1.Write(output, null);
ConnectionRequestPacket packet2 = new ConnectionRequestPacket();
packet2.Read(output, written);
Assert.AreEqual(packet1.ClientRandom, packet2.ClientRandom);
}
public void ConnectToServer(string ipAddress, int port, string username, string password)
{
if (_serverConnection != null && _serverConnection.Status == NetConnectionStatus.Connected)
{
throw new Exception("Client is already connected to a server.");
}
ConnectionRequestPacket packet = new ConnectionRequestPacket
{
Username = username,
Password = password
};
NetOutgoingMessage message = _client.CreateMessage();
MemoryStream stream = new MemoryStream();
Serializer.Serialize(stream, packet);
message.Write(stream.ToArray());
_serverConnection = _client.Connect(ipAddress, port, message);
_logger.Info($"Connecting to server: {ipAddress + ":" + port}");
}
public void ReceivingConnectionRequest(Stream stream, IPEndPoint iPEnd)
{
if (NetworkManager.Instance.isServer)
{
ConnectionRequestPacket requestPacket = new ConnectionRequestPacket();
requestPacket.Deserialize(stream);
long cSalt = requestPacket.payload.clientSalt;
long sSalt = -1;
int cId = -1;
if (NetworkManager.Instance.ipToId.ContainsKey(iPEnd))
{
cId = NetworkManager.Instance.ipToId[iPEnd];
Client client = NetworkManager.Instance.clients[cId];
sSalt = NetworkManager.Instance.clients[cId]._serverSalt;
}
else
{
sSalt = NetworkManager.Instance.rnd.Next(999999999);
cId = NetworkManager.Instance.AddClient(cSalt, sSalt, iPEnd);
}
SendChallengeRequest(requestPacket.payload, cId, cSalt, sSalt, iPEnd);
}
}
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;
}
}
private void HandlePacket(byte[] data, int length, EndPoint fromEndpoint)
{
if (length < 1)
{
// TODO: Shit hit the fan
}
PacketType type = (PacketType)data[0];
switch (type)
{
case PacketType.ConnectionRequest:
{
ConnectionRequestPacket connectionRequest = new ConnectionRequestPacket();
if (connectionRequest.Read(data, length) && !PendingPeers.ContainsKey(new ConnectKey(fromEndpoint, connectionRequest.ClientRandom)))
{
ulong localSessionPart = RandomUtils.GetULong(Constants.USE_CRYPTO_RANDOM);
RemotePeer peer = new RemotePeer()
{
ChallengeData = connectionRequest.ClientRandom,
RemoteEndpoint = fromEndpoint,
ConnectionState = ConnectState.WaitingForChallengeResponse,
ChallengeSeed = localSessionPart,
ChallengeResult = localSessionPart ^ connectionRequest.ClientRandom,
LastIncomingMessageDate = DateTime.Now
};
PendingPeers.Add(new ConnectKey(fromEndpoint, connectionRequest.ClientRandom), peer);
ChallengePacket packet = new ChallengePacket(peer.ChallengeData, peer.ChallengeSeed);
SendPacket(packet, peer);
for (int i = 0; i < Constants.CONNECTION_SEGMENT_RETRIES - 1; i++)
{
_network.PacketScheduler.Add(DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, Constants.CONNECTION_SEGMENT_RETRY_TIMEOUT * i)), new ScheduledPacket()
{
Packet = packet,
LocalPeer = this,
RemotePeer = peer
});
}
}
}
break;
case PacketType.Challenge:
{
ChallengePacket challenge = new ChallengePacket();
if (challenge.Read(data, length) && PendingPeers.ContainsKey(new ConnectKey(fromEndpoint, challenge.ClientRandom)))
{
RemotePeer peer = PendingPeers[new ConnectKey(fromEndpoint, challenge.ClientRandom)];
if (peer.ConnectionState == ConnectState.WaitingForChallenge)
{
peer.CreateChannels(_network.ChannelTypes);
peer.LastIncomingMessageDate = DateTime.Now;
peer.ChallengeData = challenge.ServerRandom;
peer.ChallengeResult = peer.ChallengeData ^ peer.ChallengeSeed;
peer.ConnectionState = ConnectState.Connected;
PendingPeers.Remove(new ConnectKey(fromEndpoint, challenge.ClientRandom));
Connected.Add(fromEndpoint, peer);
incomingEvents.Enqueue(new NetworkEvent()
{
EventType = EventType.Connect,
Packet = null,
RemotePeer = peer,
LocalPeer = this
});
ChallengeResponsePacket packet = new ChallengeResponsePacket(peer.ChallengeSeed, peer.ChallengeData, peer.ChallengeResult);
SendPacket(packet, peer);
for (int i = 0; i < Constants.CONNECTION_SEGMENT_RETRIES - 1; i++)
{
_network.PacketScheduler.Add(DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, Constants.CONNECTION_SEGMENT_RETRY_TIMEOUT * i)), new ScheduledPacket()
{
Packet = packet,
LocalPeer = this,
RemotePeer = peer
});
}
}
}
}
break;
case PacketType.ChallengeResponse:
{
ChallengeResponsePacket challengeResponse = new ChallengeResponsePacket();
if (challengeResponse.Read(data, length) && PendingPeers.ContainsKey(new ConnectKey(fromEndpoint, challengeResponse.ClientRandom)))
{
RemotePeer peer = PendingPeers[new ConnectKey(fromEndpoint, challengeResponse.ClientRandom)];
if (peer.ConnectionState == ConnectState.WaitingForChallengeResponse && peer.ChallengeResult == challengeResponse.ChallengeResponse)
{
peer.CreateChannels(_network.ChannelTypes);
peer.LastIncomingMessageDate = DateTime.Now;
peer.ConnectionState = ConnectState.Connected;
PendingPeers.Remove(new ConnectKey(fromEndpoint, challengeResponse.ClientRandom));
Connected.Add(fromEndpoint, peer);
incomingEvents.Enqueue(new NetworkEvent()
{
EventType = EventType.Connect,
Packet = null,
RemotePeer = peer,
LocalPeer = this
});
}
}
}
break;
case PacketType.Data:
{
ChanneledPacket channeledPacket = new ChanneledPacket();
if (channeledPacket.Read(data, length) && Connected.ContainsKey(fromEndpoint))
{
RemotePeer peer = Connected[fromEndpoint];
if (peer.ConnectionState == ConnectState.Connected)
{
ChanneledPacket incomingPacket = peer.Channels[channeledPacket.Channel].HandleIncomingMessagePoll(data, length, out bool hasMore);
while (incomingPacket != null)
{
peer.LastIncomingMessageDate = DateTime.Now;
incomingEvents.Enqueue(new NetworkEvent()
{
EventType = EventType.Data,
Packet = incomingPacket,
RemotePeer = peer,
LocalPeer = this
});
if (!hasMore)
{
break;
}
incomingPacket = peer.Channels[channeledPacket.Channel].HandlePoll();
}
}
}
}
break;
case PacketType.Disconnect:
{
DisconnectPacket disconnectPacket = new DisconnectPacket();
if (disconnectPacket.Read(data, length) && Connected.ContainsKey(fromEndpoint))
{
RemotePeer peer = Connected[fromEndpoint];
peer.ConnectionState = ConnectState.Disconnected;
Connected.Remove(fromEndpoint);
incomingEvents.Enqueue(new NetworkEvent()
{
EventType = EventType.Disconnect,
Packet = null,
RemotePeer = peer,
LocalPeer = this
});
}
}
break;
case PacketType.Ack:
{
AckPacket ackPacket = new AckPacket();
if (ackPacket.Read(data, length) && Connected.ContainsKey(fromEndpoint))
{
RemotePeer peer = Connected[fromEndpoint];
if (peer.Channels[ackPacket.Channel].SupportsAck)
{
peer.Channels[ackPacket.Channel].HandleAck(ackPacket);
}
}
}
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;
}
}
