/// <summary> /// Send UDP join messages to the reflector. There is no acknoweledgement, so we send /// a series of these messages, pausing briefly in between. /// /// A bit of ugliness: the joiner works over both C#'s built in socket, as well as CXP's /// UDPSender. If the class was initialized without a Socket, then we create a locale UdpSender. /// This is necessary because the client uses UdpSender, whereas the reflector uses raw sockets. /// </summary> private void SendJoinMessages() { Debug.Assert(reflectorEP != null); Debug.Assert(multicastEP != null); UdpSender sender = null; try { sender = new UdpSender(this.reflectorEP, 64); sender.DisableLoopback(); while (alive) { UdpReflectorMessage rjm = new UdpReflectorMessage(UdpReflectorMessageType.JOIN, multicastEP); BufferChunk bufferChunk = rjm.ToBufferChunk(); // UdpSender, as used by CXPClient sender.Send(bufferChunk); Thread.Sleep(JOIN_MESSAGE_DELAY); } } catch { } finally { if (sender != null) sender.Dispose(); } }
/// <summary> /// Dispose per the IDisposable pattern /// </summary> public void Dispose() { GC.SuppressFinalize(this); if (!disposed) { disposed = true; if (sock != null) { // if we are using a reflector, send a tear-down message if (!multicastEP.Equals(nextHopEP)) { try { if (joiner != null) { joiner.Terminate(); } // send a LEAVE message; this might get lost, but that doesn't matter // because the reflector wil time out. UdpSender sender = new UdpSender(nextHopEP, 64); UdpReflectorMessage message = new UdpReflectorMessage(UdpReflectorMessageType.LEAVE, multicastEP); sender.Send(message.ToBufferChunk()); sender.Dispose(); } catch (Exception) { } } LstSocks.Socket.ReleaseSharedSocket(nextHopEP, sock); sock = null; } } }
private void CheckForReflector() { // send a ping UdpReflectorMessage ping = new UdpReflectorMessage(UdpReflectorMessageType.PING); BufferChunk buffer = ping.ToBufferChunk(); reflectorSocket.SendTo(buffer.Buffer, buffer.Index, buffer.Length, SocketFlags.None, ReflectorAddress); // wait for response byte [] byteBuffer = new byte[512]; int count = reflectorSocket.Receive(byteBuffer); UdpReflectorMessage pingReply = new UdpReflectorMessage(byteBuffer,count); if (pingReply.Type == UdpReflectorMessageType.PING_REPLY) { this.ReportProgress(100); this.lastSuccessfulReading = DateTime.Now; } // wait a bit... Thread.Sleep(1500); }
/// <summary> /// Send UDP join messages to the reflector. There is no acknoweledgement, so we send /// a series of these messages, pausing briefly in between. /// /// A bit of ugliness: the joiner works over both C#'s built in socket, as well as CXP's /// UDPSender. If the class was initialized without a Socket, then we create a locale UdpSender. /// This is necessary because the client uses UdpSender, whereas the reflector uses raw sockets. /// </summary> private void SendJoinMessages() { Debug.Assert(reflectorEP != null); Debug.Assert(multicastEP != null); UdpSender sender = null; try { sender = new UdpSender(this.reflectorEP, 64); sender.DisableLoopback(); while (alive) { UdpReflectorMessage rjm = new UdpReflectorMessage(UdpReflectorMessageType.JOIN, multicastEP); BufferChunk bufferChunk = rjm.ToBufferChunk(); // UdpSender, as used by CXPClient sender.Send(bufferChunk); Thread.Sleep(JOIN_MESSAGE_DELAY); } } catch { } finally { if (sender != null) { sender.Dispose(); } } }
/// <summary> /// Dispose per the IDisposable pattern /// </summary> public void Dispose() { GC.SuppressFinalize(this); if(!disposed) { disposed = true; if (sock != null) { // if we are using a reflector, send a tear-down message if (!multicastEP.Equals(nextHopEP)) { try { if (joiner != null) joiner.Terminate(); // send a LEAVE message; this might get lost, but that doesn't matter // because the reflector wil time out. UdpSender sender = new UdpSender(nextHopEP, 64); UdpReflectorMessage message = new UdpReflectorMessage(UdpReflectorMessageType.LEAVE, multicastEP); sender.Send(message.ToBufferChunk()); sender.Dispose(); } catch (Exception) { } } LstSocks.Socket.ReleaseSharedSocket(nextHopEP, sock); sock = null; } } }
public void ProcessMessage(UdpReflectorMessage message,IPEndPoint source,Socket localSocket) { IPEndPoint localEP = localSocket.LocalEndPoint as IPEndPoint; if (message.Type == UdpReflectorMessageType.LEAVE) { // a background thread will eventually remove the multicast group, if necessary lock (clientRegTable) { clientRegTable.Remove(source); } return; } else if (message.Type == UdpReflectorMessageType.JOIN) { IPEndPoint multicastEP = message.MulticastEP; JoinMulticastGroup(multicastEP); subscribedMulticastGroups[multicastEP.Address] = multicastEP.Address; ClientEntry entry = new ClientEntry(source, multicastEP, DateTime.Now); lock (clientRegTable) { clientRegTable.Add(source, entry); } // Multi-reflector cascading join, if required. We send an identical join request on the // same port to the parent's IP address if (ParentReflector != null) { IPEndPoint parentEP = new IPEndPoint(ParentReflector, localEP.Port); UdpReflectorMessage joinMessage = new UdpReflectorMessage(UdpReflectorMessageType.JOIN, multicastEP); BufferChunk chunk = joinMessage.ToBufferChunk(); localSocket.SendTo(chunk.Buffer, chunk.Index, chunk.Length, SocketFlags.None,parentEP); // Need to add the parent to our local dispatch table (to simulate a remote join) ClientEntry parentEntry = new ClientEntry(parentEP, multicastEP, DateTime.Now); lock (clientRegTable) { clientRegTable.Add(parentEP, parentEntry); } } } else if (message.Type == UdpReflectorMessageType.PING) { // acknowledge that we're alive... UdpReflectorMessage pingReply = new UdpReflectorMessage(UdpReflectorMessageType.PING_REPLY); BufferChunk bufferChunk = pingReply.ToBufferChunk(); localSocket.SendTo(bufferChunk.Buffer, bufferChunk.Index, bufferChunk.Length, SocketFlags.None, source); } else { // unknown or unhandled message type... } }
/// <summary> /// Forwards the traffic from unicast to unicast/multicast for the given trafficType /// </summary> public void Start() { int size = 0; TrafficType traffTypes; lock (ThreadTypeData) { if (idxThreadTypeData < ThreadTypeData.Length) { traffTypes = ThreadTypeData[idxThreadTypeData]; Thread.CurrentThread.Name = "Reflector_UCtoUCMC_" + traffTypes.ToString(); idxThreadTypeData++; } else { throw new Exception(Strings.CreatedThreadsExceedThreadTypesDefined); } } #region Assigning appropriate sockets to "(mc/uc)(Ref/Srv)Sock" // The Ref(erence) socket variables are assigned to the socket protocol that this thread is not listening on // but may use for inter-protocol communication. For example if mcSrvSock is an IPv4 socket, mcRefSock would be // an IPv6 socket and vice versa. Socket mcRefSock = null; Socket ucRefSock = null; Socket ucSrvSock = null; int ucPort = 0; EndPoint remoteEP = null; switch (traffTypes) { case TrafficType.IPv4RTCP: ucPort = ReflectorMgr.ReflectorUnicastRTPListenPort + 1; remoteEP = new IPEndPoint(IPAddress.Any, 0); mcRefSock = ReflectorMgr.Sockets.SockMCv6RTCP; ucRefSock = ReflectorMgr.Sockets.SockUCv6RTCP; ucSrvSock = ReflectorMgr.Sockets.SockUCv4RTCP; break; case TrafficType.IPv6RTCP: ucPort = ReflectorMgr.ReflectorUnicastRTPListenPort + 1; remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0); mcRefSock = ReflectorMgr.Sockets.SockMCv4RTCP; ucRefSock = ReflectorMgr.Sockets.SockUCv4RTCP; ucSrvSock = ReflectorMgr.Sockets.SockUCv6RTCP; break; case TrafficType.IPv4RTP: ucPort = ReflectorMgr.ReflectorUnicastRTPListenPort; remoteEP = new IPEndPoint(IPAddress.Any, 0); mcRefSock = ReflectorMgr.Sockets.SockMCv6RTP; ucRefSock = ReflectorMgr.Sockets.SockUCv6RTP; ucSrvSock = ReflectorMgr.Sockets.SockUCv4RTP; break; case TrafficType.IPv6RTP: ucPort = ReflectorMgr.ReflectorUnicastRTPListenPort; remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0); mcRefSock = ReflectorMgr.Sockets.SockMCv4RTP; ucRefSock = ReflectorMgr.Sockets.SockUCv4RTP; ucSrvSock = ReflectorMgr.Sockets.SockUCv6RTP; break; default: Debug.Assert(false); throw new ArgumentException(Strings.InvalidTrafficTypeCombination); } #endregion IPEndPoint groupEP = null; byte [] buf = new byte[1500]; IList<IPEndPoint> members = new List<IPEndPoint>(); while (true) { try { //EndPoint ep = null; size = ucSrvSock.ReceiveFrom(buf, ref remoteEP); // First, check whether this is a control message (JOIN or LEAVE) if (size <= 50) { try { UdpReflectorMessage message = new UdpReflectorMessage(buf, size); registrar.ProcessMessage(message, remoteEP as IPEndPoint, ucSrvSock); continue; // read next message } catch (InvalidUdpReflectorMessage) { // fall through } } if ((traffTypes & TrafficType.RTP) == TrafficType.RTP) { ReflectorMgr.PC[ReflectorPC.ID.UnicastPacketsReceived]++; } ClientEntry entry = registrar.GetEntry(remoteEP as IPEndPoint); if (entry != null) { registrar.MarkAsActive(entry); // Make sure this node isn't also sending over multicast... if (registrar.IsIPAddressUsingMulticast(entry.ClientEP.Address)) { eventLog.WriteEntry("Warning: receving both unicast and multicast from: " + entry.ClientEP.Address, EventLogEntryType.Warning, (int)ReflectorEventLog.ID.UCtoUCMCException); continue; // read next message without propogating further... } // lookup the (first) group which this client is a member of that group. groupEP = entry.GroupEP; // Find the other members of the group registrar.MemberLookup(members, groupEP); // Send the data to the Multicast side if (SendMulticast) { if (groupEP.AddressFamily == ucSrvSock.AddressFamily) { ucSrvSock.SendTo(buf, 0, size, SocketFlags.None, groupEP); } else if ((mcRefSock != null) && (groupEP.AddressFamily == ucRefSock.AddressFamily)) { ucRefSock.SendTo(buf, 0, size, SocketFlags.None, groupEP); } } // Send the data to all unicast client members except the sender. for (int i = 0; i < members.Count; i++) { if (!remoteEP.Equals(members[i])) { if (members[i].AddressFamily == ucSrvSock.AddressFamily) { ucSrvSock.SendTo(buf, 0, size, SocketFlags.None, members[i]); } else if ((ucRefSock != null) && (members[i].AddressFamily == ucRefSock.AddressFamily)) { ucRefSock.SendTo(buf, 0, size, SocketFlags.None, members[i]); } } } if ((traffTypes & TrafficType.RTP) == TrafficType.RTP) { ReflectorMgr.PC[ReflectorPC.ID.UCtoUCPacketsSent] += members.Count - 1; } } } // On stopping the service, avoid the AbortException written in the event viewer catch(ThreadAbortException){} catch (Exception e) // Connection reset by peer! this happens occasionally when a UC client leaves. { eventLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, Strings.UCtoUCMCForwarderException, traffTypes, remoteEP, e.ToString()), EventLogEntryType.Warning, (int)ReflectorEventLog.ID.UCtoUCMCException); } } }