IirFilterCounter _rxBwBeforeJB = new IirFilterCounter(TimeSpan.TicksPerMillisecond * 500, TimeSpan.TicksPerSecond); // locked
void IConnectedPeerStreamExtension.OnReceivedPayloadPacket(byte[] data, int index)
{
_stream.MarkAsActiveByExtension();
// _totalUdpBytesReceived += (UInt64)data.Length;
var timeNow32 = SubtLocalPeer.LocalPeer.Time32;
lock (_rxBwBeforeJB)
{
_rxBwBeforeJB.Input((data.Length + LocalLogicConfiguration.IpAndUdpHeadersSizeBytes) * 8);
_rxBwBeforeJB.OnTimeObserved(timeNow32);
}
var timestamp32 = P2ptpCommon.DecodeUInt32(data, ref index);
_timestamp32ToReflect = timestamp32;
var sequence = P2ptpCommon.DecodeUInt16(data, ref index);
var reflectedTimestamp32 = P2ptpCommon.DecodeUInt32(data, ref index);
if (reflectedTimestamp32 != 0)
{
RecentRtt = TimeSpan.FromTicks(unchecked (SubtLocalPeer.LocalPeer.Time32 - reflectedTimestamp32));
}
_rxMeasurement.OnReceivedPacket((ushort)(data.Length * 8 + LocalLogicConfiguration.IpAndUdpHeadersSizeBits), sequence, timestamp32, timeNow32);
}
void SendPayloadPacket(int length)
{
var timestampNow32 = SubtLocalPeer.LocalPeer.Time32;
_recentTxBandwidth.OnTimeObserved(timestampNow32);
if (StreamIsIdleCached == false)
{
_txSequence++;
var index = _payloadPacketIndex;
P2ptpCommon.EncodeUInt32(_payloadPacket, ref index, timestampNow32);
P2ptpCommon.EncodeUInt16(_payloadPacket, ref index, _txSequence);
P2ptpCommon.EncodeUInt32(_payloadPacket, ref index, _timestamp32ToReflect);
_stream.SendPacket(_payloadPacket, length);
_recentTxBandwidth.Input(LocalLogicConfiguration.IpAndUdpHeadersSizeBits + length * 8);
if (Stream.Debug)
{
Debugger.Break();
}
SendStatusIfNeeded(timestampNow32);
}
}
void ThreadEntry()
{
IPEndPoint remoteEndpoint = default(IPEndPoint);
while (!_disposing)
{
try
{
_actionsQueue.ExecuteQueued();
var udpData = UdpSocket.Receive(ref remoteEndpoint);
var timestamp32 = _localPeer.Time32;
if (_previousTimestamp32.HasValue)
{
var timePassed32 = unchecked (timestamp32 - _previousTimestamp32.Value);
_pps.Input(1, timePassed32);
_bps.Input((udpData.Length + LocalLogicConfiguration.IpAndUdpHeadersSizeBytes) * 8, timePassed32);
}
_previousTimestamp32 = timestamp32;
var manager = _localPeer.Manager;
if (manager != null && _localPeer.Firewall.PacketIsAllowed(remoteEndpoint) && udpData.Length > 4)
{
if (udpData[0] == (byte)PacketTypes.NatTest1Request)
{
manager.ProcessReceivedNat1TestRequest(this, udpData, remoteEndpoint);
return;
}
var packetType = P2ptpCommon.DecodeHeader(udpData);
if (packetType.HasValue)
{
switch (packetType.Value)
{
case PacketTypes.hello:
manager.ProcessReceivedHello(udpData, remoteEndpoint, this, timestamp32);
break;
case PacketTypes.peersListIpv4:
manager.ProcessReceivedSharedPeers(udpData, remoteEndpoint);
break;
case PacketTypes.extensionSignaling:
manager.ProcessReceivedExtensionSignalingPacket(BinaryProcedures.CreateBinaryReader(udpData, P2ptpCommon.HeaderSize), remoteEndpoint);
break;
}
}
else
{
(var extension, var streamId, var index) = ExtensionProcedures.ParseReceivedExtensionPayloadPacket(udpData, _localPeer.Configuration.Extensions);
if (extension != null)
{
if (_streams.TryGetValue(streamId, out var stream))
{
stream.Extensions.TryGetValue(extension, out var streamExtension);
streamExtension.OnReceivedPayloadPacket(udpData, index);
}
//else _localPeer.WriteToLog(LogModules.Receiver, $"receiver {SocketInfo} got packet from bad stream id {streamId}");
}
}
}
}
// catch (InvalidOperationException)
// {// intentionally ignored (before "connection")
// }
catch (SocketException exc)
{
if (_disposing)
{
return;
}
if (exc.ErrorCode != 10054) // forcibly closed - ICMP port unreachable - it is normal when peer gets down
{
_localPeer.HandleException(LogModules.Receiver, exc);
}
// else ignore it
}
catch (Exception exc)
{
_localPeer.HandleException(LogModules.Receiver, exc);
}
}
}
