Ejemplo n.º 1
0
        /// <summary>
        /// This method is called when BeginAccept ha completed.
        /// </summary>
        /// <param name="ar">The result of the asynchronous operation.</param>
        private void AsynSocketsAcceptCompleted(IAsyncResult ar)
        {
            ListeningPoint lPoint = (ListeningPoint)ar.AsyncState;

            try{
                ProcessConnection(lPoint.Socket.EndAccept(ar), lPoint.BindInfo);
            }
            catch {
                // Skip accept errors.
            }

            // Begin accepting connection.
            lPoint.Socket.BeginAccept(new AsyncCallback(this.AsynSocketsAcceptCompleted), lPoint);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Starts listening incoming connections. NOTE: All active listening points will be disposed.
        /// </summary>
        private void StartListen()
        {
            try
            {
                // Dispose all old binds.
                foreach (ListeningPoint listeningPoint in m_pListeningPoints.ToArray())
                {
                    try
                    {
                        listeningPoint.Socket.Close();
                    }
                    catch (Exception x)
                    {
                        OnError(x);
                    }
                }
                m_pListeningPoints.Clear();

                // Create new listening points and start accepting connections.
                bool ioCompletion_asyncSockets = Net_Utils.IsIoCompletionPortsSupported();
                foreach (IPBindInfo bind in m_pBindings)
                {
                    try
                    {
                        Socket socket = null;
                        if (bind.IP.AddressFamily == AddressFamily.InterNetwork)
                        {
                            socket = new Socket(AddressFamily.InterNetwork,
                                                SocketType.Stream,
                                                ProtocolType.Tcp);
                        }
                        else if (bind.IP.AddressFamily == AddressFamily.InterNetworkV6)
                        {
                            socket = new Socket(AddressFamily.InterNetworkV6,
                                                SocketType.Stream,
                                                ProtocolType.Tcp);
                        }
                        else
                        {
                            // Invalid address family, just skip it.
                            continue;
                        }
                        socket.Bind(new IPEndPoint(bind.IP, bind.Port));
                        socket.Listen(100);

                        ListeningPoint listeningPoint = new ListeningPoint(socket, bind);
                        m_pListeningPoints.Add(listeningPoint);

                        // Begin accept.
                        //   We MUST use socket.AcceptAsync method, this consume all threading power in Windows paltform(IO completion ports).
                        //   For other platforms we need to use BeginAccept.

                        #region IO completion ports

                        if (ioCompletion_asyncSockets)
                        {
                            SocketAsyncEventArgs eArgs = new SocketAsyncEventArgs();
                            eArgs.Completed += delegate(object s, SocketAsyncEventArgs e)
                            {
                                if (e.SocketError == SocketError.Success)
                                {
                                    ProcessConnection(e.AcceptSocket, bind);
                                }

                                // Start accepting new connection.
                                IOCompletionBeginAccept(e, socket, bind);
                            };

                            // Move processing to thread-pool, because IOCompletionBeginAccept keeps using calling thread as loang as there is work todo.
                            ThreadPool.QueueUserWorkItem(delegate
                            {
                                // Start accepting new connection.
                                IOCompletionBeginAccept(eArgs, socket, bind);
                            });
                        }

                        #endregion

                        #region Async sockets

                        else
                        {
                            // Begin accepting connection.
                            socket.BeginAccept(new AsyncCallback(AsynSocketsAcceptCompleted), listeningPoint);
                        }

                        #endregion
                    }
                    catch (Exception x)
                    {
                        // The only exception what we should get there is if socket is in use.
                        OnError(x);
                    }
                }
            }
            catch (Exception x)
            {
                OnError(x);
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Starts listening incoming connections. NOTE: All active listening points will be disposed.
        /// </summary>
        private void StartListen()
        {
            try{
                // Dispose all old binds.
                foreach (ListeningPoint listeningPoint in m_pListeningPoints.ToArray())
                {
                    try{
                        listeningPoint.Socket.Close();
                    }
                    catch (Exception x) {
                        OnError(x);
                    }
                }
                m_pListeningPoints.Clear();

                // Create new listening points and start accepting connections.
                foreach (IPBindInfo bind in m_pBindings)
                {
                    try{
                        Socket socket = null;
                        if (bind.IP.AddressFamily == AddressFamily.InterNetwork)
                        {
                            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                        }
                        else if (bind.IP.AddressFamily == AddressFamily.InterNetworkV6)
                        {
                            socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
                        }
                        else
                        {
                            // Invalid address family, just skip it.
                            continue;
                        }
                        socket.Bind(new IPEndPoint(bind.IP, bind.Port));
                        socket.Listen(100);

                        ListeningPoint listeningPoint = new ListeningPoint(socket, bind);
                        m_pListeningPoints.Add(listeningPoint);

                        // Create TCP connection acceptors.
                        for (int i = 0; i < 10; i++)
                        {
                            TCP_Acceptor acceptor = new TCP_Server <T> .TCP_Acceptor(socket);

                            acceptor.Tags["bind"]        = bind;
                            acceptor.ConnectionAccepted += delegate(object s1, EventArgs <Socket> e1){
                                // NOTE: We may not use 'bind' variable here, foreach changes it's value before we reach here.
                                ProcessConnection(e1.Value, (IPBindInfo)acceptor.Tags["bind"]);
                            };
                            acceptor.Error += delegate(object s1, ExceptionEventArgs e1){
                                OnError(e1.Exception);
                            };
                            m_pConnectionAcceptors.Add(acceptor);
                            acceptor.Start();
                        }
                    }
                    catch (Exception x) {
                        // The only exception what we should get there is if socket is in use.
                        OnError(x);
                    }
                }
            }
            catch (Exception x) {
                OnError(x);
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Starts listening incoming connections. NOTE: All active listening points will be disposed.
        /// </summary>
        private void StartListen()
        {
            try
            {
                // Dispose all old acceptors.
                foreach (var acceptor in m_pConnectionAcceptors.ToArray())
                {
                    try
                    { acceptor.Dispose(); }
                    catch (Exception ex)
                    { OnError(ex); }
                }
                m_pConnectionAcceptors.Clear();

                // Dispose all old binds.
                foreach (var listeningPoint in m_pListeningPoints.ToArray())
                {
                    try
                    { listeningPoint.Socket.Dispose(); }
                    catch (Exception ex)
                    { OnError(ex); }
                }
                m_pListeningPoints.Clear();


                // Create new listening points and start accepting connections.
                foreach (var bindInfo in m_pBindings)
                {
                    try
                    {
                        Socket socket = null;
                        if (bindInfo.IP.AddressFamily == AddressFamily.InterNetwork)
                        {
                            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                        }
                        else if (bindInfo.IP.AddressFamily == AddressFamily.InterNetworkV6)
                        {
                            socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
                        }
                        else
                        {
                            // Invalid address family, just skip it.
                            continue;
                        }

                        socket.Bind(bindInfo.EndPoint);
                        socket.Listen(100);

                        var listeningPoint = new ListeningPoint(socket, bindInfo);
                        m_pListeningPoints.Add(listeningPoint);

                        // Create TCP connection acceptors.
                        for (int i = 0; i < m_AcceptorsPerSocket; i++)
                        {
                            var acceptor = new TCP_Acceptor(socket);
                            acceptor.Tags["bind"]        = bindInfo;
                            acceptor.ConnectionAccepted += (s1, e1) =>
                            {
                                // NOTE: We may not use 'bind' variable here, foreach changes it's value before we reach here.
                                ProcessConnection(e1.Value, (IPBindInfo)acceptor.Tags["bind"]);
                            };

                            acceptor.Error += (s1, e1) =>
                            {
                                OnError(e1.Exception);
                            };

                            m_pConnectionAcceptors.Add(acceptor);
                            acceptor.Start();
                        }
                    }
                    catch (Exception ex)
                    {
                        // The only exception what we should get there is if socket is in use.
                        OnError(ex);
                    }
                }
            }
            catch (Exception ex)
            { OnError(ex); }
        }
Ejemplo n.º 5
0
        private void OnPhoneCallStarted(IInternalPhoneCall phoneCall)
        {
            Check.Require(phoneCall, "phoneCall");
            Check.IsTrue(InternalState == _stateProvider.GetIdle(), string.Format("Failed to start the call. The phone can only start calls while in 'IDLE' state. CurrentState: '{0}'", CurrentState));
            Check.IsTrue(_isRunning, "Failed to start the call. The phone must be started first.");

            _pendingPhoneCall = phoneCall;

            if (_logger.IsInfoEnabled)
            {
                _logger.Info("Starting new phonecall...");
            }
            if (_logger.IsDebugEnabled)
            {
                _logger.Debug("Creating 'INVITE' request...");
            }
            var thisUri = AddressFactory.CreateUri(string.Empty, ListeningPoint.ToString());

            var requestUri   = phoneCall.GetToUri();
            var toAddress    = AddressFactory.CreateAddress(string.Empty, phoneCall.GetToUri());
            var fromAddress  = AddressFactory.CreateAddress(string.Empty, thisUri);
            var toHeader     = HeaderFactory.CreateToHeader(toAddress);
            var fromHeader   = HeaderFactory.CreateFromHeader(fromAddress, SipUtil.CreateTag());
            var cseqHeader   = HeaderFactory.CreateSCeqHeader(SipMethods.Invite, MessageCounter++);
            var callIdheader = HeaderFactory.CreateCallIdHeader(SipUtil.CreateCallId());
            var viaHeader    = HeaderFactory.CreateViaHeader(ListeningPoint.Address,
                                                             ListeningPoint.Port, SipConstants.Udp,
                                                             SipUtil.CreateBranch());
            var maxForwardsHeader = HeaderFactory.CreateMaxForwardsHeader(1);
            var request           = MessageFactory.CreateRequest(
                requestUri,
                SipMethods.Invite,
                callIdheader,
                cseqHeader,
                fromHeader,
                toHeader,
                viaHeader,
                maxForwardsHeader);

            /*add contactheader*/
            var contactUri    = AddressFactory.CreateUri(thisUri.User, viaHeader.SentBy.ToString());
            var contactHeader = HeaderFactory.CreateContactHeader(contactUri);

            request.Contacts.Add(contactHeader);

            if (_logger.IsDebugEnabled)
            {
                _logger.Debug("'INVITE' request created. Sending to callee..");
            }

            var clientTransaction = SipProvider.CreateClientTransaction(request);
            var dialog            = SipProvider.CreateClientDialog(clientTransaction as SipInviteClientTransaction);

            clientTransaction.SendRequest();

            if (_logger.IsDebugEnabled)
            {
                _logger.Debug("'INVITE' sent.");
            }

            if (_logger.IsInfoEnabled)
            {
                _logger.Info("Request sent. Transitioning to 'WAITPROVISIONAL' state...");
            }

            PendingInvite = new InviteInfo()
            {
                OriginalRequest = request,
                From            = request.From.SipUri,
                To = request.To.SipUri,
                InviteClientTransaction = (SipInviteClientTransaction)clientTransaction,
                IsIncomingCall          = false,
                Dialog = dialog
            };

            ChangeState(_stateProvider.GetWaitProvisional());
        }