/// <summary> /// Sends specified response to flow remote end point. /// </summary> /// <param name="response">SIP response to send.</param> /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this method is accessed.</exception> /// <exception cref="ArgumentNullException">Is raised when <b>response</b> is null reference.</exception> public void Send(SIP_Response response) { lock (m_pLock){ if (m_IsDisposed) { throw new ObjectDisposedException(this.GetType().Name); } if (response == null) { throw new ArgumentNullException("response"); } SendInternal(response.ToByteData()); } }
/// <summary> /// Sends response to request maker using RFC 3261 18. rules. /// </summary> /// <param name="transaction">Owner server transaction. Can be null if stateless response sending.</param> /// <param name="response">SIP response to send.</param> /// <param name="localEP">Local IP end point to use for sending resposne. Value null means system will allocate it.</param> /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and and this method is accessed.</exception> /// <exception cref="InvalidOperationException">Is raised when stack ahs not been started and this method is accessed.</exception> /// <exception cref="ArgumentNullException">Is raised when <b>response</b> is null reference.</exception> /// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception> /// <exception cref="SIP_TransportException">Is raised when <b>response</b> sending has failed.</exception> private void SendResponseInternal(SIP_ServerTransaction transaction,SIP_Response response,IPEndPoint localEP) { if(m_IsDisposed){ throw new ObjectDisposedException(this.GetType().Name); } if(!m_IsRunning){ throw new InvalidOperationException("Stack has not been started."); } if(response == null){ throw new ArgumentNullException("response"); } /* RFC 3261 18.2.2. The server transport uses the value of the top Via header field in order to determine where to send a response. It MUST follow the following process: o If the "sent-protocol" is a reliable transport protocol such as TCP or SCTP, or TLS over those, the response MUST be sent using the existing connection to the source of the original request that created the transaction, if that connection is still open. This requires the server transport to maintain an association between server transactions and transport connections. If that connection is no longer open, the server SHOULD open a connection to the IP address in the "received" parameter, if present, using the port in the "sent-by" value, or the default port for that transport, if no port is specified. If that connection attempt fails, the server SHOULD use the procedures in [4] for servers in order to determine the IP address and port to open the connection and send the response to. o Otherwise, if the Via header field value contains a "maddr" parameter, the response MUST be forwarded to the address listed there, using the port indicated in "sent-by", or port 5060 if none is present. If the address is a multicast address, the response SHOULD be sent using the TTL indicated in the "ttl" parameter, or with a TTL of 1 if that parameter is not present. o Otherwise (for unreliable unicast transports), if the top Via has a "received" parameter, the response MUST be sent to the address in the "received" parameter, using the port indicated in the "sent-by" value, or using port 5060 if none is specified explicitly. If this fails, for example, elicits an ICMP "port unreachable" response, the procedures of Section 5 of [4] SHOULD be used to determine where to send the response. o Otherwise, if it is not receiver-tagged, the response MUST be sent to the address indicated by the "sent-by" value, using the procedures in Section 5 of [4]. */ /* RFC 3581 4. (Adds new processing between RFC 3261 18.2.2. bullet 2 and 3) When a server attempts to send a response, it examines the topmost Via header field value of that response. If the "sent-protocol" component indicates an unreliable unicast transport protocol, such as UDP, and there is no "maddr" parameter, but there is both a "received" parameter and an "rport" parameter, the response MUST be sent to the IP address listed in the "received" parameter, and the port in the "rport" parameter. The response MUST be sent from the same address and port that the corresponding request was received on. This effectively adds a new processing step between bullets two and three in Section 18.2.2 of SIP [1]. The response must be sent from the same address and port that the request was received on in order to traverse symmetric NATs. When a server is listening for requests on multiple ports or interfaces, it will need to remember the one on which the request was received. For a stateful proxy, storing this information for the duration of the transaction is not an issue. However, a stateless proxy does not store state between a request and its response, and therefore cannot remember the address and port on which a request was received. To properly implement this specification, a stateless proxy can encode the destination address and port of a request into the Via header field value that it inserts. When the response arrives, it can extract this information and use it to forward the response. */ SIP_t_ViaParm via = response.Via.GetTopMostValue(); if(via == null){ throw new ArgumentException("Argument 'response' does not contain required Via: header field."); } // TODO: If transport is not supported. //throw new SIP_TransportException("Not supported transport '" + via.ProtocolTransport + "'."); string logID = Guid.NewGuid().ToString(); string transactionID = transaction == null ? "" : transaction.ID; // Try to get local IP end point which we should use to send response back. if(transaction != null && transaction.Request.LocalEndPoint != null){ localEP = transaction.Request.LocalEndPoint; } // TODO: no "localEP" at moment // TODO: Stateless should use flowID instead. // Our stateless proxy add 'localEP' parameter to Via: if so normally we can get it from there. else if(via.Parameters["localEP"] != null){ localEP = Net_Utils.ParseIPEndPoint(via.Parameters["localEP"].Value); } byte[] responseData = response.ToByteData(); #region Try existing flow first /* First try active flow to send response, thats not 100% as RFC says, but works better in any case. RFC says that for TCP and TLS only, we do it for any transport. */ if(transaction != null){ try{ SIP_Flow flow = transaction.Flow; flow.Send(response); if(m_pStack.Logger != null){ m_pStack.Logger.AddWrite( logID, null, 0, "Response [flowReuse=true; transactionID='" + transactionID + "'; method='" + response.CSeq.RequestMethod + "'; cseq='" + response.CSeq.SequenceNumber + "'; " + "transport='" + flow.Transport + "'; size='" + responseData.Length + "'; statusCode='" + response.StatusCode + "'; " + "reason='" + response.ReasonPhrase + "'; sent '" + flow.LocalEP + "' -> '" + flow.RemoteEP + "'.", localEP, flow.RemoteEP, responseData ); } return; } catch{ // Do nothing, processing will continue. } } #endregion #region Reliable TCP,TLS, ... if(SIP_Utils.IsReliableTransport(via.ProtocolTransport)){ // Get original request remote end point. IPEndPoint remoteEP = null; if(transaction != null && transaction.Request.RemoteEndPoint != null){ remoteEP = transaction.Request.RemoteEndPoint; } else if(via.Received != null){ remoteEP = new IPEndPoint(via.Received,via.SentBy.Port == -1 ? 5060 : via.SentBy.Port); } #region If original request connection alive, use it try{ SIP_Flow flow = null; // Statefull if(transaction != null){ if(transaction.Request.Flow != null && !transaction.Request.Flow.IsDisposed){ flow = transaction.Request.Flow; } } // Stateless else{ string flowID = via.Parameters["connectionID"].Value; if(flowID != null){ flow = m_pFlowManager[flowID]; } } if(flow != null){ flow.Send(response); if(m_pStack.Logger != null){ m_pStack.Logger.AddWrite( logID, null, 0, "Response [flowReuse=true; transactionID='" + transactionID + "'; method='" + response.CSeq.RequestMethod + "'; cseq='" + response.CSeq.SequenceNumber + "'; " + "transport='" + flow.Transport + "'; size='" + responseData.Length + "'; statusCode='" + response.StatusCode + "'; " + "reason='" + response.ReasonPhrase + "'; sent '" + flow.RemoteEP + "' -> '" + flow.LocalEP + "'.", localEP, remoteEP, responseData ); } return; } } catch{ // Do nothing, processing will continue. // Override RFC, if there is any existing connection and it gives error, try always RFC 3261 18.2.2(recieved) and 3265 5. } #endregion #region Send RFC 3261 18.2.2(recieved) if(remoteEP != null){ try{ SendResponseToHost(logID,transactionID,null,remoteEP.Address.ToString(),remoteEP.Port,via.ProtocolTransport,response); } catch{ // Do nothing, processing will continue -> "RFC 3265 5.". } } #endregion #region Send RFC 3265 5. SendResponse_RFC_3263_5(logID,transactionID,localEP,response); #endregion } #endregion #region UDP Via: maddr parameter else if(via.Maddr != null){ throw new SIP_TransportException("Sending responses to multicast address(Via: 'maddr') is not supported."); } #endregion #region RFC 3581 4. UDP Via: received and rport parameters else if(via.Maddr == null && via.Received != null && via.RPort > 0){ SendResponseToHost(logID,transactionID,localEP,via.Received.ToString(),via.RPort,via.ProtocolTransport,response); } #endregion #region UDP Via: received parameter else if(via.Received != null){ SendResponseToHost(logID,transactionID,localEP,via.Received.ToString(),via.SentByPortWithDefault,via.ProtocolTransport,response); } #endregion #region UDP else{ SendResponse_RFC_3263_5(logID,transactionID,localEP,response); } #endregion }
/// <summary> /// Sends response to the specified host. /// </summary> /// <param name="logID">Log ID.</param> /// <param name="transactionID">Transaction ID. If null, then stateless response sending.</param> /// <param name="localEP">UDP local end point to use for sending. If null, system will use default.</param> /// <param name="host">Host name or IP address where to send response.</param> /// <param name="port">Target host port.</param> /// <param name="transport">SIP transport to use.</param> /// <param name="response">SIP response to send.</param> private void SendResponseToHost(string logID,string transactionID,IPEndPoint localEP,string host,int port,string transport,SIP_Response response) { try{ IPAddress[] targets = null; if(Net_Utils.IsIPAddress(host)){ targets = new IPAddress[]{IPAddress.Parse(host)}; } else{ targets = m_pStack.Dns.GetHostAddresses(host); if(targets.Length == 0){ throw new SIP_TransportException("Invalid Via: Sent-By host name '" + host + "' could not be resolved."); } } byte[] responseData = response.ToByteData(); for(int i=0;i<targets.Length;i++){ IPEndPoint remoteEP = new IPEndPoint(targets[i],port); try{ SIP_Flow flow = GetOrCreateFlow(transport,localEP,remoteEP); flow.Send(response); // localEP = flow.LocalEP; if(m_pStack.Logger != null){ m_pStack.Logger.AddWrite( logID, null, 0, "Response [transactionID='" + transactionID + "'; method='" + response.CSeq.RequestMethod + "'; cseq='" + response.CSeq.SequenceNumber + "'; " + "transport='" + transport + "'; size='" + responseData.Length + "'; statusCode='" + response.StatusCode + "'; " + "reason='" + response.ReasonPhrase + "'; sent '" + localEP + "' -> '" + remoteEP + "'.", localEP, remoteEP, responseData ); } // If we reach so far, send succeeded. return; } catch{ // Generate error, all IP addresses has failed. if(i == (targets.Length - 1)){ if(m_pStack.Logger != null){ m_pStack.Logger.AddText(logID,"Failed to send response to host '" + host + "' IP end point '" + remoteEP + "'."); } throw new SIP_TransportException("Host '" + host + ":" + port + "' is not accessible."); } // For loop will try next IP address. else{ if(m_pStack.Logger != null){ m_pStack.Logger.AddText(logID,"Failed to send response to host '" + host + "' IP end point '" + remoteEP + "', will try next A record."); } } } } } catch(DNS_ClientException dnsX){ throw new SIP_TransportException("Dns error: " + dnsX.ErrorCode.ToString()); } }
/// <summary> /// Sends specified response to flow remote end point. /// </summary> /// <param name="response">SIP response to send.</param> /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this method is accessed.</exception> /// <exception cref="ArgumentNullException">Is raised when <b>response</b> is null reference.</exception> public void Send(SIP_Response response) { lock(m_pLock){ if(m_IsDisposed){ throw new ObjectDisposedException(this.GetType().Name); } if(response == null){ throw new ArgumentNullException("response"); } SendInternal(response.ToByteData()); m_LastPing = DateTime.Now; } }
/// <summary> /// Processes specified response through this transaction. /// </summary> /// <param name="flow">SIP data flow what received response.</param> /// <param name="response">SIP response to process.</param> /// <exception cref="ArgumentNullException">Is raised when <b>flow</b>,<b>response</b> is null reference.</exception> internal void ProcessResponse(SIP_Flow flow, SIP_Response response) { if (flow == null) { throw new ArgumentNullException("flow"); } if (response == null) { throw new ArgumentNullException("response"); } lock (this.SyncRoot){ if (this.State == SIP_TransactionState.Disposed) { return; } /* RFC 3261 9.1. CANCEL. *) If provisional response, send CANCEL, we should get '478 Request terminated'. *) If final response, skip canceling, nothing to cancel. */ else if (m_IsCanceling && response.StatusCodeType == SIP_StatusCodeType.Provisional) { SendCancel(); return; } // Log if (this.Stack.Logger != null) { byte[] responseData = response.ToByteData(); this.Stack.Logger.AddRead( Guid.NewGuid().ToString(), null, 0, "Response [transactionID='" + this.ID + "'; method='" + response.CSeq.RequestMethod + "'; cseq='" + response.CSeq.SequenceNumber + "'; " + "transport='" + flow.Transport + "'; size='" + responseData.Length + "'; statusCode='" + response.StatusCode + "'; " + "reason='" + response.ReasonPhrase + "'; received '" + flow.LocalEP + "' <- '" + flow.RemoteEP + "'.", flow.LocalEP, flow.RemoteEP, responseData ); } #region INVITE /* RFC 3261 17.1.1.2. |INVITE from TU * Timer A fires |INVITE sent * Reset A, V Timer B fires * INVITE sent +-----------+ or Transport Err. +---------| |---------------+inform TU | | Calling | | +-------->| |-------------->| +-----------+ 2xx | | | 2xx to TU | | |1xx | | 300-699 +---------------+ |1xx to TU | | ACK sent | | | | resp. to TU | 1xx V | | 1xx to TU -----------+ | | +---------| | | | | |Proceeding |-------------->| | +-------->| | 2xx | | +-----------+ 2xx to TU | | 300-699 | | | ACK sent, | | | resp. to TU| | | | | NOTE: | 300-699 V | | ACK sent +-----------+Transport Err. | transitions | +---------| |Inform TU | labeled with | | | Completed |-------------->| the event | +-------->| | | over the action | +-----------+ | to take | ^ | | | | | Timer D fires | +--------------+ | - | | | | V | +-----------+ | | | | | Terminated|<--------------+ | | +-----------+ | */ if (this.Method == SIP_Methods.INVITE) { #region Calling if (this.State == SIP_TransactionState.Calling) { // Store response. AddResponse(response); // Stop timer A,B if (m_pTimerA != null) { m_pTimerA.Dispose(); m_pTimerA = null; // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer A(INVITE request retransmission) stopped."); } } if (m_pTimerB != null) { m_pTimerB.Dispose(); m_pTimerB = null; // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer B(INVITE calling state timeout) stopped."); } } // 1xx response. if (response.StatusCodeType == SIP_StatusCodeType.Provisional) { OnResponseReceived(response); SetState(SIP_TransactionState.Proceeding); } // 2xx response. else if (response.StatusCodeType == SIP_StatusCodeType.Success) { OnResponseReceived(response); SetState(SIP_TransactionState.Terminated); } // 3xx - 6xx response. else { SendAck(response); OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.1.2. * The client transaction SHOULD start timer D when it enters the "Completed" state, * with a value of at least 32 seconds for unreliable transports, and a value of zero * seconds for reliable transports. */ m_pTimerD = new TimerEx(this.Flow.IsReliable ? 0 : 32000, false); m_pTimerD.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerD_Elapsed); // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer D(INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerD.Interval + "."); } m_pTimerD.Enabled = true; } } #endregion #region Proceeding else if (this.State == SIP_TransactionState.Proceeding) { // Store response. AddResponse(response); // 1xx response. if (response.StatusCodeType == SIP_StatusCodeType.Provisional) { OnResponseReceived(response); } // 2xx response. else if (response.StatusCodeType == SIP_StatusCodeType.Success) { OnResponseReceived(response); SetState(SIP_TransactionState.Terminated); } // 3xx - 6xx response. else { SendAck(response); OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.1.2. * The client transaction SHOULD start timer D when it enters the "Completed" state, * with a value of at least 32 seconds for unreliable transports, and a value of zero * seconds for reliable transports. */ m_pTimerD = new TimerEx(this.Flow.IsReliable ? 0 : 32000, false); m_pTimerD.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerD_Elapsed); // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer D(INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerD.Interval + "."); } m_pTimerD.Enabled = true; } } #endregion #region Completed else if (this.State == SIP_TransactionState.Completed) { // 3xx - 6xx if (response.StatusCode >= 300) { SendAck(response); } } #endregion #region Terminated else if (this.State == SIP_TransactionState.Terminated) { // We should never reach here, but if so, do nothing. } #endregion } #endregion #region Non-INVITE /* RFC 3251 17.1.2.2 |Request from TU |send request * Timer E V * send request +-----------+ +---------| |-------------------+ | | Trying | Timer F | +-------->| | or Transport Err.| +-----------+ inform TU | | 200-699 | | | | resp. to TU | |1xx | +---------------+ |resp. to TU | | | | | Timer E V Timer F | | send req +-----------+ or Transport Err. | | +---------| | inform TU | | | |Proceeding |------------------>| | +-------->| |-----+ | | +-----------+ |1xx | | | ^ |resp to TU | | 200-699 | +--------+ | | resp. to TU | | | | | | V | | +-----------+ | | | | | | | Completed | | | | | | | +-----------+ | | ^ | | | | | Timer K | +--------------+ | - | | | | V | | NOTE: +-----------+ | | | | | transitions | Terminated|<------------------+ | labeled with | | | the event +-----------+ | over the action | to take */ else { #region Trying if (this.State == SIP_TransactionState.Trying) { // Store response. AddResponse(response); // Stop timer E if (m_pTimerE != null) { m_pTimerE.Dispose(); m_pTimerE = null; // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer E(Non-INVITE request retransmission) stopped."); } } // 1xx response. if (response.StatusCodeType == SIP_StatusCodeType.Provisional) { OnResponseReceived(response); SetState(SIP_TransactionState.Proceeding); } // 2xx - 6xx response. else { // Stop timer F if (m_pTimerF != null) { m_pTimerF.Dispose(); m_pTimerF = null; // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer F(Non-INVITE trying,proceeding state timeout) stopped."); } } OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.2.2. * The client transaction enters the "Completed" state, it MUST set * Timer K to fire in T4 seconds for unreliable transports, and zero * seconds for reliable transports. */ m_pTimerK = new TimerEx(this.Flow.IsReliable ? 1 : SIP_TimerConstants.T4, false); m_pTimerK.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerK_Elapsed); // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer K(Non-INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerK.Interval + "."); } m_pTimerK.Enabled = true; } } #endregion #region Proceeding else if (this.State == SIP_TransactionState.Proceeding) { // Store response. AddResponse(response); // 1xx response. if (response.StatusCodeType == SIP_StatusCodeType.Provisional) { OnResponseReceived(response); } // 2xx - 6xx response. else { // Stop timer F if (m_pTimerF != null) { m_pTimerF.Dispose(); m_pTimerF = null; // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer F(Non-INVITE trying,proceeding state timeout) stopped."); } } OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.2.2. * The client transaction enters the "Completed" state, it MUST set * Timer K to fire in T4 seconds for unreliable transports, and zero * seconds for reliable transports. */ m_pTimerK = new TimerEx(this.Flow.IsReliable ? 0 : SIP_TimerConstants.T4, false); m_pTimerK.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerK_Elapsed); // Log if (this.Stack.Logger != null) { this.Stack.Logger.AddText(this.ID, "Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer K(Non-INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerK.Interval + "."); } m_pTimerK.Enabled = true; } } #endregion #region Completed else if (this.State == SIP_TransactionState.Completed) { // Eat retransmited response. } #endregion #region Terminated else if (this.State == SIP_TransactionState.Terminated) { // We should never reach here, but if so, do nothing. } #endregion } #endregion } }
/// <summary> /// Processes specified response through this transaction. /// </summary> /// <param name="flow">SIP data flow what received response.</param> /// <param name="response">SIP response to process.</param> /// <exception cref="ArgumentNullException">Is raised when <b>flow</b>,<b>response</b> is null reference.</exception> internal void ProcessResponse(SIP_Flow flow,SIP_Response response) { if(flow == null){ throw new ArgumentNullException("flow"); } if(response == null){ throw new ArgumentNullException("response"); } lock(this.SyncRoot){ if(this.State == SIP_TransactionState.Disposed){ return; } /* RFC 3261 9.1. CANCEL. *) If provisional response, send CANCEL, we should get '478 Request terminated'. *) If final response, skip canceling, nothing to cancel. */ else if(m_IsCanceling && response.StatusCodeType == SIP_StatusCodeType.Provisional){ SendCancel(); return; } // Log if(this.Stack.Logger != null){ byte[] responseData = response.ToByteData(); this.Stack.Logger.AddRead( Guid.NewGuid().ToString(), null, 0, "Response [transactionID='" + this.ID + "'; method='" + response.CSeq.RequestMethod + "'; cseq='" + response.CSeq.SequenceNumber + "'; " + "transport='" + flow.Transport + "'; size='" + responseData.Length + "'; statusCode='" + response.StatusCode + "'; " + "reason='" + response.ReasonPhrase + "'; received '" + flow.LocalEP + "' <- '" + flow.RemoteEP + "'.", flow.LocalEP, flow.RemoteEP, responseData ); } #region INVITE /* RFC 6026 7.2. INVITE client transaction. (Udpates RFC 3261) +-----------+ +-----------+ | | | | | Calling | | Calling | | |----------->+ | |-----------+ +-----------+ 2xx | +-----------+ 2xx | 2xx to TU | 2xx to TU | | | | | | | | | +-----------+ | +-----------+ | | | | | | | |Proceeding |----------->| |Proceeding |---------->| | | 2xx | | | 2xx | +-----------+ 2xx to TU | +-----------+ 2xx to TU | | | | | | | | V | +-----------+ | | | | | Accepted | | +---| | | 2xx | +-----------+ | 2xx to TU | ^ | | | | | | +-----+ | | | | +-----------------+ | | Timer M fires | | - | V +-----------+ | +-----------+ | | | | | | Terminated|<-----------+ | Terminated| | | | | +-----------+ +-----------+ */ if(this.Method == SIP_Methods.INVITE){ #region Calling if(this.State == SIP_TransactionState.Calling){ // Store response. AddResponse(response); // Stop timer A,B if(m_pTimerA != null){ m_pTimerA.Dispose(); m_pTimerA = null; // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer A(INVITE request retransmission) stopped."); } } if(m_pTimerB != null){ m_pTimerB.Dispose(); m_pTimerB = null; // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer B(INVITE calling state timeout) stopped."); } } // 1xx response. if(response.StatusCodeType == SIP_StatusCodeType.Provisional){ OnResponseReceived(response); SetState(SIP_TransactionState.Proceeding); } // 2xx response. else if(response.StatusCodeType == SIP_StatusCodeType.Success){ OnResponseReceived(response); SetState(SIP_TransactionState.Accpeted); /* RFC 6025 7.1. When the "Accepted" state is entered, timer L MUST be set to fire in 64*T1. */ m_pTimerM = new TimerEx(64 * SIP_TimerConstants.T1); m_pTimerM.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerM_Elapsed); m_pTimerM.Enabled = true; // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=true] timer M(2xx retransmission wait) started, will trigger after " + m_pTimerM.Interval + "."); } } // 3xx - 6xx response. else{ SendAck(response); OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.1.2. The client transaction SHOULD start timer D when it enters the "Completed" state, with a value of at least 32 seconds for unreliable transports, and a value of zero seconds for reliable transports. */ m_pTimerD = new TimerEx(this.Flow.IsReliable ? 0 : 32000,false); m_pTimerD.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerD_Elapsed); // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer D(INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerD.Interval + "."); } m_pTimerD.Enabled = true; } } #endregion #region Proceeding else if(this.State == SIP_TransactionState.Proceeding){ // Store response. AddResponse(response); // 1xx response. if(response.StatusCodeType == SIP_StatusCodeType.Provisional){ OnResponseReceived(response); } // 2xx response. else if(response.StatusCodeType == SIP_StatusCodeType.Success){ OnResponseReceived(response); SetState(SIP_TransactionState.Accpeted); /* RFC 6025 7.1. When the "Accepted" state is entered, timer L MUST be set to fire in 64*T1. */ m_pTimerM = new TimerEx(64 * SIP_TimerConstants.T1); m_pTimerM.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerM_Elapsed); m_pTimerM.Enabled = true; // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=true] timer M(2xx retransmission wait) started, will trigger after " + m_pTimerM.Interval + "."); } } // 3xx - 6xx response. else{ SendAck(response); OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.1.2. The client transaction SHOULD start timer D when it enters the "Completed" state, with a value of at least 32 seconds for unreliable transports, and a value of zero seconds for reliable transports. */ m_pTimerD = new TimerEx(this.Flow.IsReliable ? 0 : 32000,false); m_pTimerD.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerD_Elapsed); // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer D(INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerD.Interval + "."); } m_pTimerD.Enabled = true; } } #endregion #region Accepted else if(this.State == SIP_TransactionState.Accpeted){ if(response.StatusCodeType == SIP_StatusCodeType.Success){ OnResponseReceived(response); } } #endregion #region Completed else if(this.State == SIP_TransactionState.Completed){ // 3xx - 6xx if(response.StatusCode >= 300){ SendAck(response); } } #endregion #region Terminated else if(this.State == SIP_TransactionState.Terminated){ // We should never reach here, but if so, do nothing. } #endregion } #endregion #region Non-INVITE /* RFC 3251 17.1.2.2 |Request from TU |send request Timer E V send request +-----------+ +---------| |-------------------+ | | Trying | Timer F | +-------->| | or Transport Err.| +-----------+ inform TU | 200-699 | | | resp. to TU | |1xx | +---------------+ |resp. to TU | | | | | Timer E V Timer F | | send req +-----------+ or Transport Err. | | +---------| | inform TU | | | |Proceeding |------------------>| | +-------->| |-----+ | | +-----------+ |1xx | | | ^ |resp to TU | | 200-699 | +--------+ | | resp. to TU | | | | | | V | | +-----------+ | | | | | | | Completed | | | | | | | +-----------+ | | ^ | | | | | Timer K | +--------------+ | - | | | V | NOTE: +-----------+ | | | | transitions | Terminated|<------------------+ labeled with | | the event +-----------+ over the action to take */ else{ #region Trying if(this.State == SIP_TransactionState.Trying){ // Store response. AddResponse(response); // Stop timer E if(m_pTimerE != null){ m_pTimerE.Dispose(); m_pTimerE = null; // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer E(Non-INVITE request retransmission) stopped."); } } // 1xx response. if(response.StatusCodeType == SIP_StatusCodeType.Provisional){ OnResponseReceived(response); SetState(SIP_TransactionState.Proceeding); } // 2xx - 6xx response. else{ // Stop timer F if(m_pTimerF != null){ m_pTimerF.Dispose(); m_pTimerF = null; // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer F(Non-INVITE trying,proceeding state timeout) stopped."); } } OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.2.2. The client transaction enters the "Completed" state, it MUST set Timer K to fire in T4 seconds for unreliable transports, and zero seconds for reliable transports. */ m_pTimerK = new TimerEx(this.Flow.IsReliable ? 1 : SIP_TimerConstants.T4,false); m_pTimerK.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerK_Elapsed); // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer K(Non-INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerK.Interval + "."); } m_pTimerK.Enabled = true; } } #endregion #region Proceeding else if(this.State == SIP_TransactionState.Proceeding){ // Store response. AddResponse(response); // 1xx response. if(response.StatusCodeType == SIP_StatusCodeType.Provisional){ OnResponseReceived(response); } // 2xx - 6xx response. else{ // Stop timer F if(m_pTimerF != null){ m_pTimerF.Dispose(); m_pTimerF = null; // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer F(Non-INVITE trying,proceeding state timeout) stopped."); } } OnResponseReceived(response); SetState(SIP_TransactionState.Completed); /* RFC 3261 17.1.2.2. The client transaction enters the "Completed" state, it MUST set Timer K to fire in T4 seconds for unreliable transports, and zero seconds for reliable transports. */ m_pTimerK = new TimerEx(this.Flow.IsReliable ? 0 : SIP_TimerConstants.T4,false); m_pTimerK.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimerK_Elapsed); // Log if(this.Stack.Logger != null){ this.Stack.Logger.AddText(this.ID,"Transaction [branch='" + this.ID + "';method='" + this.Method + "';IsServer=false] timer K(Non-INVITE 3xx - 6xx response retransmission wait) started, will trigger after " + m_pTimerK.Interval + "."); } m_pTimerK.Enabled = true; } } #endregion #region Completed else if(this.State == SIP_TransactionState.Completed){ // Eat retransmited response. } #endregion #region Terminated else if(this.State == SIP_TransactionState.Terminated){ // We should never reach here, but if so, do nothing. } #endregion } #endregion } }
/// <summary> /// Processes SIP data (request or response). /// </summary> /// <param name="socket">Socket what accepted specified SIP message.</param> /// <param name="data">SIP message or may be junk data too.</param> /// <param name="remoteEndPoint">Remote IP end point what sent SIP message.</param> /// <param name="transport">SIP transport what received message.</param> private void Process(string transport,SocketEx socket,byte[] data,IPEndPoint remoteEndPoint) { try{ // Log m_pSipStack.Logger.AddRead(data.Length,"Received (" + data.Length + " bytes): " + socket.LocalEndPoint.ToString() + " <- " + remoteEndPoint.ToString() + "\r\n" + System.Text.Encoding.UTF8.GetString(data) + "\r\n"); // Bad request or response. if(data.Length < 10){ return; } // TODO: Check that advertised transport matches actual received transport. // Dedect if sip request or reponse. // Response if(System.Text.Encoding.UTF8.GetString(data,0,10).ToUpper().StartsWith("SIP")){ try{ SIP_Response response = SIP_Response.Parse(data); response.Validate(); ProcessResponse(response); } catch(Exception x){ // We have bad response, just skip it. // Log if(m_pSipStack.Logger != null){ m_pSipStack.Logger.AddDebug("Skipping message, parse error: " + x.Message); } } } // Request else{ SIP_Request request = null; try{ request = SIP_Request.Parse(data); try{ request.Validate(); } catch(Exception x){ // Log if(m_pSipStack.Logger != null){ m_pSipStack.Logger.AddDebug("Invalid request: " + x.Message); } // Bad request, send error to request maker. SendResponse(socket,request.CreateResponse(SIP_ResponseCodes.x400_Bad_Request + ". " + x.Message)); return; } } catch(Exception x){ // Log if(m_pSipStack.Logger != null){ m_pSipStack.Logger.AddDebug("Invalid request: " + x.Message); } // We have bad request, try to send bad request error to request maker. SIP_Response badRequestResponse = new SIP_Response(); badRequestResponse.StatusCode_ReasonPhrase = SIP_ResponseCodes.x400_Bad_Request; socket.SendTo(badRequestResponse.ToByteData(),remoteEndPoint); return; } SIP_ValidateRequestEventArgs eArgs = m_pSipStack.OnValidateRequest(request,remoteEndPoint); // Request validated, allow transport layer to handle it. if(eArgs.ResponseCode == null){ ProcessRequest(request,socket,remoteEndPoint); } // Request rejected, return response. else{ SendResponse(socket,request.CreateResponse(eArgs.ResponseCode)); } } } catch(SocketException s){ // Skip all socket errors here string dummy = s.Message; } catch(Exception x){ m_pSipStack.OnError(x); } }
/// <summary> /// Sends response to request maker. /// </summary> /// <param name="socket">Socket which to use to send response.</param> /// <param name="remoteEndPoint">Remote end point where to send response. /// If this value is null, Via header is used to get remote end point. /// </param> /// <param name="response">Response to send.</param> public void SendResponse(SocketEx socket,IPEndPoint remoteEndPoint,SIP_Response response) { /* RFC 3581 4. Server Behavior. When a server attempts to send a response, it examines the topmost Via header field value of that response. If the "sent-protocol" component indicates an unreliable unicast transport protocol, such as UDP, and there is no "maddr" parameter, but there is both a "received" parameter and an "rport" parameter, the response MUST be sent to the IP address listed in the "received" parameter, and the port in the "rport" parameter. The response MUST be sent from the same address and port that the corresponding request was received on in order to traverse symmetric NATs. */ /* RFC 3261 18.2.2 Sending Responses. The server transport uses the value of the top Via header field in order to determine where to send a response. It MUST follow the following process: o If the "sent-protocol" is a reliable transport protocol such as TCP or SCTP, or TLS over those, the response MUST be sent using the existing connection to the source of the original request that created the transaction, if that connection is still open. This requires the server transport to maintain an association between server transactions and transport connections. If that connection is no longer open, the server SHOULD open a connection to the IP address in the "received" parameter, if present, using the port in the "sent-by" value, or the default port for that transport, if no port is specified. If that connection attempt fails, the server SHOULD use the procedures in [4] for servers in order to determine the IP address and port to open the connection and send the response to. o Otherwise, if the Via header field value contains a "maddr" parameter, the response MUST be forwarded to the address listed there, using the port indicated in "sent-by", or port 5060 if none is present. If the address is a multicast address, the response SHOULD be sent using the TTL indicated in the "ttl" parameter, or with a TTL of 1 if that parameter is not present. o Otherwise (for unreliable unicast transports), if the top Via has a "received" parameter, the response MUST be sent to the address in the "received" parameter, using the port indicated in the "sent-by" value, or using port 5060 if none is specified explicitly. If this fails, for example, elicits an ICMP "port unreachable" response, the procedures of Section 5 of [4] SHOULD be used to determine where to send the response. o Otherwise, if it is not receiver-tagged, the response MUST be sent to the address indicated by the "sent-by" value, using the procedures in Section 5 of [4]. */ // TODO: Probably we can use local endpoint instead of socket. Because then we can // Search right UDP connection or TCP/TLS connection. try{ SIP_t_ViaParm via = response.Via.GetTopMostValue(); // End point not specified, get it from Via. if(remoteEndPoint == null){ string host = null; int port = 5060; // Use received host. if(via.Received != null){ host = via.Received; } // Get sent-by host else{ host = via.SentBy.Split(':')[0]; } // Use rport if recevived is specified too if(via.Received != null && via.RPort > 0){ port = via.RPort; } // Get port from sent-by else{ string[] host_port = via.SentBy.Split(':'); if(host_port.Length == 2){ port = Convert.ToInt32(host_port[1]); } } remoteEndPoint = new IPEndPoint(System.Net.Dns.GetHostAddresses(host)[0],port); } byte[] data = response.ToByteData(); // Log m_pSipStack.Logger.AddWrite(data.Length,"Sending (" + data.Length + " bytes): " + socket.LocalEndPoint.ToString() + " -> " + remoteEndPoint.ToString() + "\r\n<begin>\r\n" + System.Text.Encoding.UTF8.GetString(data) + "<end>\r\n"); // We don't have any more that socket what accepted request which response it is. // There are 2 known cases when no socket: // 1) Stateless proxy. // 2) Statefull proxy, but response didn't match any transaction. if(socket == null){ // UDP Multicast if(via.ProtocolTransport.ToUpper() == SIP_Transport.UDP && via.Maddr != null){ throw new SIP_TransportException("UDP Multicast not implemented !"); } // UDP else if(via.ProtocolTransport.ToUpper() == SIP_Transport.UDP){ foreach(SipListeningPoint listeningPoint in m_pListeningPoints){ if(listeningPoint.Protocol == BindInfoProtocol.UDP){ listeningPoint.Socket.SendTo(data,remoteEndPoint); return; } } throw new SIP_TransportException("No UDP transport available, this never should happen !"); } // TCP else if(via.ProtocolTransport.ToUpper() == SIP_Transport.TCP){ SipTcpPipe pipe = GetTcpPipe(SIP_Transport.TCP,remoteEndPoint); // Not existing connection, create it. if(pipe == null){ pipe = new SipTcpPipe(this,remoteEndPoint,true); } pipe.SendMessage(data); } // TCP TLS else if(via.ProtocolTransport.ToUpper() == SIP_Transport.TLS){ SipTcpPipe pipe = GetTcpPipe(SIP_Transport.TLS,remoteEndPoint); // Not existing connection, create it. if(pipe == null){ pipe = new SipTcpPipe(this,remoteEndPoint,true); } pipe.SendMessage(data); } } // We have existing socket, use it. else{ if(via.ProtocolTransport.ToUpper() == SIP_Transport.UDP){ socket.SendTo(data,remoteEndPoint); } else{ socket.Write(data); } } } catch(Exception x){ throw new SIP_TransportException(x.Message); } }