public override void EncodePayload()
{
WriteTriad(SequenceId, ByteOrder.Little);
for (int i = 0; i < Packets.Length; i++)
{
EncapsulatedPacket packet = Packets[i];
packet.WriteToCustomPacket(this);
}
}
public void SendPacket(HighLevelPacket packet, Reliability reliability = Reliability.Reliable)
{
byte[] buf = packet.Encode();
EncapsulatedPacket encapsulatedPacket = new EncapsulatedPacket(reliability, SendMessageId++, buf);
EncapsulatedPacket[] packets = encapsulatedPacket.GetSplitEncapsulatedPackets(SendSplitId++, MtuSize);
for (int i = 0; i < packets.Length; i++)
{
SendDataPacket(packets[i].Encode());
}
}
public void AddEncapsulatedToQueue(EncapsulatedPacket packet, int flags = RakNetProtocol.FlagNormal)
{
if (RakNetPacketReliability.IsReliable(packet.Reliability))
{
packet.MessageIndex = this.MessageIndex++;
if (RakNetPacketReliability.IsOrdered(packet.Reliability))
{
packet.OrderIndex = this.OrderIndexes[packet.OrderChannel]++;
}
}
if (packet.GetTotalLength() + 4 > this.MTUSize)
{
byte[][] buffers = Binary.SplitBytes(new MemorySpan(packet.Buffer), this.MTUSize - 60);
int splitID = ++this.SplitID % 65536;
for (int i = 0; i < buffers.Length; i++)
{
EncapsulatedPacket pk = new EncapsulatedPacket();
pk.SplitID = splitID;
pk.HasSplit = true;
pk.SplitCount = buffers.Length;
pk.Reliability = packet.Reliability;
pk.SplitIndex = i;
pk.Buffer = buffers[i];
if (i > 0)
{
pk.MessageIndex = this.MessageIndex++;
}
else
{
pk.MessageIndex = packet.MessageIndex;
}
if (RakNetPacketReliability.IsOrdered(packet.Reliability))
{
pk.OrderChannel = packet.OrderChannel;
pk.OrderIndex = packet.OrderIndex;
}
this.AddToQueue(pk, RakNetProtocol.FlagImmediate);
}
}
else
{
this.AddToQueue(packet, flags);
}
}
internal void Close(string msg, bool serverClose = true)
{
if (serverClose)
{
CLIENT_DISCONNECT_DataPacket pk = new CLIENT_DISCONNECT_DataPacket();
pk.Encode();
EncapsulatedPacket ep = new EncapsulatedPacket();
ep.buffer = pk.ToArray();
ep.reliability = PacketReliability.UNRELIABLE;
SendPacket(ep);
}
Server.Instance.NetworkManager.RemovePlayerFromRakNet(RakNetServer.IPEndPointToID(this.point));
this.server.RemoveSession(this.point, msg);
}
private void OnEncapsulatedPacket(EncapsulatedPacket encapsulatedPacket)
{
byte[] buf = encapsulatedPacket.Payload;
IPacket packet = _client.GetPacketFactory().GetPacket(buf[0]);
packet.Decode(buf);
switch (packet)
{
case ConnectionEstablishmentPacket _:
Console.WriteLine($"[{EndPoint}] ConnectionEstablishment!");
break;
case CustomDataPacket customDataPacket:
_receiveCustomDataPacketCallback?.Invoke(new ReceiveCustomDataPacketData(this, customDataPacket));
break;
}
}
public void HandleEncapsulatedPacket(EncapsulatedPacket packet)
{
if (packet.MessageIndex != -1)
{
if (packet.MessageIndex < this.ReliableWindowStart || packet.MessageIndex > this.ReliableWindowEnd ||
this.ReliableWindow.ContainsKey(packet.MessageIndex))
{
return;
}
this.ReliableWindow[packet.MessageIndex] = true;
if (packet.MessageIndex == this.ReliableWindowStart)
{
for (; this.ReliableWindow.ContainsKey(this.ReliableWindowStart); ++this.ReliableWindowStart)
{
bool v;
this.ReliableWindow.TryRemove(this.ReliableWindowStart, out v);
++this.ReliableWindowEnd;
}
}
if (packet.HasSplit && (packet = this.HandleSplit(packet)) == null)
{
return;
}
RakNetEncapsulatedReceiveEventArgs ev = new RakNetEncapsulatedReceiveEventArgs(this, packet);
Server.Instance.Event.Network.OnRakNetEncapsulatedReceive(this, ev);
if (ev.IsCancel)
{
return;
}
packet = ev.Packet;
this.HandleEncapsulatedPacketRoute(packet);
}
else
{
this.HandleEncapsulatedPacketRoute(packet);
}
}
public EncapsulatedPacket HandleSplit(EncapsulatedPacket packet)
{
if (!this.SplitPackets.ContainsKey(packet.SplitID))
{
this.SplitPackets.TryAdd(packet.SplitID, new ConcurrentDictionary <int, EncapsulatedPacket>());
if (!this.SplitPackets[packet.SplitID].ContainsKey(packet.SplitIndex))
{
this.SplitPackets[packet.SplitID].TryAdd(packet.SplitIndex, packet);
}
}
else
{
if (!this.SplitPackets[packet.SplitID].ContainsKey(packet.SplitIndex))
{
this.SplitPackets[packet.SplitID].TryAdd(packet.SplitIndex, packet);
}
}
if (this.SplitPackets[packet.SplitID].Count == packet.SplitCount)
{
EncapsulatedPacket pk = new EncapsulatedPacket();
ConcurrentDictionary <int, EncapsulatedPacket> d;
int offset = 0;
pk.Buffer = new byte[0];
for (int i = 0; i < packet.SplitCount; ++i)
{
EncapsulatedPacket p = this.SplitPackets[packet.SplitID][i];
byte[] buffer = pk.Buffer;
Array.Resize(ref buffer, pk.Buffer.Length + p.Buffer.Length);
pk.Buffer = buffer;
Buffer.BlockCopy(p.Buffer, 0, pk.Buffer, offset, p.Buffer.Length);
offset += p.Buffer.Length;
}
pk.Length = pk.Buffer.Length;
this.SplitPackets.TryRemove(pk.SplitID, out d);
return(pk);
}
return(null);
}
public void HandleConnectedPacket(EncapsulatedPacket packet)
{
byte[] buffer = packet.Payload;
RakNetPacket pk = Server.Socket.PacketIdentifier.GetPacketFormId(buffer[0]);
pk.EndPoint = PeerEndPoint;
pk.SetBuffer(buffer);
pk.DecodeHeader();
pk.DecodePayload();
if (pk is ConnectionRequest connectionRequest && State == RakNetPeerState.Connected)
{
ConnectionRequestAccepted accepted = new ConnectionRequestAccepted();
accepted.PeerAddress = PeerEndPoint;
accepted.ClientTimestamp = connectionRequest.Timestamp;
accepted.ServerTimestamp = TimeSpan.FromMilliseconds(Environment.TickCount);
accepted.EndPoint = PeerEndPoint;
SendEncapsulatedPacket(accepted, Reliability.Unreliable, 0);
State = RakNetPeerState.Handshaking;
}
private void SplitPackets(EncapsulatedPacket packet)
{
if (!splitPackets.ContainsKey(packet.splitID))
{
splitPackets.Add(packet.splitID, new Dictionary <int, EncapsulatedPacket>());
if (!splitPackets[packet.splitID].ContainsKey(packet.splitIndex))
{
splitPackets[packet.splitID].Add(packet.splitIndex, packet);
}
}
else
{
if (!splitPackets[packet.splitID].ContainsKey(packet.splitIndex))
{
splitPackets[packet.splitID].Add(packet.splitIndex, packet);
}
}
if (splitPackets[packet.splitID].Count == packet.splitCount)
{
EncapsulatedPacket pk = new EncapsulatedPacket();
int offset = 0;
pk.buffer = new byte[0];
for (int i = 0; i < packet.splitCount; ++i)
{
EncapsulatedPacket p = splitPackets[packet.splitID][i];
Array.Resize(ref pk.buffer, pk.buffer.Length + p.buffer.Length);
Buffer.BlockCopy(p.buffer, 0, pk.buffer, offset, p.buffer.Length);
offset += p.buffer.Length;
}
pk.length = pk.buffer.Length;
splitPackets.Remove(pk.splitID);
EncapsulatedPacketHandler(pk);
}
}
private void EncapsulatedPacketHandle(EncapsulatedPacket packet)
{
if (packet.hasSplit)
{
SplitPackets(packet);
return;
}
if (encapsulatedPacketWindow.ContainsKey(packet.messageIndex))
{
if (packet.messageIndex != -1)
{
Logger.Log("Handled Packet Handle!<{0}>", packet.messageIndex);
return;
}
}
else
{
encapsulatedPacketWindow.Add(packet.messageIndex, packet.messageIndex);
}
EncapsulatedPacketHandler(packet);
}
public void AddToQueue(EncapsulatedPacket pk, int flags = RakNetProtocol.FlagNormal)
{
if (flags == RakNetProtocol.FlagImmediate)
{
DataPacket p = new DataPacket0();
p.Packets = new object[] { pk };
this.SendDatagram(p);
return;
}
int length = this.SendQueue.GetLength();
if (length + pk.GetTotalLength() > this.MTUSize - 36
) //IP header (20 bytes) + UDP header (8 bytes) + RakNet weird (8 bytes) = 36 bytes
{
this.SendQueuePacket();
}
List <object> list = new List <object>(this.SendQueue.Packets);
list.Add(pk);
this.SendQueue.Packets = list.ToArray();
}
public void QueueConnectedPacket(RakNetPacket packet, int reliability, int orderChannel,
int flags = RakNetProtocol.FlagNormal)
{
packet.Encode();
EncapsulatedPacket pk = new EncapsulatedPacket();
pk.Reliability = reliability;
pk.OrderChannel = orderChannel;
pk.Buffer = packet.ToArray();
RakNetEncapsulatedSendEventArgs ev = new RakNetEncapsulatedSendEventArgs(this, pk);
Server.Instance.Event.Network.OnRakNetEncapsulatedSend(this, ev);
if (ev.IsCancel)
{
return;
}
pk = ev.Packet;
this.AddEncapsulatedToQueue(pk, flags);
}
public override void HandleEncapsulatedPacket(EncapsulatedPacket packet)
{
base.HandleEncapsulatedPacket(packet);
if (packet.Reliability.IsUnreliable())
{
HandleConnectedPacket(packet);
}
else if (packet.Reliability.IsReliable())
{
if (packet.MessageIndex < StartMessageWindow ||
packet.MessageIndex > EndMessageWindow || MessageWindow.ContainsKey(packet.MessageIndex))
{
return;
}
MessageWindow.TryAdd(packet.MessageIndex, true);
if (packet.MessageIndex == StartMessageWindow)
{
for (; MessageWindow.ContainsKey(StartMessageWindow); ++StartMessageWindow)
{
MessageWindow.TryRemove(StartMessageWindow, out bool v);
++EndMessageWindow;
}
}
if (packet.Split)
{
HandleSplitEncapsulatedPacket(packet);
return;
}
HandleConnectedPacket(packet);
}
}
public void HandleSplitEncapsulatedPacket(EncapsulatedPacket packet)
{
if (!SplitPackets.ContainsKey(packet.SplitId))
{
SplitPackets.TryAdd(packet.SplitId, new ConcurrentDictionary <int, EncapsulatedPacket>());
if (!SplitPackets[packet.SplitId].ContainsKey(packet.SplitIndex))
{
SplitPackets[packet.SplitId].TryAdd(packet.SplitIndex, packet);
}
}
else
{
if (!SplitPackets[packet.SplitId].ContainsKey(packet.SplitIndex))
{
SplitPackets[packet.SplitId].TryAdd(packet.SplitIndex, packet);
}
}
if (SplitPackets[packet.SplitId].Count == packet.SplitCount)
{
EncapsulatedPacket pk = new EncapsulatedPacket();
BinaryStream stream = new BinaryStream();
for (int i = 0; i < packet.SplitCount; ++i)
{
EncapsulatedPacket p = SplitPackets[packet.SplitId][i];
byte[] buffer = p.Payload;
stream.WriteBytes(buffer);
}
pk.Payload = stream.ToArray();
SplitPackets.TryRemove(pk.SplitId, out ConcurrentDictionary <int, EncapsulatedPacket> d);
HandleConnectedPacket(pk);
}
}
public void HandleEncapsulatedPacketRoute(EncapsulatedPacket packet)
{
if (this.Manager == null)
{
return;
}
int id = packet.Buffer[0];
RakNetPacket pk = this.Manager.GetRakNetPacket(id, packet.Buffer);
if (pk != null)
{
if (id < 0x86)
{
if (this.State == SessionState.Connecting)
{
if (id == RakNetProtocol.ClientConnectDataPacket)
{
ClientConnectDataPacket ccd = (ClientConnectDataPacket)pk;
ServerHandShakeDataPacket shd = new ServerHandShakeDataPacket();
shd.EndPoint = this.EndPoint;
shd.SendPing = ccd.SendPing;
shd.SendPong = ccd.SendPing + 1000;
this.QueueConnectedPacket(shd, RakNetPacketReliability.UNRELIABLE, -1,
RakNetProtocol.FlagImmediate);
}
else if (id == RakNetProtocol.ClientHandShakeDataPacket)
{
ClientHandShakeDataPacket chsd = (ClientHandShakeDataPacket)pk;
if (chsd.EndPoint.Port == Server.Instance.EndPoint.Port)
{
this.State = SessionState.Connected;
}
}
}
else if (id == RakNetProtocol.ClientDisconnectDataPacket)
{
this.Disconnect("clientDisconnect");
}
else if (id == RakNetProtocol.OnlinePing)
{
OnlinePing ping = (OnlinePing)pk;
OnlinePong pong = new OnlinePong();
pong.PingID = ping.PingID;
this.LastPingTime = SendPingTime;
this.QueueConnectedPacket(pong, RakNetPacketReliability.UNRELIABLE, -1,
RakNetProtocol.FlagImmediate);
}
else if (id == RakNetProtocol.OnlinePong)
{
}
}
else if (this.State == SessionState.Connected)
{
if (id == RakNetProtocol.BatchPacket)
{
this.HandleBatchPacket((BatchPacket)pk);
}
}
}
}
private void EncapsulatedPacketHandler(EncapsulatedPacket packet)
{
int id = packet.buffer[0];
if (id < 0x80)
{
if (id == CLIENT_DISCONNECT_DataPacket.ID)
{
Close("ClientDisconnect", false);
}
else if (this.state == STATE_CONNECTING)
{
if (id == CLIENT_CONNECT_DataPacket.ID)
{
CLIENT_CONNECT_DataPacket ccd = new CLIENT_CONNECT_DataPacket();
ccd.SetBuffer(packet.buffer);
ccd.Decode();
SERVER_HANDSHAKE_DataPacket shd = new SERVER_HANDSHAKE_DataPacket();
shd.EndPoint = this.point;
shd.SendPing = ccd.SendPing;
shd.SendPong = ccd.SendPing + 1000;
shd.Encode();
EncapsulatedPacket enc = new EncapsulatedPacket();
enc.buffer = shd.ToArray();
enc.reliability = PacketReliability.UNRELIABLE;
SendPacket(enc);
}
else if (id == CLIENT_HANDSHAKE_DataPacket.ID)
{
CLIENT_HANDSHAKE_DataPacket chd = new CLIENT_HANDSHAKE_DataPacket();
chd.SetBuffer(packet.buffer);
chd.Decode();
if (chd.EndPoint.Port == this.server.GetPort())
{
this.state = STATE_CONNECTED;
}
}
}
else if (id == PING_DataPacket.ID)
{
PING_DataPacket ping = new PING_DataPacket();
ping.SetBuffer(packet.buffer);
ping.Decode();
PONG_DataPacket pong = new PONG_DataPacket();
pong.PingID = ping.PingID;
pong.Encode();
EncapsulatedPacket enc = new EncapsulatedPacket();
enc.buffer = pong.ToArray();
enc.reliability = PacketReliability.UNRELIABLE;
SendPacket(enc);
}
}
else if (id == 0xfe && this.state == STATE_CONNECTED)
{
Server.Instance.NetworkManager.HandleBatchPacket(this, packet.buffer);
}
}
public void SendPacket(EncapsulatedPacket packet, bool notQueue = false)
{
if (this.server != null)
{
if (notQueue)
{
DataPacket_0 pk = new DataPacket_0();
pk.SeqNumber = this.sendSeqNumber++;
pk.Packets = new[]
{
packet
};
this.AddResendQueue(pk);
this.server.SendPacket(pk, this.point.Address, this.point.Port);
return;
}
else
{
if (packet.GetTotalLength() + 4 > this.mtuSize)
{
byte[][] buffers = Binary.SplitBytes(new MemorySpan(packet.buffer), this.mtuSize - 60);
int splitID = this.splitID++ % 65536;
for (int i = 0; i < buffers.Length; ++i)
{
EncapsulatedPacket pk = new EncapsulatedPacket();
pk.splitID = splitID;
pk.hasSplit = true;
pk.splitCount = buffers.Length;
pk.reliability = PacketReliability.UNRELIABLE;
pk.splitIndex = i;
pk.buffer = buffers[i];
if (i > 0)
{
pk.messageIndex = this.messageIndex++;
}
else
{
pk.messageIndex = this.messageIndex;
}
DataPacket_0 dp = new DataPacket_0();
dp.SeqNumber = this.sendSeqNumber++;
dp.Packets = new[]
{
pk
};
this.AddResendQueue(dp);
this.server.SendPacket(dp, this.point.Address, this.point.Port);
}
}
else
{
DataPacket_4 pk = new DataPacket_4();
pk.SeqNumber = this.sendSeqNumber++;
pk.Packets = new[]
{
packet
};
this.packetQueue.Enqueue(pk);
}
}
}
}
public RakNetEncapsulatedSendEventArgs(NetworkSession session, EncapsulatedPacket packet)
{
this.Session = session;
this.Packet = packet;
}
private int Comparison(EncapsulatedPacket x, EncapsulatedPacket y)
{
return(x.SplitIndex.CompareTo(y.SplitIndex));
}
public void OnReceive(DataPacket dataPacket)
{
AckPacket packet = new AckPacket(new[] { dataPacket.SequenceId });
_client.Send(EndPoint, packet);
if (dataPacket.SequenceId > ReceiveSequenceId)
{
uint seq = dataPacket.SequenceId - ReceiveSequenceId;
for (uint i = 0; i < seq; i++)
{
NackPacket nackPacket = new NackPacket(new[] { dataPacket.SequenceId - i - 1 });
_client.Send(EndPoint, nackPacket);
}
}
if (dataPacket.SequenceId >= ReceiveSequenceId)
{
ReceiveSequenceId = dataPacket.SequenceId + 1;
}
EncapsulatedPacket encapsulatedPacket = new EncapsulatedPacket();
encapsulatedPacket.Decode(dataPacket.Data);
if (encapsulatedPacket.IsSplit)
{
if (!SplitsPackets.ContainsKey(encapsulatedPacket.SplitId))
{
SplitsPackets[encapsulatedPacket.SplitId] =
new List <EncapsulatedPacket>();
}
SplitsPackets[encapsulatedPacket.SplitId].Add(encapsulatedPacket);
if (SplitsPackets[encapsulatedPacket.SplitId].Count == encapsulatedPacket.LastSplitIndex + 1)
{
SplitsPackets[encapsulatedPacket.SplitId].Sort(Comparison);
BinaryStream stream = new BinaryStream();
foreach (var splitsPacket in SplitsPackets[encapsulatedPacket.SplitId])
{
stream.WriteBytes(splitsPacket.Payload);
}
SplitsPackets.Remove(encapsulatedPacket.SplitId);
encapsulatedPacket = new EncapsulatedPacket(encapsulatedPacket.Reliability,
encapsulatedPacket.MessageId, stream.GetBuffer());
}
else
{
return;
}
}
if (!MessageWindow.Contains(encapsulatedPacket.MessageId))
{
if (MessageWindow.Count >= 50)
{
MessageWindow.RemoveAt(0);
}
MessageWindow.Add(encapsulatedPacket.MessageId);
OnEncapsulatedPacket(encapsulatedPacket);
}
}
public PeerHandleEncapsulatesPacketEventArgs(RakNetPeer peer, EncapsulatedPacket packet) : base(peer)
{
Packet = packet;
}
public virtual void HandleEncapsulatedPacket(EncapsulatedPacket packet)
{
new PeerHandleEncapsulatesPacketEventArgs(this, packet)
.Invoke(this, PeerHandleEncapsulatesPacketEvent);
}
