|
public static ParseSTUNMessage ( byte buffer, int bufferLength ) : |
||
| buffer | byte | |
| bufferLength | int | |
| return | ||
/// <summary>
/// From RFC5764:
/// +----------------+
/// | 127 < B< 192 -+--> forward to RTP
/// | |
/// packet --> | 19 < B< 64 -+--> forward to DTLS
/// | |
/// | B< 2 -+--> forward to STUN
/// +----------------+
/// </summary>
/// <param name="remoteEP"></param>
/// <param name="buffer"></param>
private void OnRTPDataReceived(IPEndPoint remoteEP, byte[] buffer)
{
//logger.LogDebug($"RTP channel received a packet from {remoteEP}, {buffer?.Length} bytes.");
if (buffer?.Length > 0)
{
_lastCommunicationAt = DateTime.Now;
try
{
if (buffer[0] == 0x00 || buffer[0] == 0x01)
{
// STUN packet.
_lastStunMessageReceivedAt = DateTime.Now;
var stunMessage = STUNv2Message.ParseSTUNMessage(buffer, buffer.Length);
ProcessStunMessage(stunMessage, remoteEP);
}
else if (buffer[0] >= 128 && buffer[0] <= 191)
{
// RTP/RTCP packet need to decrypt.
//if (buffer[1] == 0xC8 /* RTCP SR */ || buffer[1] == 0xC9 /* RTCP RR */)
//{
// // RTCP packet.
// //webRtcClient.LastSTUNReceiveAt = DateTime.Now;
//}
//else
//{
// // RTP packet.
// //int res = peer.SrtpReceiveContext.UnprotectRTP(buffer, buffer.Length);
// //if (res != 0)
// //{
// // logger.Warn("SRTP unprotect failed, result " + res + ".");
// //}
//}
}
else if (buffer[0] >= 20 && buffer[0] <= 63)
{
// DTLS packet.
// Do nothing. The DTLSContext already has the socket handle and is monitoring
// for DTLS packets.
}
else
{
logger.LogWarning("Unknown packet type received on RTP channel.");
}
}
catch (Exception excp)
{
logger.LogError($"Exception WebRtcSession.OnRTPDataReceived {excp.Message}.");
}
}
}
/// <summary>
/// From RFC5764:
/// +----------------+
/// | 127 < B< 192 -+--> forward to RTP
/// | |
/// packet --> | 19 < B< 64 -+--> forward to DTLS
/// | |
/// | B< 2 -+--> forward to STUN
/// +----------------+
/// </summary>
/// <param name="remoteEP"></param>
/// <param name="buffer"></param>
private void OnRTPDataReceived(IPEndPoint localEndPoint, IPEndPoint remoteEP, byte[] buffer)
{
//logger.LogDebug($"RTP channel received a packet from {remoteEP}, {buffer?.Length} bytes.");
if (buffer?.Length > 0)
{
_lastCommunicationAt = DateTime.Now;
try
{
if (buffer[0] == 0x00 || buffer[0] == 0x01)
{
// STUN packet.
_lastStunMessageReceivedAt = DateTime.Now;
var stunMessage = STUNv2Message.ParseSTUNMessage(buffer, buffer.Length);
ProcessStunMessage(stunMessage, remoteEP);
}
else if (buffer[0] >= 128 && buffer[0] <= 191)
{
// RTP/RTCP packet.
// Do nothing. The RTPSession takes care of these.
}
else if (buffer[0] >= 20 && buffer[0] <= 63)
{
// DTLS packet.
// Do nothing. The DTLSContext already has the socket handle and is monitoring
// for DTLS packets.
}
else
{
logger.LogWarning("Unknown packet type received on RTP channel.");
}
}
catch (Exception excp)
{
logger.LogError($"Exception WebRtcSession.OnRTPDataReceived {excp.Message}.");
}
}
}
private void StartWebRtcRtpListener(IceCandidate iceCandidate)
{
string localEndPoint = "?";
try
{
localEndPoint = iceCandidate.LocalRtpSocket.LocalEndPoint.ToString();
logger.Debug("Starting WebRTC RTP listener for call " + CallID + " on socket " + localEndPoint + ".");
IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
UdpClient localSocket = new UdpClient();
localSocket.Client = iceCandidate.LocalRtpSocket;
while (!IsClosed)
{
try
{
//logger.Debug("ListenToReceiverWebRTCClient Receive.");
byte[] buffer = localSocket.Receive(ref remoteEndPoint);
iceCandidate.LastCommunicationAt = DateTime.Now;
//logger.Debug(buffer.Length + " bytes read on Receiver Client media socket from " + remoteEndPoint.ToString() + ".");
//if (buffer.Length > 3 && buffer[0] == 0x16 && buffer[1] == 0xfe)
if (buffer[0] >= 20 && buffer[0] <= 64)
{
//OnMediaPacket(iceCandidate, buffer, remoteEndPoint);
if (OnDtlsPacket != null)
{
OnDtlsPacket(iceCandidate, buffer, remoteEndPoint);
}
}
//else if ((buffer[0] & 0x80) == 0)
else if (buffer[0] == 0 || buffer[0] == 1)
{
STUNv2Message stunMessage = STUNv2Message.ParseSTUNMessage(buffer, buffer.Length);
ProcessStunMessage(iceCandidate, stunMessage, remoteEndPoint);
}
else
{
if (OnMediaPacket != null)
{
OnMediaPacket(iceCandidate, buffer, remoteEndPoint);
}
}
}
catch (Exception sockExcp)
{
_communicationFailureCount++;
logger.Warn("Exception ListenToReceiverWebRTCClient Receive (" + localEndPoint + " and " + remoteEndPoint + ", failure count " + _communicationFailureCount + "). " + sockExcp.Message);
// Need to be careful about deciding when the connection has failed. Sometimes the STUN requests we send will arrive before the remote peer is ready and cause a socket exception.
// Only shutdown the peer if we are sure all ICE intialisation is complete and the socket exception occurred after the RTP had stated flowing.
if (iceCandidate.IsStunLocalExchangeComplete && iceCandidate.IsStunRemoteExchangeComplete &&
iceCandidate.RemoteRtpEndPoint != null && remoteEndPoint != null && iceCandidate.RemoteRtpEndPoint.ToString() == remoteEndPoint.ToString() &&
DateTime.Now.Subtract(IceNegotiationStartedAt).TotalSeconds > 10)
{
logger.Warn("WebRtc peer communication failure on call " + CallID + " for local RTP socket " + localEndPoint + " and remote RTP socket " + remoteEndPoint + " .");
iceCandidate.DisconnectionMessage = sockExcp.Message;
break;
}
else if (_communicationFailureCount > COMMUNICATION_FAILURE_COUNT_FOR_CLOSE)
{
logger.Warn("WebRtc peer communication failures on call " + CallID + " exceeded limit of " + COMMUNICATION_FAILURE_COUNT_FOR_CLOSE + " closing peer.");
break;
}
//else if (DateTime.Now.Subtract(peer.IceNegotiationStartedAt).TotalSeconds > ICE_CONNECTION_LIMIT_SECONDS)
//{
// logger.Warn("WebRTC peer ICE connection establishment timed out on call " + peer.CallID + " for " + iceCandidate.LocalRtpSocket.LocalEndPoint + ".");
// break;
//}
}
}
Close();
}
catch (Exception excp)
{
logger.Error("Exception ListenForWebRTCClient (" + localEndPoint + "). " + excp);
}
}
