Example #1
0
        /// <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);
                }
            }
        }