/// <summary>
/// Matches SIP response to client transaction. If not matching transaction found, returns null.
/// </summary>
/// <param name="response">SIP response to match.</param>
internal SIP_ClientTransaction MatchClientTransaction(SIP_Response response)
{
/* RFC 3261 17.1.3 Matching Responses to Client Transactions.
* 1. If the response has the same value of the branch parameter in
* the top Via header field as the branch parameter in the top
* Via header field of the request that created the transaction.
*
* 2. If the method parameter in the CSeq header field matches the
* method of the request that created the transaction. The
* method is needed since a CANCEL request constitutes a
* different transaction, but shares the same value of the branch
* parameter.
*/
SIP_ClientTransaction retVal = null;
string transactionID = response.Via.GetTopMostValue().Branch + "-" + response.CSeq.RequestMethod;
lock (m_pClientTransactions)
{
m_pClientTransactions.TryGetValue(transactionID, out retVal);
}
return(retVal);
}
/// <summary>
/// Sends specified request to the specified data flow.
/// </summary>
/// <param name="flow">SIP data flow.</param>
/// <param name="request">SIP request to send.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>flow</b> or <b>request</b> is null reference.</exception>
private void SendToFlow(SIP_Flow flow, SIP_Request request)
{
if (flow == null)
{
throw new ArgumentNullException("flow");
}
if (request == null)
{
throw new ArgumentNullException("request");
}
#region Contact (RFC 3261 8.1.1.8)
/*
* The Contact header field provides a SIP or SIPS URI that can be used
* to contact that specific instance of the UA for subsequent requests.
* The Contact header field MUST be present and contain exactly one SIP
* or SIPS URI in any request that can result in the establishment of a
* dialog. For the methods defined in this specification, that includes
* only the INVITE request. For these requests, the scope of the
* Contact is global. That is, the Contact header field value contains
* the URI at which the UA would like to receive requests, and this URI
* MUST be valid even if used in subsequent requests outside of any
* dialogs.
*
* If the Request-URI or top Route header field value contains a SIPS
* URI, the Contact header field MUST contain a SIPS URI as well.
*/
SIP_t_ContactParam contact = request.Contact.GetTopMostValue();
// Add contact header If request-Method can establish dialog and contact header not present.
if (SIP_Utils.MethodCanEstablishDialog(request.RequestLine.Method) && contact == null)
{
SIP_Uri from = (SIP_Uri)request.From.Address.Uri;
request.Contact.Add((flow.IsSecure ? "sips:" : "sip:") + from.User + "@" + flow.LocalPublicEP.ToString());
// REMOVE ME: 22.10.2010
//request.Contact.Add((flow.IsSecure ? "sips:" : "sip:" ) + from.User + "@" + m_pStack.TransportLayer.GetContactHost(flow).ToString());
}
// If contact SIP URI and host = auto-allocate, allocate it as needed.
else if (contact != null && contact.Address.Uri is SIP_Uri && ((SIP_Uri)contact.Address.Uri).Host == "auto-allocate")
{
((SIP_Uri)contact.Address.Uri).Host = flow.LocalPublicEP.ToString();
// REMOVE ME: 22.10.2010
//((SIP_Uri)contact.Address.Uri).Host = m_pStack.TransportLayer.GetContactHost(flow).ToString();
}
#endregion
m_pTransaction = m_pStack.TransactionLayer.CreateClientTransaction(flow, request, true);
m_pTransaction.ResponseReceived += new EventHandler <SIP_ResponseReceivedEventArgs>(ClientTransaction_ResponseReceived);
m_pTransaction.TimedOut += new EventHandler(ClientTransaction_TimedOut);
m_pTransaction.TransportError += new EventHandler <ExceptionEventArgs>(ClientTransaction_TransportError);
// Start transaction processing.
m_pTransaction.Start();
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="stack">Reference to SIP stack.</param>
/// <param name="transaction">Client transaction what response it is. This value can be null if no matching client response.</param>
/// <param name="response">Received response.</param>
internal SIP_ResponseReceivedEventArgs(SIP_Stack stack,
SIP_ClientTransaction transaction,
SIP_Response response)
{
m_pStack = stack;
m_pResponse = response;
m_pTransaction = transaction;
}
/// <summary>
/// Cleans up active transaction.
/// </summary>
private void CleanUpActiveTransaction()
{
if (m_pTransaction != null)
{
// Don't dispose transaction, transaction will dispose itself when done.
// Otherwise for example failed INVITE won't linger in "Completed" state as it must be.
// We just release Events processing, because you don't care about them any more.
m_pTransaction.ResponseReceived -= ClientTransaction_ResponseReceived;
m_pTransaction.TimedOut -= ClientTransaction_TimedOut;
m_pTransaction.TransportError -= ClientTransaction_TransportError;
m_pTransaction = null;
}
}
/// <summary>
/// Creates new client transaction.
/// </summary>
/// <param name="flow">SIP data flow which is used to send request.</param>
/// <param name="request">SIP request that transaction will handle.</param>
/// <param name="addVia">If true, transaction will add <b>Via:</b> header, otherwise it's user responsibility.</param>
/// <exception cref="ObjectDisposedException">Is raised when this class is Disposed and this method is accessed.</exception>
/// <exception cref="ArgumentNullException">Is raised when <b>flow</b> or <b>request</b> is null reference.</exception>
/// <returns>Returns created transaction.</returns>
public SIP_ClientTransaction CreateClientTransaction(SIP_Flow flow, SIP_Request request, bool addVia)
{
if (m_IsDisposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
if (flow == null)
{
throw new ArgumentNullException("flow");
}
if (request == null)
{
throw new ArgumentNullException("request");
}
// Add Via:
if (addVia)
{
SIP_t_ViaParm via = new SIP_t_ViaParm();
via.ProtocolName = "SIP";
via.ProtocolVersion = "2.0";
via.ProtocolTransport = flow.Transport;
via.SentBy = new HostEndPoint("transport_layer_will_replace_it", -1);
via.Branch = SIP_t_ViaParm.CreateBranch();
via.RPort = 0;
request.Via.AddToTop(via.ToStringValue());
}
lock (m_pClientTransactions){
SIP_ClientTransaction transaction = new SIP_ClientTransaction(m_pStack, flow, request);
m_pClientTransactions.Add(transaction.Key, transaction);
transaction.StateChanged += new EventHandler(delegate(object s, EventArgs e){
if (transaction.State == SIP_TransactionState.Terminated)
{
lock (m_pClientTransactions){
m_pClientTransactions.Remove(transaction.Key);
}
}
});
SIP_Dialog dialog = MatchDialog(request);
if (dialog != null)
{
dialog.AddTransaction(transaction);
}
return(transaction);
}
}
/// <summary>
/// Cleans up any resources being used.
/// </summary>
public void Dispose()
{
lock (m_pLock){
if (m_State == SIP_RequestSenderState.Disposed)
{
return;
}
m_State = SIP_RequestSenderState.Disposed;
OnDisposed();
this.ResponseReceived = null;
this.Completed = null;
this.Disposed = null;
m_pStack = null;
m_pRequest = null;
m_pCredentials = null;
m_pHops = null;
m_pTransaction = null;
m_pLock = null;
}
}
/// <summary>
/// Cleans up acitve hop resources.
/// </summary>
private void CleanUpActiveHop()
{
if (m_pTimerC != null)
{
m_pTimerC.Dispose();
m_pTimerC = null;
}
if (m_pTransaction != null)
{
m_pTransaction.Dispose();
m_pTransaction = null;
}
}
/// <summary>
/// Sends specified request to the specified data flow.
/// </summary>
/// <param name="flow">SIP data flow.</param>
/// <param name="request">SIP request to send.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>flow</b> or <b>request</b> is null reference.</exception>
private void SendToFlow(SIP_Flow flow, SIP_Request request)
{
if (flow == null)
{
throw new ArgumentNullException("flow");
}
if (request == null)
{
throw new ArgumentNullException("request");
}
/* NAT traversal.
When we do record routing, store request sender flow info and request target flow info.
Now the tricky part, how proxy later which flow is target (because both sides can send requests).
Sender-flow will store from-tag to flow and target-flow will store flowID only (Because we don't know to-tag).
Later if request to-tag matches(incoming request), use that flow, otherwise(outgoing request) other flow.
flowInfo: sender-flow "/" target-flow
sender-flow = from-tag ":" flowID
target-flow = flowID
*/
if (m_AddRecordRoute && request.From.Tag != null)
{
string flowInfo = request.From.Tag + ":" + m_pOwner.ServerTransaction.Flow.ID + "/" +
flow.ID;
((SIP_Uri) request.RecordRoute.GetTopMostValue().Address.Uri).Parameters.Add("flowInfo",
flowInfo);
}
/* RFC 3261 16.6 Request Forwarding.
Common Steps 1 - 7 are done in target Init().
8. Add a Via header field value
9. Add a Content-Length header field if necessary
10. Forward the new request
11. Set timer C
*/
#region 8. Add a Via header field value
// Skip, Client transaction will add it.
#endregion
#region 9. Add a Content-Length header field if necessary
// Skip, our SIP_Message class is smart and do it when ever it's needed.
#endregion
#region 10. Forward the new request
m_pTransaction = m_pOwner.Proxy.Stack.TransactionLayer.CreateClientTransaction(flow,
request,
true);
m_pTransaction.ResponseReceived += ClientTransaction_ResponseReceived;
m_pTransaction.TimedOut += ClientTransaction_TimedOut;
m_pTransaction.TransportError += ClientTransaction_TransportError;
m_pTransaction.Disposed += m_pTransaction_Disposed;
// Start transaction processing.
m_pTransaction.Start();
#endregion
#region 11. Set timer C
/* 11. Set timer C
In order to handle the case where an INVITE request never
generates a final response, the TU uses a timer which is called
timer C. Timer C MUST be set for each client transaction when
an INVITE request is proxied. The timer MUST be larger than 3
minutes. Section 16.7 bullet 2 discusses how this timer is
updated with provisional responses, and Section 16.8 discusses
processing when it fires.
*/
if (request.RequestLine.Method == SIP_Methods.INVITE)
{
m_pTimerC = new TimerEx();
m_pTimerC.AutoReset = false;
m_pTimerC.Interval = 3*60*1000;
m_pTimerC.Elapsed += m_pTimerC_Elapsed;
}
#endregion
}
/// <summary>
/// Cleans up any resources being used.
/// </summary>
public void Dispose()
{
lock (m_pLock)
{
if (m_IsDisposed)
{
return;
}
m_IsDisposed = true;
m_pOwner.TargetHandler_Disposed(this);
m_pOwner = null;
m_pRequest = null;
m_pTargetUri = null;
m_pHops = null;
if (m_pTransaction != null)
{
m_pTransaction.Dispose();
m_pTransaction = null;
}
if (m_pTimerC != null)
{
m_pTimerC.Dispose();
m_pTimerC = null;
}
}
}
/// <summary>
/// Sends SIP response to caller. If proxy context is in B2BUA mode, new response is generated
/// as needed.
/// </summary>
/// <param name="transaction">Client transaction what response it is.</param>
/// <param name="response">Response to send.</param>
private void SendResponse(SIP_ClientTransaction transaction, SIP_Response response)
{
if (m_IsB2BUA)
{
/* draft-marjou-sipping-b2bua-00 4.1.3.
When the UAC side of the B2BUA receives the downstream SIP response
of a forwarded request, its associated UAS creates an upstream
response (except for 100 responses). The creation of the Via, Max-
Forwards, Call-Id, CSeq, Record-Route and Contact header fields
follows the rules of [2]. The Record-Route header fields of the
downstream response are not copied in the new upstream response, as
Record-Route is meaningful for the downstream dialog. The UAS SHOULD
copy other header fields and body from the downstream response into
this upstream response before sending it.
*/
SIP_Request originalRequest = m_pServerTransaction.Request;
// We need to use caller original request to construct response from proxied response.
SIP_Response b2buaResponse = response.Copy();
b2buaResponse.Via.RemoveAll();
b2buaResponse.Via.AddToTop(originalRequest.Via.GetTopMostValue().ToStringValue());
b2buaResponse.CallID = originalRequest.CallID;
b2buaResponse.CSeq = originalRequest.CSeq;
b2buaResponse.Contact.RemoveAll();
//b2buaResponse.Contact.Add(m_pProxy.CreateContact(originalRequest.From.Address).ToStringValue());
b2buaResponse.RecordRoute.RemoveAll();
b2buaResponse.Allow.RemoveAll();
b2buaResponse.Supported.RemoveAll();
// Accept to non ACK,BYE request.
if (originalRequest.RequestLine.Method != SIP_Methods.ACK &&
originalRequest.RequestLine.Method != SIP_Methods.BYE)
{
b2buaResponse.Allow.Add("INVITE,ACK,OPTIONS,CANCEL,BYE,PRACK");
}
// Supported to non ACK request.
if (originalRequest.RequestLine.Method != SIP_Methods.ACK)
{
b2buaResponse.Supported.Add("100rel,timer");
}
// Remove Require: header.
b2buaResponse.Require.RemoveAll();
m_pServerTransaction.SendResponse(b2buaResponse);
// If INVITE 2xx response do call here.
if (response.CSeq.RequestMethod.ToUpper() == SIP_Methods.INVITE &&
response.StatusCodeType == SIP_StatusCodeType.Success)
{
m_pProxy.B2BUA.AddCall(m_pServerTransaction.Dialog, transaction.Dialog);
}
}
else
{
m_pServerTransaction.SendResponse(response);
}
}
/// <summary>
/// Processes received response.
/// </summary>
/// <param name="handler">Target handler what received response.</param>
/// <param name="transaction">Client transaction what response it is.</param>
/// <param name="response">Response received.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>handler</b>,<b>transaction</b> or <b>response</b> is null reference.</exception>
private void ProcessResponse(TargetHandler handler,
SIP_ClientTransaction transaction,
SIP_Response response)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
if (response == null)
{
throw new ArgumentNullException("response");
}
/* RFC 3261 16.7 Response Processing.
Steps 1 - 2 handled in TargetHandler.
3. Remove the topmost Via
4. Add the response to the response context
5. Check to see if this response should be forwarded immediately
6. When necessary, choose the best final response from the response context.
If no final response has been forwarded after every client
transaction associated with the response context has been terminated,
the proxy must choose and forward the "best" response from those it
has seen so far.
The following processing MUST be performed on each response that is
forwarded. It is likely that more than one response to each request
will be forwarded: at least each provisional and one final response.
7. Aggregate authorization header field values if necessary
8. Optionally rewrite Record-Route header field values
9. Forward the response
10. Generate any necessary CANCEL requests
*/
bool forwardResponse = false;
lock (m_pLock)
{
#region 3. Remove the topmost Via
/*
The proxy removes the topmost Via header field value from the
response.
If no Via header field values remain in the response, the
response was meant for this element and MUST NOT be forwarded.
The remainder of the processing described in this section is
not performed on this message, the UAC processing rules
described in Section 8.1.3 are followed instead (transport
layer processing has already occurred).
This will happen, for instance, when the element generates
CANCEL requests as described in Section 10.
NOTE: We MAY NOT do it for B2BUA, skip it for B2BUA
*/
if (!m_IsB2BUA)
{
response.Via.RemoveTopMostValue();
if (response.Via.GetAllValues().Length == 0)
{
return;
}
}
#endregion
#region 4. Add the response to the response context
/*
Final responses received are stored in the response context
until a final response is generated on the server transaction
associated with this context. The response may be a candidate
for the best final response to be returned on that server
transaction. Information from this response may be needed in
forming the best response, even if this response is not chosen.
If the proxy chooses to recurse on any contacts in a 3xx
response by adding them to the target set, it MUST remove them
from the response before adding the response to the response
context. However, a proxy SHOULD NOT recurse to a non-SIPS URI
if the Request-URI of the original request was a SIPS URI. If
the proxy recurses on all of the contacts in a 3xx response,
the proxy SHOULD NOT add the resulting contactless response to
the response context.
Removing the contact before adding the response to the response
context prevents the next element upstream from retrying a
location this proxy has already attempted.
3xx responses may contain a mixture of SIP, SIPS, and non-SIP
URIs. A proxy may choose to recurse on the SIP and SIPS URIs
and place the remainder into the response context to be
returned, potentially in the final response.
*/
if (response.StatusCodeType == SIP_StatusCodeType.Redirection && !m_NoRecurse &&
!handler.IsRecursed)
{
// Get SIP contacts and remove them from response.
SIP_t_ContactParam[] contacts = response.Contact.GetAllValues();
// Remove all contacts from response, we add non-SIP URIs back.
response.Contact.RemoveAll();
foreach (SIP_t_ContactParam contact in contacts)
{
// SIP URI add it to fork list.
if (contact.Address.IsSipOrSipsUri)
{
m_pTargets.Enqueue(new TargetHandler(this,
null,
(SIP_Uri) contact.Address.Uri,
m_AddRecordRoute,
true));
}
// Add specified URI back to response.
else
{
response.Contact.Add(contact.ToStringValue());
}
}
// There are remaining non-SIP contacts, so we need to add the response to reponses collection.
if (response.Contact.GetAllValues().Length > 0)
{
m_pResponses.Add(response);
}
// Handle forking
if (m_pTargets.Count > 0)
{
if (m_ForkingMode == SIP_ForkingMode.Parallel)
{
while (m_pTargets.Count > 0)
{
TargetHandler h = m_pTargets.Dequeue();
m_pTargetsHandlers.Add(handler);
h.Start();
}
}
// Just fork next.
else
{
TargetHandler h = m_pTargets.Dequeue();
m_pTargetsHandlers.Add(handler);
h.Start();
}
// Because we forked request to new target(s), we don't need to do steps 5 - 10.
return;
}
}
// Not 3xx response or recursing disabled.
else
{
m_pResponses.Add(response);
}
#endregion
#region 5. Check to see if this response should be forwarded immediately
/*
Until a final response has been sent on the server transaction,
the following responses MUST be forwarded immediately:
- Any provisional response other than 100 (Trying)
- Any 2xx response
If a 6xx response is received, it is not immediately forwarded,
but the stateful proxy SHOULD cancel all client pending
transactions as described in Section 10, and it MUST NOT create
any new branches in this context.
After a final response has been sent on the server transaction,
the following responses MUST be forwarded immediately:
- Any 2xx response to an INVITE request
*/
if (!m_IsFinalResponseSent)
{
if (response.StatusCodeType == SIP_StatusCodeType.Provisional &&
response.StatusCode != 100)
{
forwardResponse = true;
}
else if (response.StatusCodeType == SIP_StatusCodeType.Success)
{
forwardResponse = true;
}
else if (response.StatusCodeType == SIP_StatusCodeType.GlobalFailure)
{
CancelAllTargets();
}
}
else
{
if (response.StatusCodeType == SIP_StatusCodeType.Success &&
m_pServerTransaction.Request.RequestLine.Method == SIP_Methods.INVITE)
{
forwardResponse = true;
}
}
#endregion
#region x. Handle sequential forking
/*
Sequential Search: In a sequential search, a proxy server attempts
each contact address in sequence, proceeding to the next one
only after the previous has generated a final response. A 2xx
or 6xx class final response always terminates a sequential
search.
*/
if (m_ForkingMode == SIP_ForkingMode.Sequential &&
response.StatusCodeType != SIP_StatusCodeType.Provisional)
{
if (response.StatusCodeType == SIP_StatusCodeType.Success)
{
// Do nothing, 2xx will be always forwarded and step 10. Cancels all targets.
}
else if (response.StatusCodeType == SIP_StatusCodeType.GlobalFailure)
{
// Do nothing, 6xx is already handled in setp 5.
}
else if (m_pTargets.Count > 0)
{
TargetHandler h = m_pTargets.Dequeue();
m_pTargetsHandlers.Add(handler);
h.Start();
// Skip all next steps, we will get new responses from new target.
return;
}
}
#endregion
#region 6. When necessary, choose the best final response from the response context
/*
A stateful proxy MUST send a final response to a response
context's server transaction if no final responses have been
immediately forwarded by the above rules and all client
transactions in this response context have been terminated.
The stateful proxy MUST choose the "best" final response among
those received and stored in the response context.
If there are no final responses in the context, the proxy MUST
send a 408 (Request Timeout) response to the server
transaction.
*/
if (!m_IsFinalResponseSent && !forwardResponse && m_pTargets.Count == 0)
{
bool mustChooseBestFinalResponse = true;
// Check if all transactions terminated.
foreach (TargetHandler h in m_pTargetsHandlers)
{
if (!h.IsCompleted)
{
mustChooseBestFinalResponse = false;
break;
}
}
if (mustChooseBestFinalResponse)
{
response = GetBestFinalResponse();
if (response == null)
{
response = Proxy.Stack.CreateResponse(SIP_ResponseCodes.x408_Request_Timeout,
m_pServerTransaction.Request);
}
forwardResponse = true;
}
}
#endregion
if (forwardResponse)
{
#region 7. Aggregate authorization header field values if necessary
/*
If the selected response is a 401 (Unauthorized) or 407 (Proxy Authentication Required),
the proxy MUST collect any WWW-Authenticate and Proxy-Authenticate header field values
from all other 401 (Unauthorized) and 407 (Proxy Authentication Required) responses
received so far in this response context and add them to this response without
modification before forwarding. The resulting 401 (Unauthorized) or 407 (Proxy
Authentication Required) response could have several WWW-Authenticate AND
Proxy-Authenticate header field values.
This is necessary because any or all of the destinations the request was forwarded to
may have requested credentials. The client needs to receive all of those challenges and
supply credentials for each of them when it retries the request.
*/
if (response.StatusCode == 401 || response.StatusCode == 407)
{
foreach (SIP_Response resp in m_pResponses.ToArray())
{
if (response != resp && (resp.StatusCode == 401 || resp.StatusCode == 407))
{
// WWW-Authenticate
foreach (SIP_HeaderField hf in resp.WWWAuthenticate.HeaderFields)
{
resp.WWWAuthenticate.Add(hf.Value);
}
// Proxy-Authenticate
foreach (SIP_HeaderField hf in resp.ProxyAuthenticate.HeaderFields)
{
resp.ProxyAuthenticate.Add(hf.Value);
}
}
}
}
#endregion
#region 8. Optionally rewrite Record-Route header field values
// This is optional so we currently won't do that.
#endregion
#region 9. Forward the response
SendResponse(transaction, response);
if (response.StatusCodeType != SIP_StatusCodeType.Provisional)
{
m_IsFinalResponseSent = true;
}
#endregion
#region 10. Generate any necessary CANCEL requests
/*
If the forwarded response was a final response, the proxy MUST
generate a CANCEL request for all pending client transactions
associated with this response context.
*/
if (response.StatusCodeType != SIP_StatusCodeType.Provisional)
{
CancelAllTargets();
}
#endregion
}
}
}