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); }