/// <summary>
        /// Server TCP,TLS constructor.
        /// </summary>
        /// <param name="stack">Owner stack.</param>
        /// <param name="session">TCP session.</param>
        /// <exception cref="ArgumentNullException">Is raised when <b>stack</b> or <b>session</b> is null reference.</exception>
        internal SIP_Flow(SIP_Stack stack, TCP_ServerSession session)
        {
            if (stack == null)
            {
                throw new ArgumentNullException("stack");
            }
            if (session == null)
            {
                throw new ArgumentNullException("session");
            }

            m_pStack      = stack;
            m_pTcpSession = session;

            m_IsServer     = true;
            m_pLocalEP     = session.LocalEndPoint;
            m_pRemoteEP    = session.RemoteEndPoint;
            m_Transport    = session.IsSecureConnection ? SIP_Transport.TLS : SIP_Transport.TCP;
            m_CreateTime   = DateTime.Now;
            m_LastActivity = DateTime.Now;
            m_ID           = m_pLocalEP.ToString() + "-" + m_pRemoteEP.ToString() + "-" + m_Transport;
            m_pMessage     = new MemoryStream();

            // Dispose flow when TCP server session closed.
            session.Disposed += new EventHandler(delegate(object s, EventArgs e){
                Dispose();
            });

            BeginReadHeader();
        }
Ejemplo n.º 2
0
            /// <summary>
            /// Creates new flow from TCP server session.
            /// </summary>
            /// <param name="session">TCP server session.</param>
            /// <returns>Returns created flow.</returns>
            /// <exception cref="ArgumentNullException">Is raised when <b>session</b> is null reference.</exception>
            internal SIP_Flow CreateFromSession(TCP_ServerSession session)
            {
                if (session == null)
                {
                    throw new ArgumentNullException("session");
                }

                string flowID = session.LocalEndPoint + "-" + session.RemoteEndPoint + "-" +
                                (session.IsSecureConnection ? SIP_Transport.TLS : SIP_Transport.TCP);

                lock (m_pLock)
                {
                    SIP_Flow flow = new SIP_Flow(m_pOwner.Stack, session);
                    m_pFlows.Add(flowID, flow);
                    flow.IsDisposing += delegate
                                            {
                                                lock (m_pLock)
                                                {
                                                    m_pFlows.Remove(flowID);
                                                }
                                            };
                    flow.Start();

                    return flow;
                }
            }