private void udpServiceMessageReceived(object sender, CitpUdpService.MessageReceivedEventArgs e)
{
CitpPacket packet;
try
{
packet = CitpPacket.FromByteArray(e.Data, e.Endpoint);
}
catch (InvalidOperationException ex)
{
_log.LogError($"Failed to deserialize UDP packet from {e.Endpoint}");
_log.LogException(ex);
return;
}
if (packet is StreamFrameMessagePacket)
{
FrameQueue.Enqueue(Tuple.Create(e.Endpoint.Address, (StreamFrameMessagePacket)packet));
}
else if (packet is PeerLocationMessagePacket)
{
receivedPeerLocationMessage((PeerLocationMessagePacket)packet, e.Endpoint.Address);
}
else
{
_log.LogError($"Unrecognised/Invalid packet received via UDP from {e.Endpoint}");
}
}
public async Task SendMulticastPacketAsync(CitpPacket packet, int requestResponseIndex = 0)
{
foreach (var data in packet.ToByteArray(CitpUdpService.MaximumUdpPacketLength, requestResponseIndex))
{
await _udpService.SendAsync(data).ConfigureAwait(false);
}
}
public async Task <bool> SendPacketAsync(CitpPacket packet, CitpPeer peer, [CanBeNull] CitpPacket requestPacket = null)
{
if (peer.IsConnected == false)
{
throw new InvalidOperationException("Cannot send packet, peer is not connected");
}
packet.MessagePart = 0;
packet.MessagePartCount = 1;
packet.RequestResponseIndex = Convert.ToUInt16(requestPacket?.RequestResponseIndex ?? 0);
if (packet.LayerType == CitpLayerType.MediaServerExtensionsLayer)
{
var msexPacket = (MsexPacket)packet;
if (peer.MsexVersion.HasValue == false)
{
throw new InvalidOperationException("Peer MSEX version is unknown");
}
if (msexPacket.Version.HasValue)
{
if (msexPacket.Version.Value > peer.MsexVersion)
{
_log.LogWarning("Attempting to send an MSEX message with a higher version number than the peer supports");
}
}
else
{
((MsexPacket)packet).Version = peer.MsexVersion;
}
}
return(await sendDataToPeerAsync(peer, packet.ToByteArray(), requestPacket?.RemoteEndpoint?.Port).ConfigureAwait(false));
}
private async void tcpListenService_PacketReceived(object sender, CitpTcpListenService.MessageReceivedEventArgs e)
{
_log.LogDebug($"TCP packet ({e.Data.Length} bytes) received from {e.Endpoint}");
CitpPacket packet;
try
{
packet = CitpPacket.FromByteArray(e.Data, e.Endpoint);
}
catch (InvalidOperationException ex)
{
_log.LogError($"Error: Failed to deserialize TCP packet from {e.Endpoint}");
_log.LogException(ex);
return;
}
catch (NotImplementedException ex)
{
_log.LogError($"Error: Failed to deserialize TCP packet from {e.Endpoint}, CITP content type not implemented");
_log.LogException(ex);
return;
}
if (packet is PeerNameMessagePacket)
{
receivedPeerNameMessage((PeerNameMessagePacket)packet, e.Endpoint);
return;
}
var peer = _peers.FirstOrDefault(p => p.Ip == e.Endpoint.Address && p.RemoteTcpPorts.Contains(e.Endpoint.Port));
if (peer == null)
{
_log.LogDebug($"Failed to identify peer for received TCP packet, ignoring...");
return;
}
_log.LogDebug($"Packet identified as from CITP Peer '{peer}'");
if (packet.LayerType == CitpLayerType.MediaServerExtensionsLayer)
{
var packetVersion = ((MsexPacket)packet).Version;
Debug.Assert(packetVersion.HasValue, "Because we should not be able to deserialize a packet without finding the version");
if (!peer.MsexVersion.HasValue || peer.MsexVersion < packetVersion)
{
peer.MsexVersion = packetVersion;
}
}
if (packet is ClientInformationMessagePacket)
{
await receivedClientInformationMessageAsync((ClientInformationMessagePacket)packet, peer).ConfigureAwait(false);
}
else
{
MessageQueue.Enqueue(Tuple.Create(peer, packet));
}
}
public void BeginSend(CitpPacket citpMessage)
{
MemoryStream data = new MemoryStream();
CitpBinaryWriter writer = new CitpBinaryWriter(data);
citpMessage.WriteData(writer);
((CitpHeader)citpMessage).WriteMessageSize(writer);
client.Client.BeginSend(data.GetBuffer(), 0, (int)data.Length, SocketFlags.None, new AsyncCallback(OnSendCompleted), null);
}
public async Task SendPacketToAllConnectedPeersAsync(CitpPacket packet)
{
var connectedPeers = Peers.Where(p => p.IsConnected).ToList();
// If it's possible that different peers might need different versions of the packet,
// run this special routine to avoid serializing the packet more than once for each version.
if (packet.LayerType == CitpLayerType.MediaServerExtensionsLayer)
{
var msexPacket = (MsexPacket)packet;
if (msexPacket.Version.HasValue == false)
{
msexPacket.MessagePart = 0;
msexPacket.MessagePartCount = 1;
msexPacket.RequestResponseIndex = 0;
foreach (MsexVersion version in Enum.GetValues(typeof(MsexVersion)))
{
if (version == MsexVersion.UnsupportedVersion)
{
continue;
}
var peersWithVersion = connectedPeers.Where(p => p.MsexVersion == version).ToList();
if (peersWithVersion.Count == 0)
{
continue;
}
msexPacket.Version = version;
var data = msexPacket.ToByteArray();
foreach (var peer in peersWithVersion)
{
await sendDataToPeerAsync(peer, data).ConfigureAwait(false);
}
}
}
}
else
{
foreach (var peer in connectedPeers)
{
await SendPacketAsync(packet, peer).ConfigureAwait(false);
}
}
}
public static void TxPacket(IPEndPoint target, CitpPacket packet)
{
trace.TraceEvent(TraceEventType.Verbose, 2, string.Format("{0}: {1}", target.ToString(), packet.ToString()));
trace.Flush();
}
public static void RxPacket(IPEndPoint source, CitpPacket packet)
{
trace.TraceEvent(TraceEventType.Verbose, 1, string.Format("{0}: {1}", source.ToString(), packet.ToString()));
trace.Flush();
}
public CitpNewPacketEventArgs(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, CitpPacket packet)
{
LocalEndPoint = localEndPoint;
RemoteEndPoint = remoteEndPoint;
Packet = packet;
}
