public void Serialize_AckPacket() { AckPacket ack = new AckPacket(333); byte[] bytes = TftpPacketUtils.Serialize(ack); ack = (AckPacket)TftpPacketUtils.Parse(bytes); Debug.Assert(ack.BlockNumber == 333); }
internal override void HandleAck(AckPacket packet) { if (_outgoingPendingMessages.ContainsKey(packet.Sequence)) { _outgoingPendingMessages[packet.Sequence].ExplicitResponse = ExplicitResponseState.Ack; OnMessageAck(packet.Sequence); _outgoingPendingMessages.Remove(packet.Sequence); } }
public void OnAck(AckPacket ackPacket) { for (int i = 0; i < ackPacket.SequenceIds.Count; i++) { if (ReSendPackets.ContainsKey(ackPacket.SequenceIds[i])) { ReSendPackets.TryRemove(ackPacket.SequenceIds[i], out _); } } }
internal virtual void HandleAck(AckPacket packet) { if (SupportsAck) { throw new NotImplementedException("Not implemented"); } else { throw new NotSupportedException("Ack is not supported on this channel"); } }
public static AckPacket Deserialize(byte[] data) { AckPacket rv = new AckPacket(); MemoryStream ms = new MemoryStream(data); using (BinaryReader br = new BinaryReader(ms)) { rv.header = br.ReadBytes(2); rv.sequence = br.ReadInt32(); } return(rv); }
internal override void HandleAck(AckPacket packet) { if (_sendSequencer.HasMessage(packet.Sequence) && _sendSequencer.Peek(packet.Sequence).ExplicitResponse != ExplicitResponseState.Ack) { _sendSequencer.Peek(packet.Sequence).ExplicitResponse = ExplicitResponseState.Ack; OnMessageAck(packet.Sequence); } for (ushort i = packet.Sequence; _sendSequencer.HasMessage(i) && _sendSequencer.Peek(i).ExplicitResponse == ExplicitResponseState.Ack; i++) { _lowestAckedMessage = i; } }
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); } }
static void EncodeAckMessage(IByteBufferAllocator bufferAllocator, AckPacket packet, List <object> output) { byte[] packetPayload = null; switch (packet.PacketType) { case NATSPacketType.ACK_ACK: packetPayload = ACK_ACK_BYTES; break; case NATSPacketType.ACK_NAK: packetPayload = ACK_NAK_BYTES; break; case NATSPacketType.ACK_PROGRESS: packetPayload = ACK_PROGRESS_BYTES; break; case NATSPacketType.ACK_NEXT: packetPayload = ACK_NEXT_BYTES; break; case NATSPacketType.ACK_TERM: packetPayload = ACK_TERM_BYTES; break; default: packetPayload = ACK_ACK_BYTES; break; } byte[] SubjectNameBytes = EncodeStringInUtf8(packet.Subject); int variablePartSize = SubjectNameBytes.Length + SPACES_BYTES.Length; byte[] PayloadSize = EncodeStringInUtf8(packetPayload.Length.ToString()); variablePartSize += PayloadSize.Length + CRLF_BYTES.Length; variablePartSize += packetPayload.Length + CRLF_BYTES.Length; int fixedHeaderBufferSize = PUB_BYTES.Length + SPACES_BYTES.Length; IByteBuffer buf = null; try { buf = bufferAllocator.Buffer(fixedHeaderBufferSize + variablePartSize); buf.WriteBytes(PUB_BYTES); buf.WriteBytes(SPACES_BYTES); buf.WriteBytes(SubjectNameBytes); buf.WriteBytes(SPACES_BYTES); buf.WriteBytes(PayloadSize); buf.WriteBytes(CRLF_BYTES); if (packetPayload != null) { buf.WriteBytes(packetPayload); } buf.WriteBytes(CRLF_BYTES); output.Add(buf); buf = null; } finally { buf?.SafeRelease(); } }
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; } }
internal override void HandleAck(AckPacket packet) { }