public Task <SocketError> GotResponse(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint,
SIPResponse sipResponse)
{
if (TransactionState == SIPTransactionStatesEnum.Completed ||
TransactionState == SIPTransactionStatesEnum.Confirmed)
{
FireTransactionTraceMessage(
$"Transaction received duplicate response {localSIPEndPoint.ToString()}<-{remoteEndPoint}: {sipResponse.ShortDescription}");
TransactionDuplicateResponse?.Invoke(localSIPEndPoint, remoteEndPoint, this, sipResponse);
if (sipResponse.Header.CSeqMethod == SIPMethodsEnum.INVITE)
{
if (sipResponse.StatusCode > 100 && sipResponse.StatusCode <= 199)
{
return(ResendPrackRequest());
}
else
{
return(ResendAckRequest());
}
}
else
{
return(Task.FromResult(SocketError.Success));
}
}
else
{
FireTransactionTraceMessage(
$"Transaction received Response {localSIPEndPoint.ToString()}<-{remoteEndPoint}: {sipResponse.ShortDescription}");
if (sipResponse.StatusCode >= 100 && sipResponse.StatusCode <= 199)
{
UpdateTransactionState(SIPTransactionStatesEnum.Proceeding);
return(TransactionInformationResponseReceived(localSIPEndPoint, remoteEndPoint, this, sipResponse));
}
else
{
m_transactionFinalResponse = sipResponse;
if (TransactionType == SIPTransactionTypesEnum.NonInvite)
{
// No ACK's for non-INVITE's so go straight to confirmed.
UpdateTransactionState(SIPTransactionStatesEnum.Confirmed);
}
else
{
UpdateTransactionState(SIPTransactionStatesEnum.Completed);
}
return(TransactionFinalResponseReceived(localSIPEndPoint, remoteEndPoint, this, sipResponse));
}
}
}
public void RecordDispatch(SIPRequest sipRequest, SIPEndPoint internalEndPoint)
{
lock(m_transactionEndPoints)
{
if (m_transactionEndPoints.ContainsKey(sipRequest.Header.CallId))
{
if (m_transactionEndPoints[sipRequest.Header.CallId] == internalEndPoint.ToString())
{
// The application server end point has not changed for this Call-Id
return;
}
else
{
// The application server end point has changed within the lifetime of the Call-Id. Remove the old mapping.
lock (m_transactionEndPoints)
{
m_transactionEndPoints.Remove(sipRequest.Header.CallId);
}
}
}
m_transactionEndPoints.Add(sipRequest.Header.CallId, internalEndPoint.ToString());
m_transactionIDAddedAt.Add(sipRequest.Header.CallId, DateTime.Now);
//ProxyLogger_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.SIPProxy, SIPMonitorEventTypesEnum.CallDispatcher, "Record dispatch for " + sipRequest.Method + " " + sipRequest.URI.ToString() + " to " + internalEndPoint.ToString() + " (id=" + transactionID + ").", null));
}
if (m_lastRemove < DateTime.Now.AddSeconds(REMOVE_EXPIREDS_SECONDS * -1))
{
RemoveExpiredDispatchRecords();
}
}
private Task <SocketError> UASInviteTransaction_TransactionResponseReceived(SIPEndPoint localSIPEndPoint,
SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
logger.LogWarning("UASInviteTransaction received unexpected response, " + sipResponse.ReasonPhrase +
" from " + remoteEndPoint.ToString() + ", ignoring.");
return(Task.FromResult(SocketError.Fault));
}
private Task <SocketError> UACInviteTransaction_TransactionRequestReceived(SIPEndPoint localSIPEndPoint,
SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPRequest sipRequest)
{
Logger.Logger.Warn("UACInviteTransaction received unexpected request, " + sipRequest.Method + " from " +
remoteEndPoint.ToString() + ", ignoring.");
return(Task.FromResult(SocketError.Fault));
}
public void GotRequest(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest sipRequest)
{
FireTransactionTraceMessage("Received Request " + localSIPEndPoint.ToString() + "<-" + remoteEndPoint.ToString() + m_crLF + sipRequest.ToString());
if (TransactionRequestReceived != null)
{
TransactionRequestReceived(localSIPEndPoint, remoteEndPoint, this, sipRequest);
}
}
public bool IsAppServerEndPoint(SIPEndPoint remoteEndPoint)
{
if (m_appServerEndPoints == null || m_appServerEndPoints.Count == 0)
{
return false;
}
else
{
return m_appServerEndPoints.ContainsKey(remoteEndPoint.ToString());
}
}
public void GotResponse(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPResponse sipResponse)
{
if (TransactionState == SIPTransactionStatesEnum.Completed || TransactionState == SIPTransactionStatesEnum.Confirmed)
{
FireTransactionTraceMessage($"Received Duplicate Response {localSIPEndPoint.ToString()}<-{remoteEndPoint}: {sipResponse.ShortDescription}");
if (sipResponse.Header.CSeqMethod == SIPMethodsEnum.INVITE)
{
if (sipResponse.StatusCode >= 100 && sipResponse.StatusCode <= 199)
{
// Ignore info response on completed transaction.
}
else
{
ResendAckRequest();
}
}
if (TransactionDuplicateResponse != null)
{
TransactionDuplicateResponse(localSIPEndPoint, remoteEndPoint, this, sipResponse);
}
}
else
{
FireTransactionTraceMessage($"Received Response {localSIPEndPoint.ToString()}<-{remoteEndPoint}: {sipResponse.ShortDescription}");
if (sipResponse.StatusCode >= 100 && sipResponse.StatusCode <= 199)
{
UpdateTransactionState(SIPTransactionStatesEnum.Proceeding);
TransactionInformationResponseReceived(localSIPEndPoint, remoteEndPoint, this, sipResponse);
}
else
{
m_transactionFinalResponse = sipResponse;
UpdateTransactionState(SIPTransactionStatesEnum.Completed);
TransactionFinalResponseReceived(localSIPEndPoint, remoteEndPoint, this, sipResponse);
}
}
}
public void GotResponse(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPResponse sipResponse)
{
if (TransactionState == SIPTransactionStatesEnum.Completed || TransactionState == SIPTransactionStatesEnum.Confirmed)
{
FireTransactionTraceMessage($"Received Duplicate Response {localSIPEndPoint.ToString()}<-{remoteEndPoint}: {sipResponse.ShortDescription}");
if (sipResponse.Header.CSeqMethod == SIPMethodsEnum.INVITE)
{
if (sipResponse.StatusCode > 100 && sipResponse.StatusCode <= 199)
{
// TODO: If this transaction is using reliable provisional responses then resend the PRACK request.
}
else
{
ResendAckRequest();
}
}
TransactionDuplicateResponse?.Invoke(localSIPEndPoint, remoteEndPoint, this, sipResponse);
}
else
{
FireTransactionTraceMessage($"Received Response {localSIPEndPoint.ToString()}<-{remoteEndPoint}: {sipResponse.ShortDescription}");
if (sipResponse.StatusCode >= 100 && sipResponse.StatusCode <= 199)
{
UpdateTransactionState(SIPTransactionStatesEnum.Proceeding);
TransactionInformationResponseReceived(localSIPEndPoint, remoteEndPoint, this, sipResponse);
}
else
{
m_transactionFinalResponse = sipResponse;
UpdateTransactionState(SIPTransactionStatesEnum.Completed);
TransactionFinalResponseReceived(localSIPEndPoint, remoteEndPoint, this, sipResponse);
}
}
}
public virtual void SendFinalResponse(SIPResponse finalResponse)
{
m_transactionFinalResponse = finalResponse;
UpdateTransactionState(SIPTransactionStatesEnum.Completed);
string viaAddress = finalResponse.Header.Vias.TopViaHeader.ReceivedFromAddress;
if (TransactionType == SIPTransactionTypesEnum.InviteServer)
{
FireTransactionTraceMessage($"Send Final Response Reliable {LocalSIPEndPoint.ToString()}->{viaAddress}: {finalResponse.ShortDescription}");
m_sipTransport.SendSIPReliable(this);
}
else
{
FireTransactionTraceMessage($"Send Final Response {LocalSIPEndPoint.ToString()}->{viaAddress}: {finalResponse.ShortDescription}");
m_sipTransport.SendResponse(finalResponse);
}
}
public override bool IsSIPEndPointMonitored(SIPEndPoint sipEndPoint)
{
lock (m_activeAppServerEntry)
{
foreach (AppServerEntry appServerEntry in m_appServerEntries)
{
if (new SIPEndPoint(appServerEntry.AppServerURI).ToString() == sipEndPoint.ToString())
{
return true;
}
}
}
return false;
}
public void UpdateAppServerPriority(SIPEndPoint appServerEndPoint, int priority)
{
try
{
string appServerEndPointsText = null;
using (StreamReader sr = new StreamReader(m_appServerEndPointsPath))
{
appServerEndPointsText = sr.ReadToEnd();
}
Dictionary<string, int> appServerPriorities = LoadAppServerEndPoints(appServerEndPointsText);
bool changed = false;
if (appServerPriorities.ContainsKey(appServerEndPoint.ToString()))
{
if (appServerPriorities[appServerEndPoint.ToString()] != NEVERUSE_APPSERVER_PRIORITY)
{
appServerPriorities[appServerEndPoint.ToString()] = priority;
logger.Debug("SIPCallDispatcherFile updated priority on " + appServerEndPoint + " to " + priority + ".");
changed = true;
}
else
{
logger.Debug("SIPCallDispatcherFile did NOT priority on disabled App Server endpoint " + appServerEndPoint + ".");
}
}
if (changed)
{
using (StreamWriter sw = new StreamWriter(m_appServerEndPointsPath, false, Encoding.ASCII))
{
foreach (KeyValuePair<string, int> appServerPriority in appServerPriorities)
{
sw.WriteLine(appServerPriority.Value + "," + appServerPriority.Key);
}
}
}
}
catch (Exception excp)
{
logger.Error("Exception UpdateAppServerPriority. " + excp.Message);
}
}
public SIPClientUserAgent(
SIPTransport sipTransport,
SIPEndPoint outboundProxy,
string owner,
string adminMemberId,
SIPMonitorLogDelegate logDelegate)
{
m_sipTransport = sipTransport;
m_outboundProxy = (outboundProxy != null) ? SIPEndPoint.ParseSIPEndPoint(outboundProxy.ToString()) : null;
Owner = owner;
AdminMemberId = adminMemberId;
Log_External = logDelegate;
// If external logging is not required assign an empty handler to stop null reference exceptions.
if (Log_External == null)
{
Log_External = (e) => { };
}
}
private static void SIPResponseOutTraceEvent(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPResponse sipResponse)
{
logger.DebugFormat("RESPONSE OUT {0}->{1}", localSIPEndPoint.ToString(), remoteEndPoint.ToString());
logger.Debug(sipResponse.ToString());
}
/// <summary>
/// From RFC3261: Stateless Proxy Response Processing:
///
/// When a response arrives at a stateless proxy, the proxy MUST inspect the sent-by value in the first
/// (topmost) Via header field value. If that address matches the proxy, (it equals a value this proxy has
/// inserted into previous requests) the proxy MUST remove that header field value from the response and
/// forward the result to the location indicated in the next Via header field value. The proxy MUST NOT add
/// to, modify, or remove the message body. Unless specified otherwise, the proxy MUST NOT remove
/// any other header field values. If the address does not match the proxy, the message MUST be silently discarded.
/// </summary>
private void GotResponse(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPResponse sipResponse)
{
try
{
// Used in the proxy monitor messages only, plays no part in response processing.
string fromUser = (sipResponse.Header.From != null) ? sipResponse.Header.From.FromURI.User : null;
string toUser = (sipResponse.Header.To != null) ? sipResponse.Header.To.ToURI.User : null;
string summaryStr = "resp " + sipResponse.Header.CSeqMethod + " from=" + fromUser + ", to=" + toUser + ", " + remoteEndPoint.ToString();
SIPViaHeader topVia = sipResponse.Header.Vias.PopTopViaHeader();
SIPEndPoint outSocket = localSIPEndPoint;
// If the second Via header on the response was also set by this proxy it means the request was originally received and forwarded
// on different sockets. To get the response to travel the same path in reverse it must be forwarded from the proxy socket indicated
// by the second top Via.
if (sipResponse.Header.Vias.Length > 1)
{
SIPViaHeader nextTopVia = sipResponse.Header.Vias.TopViaHeader;
SIPEndPoint nextTopViaSIPEndPoint = SIPEndPoint.ParseSIPEndPoint(nextTopVia.Transport + ":" + nextTopVia.ReceivedFromAddress);
//if (!(PublicIPAddress != null && nextTopVia.ReceivedFromIPAddress != null && nextTopVia.ReceivedFromIPAddress != PublicIPAddress.ToString())
// &&
// (m_sipTransport.IsLocalSIPEndPoint(nextTopViaSIPEndPoint) || (PublicIPAddress != null && nextTopVia.ReceivedFromIPAddress == PublicIPAddress.ToString())))
if(m_sipTransport.IsLocalSIPEndPoint(nextTopViaSIPEndPoint))
{
sipResponse.Header.Vias.PopTopViaHeader();
outSocket = nextTopViaSIPEndPoint;
}
}
bool isFromAppServer = (m_sipCallDispatcherFile != null) ? m_sipCallDispatcherFile.IsAppServerEndPoint(remoteEndPoint) : false;
lock (this)
{
m_compiledScript.DefaultScope.RemoveVariable("sys");
m_compiledScript.DefaultScope.RemoveVariable("isreq");
m_compiledScript.DefaultScope.RemoveVariable("localEndPoint");
m_compiledScript.DefaultScope.RemoveVariable("outSocket");
m_compiledScript.DefaultScope.RemoveVariable("resp");
m_compiledScript.DefaultScope.RemoveVariable("remoteEndPoint");
m_compiledScript.DefaultScope.RemoveVariable("summary");
m_compiledScript.DefaultScope.RemoveVariable("sipMethod");
m_compiledScript.DefaultScope.RemoveVariable("topVia");
m_compiledScript.DefaultScope.RemoveVariable("IsFromAppServer");
m_compiledScript.DefaultScope.SetVariable("sys", m_proxyScriptFacade);
m_compiledScript.DefaultScope.SetVariable("isreq", false);
m_compiledScript.DefaultScope.SetVariable("localEndPoint", localSIPEndPoint);
m_compiledScript.DefaultScope.SetVariable("outSocket", outSocket);
m_compiledScript.DefaultScope.SetVariable("resp", sipResponse);
m_compiledScript.DefaultScope.SetVariable("remoteEndPoint", remoteEndPoint);
m_compiledScript.DefaultScope.SetVariable("summary", summaryStr);
m_compiledScript.DefaultScope.SetVariable("sipMethod", sipResponse.Header.CSeqMethod.ToString());
m_compiledScript.DefaultScope.SetVariable("topVia", topVia);
m_compiledScript.DefaultScope.SetVariable("IsFromAppServer", isFromAppServer);
m_compiledScript.Execute();
}
//if (responseStopwatch.ElapsedMilliseconds > 20)
//{
// logger.Debug("GotResponse processing time=" + responseStopwatch.ElapsedMilliseconds + "ms, script time=" + scriptStopwatch.ElapsedMilliseconds + "ms.");
//}
}
catch (Exception excp)
{
string respExcpError = "Exception SIPProxyCore GotResponse. " + excp.Message;
logger.Error(respExcpError + "\n" + sipResponse.ToString());
SIPMonitorEvent respExcpEvent = new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.SIPProxy, SIPMonitorEventTypesEnum.Error, respExcpError, localSIPEndPoint, remoteEndPoint, null);
SendMonitorEvent(respExcpEvent);
throw excp;
}
}
void transport_UnrecognisedMessageReceived(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, byte[] buffer)
{
Console.WriteLine("Unrecognised: " + localEndPoint + "<-" + fromEndPoint.ToString() + " " + buffer.Length + " bytes.");
}
public void SendInternal(SIPEndPoint receivedFromEP, SIPEndPoint receivedOnEP, SIPResponse sipResponse, SIPEndPoint localSIPEndPoint)
{
try
{
sipResponse.Header.ProxyReceivedFrom = receivedFromEP.ToString();
sipResponse.Header.ProxyReceivedOn = receivedOnEP.ToString();
sipResponse.LocalSIPEndPoint = localSIPEndPoint;
m_sipTransport.SendResponse(sipResponse);
}
catch (Exception excp)
{
logger.Error("Exception SIPResponse SendInternal. " + excp.Message);
logger.Error(sipResponse.ToString());
throw;
}
}
void transport_SIPRequestOutTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint toEndPoint, SIPRequest sipRequest)
{
Console.WriteLine("Request Out: " + localEndPoint + "->" + toEndPoint.ToString() + "\n" + sipRequest.ToString());
}
public void DispatchRequest(SIPEndPoint dispatchEndPoint, SIPRequest sipRequest) {
FireProxyLogEvent(new SIPMonitorControlClientEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Dispatching new " + sipRequest.Method + " request to " + dispatchEndPoint.ToString() + ", callid=" + sipRequest.Header.CallId + ".", null));
m_callIdEndPoints.Add(sipRequest.Header.CallId, dispatchEndPoint.ToString());
m_callIdAddedAt.Add(sipRequest.Header.CallId, DateTime.Now);
m_sipTransport.SendRequest(dispatchEndPoint, sipRequest);
}
/// <summary>
/// Used to send a SIP request received from an external user agent to an internal SIP server agent.
/// </summary>
/// <param name="receivedFromEP">The SIP end point the proxy received the request from.</param>
/// <param name="receivedOnEP">The SIP end point the proxy received the request on.</param>
/// <param name="dstSocket">The internal socket to send the request to.</param>
/// <param name="sipRequest">The SIP request to send.</param>
/// <param name="proxyBranch">The branch to set on the Via header when sending the request. The branch should be calculated
/// by the proxy core so that looped requests can be detected.</param>
/// <param name="sendFromSocket">The proxy socket to send the request from.</param>
public void SendInternal(SIPEndPoint receivedFromEP, SIPEndPoint receivedOnEP, string dstSocket, SIPRequest sipRequest, string proxyBranch, string sendFromSocket)
{
try
{
if (!IsDestinationValid(sipRequest, dstSocket))
{
logger.Debug("SendInternal failed destination check.");
return;
}
sipRequest.Header.ProxyReceivedFrom = receivedFromEP.ToString();
sipRequest.Header.ProxyReceivedOn = receivedOnEP.ToString();
SIPEndPoint dstSIPEndPoint = SIPEndPoint.ParseSIPEndPoint(dstSocket);
SIPEndPoint localSIPEndPoint = SIPEndPoint.ParseSIPEndPoint(sendFromSocket);
if (receivedOnEP != localSIPEndPoint)
{
// The proxy is being requested to send the request on a different socket to the one it was received on.
// A second Via header is added to ensure the response can navigate back the same path. The calculated branch
// parameter needs to go on the top Via header so that whichever internal socket the request is being sent to can
// determine re-transmits.
SIPViaHeader via = new SIPViaHeader(receivedOnEP, CallProperties.CreateBranchId());
sipRequest.Header.Vias.PushViaHeader(via);
SIPViaHeader topVia = new SIPViaHeader(localSIPEndPoint, proxyBranch);
sipRequest.Header.Vias.PushViaHeader(topVia);
}
else
{
// Only a single Via header is required as any response to this request will be sent from the same socket it gets received on.
SIPViaHeader via = new SIPViaHeader(localSIPEndPoint, proxyBranch);
sipRequest.Header.Vias.PushViaHeader(via);
}
sipRequest.LocalSIPEndPoint = localSIPEndPoint;
m_sipTransport.SendRequest(dstSIPEndPoint, sipRequest);
}
catch (Exception excp)
{
logger.Error("Exception SIPRequest SendInternal. " + excp.Message);
logger.Error(sipRequest.ToString());
throw;
}
}
public bool IsWorkerSIPEndPoint(SIPEndPoint remoteEndPoint) {
return m_workerSIPEndPoints.Contains(remoteEndPoint.ToString());
}
public void Dispatch(SIPEndPoint remoteEndPoint, SIPResponse sipResponse) {
try {
//logger.Debug("Dispatch SIPResponse from " + remoteEndPoint + " " + sipResponse.Header.CSeqMethod + " " + sipResponse.StatusCode + ".");
SIPEndPoint dispatchEndPoint = m_outboundProxy;
if (remoteEndPoint.ToString() == m_outboundProxy.ToString()) {
if (m_callIdEndPoints.ContainsKey(sipResponse.Header.CallId)) {
dispatchEndPoint = SIPEndPoint.ParseSIPEndPoint(m_callIdEndPoints[sipResponse.Header.CallId]);
}
else {
dispatchEndPoint = null;
}
}
if (dispatchEndPoint != null) {
m_sipTransport.SendResponse(dispatchEndPoint, sipResponse);
}
else {
FireProxyLogEvent(new SIPMonitorControlClientEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "The callid for an " + sipResponse.Header.CSeqMethod + " response was not found in the dispatcher callids lookup table, dropping, callid=" + sipResponse.Header.CallId + ".", null));
}
}
catch (Exception excp) {
logger.Error("Exception Dispatch SIPResponse. " + excp.Message);
throw;
}
}
private void UASInviteTransaction_TransactionResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
logger.Warn("UASInviteTransaction received unexpected response, " + sipResponse.ReasonPhrase + " from " + remoteEndPoint.ToString() + ", ignoring.");
}
private void UASInviteTransaction_TransactionResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
logger.LogWarning("UASInviteTransaction received unexpected response, " + sipResponse.ReasonPhrase + " from " + remoteEndPoint.ToString() + ", ignoring.");
}
/// <summary>
/// This method is the equivalent to the same named method for sending SIP requests. The two methods are used to allow the Proxy to
/// deliver requests to external SIP agents with only a SINGLE Via header due to a small number of providers rejecting requests with
/// more than one Via header.
/// </summary>
/// <param name="receivedFromEP">The socket the response was received from.</param>
/// <param name="receivedOnEP">The proxy socket the response was received on.</param>
/// <param name="sipResponse">The response being forwarded.</param>
/// <param name="localSIPEndPoint">The proxy socket to forward the request from.</param>
/// <param name="dstSIPEndPoint">The internal destination socket to forward the response to.</param>
/// <param name="proxyBranch">The branch parameter from the top Via header that needs to be reused when forwarding the response.</param>
public void SendTransparent(SIPEndPoint receivedFromEP, SIPEndPoint receivedOnEP, SIPResponse sipResponse, SIPEndPoint localSIPEndPoint, SIPEndPoint dstSIPEndPoint, string proxyBranch)
{
try
{
sipResponse.Header.ProxyReceivedFrom = receivedFromEP.ToString();
sipResponse.Header.ProxyReceivedOn = receivedOnEP.ToString();
sipResponse.Header.Vias.PushViaHeader(new SIPViaHeader(dstSIPEndPoint, proxyBranch));
sipResponse.LocalSIPEndPoint = localSIPEndPoint;
m_sipTransport.SendResponse(sipResponse);
}
catch (Exception excp)
{
logger.Error("Exception SIPResponse SendInternal. " + excp.Message);
logger.Error(sipResponse.ToString());
throw;
}
}
void transport_SIPRequestInTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, SIPRequest sipRequest)
{
Console.WriteLine("Request In: " + localEndPoint + "<-" + fromEndPoint.ToString() + "\n" + sipRequest.ToString());
}
public void SendRequest(SIPRequest sipRequest)
{
SIPEndPoint dstEndPoint = m_sipTransport.GetRequestEndPoint(sipRequest, OutboundProxy, true).GetSIPEndPoint();
if (dstEndPoint != null)
{
FireTransactionTraceMessage($"Send Request {LocalSIPEndPoint.ToString()}->{dstEndPoint.ToString()}: {sipRequest.StatusLine}");
if (sipRequest.Method == SIPMethodsEnum.ACK)
{
m_ackRequest = sipRequest;
m_ackRequestIPEndPoint = dstEndPoint;
}
else
{
RemoteEndPoint = dstEndPoint;
}
m_sipTransport.SendRequest(dstEndPoint, sipRequest);
}
else
{
throw new ApplicationException("Could not send Transaction Request as request end point could not be determined.\r\n" + sipRequest.ToString());
}
}
/// <summary>
/// From RFC3261: Stateless Proxy Request Processing:
///
/// For each target, the proxy forwards the request following these
/// 1. Make a copy of the received request
/// 2. Update the Request-URI
/// 3. Update the Max-Forwards header field
/// 4. Optionally add a Record-route header field value
/// 5. Optionally add additional header fields
/// 6. Postprocess routing information
/// 7. Determine the next-hop address, port, and transport
/// 8. Add a Via header field value
/// 9. Add a Content-Length header field if necessary
/// 10. Forward the new request
///
/// See sections 12.2.1.1 and 16.12.1.2 in the SIP RFC for the best explanation on the way the Route header works.
/// </summary>
/// <param name="sipRequest"></param>
/// <param name="inEndPoint">End point the request was received on.</param>
/// <param name="sipChannel"></param>
private void GotRequest(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest sipRequest)
{
try
{
// Calculate the proxy branch parameter for this request. The branch parameter has to be calculated so that INVITE's and CANCEL's generate the same branchid.
//string toTag = (sipRequest.Header.To != null) ? sipRequest.Header.To.ToTag : null;
//string fromTag = (sipRequest.Header.From != null) ? sipRequest.Header.From.FromTag : null;
string route = (sipRequest.Header.Routes != null) ? sipRequest.Header.Routes.ToString() : null;
//string authHeader = (sipRequest.Header.AuthenticationHeader != null) ? sipRequest.Header.AuthenticationHeader.ToString() : null;
string proxyBranch = CallProperties.CreateBranchId(SIPConstants.SIP_BRANCH_MAGICCOOKIE, null, null, sipRequest.Header.CallId, sipRequest.URI.ToString(), null, sipRequest.Header.CSeq, route, null, null);
// Check whether the branch parameter already exists in the Via list. One instance of an already added Via header will be allowed to support a single spiral.
int loopedViaCount = 0;
foreach (SIPViaHeader viaHeader in sipRequest.Header.Vias.Via)
{
//if (viaHeader.Branch == proxyBranch)
SIPEndPoint sentFromEndPoint = SIPEndPoint.TryParse(viaHeader.Transport + ":" + viaHeader.ContactAddress);
if (sentFromEndPoint != null && m_sipTransport.IsLocalSIPEndPoint(sentFromEndPoint))
{
loopedViaCount++;
}
if (loopedViaCount >= 2)
{
SendMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.SIPProxy, SIPMonitorEventTypesEnum.Warn, "Loop detected on request from " + remoteEndPoint + " to " + sipRequest.URI.ToString() + ".", null));
m_sipTransport.SendResponse(SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.LoopDetected, null));
return;
}
}
// Used in the proxy monitor messages only, plays no part in request routing.
string fromUser = (sipRequest.Header.From != null) ? sipRequest.Header.From.FromURI.User : null;
string toUser = (sipRequest.Header.To != null) ? sipRequest.Header.To.ToURI.User : null;
string summaryStr = "req " + sipRequest.Method + " from=" + fromUser + ", to=" + toUser + ", " + remoteEndPoint.ToString();
bool isFromAppServer = (m_sipCallDispatcherFile != null) ? m_sipCallDispatcherFile.IsAppServerEndPoint(remoteEndPoint) : false;
lock (this)
{
m_compiledScript.DefaultScope.RemoveVariable("sys");
m_compiledScript.DefaultScope.RemoveVariable("localEndPoint");
m_compiledScript.DefaultScope.RemoveVariable("isreq");
m_compiledScript.DefaultScope.RemoveVariable("req");
m_compiledScript.DefaultScope.RemoveVariable("remoteEndPoint");
m_compiledScript.DefaultScope.RemoveVariable("summary");
m_compiledScript.DefaultScope.RemoveVariable("proxyBranch");
m_compiledScript.DefaultScope.RemoveVariable("sipMethod");
m_compiledScript.DefaultScope.RemoveVariable("publicip");
m_compiledScript.DefaultScope.RemoveVariable("IsFromAppServer");
m_compiledScript.DefaultScope.SetVariable("sys", m_proxyScriptFacade);
m_compiledScript.DefaultScope.SetVariable("localEndPoint", localSIPEndPoint);
m_compiledScript.DefaultScope.SetVariable("isreq", true);
m_compiledScript.DefaultScope.SetVariable("req", sipRequest);
m_compiledScript.DefaultScope.SetVariable("remoteEndPoint", remoteEndPoint);
m_compiledScript.DefaultScope.SetVariable("summary", summaryStr);
m_compiledScript.DefaultScope.SetVariable("proxyBranch", proxyBranch);
m_compiledScript.DefaultScope.SetVariable("sipMethod", sipRequest.Method.ToString());
m_compiledScript.DefaultScope.SetVariable("publicip", PublicIPAddress);
m_compiledScript.DefaultScope.SetVariable("IsFromAppServer", isFromAppServer);
m_compiledScript.Execute();
}
//if (requestStopwatch.ElapsedMilliseconds > 20)
//{
// logger.Debug("GotRequest processing time=" + requestStopwatch.ElapsedMilliseconds + "ms, script time=" + scriptStopwatch.ElapsedMilliseconds + "ms.");
//}
}
catch (SIPValidationException)
{
throw;
}
catch (Exception excp)
{
string remoteEndPointStr = (remoteEndPoint != null) ? remoteEndPoint.ToString() : null;
string reqExcpError = "Exception SIPProxyCore GotRequest (from " + remoteEndPointStr + "). " + excp.Message;
logger.Error(reqExcpError);
SIPMonitorEvent reqExcpEvent = new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.SIPProxy, SIPMonitorEventTypesEnum.Error, reqExcpError, localSIPEndPoint, remoteEndPoint, null);
SendMonitorEvent(reqExcpEvent);
throw excp;
}
}
/// <summary>
/// Periodically checks the established connections and closes any that have not had a transmission for a specified
/// period or where the number of connections allowed per IP address has been exceeded. Only relevant for connection
/// oriented channels such as TCP and TLS.
/// </summary>
protected void PruneConnections(string threadName)
{
try
{
Thread.CurrentThread.Name = threadName;
Thread.Sleep(INITIALPRUNE_CONNECTIONS_DELAY);
while (!Closed)
{
bool checkComplete = false;
while (!checkComplete)
{
try
{
SIPStreamConnection inactiveConnection = null;
Dictionary <string, SIPStreamConnection> connections = GetConnectionsList();
lock (connections)
{
var inactiveConnectionKey = (from connection in connections
where connection.Value.LastTransmission < DateTime.Now.AddMinutes(PRUNE_NOTRANSMISSION_MINUTES * -1)
select connection.Key).FirstOrDefault();
if (inactiveConnectionKey != null)
{
inactiveConnection = connections[inactiveConnectionKey];
connections.Remove(inactiveConnectionKey);
}
}
if (inactiveConnection != null)
{
logger.LogDebug($"Pruning inactive connection on {SIPChannelContactURI}to remote end point {inactiveConnection.RemoteEndPoint}.");
inactiveConnection.StreamSocket.Close();
}
else
{
checkComplete = true;
}
}
catch (SocketException)
{
// Will be thrown if the socket is already closed.
}
catch (Exception pruneExcp)
{
logger.LogError("Exception PruneConnections (pruning). " + pruneExcp.Message);
checkComplete = true;
}
}
Thread.Sleep(PRUNE_CONNECTIONS_INTERVAL);
checkComplete = false;
}
logger.LogDebug("SIPChannel socket on " + m_localSIPEndPoint.ToString() + " pruning connections halted.");
}
catch (Exception excp)
{
logger.LogError("Exception SIPChannel PruneConnections. " + excp.Message);
}
}
public void AddRegisterRequest(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest registerRequest)
{
try
{
if (registerRequest.Method != SIPMethodsEnum.REGISTER)
{
SIPResponse notSupportedResponse = GetErrorResponse(registerRequest, SIPResponseStatusCodesEnum.MethodNotAllowed, "Registration requests only");
m_sipTransport.SendResponse(notSupportedResponse);
}
else
{
SIPSorceryPerformanceMonitor.IncrementCounter(SIPSorceryPerformanceMonitor.REGISTRAR_REGISTRATION_REQUESTS_PER_SECOND);
int requestedExpiry = GetRequestedExpiry(registerRequest);
if (registerRequest.Header.To == null)
{
logger.Debug("Bad register request, no To header from " + remoteEndPoint + ".");
SIPResponse badReqResponse = SIPTransport.GetResponse(registerRequest, SIPResponseStatusCodesEnum.BadRequest, "Missing To header");
m_sipTransport.SendResponse(badReqResponse);
}
else if(registerRequest.Header.To.ToURI.User.IsNullOrBlank())
{
logger.Debug("Bad register request, no To user from " + remoteEndPoint + ".");
SIPResponse badReqResponse = SIPTransport.GetResponse(registerRequest, SIPResponseStatusCodesEnum.BadRequest, "Missing username on To header");
m_sipTransport.SendResponse(badReqResponse);
}
else if (registerRequest.Header.Contact == null || registerRequest.Header.Contact.Count == 0)
{
logger.Debug("Bad register request, no Contact header from " + remoteEndPoint + ".");
SIPResponse badReqResponse = SIPTransport.GetResponse(registerRequest, SIPResponseStatusCodesEnum.BadRequest, "Missing Contact header");
m_sipTransport.SendResponse(badReqResponse);
}
else if (requestedExpiry > 0 && requestedExpiry < m_minimumBindingExpiry)
{
logger.Debug("Bad register request, no expiry of " + requestedExpiry + " to small from " + remoteEndPoint + ".");
SIPResponse tooFrequentResponse = GetErrorResponse(registerRequest, SIPResponseStatusCodesEnum.IntervalTooBrief, null);
tooFrequentResponse.Header.MinExpires = m_minimumBindingExpiry;
m_sipTransport.SendResponse(tooFrequentResponse);
}
else
{
if (m_registerQueue.Count < MAX_REGISTER_QUEUE_SIZE)
{
SIPNonInviteTransaction registrarTransaction = m_sipTransport.CreateNonInviteTransaction(registerRequest, remoteEndPoint, localSIPEndPoint, null);
lock (m_registerQueue)
{
m_registerQueue.Enqueue(registrarTransaction);
}
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.BindingInProgress, "Register queued for " + registerRequest.Header.To.ToURI.ToString() + ".", null));
}
else
{
logger.Error("Register queue exceeded max queue size " + MAX_REGISTER_QUEUE_SIZE + ", overloaded response sent.");
SIPResponse overloadedResponse = SIPTransport.GetResponse(registerRequest, SIPResponseStatusCodesEnum.TemporarilyUnavailable, "Registrar overloaded, please try again shortly");
m_sipTransport.SendResponse(overloadedResponse);
}
m_registerARE.Set();
}
}
}
catch (Exception excp)
{
logger.Error("Exception AddRegisterRequest (" + remoteEndPoint.ToString() + "). " + excp.Message);
}
}
/// <summary>
/// Attempts to match a SIPChannel for this process that has the specified local end point and protocol.
/// </summary>
/// <param name="localEndPoint">The local socket endpoint of the SIPChannel to find.</param>
/// <returns>A matching SIPChannel if found otherwise null.</returns>
public SIPChannel FindSIPChannel(SIPEndPoint localSIPEndPoint)
{
//bool isEqual = (localSIPEndPoint == m_sipChannels.Keys.First<SIPEndPoint>());
//logger.Debug("Searching for SIP channel for endpoint " + localSIPEndPoint.ToString() + ". First channel in transport list is " + m_sipChannels.Keys.First().ToString() + ". " + m_sipChannels.Keys.Contains(localSIPEndPoint) + ", " + isEqual);
if (localSIPEndPoint == null)
{
return null;
}
else
{
if (m_sipChannels.ContainsKey(localSIPEndPoint.ToString()))
{
return m_sipChannels[localSIPEndPoint.ToString()];
}
else
{
logger.Warn("No SIP channel could be found for local SIP end point " + localSIPEndPoint.ToString() + ".");
return null;
}
}
}
/// <summary>
/// Updates the bindings list for a registrar's address-of-records.
/// </summary>
/// <param name="proxyEndPoint">If the request arrived at this registrar via a proxy then this will contain the end point of the proxy.</param>
/// <param name="uacRecvdEndPoint">The public end point the UAC REGISTER request was deemded to have originated from.</param>
/// <param name="registrarEndPoint">The registrar end point the registration request was received on.</param>
/// <param name="maxAllowedExpiry">The maximum allowed expiry that can be granted to this binding request.</param>
/// <returns>If the binding update was successful the expiry time for it is returned otherwise 0.</returns>
public List<SIPRegistrarBinding> UpdateBindings(
SIPAccount sipAccount,
SIPEndPoint proxySIPEndPoint,
SIPEndPoint remoteSIPEndPoint,
SIPEndPoint registrarSIPEndPoint,
List<SIPContactHeader> contactHeaders,
string callId,
int cseq,
//int contactHeaderExpiresValue,
int expiresHeaderValue,
string userAgent,
out SIPResponseStatusCodesEnum responseStatus,
out string responseMessage)
{
//logger.Debug("UpdateBinding " + bindingURI.ToString() + ".");
int maxAllowedExpiry = m_userAgentConfigs.GetMaxAllowedExpiry(userAgent);
responseMessage = null;
string sipAccountAOR = sipAccount.SIPUsername + "@" + sipAccount.SIPDomain;
responseStatus = SIPResponseStatusCodesEnum.Ok;
try
{
userAgent = (userAgent != null && userAgent.Length > MAX_USERAGENT_LENGTH) ? userAgent.Substring(0, MAX_USERAGENT_LENGTH) : userAgent;
List<SIPRegistrarBinding> bindings = m_bindingsPersistor.Get(b => b.SIPAccountId == sipAccount.Id, null, 0, Int32.MaxValue);
foreach (SIPContactHeader contactHeader in contactHeaders)
{
SIPURI bindingURI = contactHeader.ContactURI.CopyOf();
int contactHeaderExpiresValue = contactHeader.Expires;
int bindingExpiry = 0;
if (bindingURI.Host == m_sipRegisterRemoveAll)
{
if (contactHeaders.Count > 1)
{
// If a register request specifies remove all it cannot contain any other binding requests.
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.BindingRemoval, "Remove all bindings requested for " + sipAccountAOR + " but mutliple bindings specified, rejecting as a bad request.", sipAccount.SIPUsername));
responseStatus = SIPResponseStatusCodesEnum.BadRequest;
break;
}
#region Process remove all bindings.
if (expiresHeaderValue == 0)
{
// Removing all bindings for user.
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.BindingRemoval, "Remove all bindings requested for " + sipAccountAOR + ".", sipAccount.SIPUsername));
// Mark all the current bindings as expired.
if (bindings != null && bindings.Count > 0)
{
for (int index = 0; index < bindings.Count; index++)
{
bindings[index].RemovalReason = SIPBindingRemovalReason.ClientExpiredAll;
bindings[index].Expiry = 0;
m_bindingsPersistor.Update(bindings[index]);
// Remove the NAT keep-alive job if present.
if (m_natKeepAliveJobs.ContainsKey(bindings[index].RemoteSIPSocket))
{
m_natKeepAliveJobs[bindings[index].RemoteSIPSocket].CancelJob();
}
}
}
FireSIPMonitorLogEvent(new SIPMonitorMachineEvent(SIPMonitorMachineEventTypesEnum.SIPRegistrarBindingRemoval, sipAccount.Owner, sipAccount.Id.ToString(), SIPURI.ParseSIPURIRelaxed(sipAccountAOR)));
responseStatus = SIPResponseStatusCodesEnum.Ok;
}
else
{
// Remove all header cannot be present with other headers and must have an Expiry equal to 0.
responseStatus = SIPResponseStatusCodesEnum.BadRequest;
}
#endregion
}
else
{
int requestedExpiry = (contactHeaderExpiresValue != -1) ? contactHeaderExpiresValue : expiresHeaderValue;
requestedExpiry = (requestedExpiry == -1) ? maxAllowedExpiry : requestedExpiry; // This will happen if the Expires header and the Expiry on the Contact are both missing.
bindingExpiry = (requestedExpiry > maxAllowedExpiry) ? maxAllowedExpiry : requestedExpiry;
bindingExpiry = (bindingExpiry < MINIMUM_EXPIRY_SECONDS) ? MINIMUM_EXPIRY_SECONDS : bindingExpiry;
bindingURI.Parameters.Remove(m_sipExpiresParameterKey);
SIPRegistrarBinding binding = GetBindingForContactURI(bindings, bindingURI.ToString());
if (binding != null)
{
if (requestedExpiry <= 0)
{
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.BindingExpired, "Binding expired by client for " + sipAccountAOR + " from " + remoteSIPEndPoint.ToString() + ".", sipAccount.SIPUsername));
bindings.Remove(binding);
m_bindingsPersistor.Delete(binding);
bindingExpiry = 0;
FireSIPMonitorLogEvent(new SIPMonitorMachineEvent(SIPMonitorMachineEventTypesEnum.SIPRegistrarBindingRemoval, sipAccount.Owner, sipAccount.Id.ToString(), SIPURI.ParseSIPURIRelaxed(sipAccountAOR)));
// Remove the NAT keep-alive job if present.
if (m_natKeepAliveJobs.ContainsKey(binding.RemoteSIPSocket))
{
m_natKeepAliveJobs[binding.RemoteSIPSocket].CancelJob();
}
}
else
{
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.Registrar, "Binding update request for " + sipAccountAOR + " from " + remoteSIPEndPoint.ToString() + ", expiry requested " + requestedExpiry + "s granted " + bindingExpiry + "s.", sipAccount.Owner));
binding.RefreshBinding(bindingExpiry, remoteSIPEndPoint, proxySIPEndPoint, registrarSIPEndPoint, sipAccount.DontMangleEnabled);
DateTime startTime = DateTime.Now;
m_bindingsPersistor.Update(binding);
TimeSpan duration = DateTime.Now.Subtract(startTime);
//FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.RegistrarTiming, "Binding database update time for " + sipAccountAOR + " took " + duration.TotalMilliseconds + "ms.", null));
FireSIPMonitorLogEvent(new SIPMonitorMachineEvent(SIPMonitorMachineEventTypesEnum.SIPRegistrarBindingUpdate, sipAccount.Owner, sipAccount.Id.ToString(), SIPURI.ParseSIPURIRelaxed(sipAccountAOR)));
// Add a NAT keep-alive job if required.
if (sipAccount.SendNATKeepAlives && proxySIPEndPoint != null)
{
AddNATKeepAliveJob(sipAccount, remoteSIPEndPoint, proxySIPEndPoint, binding, bindingExpiry);
}
}
}
else
{
if (requestedExpiry > 0)
{
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.BindingInProgress, "New binding request for " + sipAccountAOR + " from " + remoteSIPEndPoint.ToString() + ", expiry requested " + requestedExpiry + "s granted " + bindingExpiry + "s.", sipAccount.Owner));
if (bindings.Count >= m_maxBindingsPerAccount)
{
// Need to remove the oldest binding to stay within limit.
//SIPRegistrarBinding oldestBinding = m_bindingsPersistor.Get(b => b.SIPAccountId == sipAccount.Id, null, 0, Int32.MaxValue).OrderBy(x => x.LastUpdateUTC).Last();
SIPRegistrarBinding oldestBinding = bindings.OrderBy(x => x.LastUpdate).Last();
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.BindingInProgress, "Binding limit exceeded for " + sipAccountAOR + " from " + remoteSIPEndPoint.ToString() + " removing oldest binding to stay within limit of " + m_maxBindingsPerAccount + ".", sipAccount.Owner));
m_bindingsPersistor.Delete(oldestBinding);
if (m_natKeepAliveJobs.ContainsKey(binding.RemoteSIPSocket))
{
m_natKeepAliveJobs[binding.RemoteSIPSocket].CancelJob();
}
}
SIPRegistrarBinding newBinding = new SIPRegistrarBinding(sipAccount, bindingURI, callId, cseq, userAgent, remoteSIPEndPoint, proxySIPEndPoint, registrarSIPEndPoint, bindingExpiry);
DateTime startTime = DateTime.Now;
bindings.Add(newBinding);
m_bindingsPersistor.Add(newBinding);
TimeSpan duration = DateTime.Now.Subtract(startTime);
//FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.RegistrarTiming, "Binding database add time for " + sipAccountAOR + " took " + duration.TotalMilliseconds + "ms.", null));
// Add a NAT keep-alive job if required.
if (sipAccount.SendNATKeepAlives && proxySIPEndPoint != null)
{
AddNATKeepAliveJob(sipAccount, remoteSIPEndPoint, proxySIPEndPoint, newBinding, bindingExpiry);
}
FireSIPMonitorLogEvent(new SIPMonitorMachineEvent(SIPMonitorMachineEventTypesEnum.SIPRegistrarBindingUpdate, sipAccount.Owner, sipAccount.Id.ToString(), SIPURI.ParseSIPURIRelaxed(sipAccountAOR)));
}
else
{
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.BindingFailed, "New binding received for " + sipAccountAOR + " with expired contact," + bindingURI.ToString() + " no update.", sipAccount.Owner));
bindingExpiry = 0;
}
}
responseStatus = SIPResponseStatusCodesEnum.Ok;
}
}
return bindings;
}
catch (Exception excp)
{
logger.Error("Exception UpdateBinding. " + excp.Message);
FireSIPMonitorLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Registrar, SIPMonitorEventTypesEnum.Error, "Registrar error updating binding: " + excp.Message + " Binding not updated.", sipAccount.SIPUsername));
responseStatus = SIPResponseStatusCodesEnum.InternalServerError;
return null;
}
}
/// <summary>
/// Allows raw bytes to be sent from one of the SIPTransport sockets. This should not be used for SIP payloads and instead is
/// provided to allow other types of payloads to be multi-plexed on the SIP socket. Examples are sending NAT keep alives and
/// STUN responses where it's useful to use the same socket as the SIP packets.
/// </summary>
public void SendRaw(SIPEndPoint localSIPEndPoint, SIPEndPoint destinationEndPoint, byte[] buffer)
{
if (destinationEndPoint != null && destinationEndPoint.Address.Equals(BlackholeAddress))
{
// Ignore packet, it's destined for the blackhole.
return;
}
if (m_sipChannels.Count == 0)
{
throw new ApplicationException("No channels are configured in the SIP transport layer. The data could not be sent.");
}
SIPChannel sendSIPChannel = FindSIPChannel(localSIPEndPoint);
if (sendSIPChannel != null)
{
sendSIPChannel.Send(destinationEndPoint.GetIPEndPoint(), buffer);
}
else
{
logger.Warn("No SIPChannel could be found for " + localSIPEndPoint + " in SIPTransport.SendRaw, sending to " + destinationEndPoint.ToString() + ".");
//logger.Warn(Encoding.UTF8.GetString(buffer));
}
}
public void GotRequest(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest sipRequest)
{
FireTransactionTraceMessage($"Received Request {localSIPEndPoint.ToString()}<-{remoteEndPoint.ToString()}: {sipRequest.StatusLine}");
TransactionRequestReceived?.Invoke(localSIPEndPoint, remoteEndPoint, this, sipRequest);
}
private void LogSIPRequestIn(SIPEndPoint localSIPEndPoint, SIPEndPoint endPoint, SIPRequest sipRequest)
{
string message = "App Svr Received: " + localSIPEndPoint.ToString() + "<-" + endPoint.ToString() + "\r\n" + sipRequest.ToString();
//logger.Debug("as: request in " + sipRequest.Method + " " + localSIPEndPoint.ToString() + "<-" + endPoint.ToString() + ", callid=" + sipRequest.Header.CallId + ".");
string fromUser = (sipRequest.Header.From != null && sipRequest.Header.From.FromURI != null) ? sipRequest.Header.From.FromURI.User : "******";
FireSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.FullSIPTrace, message, fromUser, localSIPEndPoint, endPoint));
}
private void UACInviteTransaction_TransactionRequestReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPRequest sipRequest)
{
logger.LogWarning("UACInviteTransaction received unexpected request, " + sipRequest.Method + " from " + remoteEndPoint.ToString() + ", ignoring.");
}
void transport_SIPBadRequestInTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, string message, SIPValidationFieldsEnum errorField, string rawMessage)
{
Console.WriteLine("Bad Request: " + localEndPoint + "<-" + fromEndPoint.ToString() + " " + errorField + "." + message + "\n" + rawMessage);
}
private void UACInviteTransaction_TransactionRequestReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPRequest sipRequest)
{
logger.Warn("UACInviteTransaction received unexpected request, " + sipRequest.Method + " from " + remoteEndPoint.ToString() + ", ignoring.");
}
public void GotRequest(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest sipRequest)
{
try
{
// Used in the proxy monitor messages only, plays no part in request routing.
string fromUser = (sipRequest.Header.From != null) ? sipRequest.Header.From.FromURI.User : null;
string fromURIStr = (sipRequest.Header.From != null) ? sipRequest.Header.From.FromURI.ToString() : "null";
//string toUser = (sipRequest.Header.To != null) ? sipRequest.Header.To.ToURI.User : null;
//string summaryStr = "req " + sipRequest.Method + " from=" + fromUser + ", to=" + toUser + ", " + remoteEndPoint.ToString();
//logger.Debug("AppServerCore GotRequest " + sipRequest.Method + " from " + remoteEndPoint.ToString() + " callid=" + sipRequest.Header.CallId + ".");
SIPDialogue dialogue = null;
// Check dialogue requests for an existing dialogue.
if ((sipRequest.Method == SIPMethodsEnum.BYE || sipRequest.Method == SIPMethodsEnum.INFO || sipRequest.Method == SIPMethodsEnum.INVITE ||
sipRequest.Method == SIPMethodsEnum.MESSAGE || sipRequest.Method == SIPMethodsEnum.NOTIFY || sipRequest.Method == SIPMethodsEnum.OPTIONS ||
sipRequest.Method == SIPMethodsEnum.REFER)
&& sipRequest.Header.From != null && sipRequest.Header.From.FromTag != null && sipRequest.Header.To != null && sipRequest.Header.To.ToTag != null)
{
dialogue = m_sipDialogueManager.GetDialogue(sipRequest);
}
if (dialogue != null && sipRequest.Method != SIPMethodsEnum.ACK)
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Matching dialogue found for " + sipRequest.Method + " to " + sipRequest.URI.ToString() + " from " + remoteEndPoint + ".", dialogue.Owner));
if (sipRequest.Method != SIPMethodsEnum.REFER)
{
m_sipDialogueManager.ProcessInDialogueRequest(localSIPEndPoint, remoteEndPoint, sipRequest, dialogue);
}
else
{
m_sipDialogueManager.ProcessInDialogueReferRequest(localSIPEndPoint, remoteEndPoint, sipRequest, dialogue, m_callManager.BlindTransfer);
}
}
else if (sipRequest.Method == SIPMethodsEnum.CANCEL)
{
#region CANCEL request handling.
UASInviteTransaction inviteTransaction = (UASInviteTransaction)m_sipTransport.GetTransaction(SIPTransaction.GetRequestTransactionId(sipRequest.Header.Vias.TopViaHeader.Branch, SIPMethodsEnum.INVITE));
if (inviteTransaction != null)
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Cancelling call for " + sipRequest.URI.ToString() + ".", fromUser));
SIPCancelTransaction cancelTransaction = m_sipTransport.CreateCancelTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, inviteTransaction);
cancelTransaction.GotRequest(localSIPEndPoint, remoteEndPoint, sipRequest);
}
else
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "No matching transaction was found for CANCEL to " + sipRequest.URI.ToString() + ".", fromUser));
SIPResponse noCallLegResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.CallLegTransactionDoesNotExist, null);
m_sipTransport.SendResponse(noCallLegResponse);
}
#endregion
}
else if (sipRequest.Method == SIPMethodsEnum.BYE)
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "No dialogue matched for BYE to " + sipRequest.URI.ToString() + ".", fromUser));
SIPResponse noCallLegResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.CallLegTransactionDoesNotExist, null);
m_sipTransport.SendResponse(noCallLegResponse);
}
else if (sipRequest.Method == SIPMethodsEnum.REFER)
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "No dialogue matched for REFER to " + sipRequest.URI.ToString() + ".", fromUser));
SIPResponse noCallLegResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.CallLegTransactionDoesNotExist, null);
m_sipTransport.SendResponse(noCallLegResponse);
}
else if (sipRequest.Method == SIPMethodsEnum.ACK)
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "No transaction matched for ACK for " + sipRequest.URI.ToString() + ".", fromUser));
}
else if (sipRequest.Method == SIPMethodsEnum.INVITE)
{
#region INVITE request processing.
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "AppServerCore INVITE received, uri=" + sipRequest.URI.ToString() + ", cseq=" + sipRequest.Header.CSeq + ".", null));
if (sipRequest.URI.User == m_dispatcherUsername)
{
// Incoming call from monitoring process checking the application server is still running.
UASInviteTransaction uasTransaction = m_sipTransport.CreateUASTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, m_outboundProxy);
uasTransaction.CDR = null;
SIPServerUserAgent incomingCall = new SIPServerUserAgent(m_sipTransport, m_outboundProxy, sipRequest.URI.User, sipRequest.URI.Host, SIPCallDirection.In, null, null, null, uasTransaction);
incomingCall.NoCDR();
uasTransaction.NewCallReceived += (local, remote, transaction, request) => { m_callManager.QueueNewCall(incomingCall); };
uasTransaction.GotRequest(localSIPEndPoint, remoteEndPoint, sipRequest);
}
else if (GetCanonicalDomain_External(sipRequest.Header.From.FromUserField.URI.Host, false) != null)
{
// Call identified as outgoing call for application server serviced domain.
string fromDomain = GetCanonicalDomain_External(sipRequest.Header.From.FromUserField.URI.Host, false);
UASInviteTransaction uasTransaction = m_sipTransport.CreateUASTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, m_outboundProxy);
SIPServerUserAgent outgoingCall = new SIPServerUserAgent(m_sipTransport, m_outboundProxy, fromUser, fromDomain, SIPCallDirection.Out, GetSIPAccount_External, SIPRequestAuthenticator.AuthenticateSIPRequest, FireProxyLogEvent, uasTransaction);
uasTransaction.NewCallReceived += (local, remote, transaction, request) => { m_callManager.QueueNewCall(outgoingCall); };
uasTransaction.GotRequest(localSIPEndPoint, remoteEndPoint, sipRequest);
}
else if (GetCanonicalDomain_External(sipRequest.URI.Host, true) != null)
{
// Call identified as incoming call for application server serviced domain.
if (sipRequest.URI.User.IsNullOrBlank())
{
// Cannot process incoming call if no user is specified.
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "INVITE received with an empty URI user " + sipRequest.URI.ToString() + ", returning address incomplete.", null));
UASInviteTransaction uasTransaction = m_sipTransport.CreateUASTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, m_outboundProxy);
SIPResponse addressIncompleteResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.AddressIncomplete, "No user specified");
uasTransaction.SendFinalResponse(addressIncompleteResponse);
}
else
{
// Send the incoming call to the call manager for processing.
string uriUser = sipRequest.URI.User;
string uriDomain = GetCanonicalDomain_External(sipRequest.URI.Host, true);
UASInviteTransaction uasTransaction = m_sipTransport.CreateUASTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, m_outboundProxy);
SIPServerUserAgent incomingCall = new SIPServerUserAgent(m_sipTransport, m_outboundProxy, uriUser, uriDomain, SIPCallDirection.In, GetSIPAccount_External, null, FireProxyLogEvent, uasTransaction);
uasTransaction.NewCallReceived += (local, remote, transaction, request) => { m_callManager.QueueNewCall(incomingCall); };
uasTransaction.GotRequest(localSIPEndPoint, remoteEndPoint, sipRequest);
}
}
else
{
// Return not found for non-serviced domain.
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Domain not serviced " + sipRequest.URI.ToString() + ", returning not found.", null));
UASInviteTransaction uasTransaction = m_sipTransport.CreateUASTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, m_outboundProxy);
SIPResponse notServicedResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.NotFound, "Domain not serviced");
uasTransaction.SendFinalResponse(notServicedResponse);
}
#endregion
}
else if (sipRequest.Method == SIPMethodsEnum.MESSAGE)
{
#region Processing non-INVITE requests that are accepted by the dialplan processing engine.
if (GetCanonicalDomain_External(sipRequest.Header.From.FromUserField.URI.Host, false) != null)
{
// Call identified as outgoing request for application server serviced domain.
string fromDomain = GetCanonicalDomain_External(sipRequest.Header.From.FromUserField.URI.Host, false);
SIPNonInviteTransaction nonInviteTransaction = m_sipTransport.CreateNonInviteTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, m_outboundProxy);
SIPNonInviteServerUserAgent outgoingRequest = new SIPNonInviteServerUserAgent(m_sipTransport, m_outboundProxy, fromUser, fromDomain, SIPCallDirection.Out, GetSIPAccount_External, SIPRequestAuthenticator.AuthenticateSIPRequest, FireProxyLogEvent, nonInviteTransaction);
nonInviteTransaction.NonInviteRequestReceived += (local, remote, transaction, request) => { m_callManager.QueueNewCall(outgoingRequest); };
nonInviteTransaction.GotRequest(localSIPEndPoint, remoteEndPoint, sipRequest);
}
else if (GetCanonicalDomain_External(sipRequest.URI.Host, true) != null)
{
// Call identified as incoming call for application server serviced domain.
if (sipRequest.URI.User.IsNullOrBlank())
{
// Cannot process incoming call if no user is specified.
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, sipRequest.Method + " request received with an empty URI user " + sipRequest.URI.ToString() + ", returning address incomplete.", null));
SIPResponse addressIncompleteResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.AddressIncomplete, "No user specified");
m_sipTransport.SendResponse(addressIncompleteResponse);
}
else
{
// Send the incoming call to the call manager for processing.
string uriUser = sipRequest.URI.User;
string uriDomain = GetCanonicalDomain_External(sipRequest.URI.Host, true);
SIPNonInviteTransaction nonInviteTransaction = m_sipTransport.CreateNonInviteTransaction(sipRequest, remoteEndPoint, localSIPEndPoint, m_outboundProxy);
SIPNonInviteServerUserAgent incomingRequest = new SIPNonInviteServerUserAgent(m_sipTransport, m_outboundProxy, uriUser, uriDomain, SIPCallDirection.In, GetSIPAccount_External, null, FireProxyLogEvent, nonInviteTransaction);
nonInviteTransaction.NonInviteRequestReceived += (local, remote, transaction, request) => { m_callManager.QueueNewCall(incomingRequest); };
nonInviteTransaction.GotRequest(localSIPEndPoint, remoteEndPoint, sipRequest);
}
}
else
{
// Return not found for non-serviced domain.
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Domain not serviced " + sipRequest.URI.ToString() + ", returning not found.", null));
SIPResponse notServicedResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.NotFound, "Domain not serviced");
m_sipTransport.SendResponse(notServicedResponse);
}
#endregion
}
else
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.UnrecognisedMessage, "MethodNotAllowed response for " + sipRequest.Method + " from " + fromUser + " socket " + remoteEndPoint.ToString() + ".", null));
SIPResponse notAllowedResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.MethodNotAllowed, null);
m_sipTransport.SendResponse(notAllowedResponse);
}
}
catch (Exception excp)
{
string reqExcpError = "Exception SIPAppServerCore GotRequest (" + remoteEndPoint + "). " + excp.Message;
logger.Error(reqExcpError);
SIPMonitorEvent reqExcpEvent = new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.Error, reqExcpError, sipRequest, null, localSIPEndPoint, remoteEndPoint, SIPCallDirection.In);
FireProxyLogEvent(reqExcpEvent);
throw excp;
}
}
private void SIPMessageReceived(SIPChannel sipChannel, SIPEndPoint remoteEndPoint, byte[] buffer)
{
string rawSIPMessage = null;
try
{
if (buffer != null && buffer.Length > 0)
{
if ((buffer[0] == 0x0 || buffer[0] == 0x1) && buffer.Length >= 20)
{
// Treat any messages that cannot be SIP as STUN requests.
if (STUNRequestReceived != null)
{
STUNRequestReceived(sipChannel.SIPChannelEndPoint.GetIPEndPoint(), remoteEndPoint.GetIPEndPoint(), buffer, buffer.Length);
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_STUN_REQUESTS_PER_SECOND_SUFFIX);
}
#endif
}
}
else
{
// Treat all messages that don't match STUN requests as SIP.
if (buffer.Length > SIPConstants.SIP_MAXIMUM_RECEIVE_LENGTH)
{
string rawErrorMessage = Encoding.UTF8.GetString(buffer, 0, 1024) + "\r\n..truncated";
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "SIP message too large, " + buffer.Length + " bytes, maximum allowed is " + SIPConstants.SIP_MAXIMUM_RECEIVE_LENGTH + " bytes.", SIPValidationFieldsEnum.Request, rawErrorMessage);
SIPResponse tooLargeResponse = GetResponse(sipChannel.SIPChannelEndPoint, remoteEndPoint, SIPResponseStatusCodesEnum.MessageTooLarge, null);
SendResponse(tooLargeResponse);
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_SIP_BAD_MESSAGES_PER_SECOND_SUFFIX);
}
#endif
}
else
{
rawSIPMessage = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
if (rawSIPMessage.IsNullOrBlank())
{
// An emptry transmission has been received. More than likely this is a NAT keep alive and can be disregarded.
//FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "No printable characters, length " + buffer.Length + " bytes.", SIPValidationFieldsEnum.Unknown, null);
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
// SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_SIP_BAD_MESSAGES_PER_SECOND_SUFFIX);
}
#endif
return;
}
else if (!rawSIPMessage.Contains("SIP"))
{
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "Missing SIP string.", SIPValidationFieldsEnum.NoSIPString, rawSIPMessage);
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_SIP_BAD_MESSAGES_PER_SECOND_SUFFIX);
}
#endif
return;
}
SIPMessage sipMessage = SIPMessage.ParseSIPMessage(rawSIPMessage, sipChannel.SIPChannelEndPoint, remoteEndPoint);
if (sipMessage != null)
{
if (sipMessage.SIPMessageType == SIPMessageTypesEnum.Response)
{
#region SIP Response.
try
{
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_SIP_RESPONSES_PER_SECOND_SUFFIX);
}
#endif
SIPResponse sipResponse = SIPResponse.ParseSIPResponse(sipMessage);
if (SIPResponseInTraceEvent != null)
{
FireSIPResponseInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipResponse);
}
if (m_transactionEngine != null && m_transactionEngine.Exists(sipResponse))
{
SIPTransaction transaction = m_transactionEngine.GetTransaction(sipResponse);
if (transaction.TransactionState != SIPTransactionStatesEnum.Completed)
{
transaction.DeliveryPending = false;
if (m_reliableTransmissions.ContainsKey(transaction.TransactionId))
{
lock (m_reliableTransmissions)
{
m_reliableTransmissions.Remove(transaction.TransactionId);
}
}
}
transaction.GotResponse(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipResponse);
}
else if (SIPTransportResponseReceived != null)
{
SIPTransportResponseReceived(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipResponse);
}
}
catch (SIPValidationException sipValidationException)
{
//logger.Warn("Invalid SIP response from " + sipMessage.ReceivedFrom + ", " + sipResponse.ValidationError + " , ignoring.");
//logger.Warn(sipMessage.RawMessage);
FireSIPBadResponseInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipMessage.RawMessage, sipValidationException.SIPErrorField, sipMessage.RawMessage);
}
#endregion
}
else
{
#region SIP Request.
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_SIP_REQUESTS_PER_SECOND_SUFFIX);
}
#endif
try
{
SIPRequest sipRequest = SIPRequest.ParseSIPRequest(sipMessage);
SIPValidationFieldsEnum sipRequestErrorField = SIPValidationFieldsEnum.Unknown;
string sipRequestValidationError = null;
if (!sipRequest.IsValid(out sipRequestErrorField, out sipRequestValidationError))
{
throw new SIPValidationException(sipRequestErrorField, sipRequestValidationError);
}
if (SIPRequestInTraceEvent != null)
{
FireSIPRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipRequest);
}
// Stateful cores will create transactions once they get the request and the transport layer will use those transactions.
// Stateless cores will not be affected by this step as the transaction layer will always return false.
SIPTransaction requestTransaction = (m_transactionEngine != null) ? m_transactionEngine.GetTransaction(sipRequest) : null;
if (requestTransaction != null)
{
if (requestTransaction.TransactionState == SIPTransactionStatesEnum.Completed && sipRequest.Method != SIPMethodsEnum.ACK)
{
logger.Warn("Resending final response for " + sipRequest.Method + ", " + sipRequest.URI.ToString() + ", cseq=" + sipRequest.Header.CSeq + ".");
requestTransaction.RetransmitFinalResponse();
}
else if (sipRequest.Method == SIPMethodsEnum.ACK)
{
//logger.Debug("ACK received for " + requestTransaction.TransactionRequest.URI.ToString() + ".");
if (requestTransaction.TransactionState == SIPTransactionStatesEnum.Completed)
{
//logger.Debug("ACK received for INVITE, setting state to Confirmed, " + sipRequest.URI.ToString() + " from " + sipRequest.Header.From.FromURI.User + " " + remoteEndPoint + ".");
//requestTransaction.UpdateTransactionState(SIPTransactionStatesEnum.Confirmed);
requestTransaction.ACKReceived(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipRequest);
}
else if (requestTransaction.TransactionState == SIPTransactionStatesEnum.Confirmed)
{
// ACK retransmit, ignore as a previous ACK was received and the transaction has already been confirmed.
}
else
{
//logger.Warn("ACK recieved from " + remoteEndPoint.ToString() + " on " + requestTransaction.TransactionState + " transaction, ignoring.");
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "ACK recieved on " + requestTransaction.TransactionState + " transaction, ignoring.", SIPValidationFieldsEnum.Request, null);
}
}
else
{
logger.Warn("Transaction already exists, ignoring duplicate request, " + sipRequest.Method + " " + sipRequest.URI.ToString() + ".");
//FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "Transaction already exists, ignoring duplicate request, " + sipRequest.Method + " " + sipRequest.URI.ToString() + " from " + remoteEndPoint + ".", SIPValidationFieldsEnum.Request);
}
}
else if (SIPTransportRequestReceived != null)
{
// This is a new SIP request and if the validity checks are passed it will be handed off to all subscribed new request listeners.
#region Check for invalid SIP requests.
if (sipRequest.Header.MaxForwards == 0 && sipRequest.Method != SIPMethodsEnum.OPTIONS)
{
// Check the MaxForwards value, if equal to 0 the request must be discarded. If MaxForwards is -1 it indicates the
// header was not present in the request and that the MaxForwards check should not be undertaken.
//logger.Warn("SIPTransport responding with TooManyHops due to 0 MaxForwards.");
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "Zero MaxForwards on " + sipRequest.Method + " " + sipRequest.URI.ToString() + " from " + sipRequest.Header.From.FromURI.User + " " + remoteEndPoint.ToString(), SIPValidationFieldsEnum.Request, sipRequest.ToString());
SIPResponse tooManyHops = GetResponse(sipRequest, SIPResponseStatusCodesEnum.TooManyHops, null);
SendResponse(sipChannel, tooManyHops);
return;
}
/*else if (sipRequest.IsLoop(sipChannel.SIPChannelEndPoint.SocketEndPoint.Address.ToString(), sipChannel.SIPChannelEndPoint.SocketEndPoint.Port, sipRequest.CreateBranchId()))
{
//logger.Warn("SIPTransport Dropping looped request.");
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "Dropping looped request, " + sipRequest.Method + " " + sipRequest.URI.ToString() + " from " + sipRequest.Header.From.FromURI.User + " " + IPSocket.GetSocketString(remoteEndPoint), SIPValidationFieldsEnum.Request);
SIPResponse loopResponse = GetResponse(sipRequest, SIPResponseStatusCodesEnum.LoopDetected, null);
SendResponse(loopResponse);
return;
}*/
#endregion
#region Route pre-processing.
if (sipRequest.Header.Routes.Length > 0)
{
PreProcessRouteInfo(sipRequest);
}
#endregion
// Request has passed validity checks, adjust the client Via header to reflect the socket the request was received on.
//SIPViaHeader originalTopViaHeader = sipRequest.Header.Via.TopViaHeader;
sipRequest.Header.Vias.UpateTopViaHeader(remoteEndPoint.GetIPEndPoint());
// Stateful cores should create a transaction once they receive this event, stateless cores should not.
SIPTransportRequestReceived(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipRequest);
}
}
catch (SIPValidationException sipRequestExcp)
{
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipRequestExcp.Message, sipRequestExcp.SIPErrorField, sipMessage.RawMessage);
SIPResponse errorResponse = GetResponse(sipChannel.SIPChannelEndPoint, remoteEndPoint, sipRequestExcp.SIPResponseErrorCode, sipRequestExcp.Message);
SendResponse(sipChannel, errorResponse);
}
#endregion
}
}
else
{
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "Not parseable as SIP message.", SIPValidationFieldsEnum.Unknown, rawSIPMessage);
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_SIP_BAD_MESSAGES_PER_SECOND_SUFFIX);
}
#endif
}
}
}
}
}
catch (Exception excp)
{
FireSIPBadRequestInTraceEvent(sipChannel.SIPChannelEndPoint, remoteEndPoint, "Exception SIPTransport. " + excp.Message, SIPValidationFieldsEnum.Unknown, rawSIPMessage);
#if !SILVERLIGHT
if (PerformanceMonitorPrefix != null)
{
SIPSorceryPerformanceMonitor.IncrementCounter(PerformanceMonitorPrefix + SIPSorceryPerformanceMonitor.SIP_TRANSPORT_SIP_BAD_MESSAGES_PER_SECOND_SUFFIX);
}
#endif
}
}
void sipTransport1_SIPRequestOutTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint toEndPoint, SIPRequest sipRequest)
{
Console.WriteLine("Request Sent: " + localEndPoint.ToString() + "<-" + toEndPoint.ToString() + "\r\n" + sipRequest.ToString());
}
public bool IsLocalSIPEndPoint(SIPEndPoint sipEndPoint)
{
return m_sipChannels.ContainsKey(sipEndPoint.ToString());
}
void sipTransport1_SIPResponseInTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, SIPResponse sipResponse)
{
Console.WriteLine("Response Received: " + localEndPoint.ToString() + "<-" + fromEndPoint.ToString() + "\r\n" + sipResponse.ToString());
}
private void LogSIPBadResponseIn(SIPEndPoint localSIPEndPoint, SIPEndPoint endPoint, string sipMessage, SIPValidationFieldsEnum errorField, string rawMessage)
{
string errorMessage = "App Svr Bad Response Received: " + localSIPEndPoint + "<-" + endPoint.ToString() + ", " + errorField + ". " + sipMessage;
FireSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.BadSIPMessage, errorMessage, null));
if (rawMessage != null)
{
FireSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.FullSIPTrace, errorMessage + "\r\n" + rawMessage, null));
}
}
void sipTransport2_SIPRequestInTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, SIPRequest sipRequest)
{
Console.WriteLine("Request Received: " + localEndPoint.ToString() + "<-" + fromEndPoint.ToString() + "\r\n" + sipRequest.ToString());
}
private void LogSIPResponseOut(SIPEndPoint localSIPEndPoint, SIPEndPoint endPoint, SIPResponse sipResponse)
{
string message = "App Svr Sent: " + localSIPEndPoint.ToString() + "->" + endPoint.ToString() + "\r\n" + sipResponse.ToString();
//logger.Debug("as: response out " + sipResponse.Header.CSeqMethod + " " + localSIPEndPoint.ToString() + "->" + endPoint.ToString() + ", callid=" + sipResponse.Header.CallId + ".");
string fromUser = (sipResponse.Header.From != null && sipResponse.Header.From.FromURI != null) ? sipResponse.Header.From.FromURI.User : "******";
FireSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.FullSIPTrace, message, fromUser, localSIPEndPoint, endPoint));
}
void sipTransport2_SIPResponseOutTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint toEndPoint, SIPResponse sipResponse)
{
Console.WriteLine("Response Sent: " + localEndPoint.ToString() + "<-" + toEndPoint.ToString() + "\r\n" + sipResponse.ToString());
}
