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