public SIPNonInviteServerUserAgent(
SIPTransport sipTransport,
SIPEndPoint outboundProxy,
string sipUsername,
string sipDomain,
SIPCallDirection callDirection,
SIPAssetGetDelegate<SIPAccount> getSIPAccount,
SIPAuthenticateRequestDelegate sipAuthenticateRequest,
SIPMonitorLogDelegate logDelegate,
SIPNonInviteTransaction transaction)
{
m_sipTransport = sipTransport;
m_outboundProxy = outboundProxy;
m_sipUsername = sipUsername;
m_sipDomain = sipDomain;
m_sipCallDirection = callDirection;
GetSIPAccount_External = getSIPAccount;
SIPAuthenticateRequest_External = sipAuthenticateRequest;
Log_External = logDelegate ?? Log_External;
m_transaction = transaction;
m_transaction.TransactionTraceMessage += TransactionTraceMessage;
//m_uasTransaction.UASInviteTransactionTimedOut += ClientTimedOut;
//m_uasTransaction.UASInviteTransactionCancelled += UASTransactionCancelled;
//m_uasTransaction.TransactionRemoved += new SIPTransactionRemovedDelegate(UASTransaction_TransactionRemoved);
//m_uasTransaction.TransactionStateChanged += (t) => { logger.Debug("Transaction state change to " + t.TransactionState + ", uri=" + t.TransactionRequestURI.ToString() + "."); };
}
public void EqualityTestRouteTest()
{
Console.WriteLine(System.Reflection.MethodBase.GetCurrentMethod().Name);
SIPEndPoint sipEP1 = SIPEndPoint.ParseSIPEndPoint("sip:10.0.0.100;lr");
SIPEndPoint sipEP2 = new SIPEndPoint(SIPProtocolsEnum.udp, new IPEndPoint(IPAddress.Parse("10.0.0.100"), 5060));
Assert.IsTrue(sipEP1 == sipEP2, "The SIP end points should have been detected as equal.");
}
public SIPMonitorMachineEvent(SIPMonitorMachineEventTypesEnum machineEventType, string owner, SIPEndPoint remoteEndPoint, string message)
{
m_serialisationPrefix = SERIALISATION_PREFIX;
RemoteEndPoint = remoteEndPoint;
ClientType = SIPMonitorClientTypesEnum.Machine;
Username = owner;
MachineEventType = machineEventType;
Message = message;
}
public bool IsAppServerEndPoint(SIPEndPoint remoteEndPoint)
{
if (m_appServerEndPoints == null || m_appServerEndPoints.Count == 0)
{
return false;
}
else
{
return m_appServerEndPoints.ContainsKey(remoteEndPoint.ToString());
}
}
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 SIPReferClientUserAgent(
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) => { };
}
}
public SIPTransferServerUserAgent(
SIPMonitorLogDelegate logDelegate,
BlindTransferDelegate blindTransfer,
SIPTransport sipTransport,
SIPEndPoint outboundProxy,
SIPDialogue dialogueToReplace,
SIPDialogue oppositeDialogue,
string callDestination,
string owner,
string adminID)
{
Log_External = logDelegate;
BlindTransfer_External = blindTransfer;
m_sipTransport = sipTransport;
m_outboundProxy = outboundProxy;
m_dialogueToReplace = dialogueToReplace;
m_oppositeDialogue = oppositeDialogue;
m_callDestination = callDestination;
m_owner = owner;
m_adminID = adminID;
m_dummyRequest = CreateDummyRequest(m_dialogueToReplace, m_callDestination);
}
void m_serverTransaction_NonInviteTransactionFinalResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
if (sipResponse.Status == SIPResponseStatusCodesEnum.Accepted)
{
FireReferAccepted();
}
else if (sipResponse.Status == SIPResponseStatusCodesEnum.Decline)
{
FireReferDenied();
}
else if (sipResponse.Status == SIPResponseStatusCodesEnum.MethodNotAllowed)
{
FireReferDenied();
}
}
public bool AuthenticateCall()
{
m_isAuthenticated = false;
try
{
if (SIPAuthenticateRequest_External == null)
{
// No point trying to authenticate if we haven't been given an authentication delegate.
Reject(SIPResponseStatusCodesEnum.InternalServerError, null, null);
}
else if (GetSIPAccount_External == null)
{
// No point trying to authenticate if we haven't been given a delegate to load the SIP account.
Reject(SIPResponseStatusCodesEnum.InternalServerError, null, null);
}
else
{
m_sipAccount = GetSIPAccount_External(m_sipUsername, m_sipDomain);
if (m_sipAccount == null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Rejecting authentication required call for " + m_sipUsername + "@" + m_sipDomain + ", SIP account not found.", null));
Reject(SIPResponseStatusCodesEnum.Forbidden, null, null);
}
else
{
SIPRequest sipRequest = m_uasTransaction.TransactionRequest;
SIPEndPoint localSIPEndPoint = (!sipRequest.Header.ProxyReceivedOn.IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(sipRequest.Header.ProxyReceivedOn) : sipRequest.LocalSIPEndPoint;
SIPEndPoint remoteEndPoint = (!sipRequest.Header.ProxyReceivedFrom.IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(sipRequest.Header.ProxyReceivedFrom) : sipRequest.RemoteSIPEndPoint;
SIPRequestAuthenticationResult authenticationResult = SIPAuthenticateRequest_External(localSIPEndPoint, remoteEndPoint, sipRequest, m_sipAccount, Log_External);
if (authenticationResult.Authenticated)
{
if (authenticationResult.WasAuthenticatedByIP)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "New call from " + remoteEndPoint.ToString() + " successfully authenticated by IP address.", m_sipAccount.Owner));
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "New call from " + remoteEndPoint.ToString() + " successfully authenticated by digest.", m_sipAccount.Owner));
}
SetOwner(m_sipAccount.Owner, m_sipAccount.AdminMemberId);
m_isAuthenticated = true;
}
else
{
// Send authorisation failure or required response
SIPResponse authReqdResponse = SIPTransport.GetResponse(sipRequest, authenticationResult.ErrorResponse, null);
authReqdResponse.Header.AuthenticationHeader = authenticationResult.AuthenticationRequiredHeader;
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Call not authenticated for " + m_sipUsername + "@" + m_sipDomain + ", responding with " + authenticationResult.ErrorResponse + ".", null));
m_uasTransaction.SendFinalResponse(authReqdResponse);
}
}
}
}
catch (Exception excp)
{
logger.LogError("Exception SIPServerUserAgent AuthenticateCall. " + excp.Message);
Reject(SIPResponseStatusCodesEnum.InternalServerError, null, null);
}
return(m_isAuthenticated);
}
void transport_SIPResponseInTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, SIPResponse sipResponse)
{
Console.WriteLine("Response In: " + localEndPoint + "<-" + fromEndPoint.ToString() + "\n" + sipResponse.ToString());
}
public void Call(SIPCallDescriptor sipCallDescriptor)
{
try
{
m_sipCallDescriptor = sipCallDescriptor;
SIPURI callURI = SIPURI.ParseSIPURI(sipCallDescriptor.Uri);
SIPRouteSet routeSet = null;
if (!m_callCancelled)
{
// If the outbound proxy is a loopback address, as it will normally be for local deployments, then it cannot be overriden.
if (m_outboundProxy != null && IPAddress.IsLoopback(m_outboundProxy.Address))
{
m_serverEndPoint = m_outboundProxy;
}
else if (!sipCallDescriptor.ProxySendFrom.IsNullOrBlank())
{
// If the binding has a specific proxy end point sent then the request needs to be forwarded to the proxy's default end point for it to take care of.
SIPEndPoint outboundProxyEndPoint = SIPEndPoint.ParseSIPEndPoint(sipCallDescriptor.ProxySendFrom);
m_outboundProxy = new SIPEndPoint(SIPProtocolsEnum.udp, new IPEndPoint(outboundProxyEndPoint.Address, m_defaultSIPPort));
m_serverEndPoint = m_outboundProxy;
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "SIPClientUserAgent Call using alternate outbound proxy of " + m_outboundProxy + ".", Owner));
}
else if (m_outboundProxy != null)
{
// Using the system outbound proxy only, no additional user routing requirements.
m_serverEndPoint = m_outboundProxy;
}
// A custom route set may have been specified for the call.
if (m_sipCallDescriptor.RouteSet != null && m_sipCallDescriptor.RouteSet.IndexOf(OUTBOUNDPROXY_AS_ROUTESET_CHAR) != -1)
{
try
{
routeSet = new SIPRouteSet();
routeSet.PushRoute(new SIPRoute(m_sipCallDescriptor.RouteSet, true));
}
catch
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Error an outbound proxy value was not recognised in SIPClientUserAgent Call. " + m_sipCallDescriptor.RouteSet + ".", Owner));
}
}
// No outbound proxy, determine the forward destination based on the SIP request.
if (m_serverEndPoint == null)
{
SIPDNSLookupResult lookupResult = null;
if (routeSet == null || routeSet.Length == 0)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Attempting to resolve " + callURI.Host + ".", Owner));
lookupResult = m_sipTransport.GetURIEndPoint(callURI, false);
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Route set for call " + routeSet.ToString() + ".", Owner));
lookupResult = m_sipTransport.GetURIEndPoint(routeSet.TopRoute.URI, false);
}
if (lookupResult.LookupError != null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "DNS error resolving " + callURI.Host + ", " + lookupResult.LookupError + ". Call cannot proceed.", Owner));
}
else
{
m_serverEndPoint = lookupResult.GetSIPEndPoint();
}
}
if (m_callCancelled)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Call was cancelled during DNS resolution of " + callURI.Host, Owner));
FireCallFailed(this, "Cancelled by caller");
}
else if (m_serverEndPoint != null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Switching to " + SIPURI.ParseSIPURI(m_sipCallDescriptor.Uri).CanonicalAddress + " via " + m_serverEndPoint + ".", Owner));
m_localSIPEndPoint = m_sipTransport.GetDefaultSIPEndPoint(m_serverEndPoint);
if (m_localSIPEndPoint == null)
{
throw new ApplicationException("The call could not locate an appropriate SIP transport channel for protocol " + callURI.Protocol + ".");
}
string content = sipCallDescriptor.Content;
if (content.IsNullOrBlank())
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Body on UAC call was empty.", Owner));
}
else if (m_sipCallDescriptor.ContentType == m_sdpContentType)
{
if (!m_sipCallDescriptor.MangleResponseSDP)
{
IPEndPoint sdpEndPoint = SDP.GetSDPRTPEndPoint(content);
if (sdpEndPoint != null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC call was set to NOT mangle, RTP socket " + sdpEndPoint.ToString() + ".", Owner));
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC call was set to NOT mangle, RTP socket could not be determined.", Owner));
}
}
else
{
IPEndPoint sdpEndPoint = SDP.GetSDPRTPEndPoint(content);
if (sdpEndPoint != null)
{
if (!IPSocket.IsPrivateAddress(sdpEndPoint.Address.ToString()))
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC call had public IP not mangled, RTP socket " + sdpEndPoint.ToString() + ".", Owner));
}
else
{
bool wasSDPMangled = false;
if (sipCallDescriptor.MangleIPAddress != null)
{
if (sdpEndPoint != null)
{
content = SIPPacketMangler.MangleSDP(content, sipCallDescriptor.MangleIPAddress.ToString(), out wasSDPMangled);
}
}
if (wasSDPMangled)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC call had RTP socket mangled from " + sdpEndPoint.ToString() + " to " + sipCallDescriptor.MangleIPAddress.ToString() + ":" + sdpEndPoint.Port + ".", Owner));
}
else if (sdpEndPoint != null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC could not be mangled, using original RTP socket of " + sdpEndPoint.ToString() + ".", Owner));
}
}
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP RTP socket on UAC call could not be determined.", Owner));
}
}
}
SIPRequest switchServerInvite = GetInviteRequest(m_sipCallDescriptor, CallProperties.CreateBranchId(), CallProperties.CreateNewCallId(), m_localSIPEndPoint, routeSet, content, sipCallDescriptor.ContentType);
// Now that we have a destination socket create a new UAC transaction for forwarded leg of the call.
m_serverTransaction = m_sipTransport.CreateUACTransaction(switchServerInvite, m_serverEndPoint, m_localSIPEndPoint, m_outboundProxy);
m_serverTransaction.CDR.DialPlanContextID = m_sipCallDescriptor.DialPlanContextID;
#region Real-time call control processing.
string rtccError = null;
if (m_serverTransaction.CDR != null)
{
m_serverTransaction.CDR.Owner = Owner;
m_serverTransaction.CDR.AdminMemberId = AdminMemberId;
m_serverTransaction.CDR.Updated();
#if !SILVERLIGHT
if (m_sipCallDescriptor.AccountCode != null && RtccGetCustomer_External != null)
{
//var customerAccount = m_customerAccountDataLayer.CheckAccountCode(Owner, m_sipCallDescriptor.AccountCode);
var customerAccount = RtccGetCustomer_External(Owner, m_sipCallDescriptor.AccountCode);
if (customerAccount == null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "A billable call could not proceed as no account exists for account code or number " + m_sipCallDescriptor.AccountCode + ".", Owner));
rtccLogger.Debug("A billable call could not proceed as no account exists for account code or number " + m_sipCallDescriptor.AccountCode + " and owner " + Owner + ".");
rtccError = "Real-time call control invalid account code";
}
else
{
AccountCode = customerAccount.AccountCode;
string rateDestination = m_sipCallDescriptor.Uri;
if (SIPURI.TryParse(m_sipCallDescriptor.Uri))
{
rateDestination = SIPURI.ParseSIPURIRelaxed(m_sipCallDescriptor.Uri).User;
}
//var rate = m_customerAccountDataLayer.GetRate(Owner, m_sipCallDescriptor.RateCode, rateDestination, customerAccount.RatePlan);
var rate = RtccGetRate_External(Owner, m_sipCallDescriptor.RateCode, rateDestination, customerAccount.RatePlan);
if (rate == null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "A billable call could not proceed as no rate could be determined for destination " + rateDestination + ".", Owner));
rtccLogger.Debug("A billable call could not proceed as no rate could be determined for destination " + rateDestination + " and owner " + Owner + ".");
rtccError = "Real-time call control no rate";
}
else
{
Rate = rate.RatePerIncrement;
if (rate.RatePerIncrement == 0 && rate.SetupCost == 0)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "The rate and setup cost for the " + rateDestination + "were both zero. The call will be allowed to proceed with no RTCC reservation.", Owner));
}
else
{
//decimal balance = m_customerAccountDataLayer.GetBalance(AccountCode);
decimal balance = RtccGetBalance_External(AccountCode);
if (balance < Rate)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "A billable call could not proceed as the available credit for " + AccountCode + " was not sufficient for 60 seconds to destination " + rateDestination + ".", Owner));
rtccLogger.Debug("A billable call could not proceed as the available credit for " + AccountCode + " was not sufficient for 60 seconds to destination " + rateDestination + " and owner " + Owner + ".");
rtccError = "Real-time call control insufficient credit";
}
else
{
int intialSeconds = 0;
//var reservationCost = m_customerAccountDataLayer.ReserveInitialCredit(AccountCode, rate, m_serverTransaction.CDR, out intialSeconds);
var reservationCost = RtccReserveInitialCredit_External(AccountCode, rate.ID, m_serverTransaction.CDR, out intialSeconds);
if (reservationCost == Decimal.MinusOne)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Call will not proceed as the intial real-time call control credit reservation failed.", Owner));
rtccLogger.Debug("Call will not proceed as the intial real-time call control credit reservation failed for owner " + Owner + ".");
rtccError = "Real-time call control initial reservation failed";
}
else
{
ReservedCredit = reservationCost;
ReservedSeconds = intialSeconds;
}
}
}
}
}
}
#endif
}
#endregion
if (rtccError == null)
{
m_serverTransaction.UACInviteTransactionInformationResponseReceived += ServerInformationResponseReceived;
m_serverTransaction.UACInviteTransactionFinalResponseReceived += ServerFinalResponseReceived;
m_serverTransaction.UACInviteTransactionTimedOut += ServerTimedOut;
m_serverTransaction.TransactionTraceMessage += TransactionTraceMessage;
m_serverTransaction.SendInviteRequest(m_serverEndPoint, m_serverTransaction.TransactionRequest);
}
else
{
m_serverTransaction.CancelCall(rtccError);
FireCallFailed(this, rtccError);
}
}
else
{
if (routeSet == null || routeSet.Length == 0)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Forward leg failed, could not resolve URI host " + callURI.Host, Owner));
m_serverTransaction?.CancelCall("Unresolvable destination " + callURI.Host);
FireCallFailed(this, "unresolvable destination " + callURI.Host);
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Forward leg failed, could not resolve top Route host " + routeSet.TopRoute.Host, Owner));
m_serverTransaction?.CancelCall("Unresolvable destination " + routeSet.TopRoute.Host);
FireCallFailed(this, "unresolvable destination " + routeSet.TopRoute.Host);
}
}
}
}
catch (ApplicationException appExcp)
{
m_serverTransaction?.CancelCall(appExcp.Message);
FireCallFailed(this, appExcp.Message);
}
catch (Exception excp)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Exception UserAgentClient Call. " + excp.Message, Owner));
m_serverTransaction?.CancelCall("Unknown exception");
FireCallFailed(this, excp.Message);
}
}
/// <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 expiresHeaderValue,
string userAgent,
out SIPResponseStatusCodesEnum responseStatus,
out string responseMessage)
{
//logger.Debug("UpdateBinding " + bindingURI.ToString() + ".");
int maxAllowedExpiry = DEFAULT_MAX_EXPIRY_SECONDS;
responseMessage = null;
string sipAccountAOR = sipAccount.AOR;
responseStatus = SIPResponseStatusCodesEnum.Ok;
try
{
userAgent = (userAgent != null && userAgent.Length > MAX_USERAGENT_LENGTH) ? userAgent.Substring(0, MAX_USERAGENT_LENGTH) : userAgent;
List <SIPRegistrarBinding> bindings = m_registrarBindingDataLayer.GetForSIPAccount(new Guid(sipAccount.ID));
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.
Logger.LogDebug("Remove all bindings requested for " + sipAccountAOR + " but mutliple bindings specified, rejecting as a bad request.");
responseStatus = SIPResponseStatusCodesEnum.BadRequest;
break;
}
#region Process remove all bindings.
if (expiresHeaderValue == 0)
{
// Removing all bindings for user.
Logger.LogDebug("Remove all bindings requested for " + sipAccountAOR + ".");
// 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]);
}
}
//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());
SIPRegistrarBinding binding = bindings.Where(x => x.ContactURI == bindingURI.ToString()).FirstOrDefault();
if (binding != null)
{
if (requestedExpiry <= 0)
{
Logger.LogDebug($"Binding expired by client for {sipAccountAOR} from {remoteSIPEndPoint}.");
bindings.Remove(binding);
m_registrarBindingDataLayer.Delete(new Guid(binding.ID));
bindingExpiry = 0;
}
else
{
Logger.LogDebug($"Binding update request for {sipAccountAOR} from {remoteSIPEndPoint}, expiry requested {requestedExpiry}s granted {bindingExpiry}s.");
//binding.RefreshBinding(bindingExpiry, remoteSIPEndPoint, proxySIPEndPoint, registrarSIPEndPoint, sipAccount.DontMangleEnabled);
//binding.RefreshBinding(bindingExpiry, remoteSIPEndPoint, proxySIPEndPoint, registrarSIPEndPoint, false);
//DateTime startTime = DateTime.Now;
//m_bindingsPersistor.Update(binding);
//m_registrarBindingDataLayer.Update(binding);
m_registrarBindingDataLayer.RefreshBinding(new Guid(binding.ID), bindingExpiry, remoteSIPEndPoint, proxySIPEndPoint, registrarSIPEndPoint);
//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)));
}
}
else
{
if (requestedExpiry > 0)
{
Logger.LogDebug($"New binding request for {sipAccountAOR} from {remoteSIPEndPoint}, expiry requested {requestedExpiry}s granted {bindingExpiry}s.");
if (bindings.Count >= m_maxBindingsPerAccount)
{
// Need to remove the oldest binding to stay within limit.
SIPRegistrarBinding oldestBinding = bindings.OrderBy(x => x.LastUpdate).Last();
Logger.LogDebug($"Binding limit exceeded for {sipAccountAOR} from {remoteSIPEndPoint} removing oldest binding to stay within limit of {m_maxBindingsPerAccount}.");
m_registrarBindingDataLayer.Delete(new Guid(oldestBinding.ID));
}
SIPRegistrarBinding newBinding = new SIPRegistrarBinding(sipAccount, bindingURI, callId, cseq, userAgent,
remoteSIPEndPoint, proxySIPEndPoint, registrarSIPEndPoint, bindingExpiry);
m_registrarBindingDataLayer.Add(newBinding);
}
else
{
Logger.LogDebug($"New binding received for {sipAccountAOR} with expired contact, {bindingURI} no update.");
bindingExpiry = 0;
}
}
responseStatus = SIPResponseStatusCodesEnum.Ok;
}
}
return(m_registrarBindingDataLayer.GetForSIPAccount(new Guid(sipAccount.ID)));
}
catch (Exception excp)
{
Logger.LogError("Exception UpdateBinding. " + excp);
responseStatus = SIPResponseStatusCodesEnum.InternalServerError;
return(null);
}
}
/// <summary>
/// Authenticates a SIP request.
/// </summary>
public static SIPRequestAuthenticationResult AuthenticateSIPRequest(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest sipRequest, SIPAccount sipAccount, SIPMonitorLogDelegate logSIPMonitorEvent)
{
try
{
if (sipAccount == null)
{
return new SIPRequestAuthenticationResult(SIPResponseStatusCodesEnum.Forbidden, null);
}
else if (sipAccount.IsDisabled)
{
if (logSIPMonitorEvent != null)
{
logSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Authoriser, SIPMonitorEventTypesEnum.DialPlan, "SIP account " + sipAccount.SIPUsername + "@" + sipAccount.SIPDomain + " is disabled for " + sipRequest.Method + ".", sipAccount.Owner));
}
return new SIPRequestAuthenticationResult(SIPResponseStatusCodesEnum.Forbidden, null);
}
else
{
SIPAuthenticationHeader reqAuthHeader = sipRequest.Header.AuthenticationHeader;
if (reqAuthHeader == null)
{
// Check for IP address authentication.
if (!sipAccount.IPAddressACL.IsNullOrBlank())
{
SIPEndPoint uaEndPoint = (!sipRequest.Header.ProxyReceivedFrom.IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(sipRequest.Header.ProxyReceivedFrom) : remoteEndPoint;
if (Regex.Match(uaEndPoint.GetIPEndPoint().ToString(), sipAccount.IPAddressACL).Success)
{
// Successfully authenticated
return new SIPRequestAuthenticationResult(true, true);
}
}
SIPAuthenticationHeader authHeader = new SIPAuthenticationHeader(SIPAuthorisationHeadersEnum.WWWAuthenticate, sipAccount.SIPDomain, GetNonce());
return new SIPRequestAuthenticationResult(SIPResponseStatusCodesEnum.Unauthorised, authHeader);
}
else
{
// Check for IP address authentication.
if (!sipAccount.IPAddressACL.IsNullOrBlank())
{
SIPEndPoint uaEndPoint = (!sipRequest.Header.ProxyReceivedFrom.IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(sipRequest.Header.ProxyReceivedFrom) : remoteEndPoint;
if (Regex.Match(uaEndPoint.GetIPEndPoint().ToString(), sipAccount.IPAddressACL).Success)
{
// Successfully authenticated
return new SIPRequestAuthenticationResult(true, true);
}
}
string requestNonce = reqAuthHeader.SIPDigest.Nonce;
string uri = reqAuthHeader.SIPDigest.URI;
string response = reqAuthHeader.SIPDigest.Response;
// Check for stale nonces.
if (IsNonceStale(requestNonce))
{
if (logSIPMonitorEvent != null)
{
logSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Authoriser, SIPMonitorEventTypesEnum.Warn, "Authentication failed stale nonce for realm=" + sipAccount.SIPDomain + ", username="******", uri=" + uri + ", nonce=" + requestNonce + ", method=" + sipRequest.Method + ".", null));
}
SIPAuthenticationHeader authHeader = new SIPAuthenticationHeader(SIPAuthorisationHeadersEnum.WWWAuthenticate, sipAccount.SIPDomain, GetNonce());
return new SIPRequestAuthenticationResult(SIPResponseStatusCodesEnum.Unauthorised, authHeader);
}
else
{
SIPAuthorisationDigest checkAuthReq = reqAuthHeader.SIPDigest;
checkAuthReq.SetCredentials(sipAccount.SIPUsername, sipAccount.SIPPassword, uri, sipRequest.Method.ToString());
string digest = checkAuthReq.Digest;
if (digest == response)
{
// Successfully authenticated
return new SIPRequestAuthenticationResult(true, false);
}
else
{
if (logSIPMonitorEvent != null)
{
logSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Authoriser, SIPMonitorEventTypesEnum.Warn, "Authentication token check failed for realm=" + sipAccount.SIPDomain + ", username="******", uri=" + uri + ", nonce=" + requestNonce + ", method=" + sipRequest.Method + ".", sipAccount.Owner));
}
SIPAuthenticationHeader authHeader = new SIPAuthenticationHeader(SIPAuthorisationHeadersEnum.WWWAuthenticate, sipAccount.SIPDomain, GetNonce());
return new SIPRequestAuthenticationResult(SIPResponseStatusCodesEnum.Unauthorised, authHeader);
}
}
}
}
}
catch (Exception excp)
{
if (logSIPMonitorEvent != null)
{
logSIPMonitorEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.Authoriser, SIPMonitorEventTypesEnum.Error, "Exception AuthoriseSIPRequest. " + excp.Message, null));
}
return new SIPRequestAuthenticationResult(SIPResponseStatusCodesEnum.InternalServerError, null);
}
}
public void ReferOutOfDialog(SIPURI fromUri, SIPURI toUri, SIPURI referToUri, ReplacesCallDescriptor sipReplacesCallDescriptor)
{
try
{
m_sipCallDescriptor = new SIPCallDescriptor(null,toUri.ToString(),fromUri.ToString(),null,null);
m_sipCallDescriptor.Gruu = toUri.Parameters.Get(SIPCallDescriptor.GRUU_KEY);
m_sipCallDescriptor.ReplacesCall = sipReplacesCallDescriptor;
SIPURI callURI = SIPURI.ParseSIPURI(m_sipCallDescriptor.Uri);
// If the outbound proxy is a loopback address, as it will normally be for local deployments, then it cannot be overriden.
if (m_outboundProxy != null && IPAddress.IsLoopback(m_outboundProxy.Address))
{
m_serverEndPoint = m_outboundProxy;
}
else if (!m_sipCallDescriptor.ProxySendFrom.IsNullOrBlank())
{
// If the binding has a specific proxy end point sent then the request needs to be forwarded to the proxy's default end point for it to take care of.
SIPEndPoint outboundProxyEndPoint = SIPEndPoint.ParseSIPEndPoint(m_sipCallDescriptor.ProxySendFrom);
m_outboundProxy = new SIPEndPoint(SIPProtocolsEnum.udp, new IPEndPoint(outboundProxyEndPoint.Address, m_defaultSIPPort));
m_serverEndPoint = m_outboundProxy;
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "SIPReferClientUserAgent refer request using alternate outbound proxy of " + m_outboundProxy + ".", Owner));
}
else if (m_outboundProxy != null)
{
// Using the system outbound proxy only, no additional user routing requirements.
m_serverEndPoint = m_outboundProxy;
}
// A custom route set may have been specified for the call.
if (m_sipCallDescriptor.RouteSet != null && m_sipCallDescriptor.RouteSet.IndexOf(OUTBOUNDPROXY_AS_ROUTESET_CHAR) != -1)
{
try
{
RouteSet = new SIPRouteSet();
RouteSet.PushRoute(new SIPRoute(m_sipCallDescriptor.RouteSet, true));
}
catch
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "Error an outbound proxy value was not recognised in SIPReferClientUserAgent refer request. " + m_sipCallDescriptor.RouteSet + ".", Owner));
}
}
// No outbound proxy, determine the forward destination based on the SIP request.
if (m_serverEndPoint == null)
{
SIPDNSLookupResult lookupResult = null;
if (RouteSet == null || RouteSet.Length == 0)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "Attempting to resolve " + callURI.Host + ".", Owner));
lookupResult = m_sipTransport.GetURIEndPoint(callURI, false);
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "Route set for refer request " + RouteSet.ToString() + ".", Owner));
lookupResult = m_sipTransport.GetURIEndPoint(RouteSet.TopRoute.URI, false);
}
if (lookupResult.LookupError != null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "DNS error resolving " + callURI.Host + ", " + lookupResult.LookupError + ". Refer request cannot proceed.", Owner));
}
else
{
m_serverEndPoint = lookupResult.GetSIPEndPoint();
}
}
if (m_serverEndPoint != null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "Switching to " + SIPURI.ParseSIPURI(m_sipCallDescriptor.Uri).CanonicalAddress + " via " + m_serverEndPoint + ".", Owner));
m_localSIPEndPoint = m_sipTransport.GetDefaultSIPEndPoint(m_serverEndPoint);
if (m_localSIPEndPoint == null)
{
throw new ApplicationException("The refer request could not locate an appropriate SIP transport channel for protocol " + callURI.Protocol + ".");
}
SIPRequest referRequest = GetReferRequest(m_localSIPEndPoint,referToUri, sipReplacesCallDescriptor);
// Now that we have a destination socket create a new UAC transaction for forwarded leg of the call.
m_serverTransaction = m_sipTransport.CreateNonInviteTransaction(referRequest, m_serverEndPoint, m_localSIPEndPoint, m_outboundProxy);
m_serverTransaction.NonInviteTransactionFinalResponseReceived += m_serverTransaction_NonInviteTransactionFinalResponseReceived;
m_serverTransaction.NonInviteTransactionTimedOut += m_serverTransaction_NonInviteTransactionTimedOut;
m_serverTransaction.TransactionTraceMessage += TransactionTraceMessage;
m_serverTransaction.SendReliableRequest();
}
else
{
if (RouteSet == null || RouteSet.Length == 0)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "Forward leg failed, could not resolve URI host " + callURI.Host, Owner));
FireReferFailed(this, "unresolvable destination " + callURI.Host);
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "Forward leg failed, could not resolve top Route host " + RouteSet.TopRoute.Host, Owner));
FireReferFailed(this, "unresolvable destination " + RouteSet.TopRoute.Host);
}
}
}
catch (ApplicationException appExcp)
{
FireReferFailed(this, appExcp.Message);
}
catch (Exception excp)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.ReferUserAgentClient, SIPMonitorEventTypesEnum.Refer, "Exception UserAgentClient Call. " + excp.Message, Owner));
FireReferFailed(this, excp.Message);
}
}
void sipTransport1_SIPResponseInTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, SIPResponse sipResponse)
{
Console.WriteLine("Response Received: " + localEndPoint.ToString() + "<-" + fromEndPoint.ToString() + "\r\n" + sipResponse.ToString());
}
void sipTransport2_SIPRequestInTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, SIPRequest sipRequest)
{
Console.WriteLine("Request Received: " + localEndPoint.ToString() + "<-" + fromEndPoint.ToString() + "\r\n" + sipRequest.ToString());
}
private void ServerInformationResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Information response " + sipResponse.StatusCode + " " + sipResponse.ReasonPhrase + " for " + m_serverTransaction.TransactionRequest.URI.ToString() + ".", Owner));
if (m_callCancelled)
{
// Call was cancelled in the interim.
Cancel();
}
else
{
if (sipResponse.Status == SIPResponseStatusCodesEnum.Ringing || sipResponse.Status == SIPResponseStatusCodesEnum.SessionProgress)
{
FireCallRinging(this, sipResponse);
}
else
{
FireCallTrying(this, sipResponse);
}
}
}
public SIPDNSLookupEndPoint(SIPEndPoint sipEndPoint, int ttl)
{
LookupEndPoint = sipEndPoint;
TTL = ttl;
ResolvedAt = DateTime.Now;
}
private void ServerFinalResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
try
{
//if (Thread.CurrentThread.Name.IsNullOrBlank())
//{
// Thread.CurrentThread.Name = THREAD_NAME + DateTime.Now.ToString("HHmmss") + "-" + Crypto.GetRandomString(3);
//}
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Response " + sipResponse.StatusCode + " " + sipResponse.ReasonPhrase + " for " + m_serverTransaction.TransactionRequest.URI.ToString() + ".", Owner));
//m_sipTrace += "Received " + DateTime.Now.ToString("dd MMM yyyy HH:mm:ss") + " " + localEndPoint + "<-" + remoteEndPoint + "\r\n" + sipResponse.ToString();
m_serverTransaction.UACInviteTransactionInformationResponseReceived -= ServerInformationResponseReceived;
m_serverTransaction.UACInviteTransactionFinalResponseReceived -= ServerFinalResponseReceived;
m_serverTransaction.TransactionTraceMessage -= TransactionTraceMessage;
if (m_callCancelled && sipResponse.Status == SIPResponseStatusCodesEnum.RequestTerminated)
{
// No action required. Correctly received request terminated on an INVITE we cancelled.
}
else if (m_callCancelled)
{
#region Call has been cancelled, hangup.
if (m_hungupOnCancel)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "A cancelled call to " + m_sipCallDescriptor.Uri + " has been answered AND has already been hungup, no further action being taken.", Owner));
}
else
{
m_hungupOnCancel = true;
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "A cancelled call to " + m_sipCallDescriptor.Uri + " has been answered, hanging up.", Owner));
if (sipResponse.Header.Contact != null && sipResponse.Header.Contact.Count > 0)
{
SIPURI byeURI = sipResponse.Header.Contact[0].ContactURI;
SIPRequest byeRequest = GetByeRequest(sipResponse, byeURI, localSIPEndPoint);
//SIPEndPoint byeEndPoint = m_sipTransport.GetRequestEndPoint(byeRequest, m_outboundProxy, true);
// if (byeEndPoint != null)
// {
SIPNonInviteTransaction byeTransaction = m_sipTransport.CreateNonInviteTransaction(byeRequest, null, localSIPEndPoint, m_outboundProxy);
byeTransaction.SendReliableRequest();
// }
// else
// {
// Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Could not end BYE on cancelled call as request end point could not be determined " + byeRequest.URI.ToString(), Owner));
//}
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "No contact header provided on response for cancelled call to " + m_sipCallDescriptor.Uri + " no further action.", Owner));
}
}
#endregion
}
else if (sipResponse.Status == SIPResponseStatusCodesEnum.ProxyAuthenticationRequired || sipResponse.Status == SIPResponseStatusCodesEnum.Unauthorised)
{
#region Authenticate client call to third party server.
if (!m_callCancelled)
{
if (m_sipCallDescriptor.Password.IsNullOrBlank())
{
// No point trying to authenticate if there is no password to use.
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "Forward leg failed, authentication was requested but no credentials were available.", Owner));
FireCallFailed(this, "Authentication requested when no credentials available");
}
else if (m_serverAuthAttempts == 0)
{
m_serverAuthAttempts = 1;
// Resend INVITE with credentials.
string username = (m_sipCallDescriptor.AuthUsername != null && m_sipCallDescriptor.AuthUsername.Trim().Length > 0) ? m_sipCallDescriptor.AuthUsername : m_sipCallDescriptor.Username;
SIPAuthorisationDigest authRequest = sipResponse.Header.AuthenticationHeader.SIPDigest;
authRequest.SetCredentials(username, m_sipCallDescriptor.Password, m_sipCallDescriptor.Uri, SIPMethodsEnum.INVITE.ToString());
SIPRequest authInviteRequest = m_serverTransaction.TransactionRequest;
authInviteRequest.Header.AuthenticationHeader = new SIPAuthenticationHeader(authRequest);
authInviteRequest.Header.AuthenticationHeader.SIPDigest.Response = authRequest.Digest;
authInviteRequest.Header.Vias.TopViaHeader.Branch = CallProperties.CreateBranchId();
authInviteRequest.Header.CSeq = authInviteRequest.Header.CSeq + 1;
// Create a new UAC transaction to establish the authenticated server call.
var originalCallTransaction = m_serverTransaction;
m_serverTransaction = m_sipTransport.CreateUACTransaction(authInviteRequest, m_serverEndPoint, localSIPEndPoint, m_outboundProxy);
if (m_serverTransaction.CDR != null)
{
m_serverTransaction.CDR.Owner = Owner;
m_serverTransaction.CDR.AdminMemberId = AdminMemberId;
m_serverTransaction.CDR.DialPlanContextID = m_sipCallDescriptor.DialPlanContextID;
m_serverTransaction.CDR.Updated();
if (AccountCode != null)
{
#if !SILVERLIGHT
RtccUpdateCdr_External?.Invoke(originalCallTransaction.CDR?.CDRId.ToString(), m_serverTransaction.CDR);
#endif
}
logger.Debug("RTCC reservation was reallocated from CDR " + originalCallTransaction.CDR?.CDRId + " to " + m_serverTransaction.CDR?.CDRId + " for owner " + Owner + ".");
}
m_serverTransaction.UACInviteTransactionInformationResponseReceived += ServerInformationResponseReceived;
m_serverTransaction.UACInviteTransactionFinalResponseReceived += ServerFinalResponseReceived;
m_serverTransaction.UACInviteTransactionTimedOut += ServerTimedOut;
m_serverTransaction.TransactionTraceMessage += TransactionTraceMessage;
m_serverTransaction.SendInviteRequest(m_serverEndPoint, authInviteRequest);
}
else
{
FireCallFailed(this, "Authentication with provided credentials failed");
}
}
#endregion
}
else
{
if (sipResponse.StatusCode >= 200 && sipResponse.StatusCode <= 299)
{
if (sipResponse.Body.IsNullOrBlank())
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "Body on UAC response was empty.", Owner));
}
else if (m_sipCallDescriptor.ContentType == m_sdpContentType)
{
if (!m_sipCallDescriptor.MangleResponseSDP)
{
IPEndPoint sdpEndPoint = SDP.GetSDPRTPEndPoint(sipResponse.Body);
string sdpSocket = (sdpEndPoint != null) ? sdpEndPoint.ToString() : "could not determine";
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC response was set to NOT mangle, RTP socket " + sdpEndPoint.ToString() + ".", Owner));
}
else
{
//m_callInProgress = false; // the call is now established
//logger.Debug("Final response " + sipResponse.StatusCode + " " + sipResponse.ReasonPhrase + " for " + ForwardedTransaction.TransactionRequest.URI.ToString() + ".");
// Determine of response SDP should be mangled.
IPEndPoint sdpEndPoint = SDP.GetSDPRTPEndPoint(sipResponse.Body);
//Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "UAC response SDP was mangled from sdp=" + sdpEndPoint.Address.ToString() + ", proxyfrom=" + sipResponse.Header.ProxyReceivedFrom + ", mangle=" + m_sipCallDescriptor.MangleResponseSDP + ".", null));
if (sdpEndPoint != null)
{
if (!IPSocket.IsPrivateAddress(sdpEndPoint.Address.ToString()))
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC response had public IP not mangled, RTP socket " + sdpEndPoint.ToString() + ".", Owner));
}
else
{
bool wasSDPMangled = false;
string publicIPAddress = null;
if (!sipResponse.Header.ProxyReceivedFrom.IsNullOrBlank())
{
IPAddress remoteUASAddress = SIPEndPoint.ParseSIPEndPoint(sipResponse.Header.ProxyReceivedFrom).Address;
if (IPSocket.IsPrivateAddress(remoteUASAddress.ToString()) && m_sipCallDescriptor.MangleIPAddress != null)
{
// If the response has arrived here on a private IP address then it must be
// for a local version install and an incoming call that needs it's response mangled.
if(!IPSocket.IsPrivateAddress(m_sipCallDescriptor.MangleIPAddress.ToString()))
{
publicIPAddress = m_sipCallDescriptor.MangleIPAddress.ToString();
}
}
else
{
publicIPAddress = remoteUASAddress.ToString();
}
}
else if (!IPSocket.IsPrivateAddress(remoteEndPoint.Address.ToString()) && remoteEndPoint.Address != IPAddress.Any)
{
publicIPAddress = remoteEndPoint.Address.ToString();
}
else if (m_sipCallDescriptor.MangleIPAddress != null)
{
publicIPAddress = m_sipCallDescriptor.MangleIPAddress.ToString();
}
if (publicIPAddress != null)
{
sipResponse.Body = SIPPacketMangler.MangleSDP(sipResponse.Body, publicIPAddress, out wasSDPMangled);
}
if (wasSDPMangled)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC response had RTP socket mangled from " + sdpEndPoint.ToString() + " to " + publicIPAddress + ":" + sdpEndPoint.Port + ".", Owner));
}
else if (sdpEndPoint != null)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP on UAC response could not be mangled, RTP socket " + sdpEndPoint.ToString() + ".", Owner));
}
}
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.DialPlan, "SDP RTP socket on UAC response could not be determined.", Owner));
}
}
}
m_sipDialogue = new SIPDialogue(m_serverTransaction, Owner, AdminMemberId);
m_sipDialogue.CallDurationLimit = m_sipCallDescriptor.CallDurationLimit;
// Set switchboard dialogue values from the answered response or from dialplan set values.
//m_sipDialogue.SwitchboardCallerDescription = sipResponse.Header.SwitchboardCallerDescription;
m_sipDialogue.SwitchboardLineName = sipResponse.Header.SwitchboardLineName;
m_sipDialogue.CRMPersonName = sipResponse.Header.CRMPersonName;
m_sipDialogue.CRMCompanyName = sipResponse.Header.CRMCompanyName;
m_sipDialogue.CRMPictureURL = sipResponse.Header.CRMPictureURL;
if (m_sipCallDescriptor.SwitchboardHeaders != null)
{
//if (!m_sipCallDescriptor.SwitchboardHeaders.SwitchboardDialogueDescription.IsNullOrBlank())
//{
// m_sipDialogue.SwitchboardDescription = m_sipCallDescriptor.SwitchboardHeaders.SwitchboardDialogueDescription;
//}
m_sipDialogue.SwitchboardLineName = m_sipCallDescriptor.SwitchboardHeaders.SwitchboardLineName;
m_sipDialogue.SwitchboardOwner = m_sipCallDescriptor.SwitchboardHeaders.SwitchboardOwner;
}
}
FireCallAnswered(this, sipResponse);
}
}
catch (Exception excp)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.Error, "Exception ServerFinalResponseReceived. " + excp.Message, Owner));
}
}
//private void ByeFinalResponseReceived(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
//{
// Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.UserAgentClient, SIPMonitorEventTypesEnum.DialPlan, "BYE response " + sipResponse.StatusCode + " " + sipResponse.ReasonPhrase + ".", Owner));
//}
private SIPRequest GetInviteRequest(SIPCallDescriptor sipCallDescriptor, string branchId, string callId, SIPEndPoint localSIPEndPoint, SIPRouteSet routeSet, string content, string contentType)
{
SIPRequest inviteRequest = new SIPRequest(SIPMethodsEnum.INVITE, sipCallDescriptor.Uri);
inviteRequest.LocalSIPEndPoint = localSIPEndPoint;
SIPHeader inviteHeader = new SIPHeader(sipCallDescriptor.GetFromHeader(), SIPToHeader.ParseToHeader(sipCallDescriptor.To), 1, callId);
inviteHeader.From.FromTag = CallProperties.CreateNewTag();
// For incoming calls forwarded via the dial plan the username needs to go into the Contact header.
inviteHeader.Contact = new List<SIPContactHeader>() { new SIPContactHeader(null, new SIPURI(inviteRequest.URI.Scheme, localSIPEndPoint)) };
inviteHeader.Contact[0].ContactURI.User = sipCallDescriptor.Username;
inviteHeader.CSeqMethod = SIPMethodsEnum.INVITE;
inviteHeader.UserAgent = m_userAgent;
inviteHeader.Routes = routeSet;
inviteRequest.Header = inviteHeader;
if (!sipCallDescriptor.ProxySendFrom.IsNullOrBlank())
{
inviteHeader.ProxySendFrom = sipCallDescriptor.ProxySendFrom;
}
SIPViaHeader viaHeader = new SIPViaHeader(localSIPEndPoint, branchId);
inviteRequest.Header.Vias.PushViaHeader(viaHeader);
inviteRequest.Body = content;
inviteRequest.Header.ContentLength = (inviteRequest.Body != null) ? inviteRequest.Body.Length : 0;
inviteRequest.Header.ContentType = contentType;
// Add custom switchboard headers.
if (CallDescriptor.SwitchboardHeaders != null)
{
inviteHeader.SwitchboardOriginalCallID = CallDescriptor.SwitchboardHeaders.SwitchboardOriginalCallID;
//inviteHeader.SwitchboardCallerDescription = CallDescriptor.SwitchboardHeaders.SwitchboardCallerDescription;
inviteHeader.SwitchboardLineName = CallDescriptor.SwitchboardHeaders.SwitchboardLineName;
//inviteHeader.SwitchboardOwner = CallDescriptor.SwitchboardHeaders.SwitchboardOwner;
//inviteHeader.SwitchboardOriginalFrom = CallDescriptor.SwitchboardHeaders.SwitchboardOriginalFrom;
}
// Add custom CRM headers.
if (CallDescriptor.CRMHeaders != null)
{
inviteHeader.CRMPersonName = CallDescriptor.CRMHeaders.PersonName;
inviteHeader.CRMCompanyName = CallDescriptor.CRMHeaders.CompanyName;
inviteHeader.CRMPictureURL = CallDescriptor.CRMHeaders.AvatarURL;
}
try
{
if (sipCallDescriptor.CustomHeaders != null && sipCallDescriptor.CustomHeaders.Count > 0)
{
foreach (string customHeader in sipCallDescriptor.CustomHeaders)
{
if (customHeader.IsNullOrBlank())
{
continue;
}
else if (customHeader.Trim().StartsWith(SIPHeaders.SIP_HEADER_USERAGENT))
{
inviteRequest.Header.UserAgent = customHeader.Substring(customHeader.IndexOf(":") + 1).Trim();
}
else
{
inviteRequest.Header.UnknownHeaders.Add(customHeader);
}
}
}
}
catch (Exception excp)
{
logger.Error("Exception Parsing CustomHeader for GetInviteRequest. " + excp.Message + sipCallDescriptor.CustomHeaders);
}
return inviteRequest;
}
private SIPRequest GetByeRequest(SIPResponse inviteResponse, SIPURI byeURI, SIPEndPoint localSIPEndPoint)
{
SIPRequest byeRequest = new SIPRequest(SIPMethodsEnum.BYE, byeURI);
byeRequest.LocalSIPEndPoint = localSIPEndPoint;
SIPFromHeader byeFromHeader = inviteResponse.Header.From;
SIPToHeader byeToHeader = inviteResponse.Header.To;
int cseq = inviteResponse.Header.CSeq + 1;
SIPHeader byeHeader = new SIPHeader(byeFromHeader, byeToHeader, cseq, inviteResponse.Header.CallId);
byeHeader.CSeqMethod = SIPMethodsEnum.BYE;
byeHeader.ProxySendFrom = m_serverTransaction.TransactionRequest.Header.ProxySendFrom;
byeRequest.Header = byeHeader;
byeRequest.Header.Routes = (inviteResponse.Header.RecordRoutes != null) ? inviteResponse.Header.RecordRoutes.Reversed() : null;
SIPViaHeader viaHeader = new SIPViaHeader(localSIPEndPoint, CallProperties.CreateBranchId());
byeRequest.Header.Vias.PushViaHeader(viaHeader);
return byeRequest;
}
private SIPRequest GetReferRequest(SIPEndPoint localSIPEndPoint, SIPURI referTo, ReplacesCallDescriptor sipReplacesCallDescriptor)
{
SIPRequest referRequest = new SIPRequest(SIPMethodsEnum.REFER, m_sipCallDescriptor.Uri);
SIPFromHeader referFromHeader = SIPFromHeader.ParseFromHeader(m_sipCallDescriptor.From);
SIPToHeader referToHeader = SIPToHeader.ParseToHeader(m_sipCallDescriptor.Uri);
int cseq = ++CSeq;
CallId = CallProperties.CreateNewCallId();
SIPHeader referHeader = new SIPHeader(referFromHeader, referToHeader, cseq, CallId);
referHeader.CSeqMethod = SIPMethodsEnum.REFER;
referRequest.Header = referHeader;
referRequest.Header.Routes = RouteSet;
referRequest.Header.ProxySendFrom = m_sipCallDescriptor.ProxySendFrom;
if (sipReplacesCallDescriptor != null)
{
referTo.Headers.Set("Replaces", sipReplacesCallDescriptor.GetUrlEncodedReplacesUriHeader());
referRequest.Header.ReferTo = referTo.ToString();
}
else
{
referRequest.Header.ReferTo = referTo.ToString();
}
// "Requires" Header
referRequest.Header.Require = (String.IsNullOrWhiteSpace(referRequest.Header.Require)) ? "replaces" : referRequest.Header.Require + ",replaces";
SIPViaHeader viaHeader = new SIPViaHeader(localSIPEndPoint, CallProperties.CreateBranchId());
referRequest.Header.Vias.PushViaHeader(viaHeader);
return referRequest;
}
/// <summary>
/// Use to cause a mock message to be passed through to the SIP Transport class monitoring this mock channel.
/// </summary>
public void FireMessageReceived(SIPEndPoint localEndPoint, SIPEndPoint remoteEndPoint, byte[] sipMsgBuffer)
{
SIPMessageReceived.Invoke(this, localEndPoint, remoteEndPoint, sipMsgBuffer);
}
public SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum serverType, SIPMonitorEventTypesEnum eventType, string message, SIPEndPoint serverSocket, SIPEndPoint fromSocket, SIPEndPoint toSocket)
{
m_serialisationPrefix = SERIALISATION_PREFIX;
ClientType = SIPMonitorClientTypesEnum.Console;
ServerType = serverType;
EventType = eventType;
Message = message;
ServerEndPoint = serverSocket;
RemoteEndPoint = fromSocket;
DestinationEndPoint = toSocket;
Created = DateTimeOffset.UtcNow;
#if !SILVERLIGHT
ProcessID = Process.GetCurrentProcess().Id;
#endif
}
public override Task <SocketError> SendSecureAsync(SIPEndPoint destinationEndPoint, byte[] buffer, string serverCertificate, string connectionIDHint)
{
throw new NotImplementedException();
}
public void Load(DataRow row)
{
try
{
Id = new Guid(row["id"] as string);
SIPAccountId = new Guid(row["sipaccountid"] as string);
SIPAccountName = row["sipaccountname"] as string;
Owner = row["owner"] as string;
AdminMemberId = row["adminmemberid"] as string;
UserAgent = row["useragent"] as string;
m_contactURI = SIPURI.ParseSIPURI(row["contacturi"] as string);
m_mangledContactURI = (!(row["mangledcontacturi"] as string).IsNullOrBlank()) ? SIPURI.ParseSIPURI(row["mangledcontacturi"] as string) : null;
Expiry = Convert.ToInt32(row["expiry"]);
RemoteSIPEndPoint = (!(row["remotesipsocket"] as string).IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(row["remotesipsocket"] as string) : null;
m_proxySIPEndPoint = (!(row["proxysipsocket"] as string).IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(row["proxysipsocket"] as string) : null;
m_registrarSIPEndPoint = (!(row["registrarsipsocket"] as string).IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(row["registrarsipsocket"] as string) : null;
LastUpdate = DateTimeOffset.Parse(row["lastupdate"] as string);
}
catch (Exception excp)
{
logger.Error("Exception SIPRegistrarBinding Load. " + 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.");
}
void sipTransport2_SIPResponseOutTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint toEndPoint, SIPResponse sipResponse)
{
Console.WriteLine("Response Sent: " + localEndPoint.ToString() + "<-" + toEndPoint.ToString() + "\r\n" + sipResponse.ToString());
}
public SIPClientUserAgent(
SIPTransport sipTransport,
SIPEndPoint outboundProxy,
string owner,
string adminMemberId,
SIPMonitorLogDelegate logDelegate,
RtccGetCustomerDelegate rtccGetCustomer,
RtccGetRateDelegate rtccGetRate,
RtccGetBalanceDelegate rtccGetBalance,
RtccReserveInitialCreditDelegate rtccReserveInitialCredit,
RtccUpdateCdrDelegate rtccUpdateCdr
)
: this(sipTransport, outboundProxy, owner, adminMemberId, logDelegate)
{
RtccGetCustomer_External = rtccGetCustomer;
RtccGetRate_External = rtccGetRate;
RtccGetBalance_External = rtccGetBalance;
RtccReserveInitialCredit_External = rtccReserveInitialCredit;
RtccUpdateCdr_External = rtccUpdateCdr;
}
void sipTransport1_SIPRequestOutTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint toEndPoint, SIPRequest sipRequest)
{
Console.WriteLine("Request Sent: " + localEndPoint.ToString() + "<-" + toEndPoint.ToString() + "\r\n" + sipRequest.ToString());
}
private void AddNATKeepAliveJob(SIPAccount sipAccount, SIPEndPoint remoteSIPEndPoint, SIPEndPoint proxySIPEndPoint, SIPRegistrarBinding binding, int bindingExpiry)
{
try
{
lock (m_natKeepAliveJobs)
{
if (m_natKeepAliveJobs.ContainsKey(binding.RemoteSIPSocket))
{
//logger.Debug("Updating NAT keep-alive job for binding socket " + binding.RemoteSIPSocket + ".");
m_natKeepAliveJobs[binding.RemoteSIPSocket].Update(proxySIPEndPoint, DateTime.Now.AddSeconds(bindingExpiry));
}
else
{
//logger.Debug("Adding NAT keep-alive job for binding socket " + binding.RemoteSIPSocket + ".");
m_natKeepAliveJobs.Add(binding.RemoteSIPSocket, new NATKeepAliveJob(proxySIPEndPoint, remoteSIPEndPoint, DateTime.Now.AddSeconds(bindingExpiry), sipAccount.Owner));
}
}
}
catch (Exception natAddExcp)
{
logger.Error("Exception AddNATKeepAliveJob for SIP account " + sipAccount.SIPUsername + ". " + natAddExcp.Message);
}
}
/// <summary>
/// Gets a serialised HEP packet for a SIP request or response that can be sent to a HOMER server.
/// </summary>
/// <param name="srcEndPoint">The end point that sent the SIP request or response.</param>
/// <param name="dstEndPoint">The end point that the SIP request or response was sent to.</param>
/// <param name="timestamp">The timestamp the request or response was generated.</param>
/// <param name="agentID">An agent ID that is used by the HOMER server to identify the agent generating
/// HEP packets. Ideally should be unique amongst all agents logging to the same HOMER server.</param>
/// <param name="password">The password required by the HOMER server. Can be set to null if no password
/// is required. Default value for HOMER5 and 7 is 'myHep".</param>
/// <param name="payload">The SIP request or response.</param>
/// <returns>An array of bytes representing the serialised HEP packet and that is ready for transmission
/// to a HOMER server.</returns>
public static byte[] GetBytes(SIPEndPoint srcEndPoint, SIPEndPoint dstEndPoint, DateTime timestamp,
uint agentID, string password, string payload)
{
byte[] packetBuffer = new byte[MAX_HEP_PACKET_LENGTH];
int offset = 0;
// HEP3 ASCII code to start the packet.
packetBuffer[0] = 0x48;
packetBuffer[1] = 0x45;
packetBuffer[2] = 0x50;
packetBuffer[3] = 0x33;
offset = 6;
// IP family.
var familyChunkBuffer = HepChunk.GetBytes(ChunkTypeEnum.IPFamily, (byte)srcEndPoint.Address.AddressFamily);
Buffer.BlockCopy(familyChunkBuffer, 0, packetBuffer, offset, familyChunkBuffer.Length);
offset += familyChunkBuffer.Length;
// IP transport layer protocol.
var protocolChunkBuffer =
HepChunk.GetBytes(ChunkTypeEnum.IPProtocolID, GetProtocolNumber(srcEndPoint.Protocol));
Buffer.BlockCopy(protocolChunkBuffer, 0, packetBuffer, offset, protocolChunkBuffer.Length);
offset += protocolChunkBuffer.Length;
// Source IP address.
ChunkTypeEnum srcChunkType = srcEndPoint.Address.AddressFamily == AddressFamily.InterNetwork
? ChunkTypeEnum.IPv4SourceAddress
: ChunkTypeEnum.IPv6SourceAddress;
var srcIPAddress = HepChunk.GetBytes(srcChunkType, srcEndPoint.Address);
Buffer.BlockCopy(srcIPAddress, 0, packetBuffer, offset, srcIPAddress.Length);
offset += srcIPAddress.Length;
// Destination IP address.
ChunkTypeEnum dstChunkType = dstEndPoint.Address.AddressFamily == AddressFamily.InterNetwork
? ChunkTypeEnum.IPv4DesinationAddress
: ChunkTypeEnum.IPv6DesinationAddress;
var dstIPAddress = HepChunk.GetBytes(dstChunkType, dstEndPoint.Address);
Buffer.BlockCopy(dstIPAddress, 0, packetBuffer, offset, dstIPAddress.Length);
offset += dstIPAddress.Length;
// Source port.
var srcPortBuffer = HepChunk.GetBytes(ChunkTypeEnum.SourcePort, (ushort)srcEndPoint.Port);
Buffer.BlockCopy(srcPortBuffer, 0, packetBuffer, offset, srcPortBuffer.Length);
offset += srcPortBuffer.Length;
// Destination port.
var dstPortBuffer = HepChunk.GetBytes(ChunkTypeEnum.DestinationPort, (ushort)dstEndPoint.Port);
Buffer.BlockCopy(dstPortBuffer, 0, packetBuffer, offset, dstPortBuffer.Length);
offset += dstPortBuffer.Length;
// Timestamp.
var timestampBuffer = HepChunk.GetBytes(ChunkTypeEnum.TimestampSeconds, (uint)timestamp.GetEpoch());
Buffer.BlockCopy(timestampBuffer, 0, packetBuffer, offset, timestampBuffer.Length);
offset += timestampBuffer.Length;
// Timestamp micro seconds (.NET only has millisecond resolution).
var timestampMicrosBuffer =
HepChunk.GetBytes(ChunkTypeEnum.TimestampMicroSeconds, (uint)(timestamp.Millisecond * 1000));
Buffer.BlockCopy(timestampMicrosBuffer, 0, packetBuffer, offset, timestampMicrosBuffer.Length);
offset += timestampMicrosBuffer.Length;
// Protocol type, only interested in SIP at this point.
var protocolTypeBuffer = HepChunk.GetBytes(ChunkTypeEnum.ProtocolType, (byte)CaptureProtocolTypeEnum.SIP);
Buffer.BlockCopy(protocolTypeBuffer, 0, packetBuffer, offset, protocolTypeBuffer.Length);
offset += protocolTypeBuffer.Length;
// Capture agent ID.
var agentIDBuffer = HepChunk.GetBytes(ChunkTypeEnum.CaptureAgentID, agentID);
Buffer.BlockCopy(agentIDBuffer, 0, packetBuffer, offset, agentIDBuffer.Length);
offset += agentIDBuffer.Length;
// Auth key
if (!String.IsNullOrEmpty(password))
{
var passwordBuffer =
HepChunk.GetBytes(ChunkTypeEnum.AuthenticationKey, Encoding.UTF8.GetBytes(password));
Buffer.BlockCopy(passwordBuffer, 0, packetBuffer, offset, passwordBuffer.Length);
offset += passwordBuffer.Length;
}
// Payload
var payloadBuffer = HepChunk.GetBytes(ChunkTypeEnum.CapturedPayload, Encoding.UTF8.GetBytes(payload));
// If we don't have enough space left truncate the payload.
int payloadLength = (payloadBuffer.Length > packetBuffer.Length - offset)
? packetBuffer.Length - offset
: payloadBuffer.Length;
Buffer.BlockCopy(payloadBuffer, 0, packetBuffer, offset, payloadLength);
offset += payloadLength;
// Length
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian((ushort)offset)), 0, packetBuffer, 4,
2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes((ushort)offset), 0, packetBuffer, 4, 2);
}
return(packetBuffer.Take(offset).ToArray());
}
public void Update(SIPEndPoint proxyEndPoint, DateTime endTime)
{
ProxyEndPoint = proxyEndPoint;
NextSendTime = null;
EndTime = endTime;
}
public override Task <SocketError> SendAsync(SIPEndPoint destinationEndPoint, byte[] buffer, string connectionIDHint)
{
LastSIPMessageSent = System.Text.Encoding.UTF8.GetString(buffer);
SIPMessageSent.Set();
return(Task.FromResult(SocketError.Success));
}
public async Task HangupUserAgentUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
SIPTransport transport = new SIPTransport(false, MockSIPDNSManager.Resolve);
MockSIPChannel mockChannel = new MockSIPChannel(new System.Net.IPEndPoint(IPAddress.Any, 0));
transport.AddSIPChannel(mockChannel);
SIPUserAgent userAgent = new SIPUserAgent(transport, null);
string inviteReqStr = "INVITE sip:192.168.11.50:5060 SIP/2.0" + m_CRLF +
"Via: SIP/2.0/UDP 192.168.11.50:60163;rport;branch=z9hG4bKPj869f70960bdd4204b1352eaf242a3691" + m_CRLF +
"To: <sip:[email protected]>;tag=ZUJSXRRGXQ" + m_CRLF +
"From: <sip:[email protected]>;tag=4a60ce364b774258873ff199e5e39938" + m_CRLF +
"Call-ID: 17324d6df8744d978008c8997bfd208d" + m_CRLF +
"CSeq: 3532 INVITE" + m_CRLF +
"Contact: <sip:[email protected]:60163;ob>" + m_CRLF +
"Max-Forwards: 70" + m_CRLF +
"User-Agent: MicroSIP/3.19.22" + m_CRLF +
"Allow: PRACK, INVITE, ACK, BYE, CANCEL, UPDATE, INFO, SUBSCRIBE, NOTIFY, REFER, MESSAGE, OPTIONS" + m_CRLF +
"Supported: replaces, 100rel, timer, norefersub" + m_CRLF +
"Content-Length: 343" + m_CRLF +
"Content-Type: application/sdp" + m_CRLF +
"Session-Expires: 1800" + m_CRLF +
"Min-SE: 90" + m_CRLF +
"" + m_CRLF +
"v=0" + m_CRLF +
"o=- 3785527268 3785527269 IN IP4 192.168.11.50" + m_CRLF +
"s=pjmedia" + m_CRLF +
"t=0 0" + m_CRLF +
"m=audio 4032 RTP/AVP 0 101" + m_CRLF +
"c=IN IP4 192.168.11.50" + m_CRLF +
"a=rtpmap:0 PCMU/8000" + m_CRLF +
"a=rtpmap:101 telephone-event/8000" + m_CRLF +
"a=fmtp:101 0-16" + m_CRLF +
"a=sendrecv";
SIPEndPoint dummySipEndPoint = new SIPEndPoint(new IPEndPoint(IPAddress.Loopback, 0));
SIPMessageBuffer sipMessageBuffer = SIPMessageBuffer.ParseSIPMessage(inviteReqStr, dummySipEndPoint, dummySipEndPoint);
SIPRequest inviteReq = SIPRequest.ParseSIPRequest(sipMessageBuffer);
UASInviteTransaction uasTx = new UASInviteTransaction(transport, inviteReq, null);
SIPServerUserAgent mockUas = new SIPServerUserAgent(transport, null, null, null, SIPCallDirection.In, null, null, null, uasTx);
await userAgent.Answer(mockUas, CreateMediaSession());
// Incremented Cseq and modified Via header from original request. Means the request is the same dialog but different tx.
string inviteReqStr2 = "BYE sip:192.168.11.50:5060 SIP/2.0" + m_CRLF +
"Via: SIP/2.0/UDP 192.168.11.50:60163;rport;branch=z9hG4bKPj869f70960bdd4204b1352eaf242a3700" + m_CRLF +
"To: <sip:[email protected]>;tag=ZUJSXRRGXQ" + m_CRLF +
"From: <sip:[email protected]>;tag=4a60ce364b774258873ff199e5e39938" + m_CRLF +
"Call-ID: 17324d6df8744d978008c8997bfd208d" + m_CRLF +
"CSeq: 3533 BYE" + m_CRLF +
"Contact: <sip:[email protected]:60163;ob>" + m_CRLF +
"Max-Forwards: 70" + m_CRLF +
"User-Agent: MicroSIP/3.19.22" + m_CRLF +
"Allow: PRACK, INVITE, ACK, BYE, CANCEL, UPDATE, INFO, SUBSCRIBE, NOTIFY, REFER, MESSAGE, OPTIONS" + m_CRLF +
"Supported: replaces, 100rel, timer, norefersub" + m_CRLF +
"";
mockChannel.FireMessageReceived(dummySipEndPoint, dummySipEndPoint, Encoding.UTF8.GetBytes(inviteReqStr2));
}
public override bool HasConnection(SIPEndPoint remoteEndPoint)
{
throw new NotImplementedException();
}
public async Task IncomingCallNoSdpWithACKUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
SIPTransport transport = new SIPTransport();
transport.AddSIPChannel(new MockSIPChannel(new System.Net.IPEndPoint(IPAddress.Any, 0)));
var dummySep = SIPEndPoint.ParseSIPEndPoint("udp:127.0.0.1:5060");
SIPUserAgent userAgent = new SIPUserAgent(transport, null);
string inviteReqStr = @"INVITE sip:[email protected] SIP/2.0
Via: SIP/2.0/UDP 127.0.0.1:51200;branch=z9hG4bKbeed9b0cde8d43cc8a2aae91526b6a1d;rport
To: <sip:[email protected]>
From: <sip:[email protected]>;tag=GCLNRILCDU
Call-ID: 7265e19f53a146a1bacdf4f4f8ea70b2
CSeq: 1 INVITE
Contact: <sip:127.0.0.1:51200>
Max-Forwards: 70
User-Agent: www.sipsorcery.com
Content-Length: 0
Content-Type: application/sdp" + m_CRLF + m_CRLF;
SIPEndPoint dummySipEndPoint = new SIPEndPoint(new IPEndPoint(IPAddress.Loopback, 0));
SIPMessageBuffer sipMessageBuffer = SIPMessageBuffer.ParseSIPMessage(inviteReqStr, dummySipEndPoint, dummySipEndPoint);
SIPRequest inviteReq = SIPRequest.ParseSIPRequest(sipMessageBuffer);
var uas = userAgent.AcceptCall(inviteReq);
var mediaSession = CreateMediaSession();
_ = Task.Run(() =>
{
Task.Delay(2000).Wait();
string ackReqStr = @"ACK sip:127.0.0.1:5060 SIP/2.0
Via: SIP/2.0/UDP 127.0.0.1:51200;branch=z9hG4bK76dfb1480ea14f778bd24afed1c8ded0;rport
To: <sip:[email protected]>;tag=YWPNZPMLPB
From: <sip:[email protected]>;tag=GCLNRILCDU
Call-ID: 7265e19f53a146a1bacdf4f4f8ea70b2
CSeq: 1 ACK
Max-Forwards: 70
Content-Length: 160
v=0
o=- 67424 0 IN IP4 127.0.0.1
s=-
c=IN IP4 127.0.0.1
t=0 0
m=audio 16976 RTP/AVP 8 101
a=rtpmap:101 telephone-event/8000
a=fmtp:101 0-16
a=sendrecv" + m_CRLF + m_CRLF;
uas.ClientTransaction.ACKReceived(dummySep, dummySep, SIPRequest.ParseSIPRequest(ackReqStr));
});
await userAgent.Answer(uas, mediaSession);
Assert.True(userAgent.IsCallActive);
}
private void UASInviteTransaction_TransactionRequestReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPRequest sipRequest)
{
try
{
if (TransactionState == SIPTransactionStatesEnum.Terminated)
{
logger.Debug("Request received by UASInviteTransaction for a terminated transaction, ignoring.");
}
else if (sipRequest.Method != SIPMethodsEnum.INVITE)
{
logger.Warn("Unexpected " + sipRequest.Method + " passed to UASInviteTransaction.");
}
else
{
if (TransactionState != SIPTransactionStatesEnum.Trying)
{
SIPResponse tryingResponse = GetInfoResponse(m_transactionRequest, SIPResponseStatusCodesEnum.Trying);
SendInformationalResponse(tryingResponse);
}
// Notify new call subscribers.
if (NewCallReceived != null)
{
NewCallReceived(localSIPEndPoint, remoteEndPoint, this, sipRequest);
}
else
{
// Nobody wants the call so return an error response.
SIPResponse declinedResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.Decline, "Nothing listening");
SendFinalResponse(declinedResponse);
}
}
}
catch (Exception excp)
{
logger.Error("Exception UASInviteTransaction GotRequest. " + excp.Message);
}
}
/// <summary>
/// Handles responses to our re-INVITE requests.
/// </summary>
/// <param name="localSIPEndPoint">The local end point the response was received on.</param>
/// <param name="remoteEndPoint">The remote end point the response came from.</param>
/// <param name="sipTransaction">The UAS transaction the response is part of.</param>
/// <param name="sipResponse">The SIP response.</param>
private Task <SocketError> ReinviteRequestFinalResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
if (sipResponse.Status == SIPResponseStatusCodesEnum.Ok)
{
// Update the remote party's SDP.
Dialogue.RemoteSDP = sipResponse.Body;
MediaSession.setRemoteDescription(new RTCSessionDescription {
sdp = SDP.ParseSDPDescription(sipResponse.Body), type = RTCSdpType.answer
});
}
else
{
logger.LogWarning($"Re-INVITE request failed with response {sipResponse.ShortDescription}.");
}
return(Task.FromResult(SocketError.Success));
}
private static Task OnSIPTransportRequestReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest sipRequest)
{
if (sipRequest.Method == SIPMethodsEnum.INFO)
{
var notImplResp = SIPResponse.GetResponse(sipRequest, SIPResponseStatusCodesEnum.NotImplemented, null);
return(_sipTransport.SendResponseAsync(notImplResp));
}
return(Task.CompletedTask);
}
public void Load(DataRow cdrRow)
{
m_sipCDR = new SIPCDR();
m_sipCDR.CDRId = new Guid(cdrRow["id"] as string);
m_sipCDR.Owner = cdrRow["owner"] as string;
m_sipCDR.AdminMemberId = cdrRow["adminmemberid"] as string;
Inserted = DateTimeOffset.Parse(cdrRow["inserted"] as string);
m_sipCDR.CallDirection = (cdrRow["direction"] as string == SIPCallDirection.In.ToString()) ? SIPCallDirection.In : SIPCallDirection.Out;
Created = DateTimeOffset.Parse(cdrRow["created"] as string);
m_sipCDR.Destination = SIPURI.ParseSIPURI(cdrRow["dsturi"] as string);
m_sipCDR.From = SIPFromHeader.ParseFromHeader(cdrRow["fromheader"] as string);
m_sipCDR.CallId = cdrRow["callid"] as string;
m_sipCDR.LocalSIPEndPoint = (!(cdrRow["localsocket"] as string).IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(cdrRow["localsocket"] as string) : null;
m_sipCDR.RemoteEndPoint = (!(cdrRow["remotesocket"] as string).IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(cdrRow["remotesocket"] as string) : null;
m_sipCDR.BridgeId = (!(cdrRow["bridgeid"] as string).IsNullOrBlank()) ? new Guid(cdrRow["bridgeid"] as string) : Guid.Empty;
if (cdrRow["inprogresstime"] != DBNull.Value && cdrRow["inprogresstime"] != null && !(cdrRow["inprogresstime"] as string).IsNullOrBlank())
{
InProgressTime = DateTimeOffset.Parse(cdrRow["inprogresstime"] as string);
}
else
{
InProgressTime = null;
}
m_sipCDR.ProgressStatus = (cdrRow["inprogressstatus"] != null && cdrRow["inprogressstatus"] != DBNull.Value) ? Convert.ToInt32(cdrRow["inprogressstatus"]) : 0;
m_sipCDR.ProgressReasonPhrase = cdrRow["inprogressreason"] as string;
if (cdrRow["answeredtime"] != DBNull.Value && cdrRow["answeredtime"] != null && !(cdrRow["answeredtime"] as string).IsNullOrBlank())
{
AnsweredTime = DateTimeOffset.Parse(cdrRow["answeredtime"] as string);
}
else
{
AnsweredTime = null;
}
m_sipCDR.AnswerStatus = (cdrRow["answeredstatus"] != DBNull.Value && cdrRow["answeredstatus"] != null) ? Convert.ToInt32(cdrRow["answeredstatus"]) : 0;
m_sipCDR.AnswerReasonPhrase = cdrRow["answeredreason"] as string;
if (cdrRow["hunguptime"] != DBNull.Value && cdrRow["hunguptime"] != null && !(cdrRow["hunguptime"] as string).IsNullOrBlank())
{
HungupTime = DateTimeOffset.Parse(cdrRow["hunguptime"] as string);
}
else
{
HungupTime = null;
}
m_sipCDR.HangupReason = cdrRow["hungupreason"] as string;
m_sipCDR.InProgress = (m_sipCDR.ProgressTime != null);
m_sipCDR.IsAnswered = (m_sipCDR.AnswerTime != null);
m_sipCDR.IsHungup = (m_sipCDR.HangupTime != null);
if (cdrRow["answeredat"] != DBNull.Value && cdrRow["answeredat"] != null)
{
AnsweredAt = (DateTime)cdrRow["answeredat"];
}
m_sipCDR.DialPlanContextID = (!(cdrRow["dialplancontextid"] as string).IsNullOrBlank()) ? new Guid(cdrRow["dialplancontextid"] as string) : Guid.Empty;
}
void transport_UnrecognisedMessageReceived(SIPEndPoint localEndPoint, SIPEndPoint fromEndPoint, byte[] buffer)
{
Console.WriteLine("Unrecognised: " + localEndPoint + "<-" + fromEndPoint.ToString() + " " + buffer.Length + " bytes.");
}
public bool ShowEvent(SIPMonitorEventTypesEnum eventType, SIPEndPoint serverEndPoint)
{
if (EventTypeId != 0)
{
if ((int)eventType == EventTypeId)
{
return(true);
}
else
{
return(false);
}
}
else
{
if (EventFilterDescr == EVENTTYPE_FULL_VALUE && eventType == SIPMonitorEventTypesEnum.FullSIPTrace)
{
// if (serverEndPoint != null && serverEndPoint.SocketEndPoint.Address.ToString() == "127.0.0.1") {
// return false;
// }
//else {
return(true);
// }
}
else if (EventFilterDescr == EVENTTYPE_SYSTEM_VALUE)
{
// Assume EVENTTYPE_ALL_VALUE.
if (eventType == SIPMonitorEventTypesEnum.Monitor ||
eventType == SIPMonitorEventTypesEnum.HealthCheck ||
eventType == SIPMonitorEventTypesEnum.ParseSIPMessage ||
eventType == SIPMonitorEventTypesEnum.SIPMessageArrivalStats)
{
return(true);
}
else
{
return(false);
}
}
else if (EventFilterDescr == EVENTTYPE_TROUBLE_VALUE)
{
// Assume EVENTTYPE_ALL_VALUE.
if (eventType == SIPMonitorEventTypesEnum.Error ||
eventType == SIPMonitorEventTypesEnum.Warn ||
eventType == SIPMonitorEventTypesEnum.BadSIPMessage)
{
return(true);
}
else
{
return(false);
}
}
else
{
// Assume EVENTTYPE_ALL_VALUE if nothing has been specified by the user, however do not display the full SIP trace messages.
if (EventFilterDescr == WILDCARD && eventType != SIPMonitorEventTypesEnum.FullSIPTrace && eventType != SIPMonitorEventTypesEnum.UserSpecificSIPTrace)
{
return(true);
}
else
{
return(false);
}
}
}
}
void transport_SIPRequestOutTraceEvent(SIPEndPoint localEndPoint, SIPEndPoint toEndPoint, SIPRequest sipRequest)
{
Console.WriteLine("Request Out: " + localEndPoint + "->" + toEndPoint.ToString() + "\n" + sipRequest.ToString());
}
public void BlockIPAddressUnitTest()
{
Console.WriteLine("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
SIPMonitorFilter filter = new SIPMonitorFilter("ipaddress 127.0.0.1 and event full");
Console.WriteLine(filter.GetFilterDescription());
Assert.IsTrue(filter != null, "The filter was not correctly instantiated.");
Assert.AreEqual(filter.IPAddress, "127.0.0.1", "The filter ip address was not correctly set.");
SIPMonitorEvent monitorEvent = new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.FullSIPTrace, "blah blah", String.Empty, SIPEndPoint.ParseSIPEndPoint("127.0.0.2"), null);
bool showEventResult = filter.ShowSIPMonitorEvent(monitorEvent);
Assert.IsFalse(showEventResult, "The filter should not have shown this event.");
}
public void Load(DataRow bindingRow)
{
try {
m_id = (bindingRow.Table.Columns.Contains("id") && bindingRow["id"] != DBNull.Value && bindingRow["id"] != null) ? new Guid(bindingRow["id"] as string) : Guid.NewGuid();
m_providerId = new Guid(bindingRow["providerid"] as string);
ProviderName = bindingRow["providername"] as string;
m_owner = bindingRow["owner"] as string;
AdminMemberId = bindingRow["adminmemberid"] as string;
m_isRegistered = (bindingRow.Table.Columns.Contains("isregistered") && bindingRow["isregistered"] != DBNull.Value && bindingRow["isregistered"] != null) ? Convert.ToBoolean(bindingRow["isregistered"]) : false;
if (bindingRow.Table.Columns.Contains("bindinguri") && bindingRow["bindinguri"] != DBNull.Value && bindingRow["bindinguri"] != null && !bindingRow["bindinguri"].ToString().IsNullOrBlank()) {
m_bindingURI = SIPURI.ParseSIPURI(bindingRow["bindinguri"] as string);
}
else {
logger.Warn("Could not load BindingURI for SIPProviderBinding with id=" + m_id + ".");
}
if (bindingRow.Table.Columns.Contains("bindingexpiry") && bindingRow["bindingexpiry"] != DBNull.Value && bindingRow["bindingexpiry"] != null) {
m_bindingExpiry = Convert.ToInt32(bindingRow["bindingexpiry"]);
}
if (bindingRow.Table.Columns.Contains("cseq") && bindingRow["cseq"] != DBNull.Value && bindingRow["cseq"] != null && bindingRow["cseq"].ToString().Length > 0) {
CSeq = Convert.ToInt32(bindingRow["cseq"]);
}
if (bindingRow.Table.Columns.Contains("lastregistertime") && bindingRow["lastregistertime"] != DBNull.Value && bindingRow["lastregistertime"] != null && !(bindingRow["lastregistertime"] as string).IsNullOrBlank()) {
LastRegisterTime = DateTimeOffset.Parse(bindingRow["lastregistertime"] as string);
}
if (bindingRow.Table.Columns.Contains("lastregisterattempt") && bindingRow["lastregisterattempt"] != DBNull.Value && bindingRow["lastregisterattempt"] != null && !(bindingRow["lastregisterattempt"] as string).IsNullOrBlank()) {
LastRegisterAttempt = DateTimeOffset.Parse(bindingRow["lastregisterattempt"] as string);
}
if (bindingRow.Table.Columns.Contains("nextregistrationtime") && bindingRow["nextregistrationtime"] != DBNull.Value && bindingRow["nextregistrationtime"] != null && !(bindingRow["nextregistrationtime"] as string).IsNullOrBlank()) {
NextRegistrationTime = DateTimeOffset.Parse(bindingRow["nextregistrationtime"] as string);
}
if (bindingRow.Table.Columns.Contains("registrarsipsocket") && bindingRow["registrarsipsocket"] != DBNull.Value && bindingRow["registrarsipsocket"] != null && bindingRow["registrarsipsocket"].ToString().Length > 0) {
RegistrarSIPEndPoint = SIPEndPoint.ParseSIPEndPoint(bindingRow["registrarsipsocket"] as string);
}
m_registrationFailureMessage = bindingRow["registrationfailuremessage"] as string;
//logger.Debug(" loaded SIPProviderBinding for " + Owner + " and " + ProviderName + " and binding " + BindingURI.ToString() + ".");
}
catch (Exception excp) {
logger.Error("Exception SIPProviderBinding Load. " + excp.Message);
throw excp;
}
}
private Task <SocketError> SubscribeTransactionFinalResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
try
{
if (sipResponse.Status == SIPResponseStatusCodesEnum.IntervalTooBrief)
{
// The expiry interval used was too small. Adjust and try again.
m_expiry = (sipResponse.Header.MinExpires > 0) ? sipResponse.Header.MinExpires : m_expiry * 2;
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.NotifierClient, SIPMonitorEventTypesEnum.SubscribeFailed, "A subscribe request was rejected with IntervalTooBrief, adjusting expiry to " + m_expiry + " and trying again.", null));
Subscribe(m_resourceURI, m_expiry, m_sipEventPackage, m_subscribeCallID, null);
}
else if (sipResponse.Status == SIPResponseStatusCodesEnum.Forbidden)
{
// The subscription is never going to succeed so cancel it.
SubscriptionFailed(m_resourceURI, sipResponse.Status, "A Forbidden response was received on a subscribe attempt to " + m_resourceURI.ToString() + " for user " + m_authUsername + ".");
m_exit = true;
m_waitForSubscribeResponse.Set();
}
else if (sipResponse.Status == SIPResponseStatusCodesEnum.BadEvent)
{
// The subscription is never going to succeed so cancel it.
SubscriptionFailed(m_resourceURI, sipResponse.Status, "A BadEvent response was received on a subscribe attempt to " + m_resourceURI.ToString() + " for event package " + m_sipEventPackage.ToString() + ".");
m_exit = true;
m_waitForSubscribeResponse.Set();
}
else if (sipResponse.Status == SIPResponseStatusCodesEnum.CallLegTransactionDoesNotExist)
{
// The notifier server does not have a record for the existing subscription.
SubscriptionFailed(m_resourceURI, sipResponse.Status, "Subscribe failed with response " + sipResponse.StatusCode + " " + sipResponse.ReasonPhrase + ".");
m_waitForSubscribeResponse.Set();
}
else if (sipResponse.Status == SIPResponseStatusCodesEnum.ProxyAuthenticationRequired || sipResponse.Status == SIPResponseStatusCodesEnum.Unauthorised)
{
if (m_authUsername.IsNullOrBlank() || m_authPassword.IsNullOrBlank())
{
// No point trying to authenticate if there are no credentials to use.
SubscriptionFailed(m_resourceURI, sipResponse.Status, "Authentication requested on subscribe request when no credentials available.");
m_waitForSubscribeResponse.Set();
}
else if (sipResponse.Header.AuthenticationHeader != null)
{
if (m_attempts >= MAX_SUBSCRIBE_ATTEMPTS)
{
m_subscribed = false;
SubscriptionFailed(m_resourceURI, SIPResponseStatusCodesEnum.InternalServerError, "Subscription reached the maximum number of allowed attempts.");
m_waitForSubscribeResponse.Set();
}
else
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.NotifierClient, SIPMonitorEventTypesEnum.SubscribeAuth, "Attempting authentication for subscribe request for event package " + m_sipEventPackage.ToString() + " and " + m_resourceURI.ToString() + ".", null));
m_attempts++;
// Resend SUBSCRIBE with credentials.
SIPAuthorisationDigest authRequest = sipResponse.Header.AuthenticationHeader.SIPDigest;
authRequest.SetCredentials(m_authUsername, m_authPassword, m_resourceURI.ToString(), SIPMethodsEnum.SUBSCRIBE.ToString());
SIPRequest authSubscribeRequest = sipTransaction.TransactionRequest;
authSubscribeRequest.Header.AuthenticationHeader = new SIPAuthenticationHeader(authRequest);
authSubscribeRequest.Header.AuthenticationHeader.SIPDigest.Response = authRequest.Digest;
authSubscribeRequest.Header.Vias.TopViaHeader.Branch = CallProperties.CreateBranchId();
m_localCSeq = sipTransaction.TransactionRequest.Header.CSeq + 1;
authSubscribeRequest.Header.CSeq = m_localCSeq;
authSubscribeRequest.Header.CallId = m_subscribeCallID;
if (!m_filter.IsNullOrBlank())
{
authSubscribeRequest.Body = m_filter;
authSubscribeRequest.Header.ContentLength = m_filter.Length;
authSubscribeRequest.Header.ContentType = m_filterTextType;
}
// Create a new transaction to establish the authenticated server call.
SIPNonInviteTransaction subscribeTransaction = new SIPNonInviteTransaction(m_sipTransport, authSubscribeRequest, m_outboundProxy);
subscribeTransaction.NonInviteTransactionFinalResponseReceived += SubscribeTransactionFinalResponseReceived;
subscribeTransaction.NonInviteTransactionTimedOut += SubsribeTransactionTimedOut;
m_sipTransport.SendTransaction(subscribeTransaction);
}
}
else
{
SubscriptionFailed(sipTransaction.TransactionRequestURI, sipResponse.Status, "Subscribe requested authentication but did not provide an authentication header.");
m_waitForSubscribeResponse.Set();
}
}
else if (sipResponse.StatusCode >= 200 && sipResponse.StatusCode <= 299)
{
Log_External(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.NotifierClient, SIPMonitorEventTypesEnum.SubscribeAuth, "Authenticating subscribe request for event package " + m_sipEventPackage.ToString() + " and " + m_resourceURI.ToString() + " was successful.", null));
m_subscribed = true;
m_subscriptionToTag = sipResponse.Header.To.ToTag;
SubscriptionSuccessful(m_resourceURI);
m_waitForSubscribeResponse.Set();
}
else
{
SubscriptionFailed(m_resourceURI, sipResponse.Status, "Subscribe failed with response " + sipResponse.StatusCode + " " + sipResponse.ReasonPhrase + ".");
m_waitForSubscribeResponse.Set();
}
return(Task.FromResult(SocketError.Success));
}
catch (Exception excp)
{
logger.LogError("Exception SubscribeTransactionFinalResponseReceived. " + excp.Message);
SubscriptionFailed(m_resourceURI, SIPResponseStatusCodesEnum.InternalServerError, "Exception processing subscribe response. " + excp.Message);
m_waitForSubscribeResponse.Set();
return(Task.FromResult(SocketError.Fault));
}
}
public SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum serverType, SIPMonitorEventTypesEnum eventType, string message, string username, SIPEndPoint localEndPoint, SIPEndPoint remoteEndPoint)
{
m_serialisationPrefix = SERIALISATION_PREFIX;
ClientType = SIPMonitorClientTypesEnum.Console;
ServerType = serverType;
EventType = eventType;
Message = message;
Username = username;
Created = DateTimeOffset.UtcNow;
ServerEndPoint = localEndPoint;
RemoteEndPoint = remoteEndPoint;
#if !SILVERLIGHT
ProcessID = Process.GetCurrentProcess().Id;
#endif
}
public bool AuthenticateCall()
{
m_isAuthenticated = false;
try
{
if (m_sipAccount == null)
{
logger.LogWarning($"Rejecting authentication required call for {m_uasTransaction.TransactionRequestFrom}, SIP account not found.");
Reject(SIPResponseStatusCodesEnum.Forbidden, null, null);
}
else
{
SIPRequest sipRequest = m_uasTransaction.TransactionRequest;
SIPEndPoint localSIPEndPoint = (!sipRequest.Header.ProxyReceivedOn.IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(sipRequest.Header.ProxyReceivedOn) : sipRequest.LocalSIPEndPoint;
SIPEndPoint remoteEndPoint = (!sipRequest.Header.ProxyReceivedFrom.IsNullOrBlank()) ? SIPEndPoint.ParseSIPEndPoint(sipRequest.Header.ProxyReceivedFrom) : sipRequest.RemoteSIPEndPoint;
var authenticationResult = SIPRequestAuthenticator.AuthenticateSIPRequest(localSIPEndPoint, remoteEndPoint, sipRequest, m_sipAccount);
if (authenticationResult.Authenticated)
{
if (authenticationResult.WasAuthenticatedByIP)
{
logger.LogDebug($"New call from {remoteEndPoint} successfully authenticated by IP address.");
}
else
{
logger.LogDebug($"New call from {remoteEndPoint} successfully authenticated by digest.");
}
m_isAuthenticated = true;
}
else
{
if (sipRequest.Header.AuthenticationHeader != null)
{
logger.LogWarning($"Call not authenticated for {m_sipAccount.SIPUsername}@{m_sipAccount.SIPDomain}, responding with {authenticationResult.ErrorResponse}.");
}
// Send authorisation failure or required response
SIPResponse authReqdResponse = SIPResponse.GetResponse(sipRequest, authenticationResult.ErrorResponse, null);
authReqdResponse.Header.AuthenticationHeader = authenticationResult.AuthenticationRequiredHeader;
m_uasTransaction.SendFinalResponse(authReqdResponse);
}
}
}
catch (Exception excp)
{
logger.LogError("Exception SIPServerUserAgent AuthenticateCall. " + excp.Message);
Reject(SIPResponseStatusCodesEnum.InternalServerError, null, null);
}
return(m_isAuthenticated);
}
public SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum serverType, SIPMonitorEventTypesEnum eventType, string message, SIPRequest sipRequest, SIPResponse sipResponse, SIPEndPoint localEndPoint, SIPEndPoint remoteEndPoint, SIPCallDirection callDirection)
{
m_serialisationPrefix = SERIALISATION_PREFIX;
ClientType = SIPMonitorClientTypesEnum.Console;
ServerType = serverType;
EventType = eventType;
Message = message;
RemoteEndPoint = remoteEndPoint;
ServerEndPoint = localEndPoint;
Created = DateTimeOffset.UtcNow;
#if !SILVERLIGHT
ProcessID = Process.GetCurrentProcess().Id;
#endif
string dirn = (callDirection == SIPCallDirection.In) ? CALLDIRECTION_IN_STRING : CALLDIRECTION_OUT_STRING;
if (sipRequest != null)
{
Message = "REQUEST (" + Created.ToString("HH:mm:ss:fff") + "): " + localEndPoint + dirn + remoteEndPoint + "\r\n" + sipRequest.ToString();
}
else if (sipResponse != null)
{
Message = "RESPONSE (" + Created.ToString("HH:mm:ss:fff") + "): " + localEndPoint + dirn + remoteEndPoint + "\r\n" + sipResponse.ToString();
}
}
private Task <SocketError> ByeServerFinalResponseReceived(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPTransaction sipTransaction, SIPResponse sipResponse)
{
try
{
logger.LogDebug("Response " + sipResponse.StatusCode + " " + sipResponse.ReasonPhrase + " for " + sipTransaction.TransactionRequest.URI.ToString() + ".");
SIPNonInviteTransaction byeTransaction = sipTransaction as SIPNonInviteTransaction;
if ((sipResponse.Status == SIPResponseStatusCodesEnum.ProxyAuthenticationRequired || sipResponse.Status == SIPResponseStatusCodesEnum.Unauthorised) && SIPAccount != null)
{
// Resend BYE with credentials.
SIPAuthorisationDigest authRequest = sipResponse.Header.AuthenticationHeader.SIPDigest;
SIPURI contactUri = sipResponse.Header.Contact.Any() ? sipResponse.Header.Contact[0].ContactURI : sipResponse.Header.From.FromURI;
authRequest.SetCredentials(SIPAccount.SIPUsername, SIPAccount.SIPPassword, contactUri.ToString(), SIPMethodsEnum.BYE.ToString());
SIPRequest authByeRequest = byeTransaction.TransactionRequest;
authByeRequest.Header.AuthenticationHeader = new SIPAuthenticationHeader(authRequest);
authByeRequest.Header.AuthenticationHeader.SIPDigest.Response = authRequest.Digest;
authByeRequest.Header.Vias.TopViaHeader.Branch = CallProperties.CreateBranchId();
authByeRequest.Header.CSeq = authByeRequest.Header.CSeq + 1;
SIPNonInviteTransaction authByeTransaction = new SIPNonInviteTransaction(m_sipTransport, authByeRequest, null);
authByeTransaction.SendRequest();
}
return(Task.FromResult(SocketError.Success));
}
catch (Exception excp)
{
logger.LogError("Exception ByServerFinalResponseReceived. " + excp.Message);
return(Task.FromResult(SocketError.Fault));
}
}
/// <summary></summary>
/// <param name="uacRecvdEndPoint">If this is non-null it indicates the contact header should be mangled based on the public socket the register request was demmed
/// to have originated from rather then relying on the contact value recieved from the uac.</param>
public SIPRegistrarBinding(
SIPAccount sipAccount,
SIPURI bindingURI,
string callId,
int cseq,
string userAgent,
SIPEndPoint remoteSIPEndPoint,
SIPEndPoint proxySIPEndPoint,
SIPEndPoint registrarSIPEndPoint,
int expiry)
{
Id = Guid.NewGuid();
LastUpdate = DateTime.UtcNow;
SIPAccountId = sipAccount.Id;
SIPAccountName = sipAccount.SIPUsername + "@" + sipAccount.SIPDomain;
Owner = sipAccount.Owner;
AdminMemberId = sipAccount.AdminMemberId;
m_contactURI = bindingURI.CopyOf();
m_mangledContactURI = m_contactURI.CopyOf();
CallId = callId;
CSeq = cseq;
UserAgent = userAgent;
RemoteSIPEndPoint = remoteSIPEndPoint;
m_proxySIPEndPoint = proxySIPEndPoint;
m_registrarSIPEndPoint = registrarSIPEndPoint;
//if (SIPTransport.IsPrivateAddress(sipRequest.Header.Contact[0].ContactURI.Host) && m_mangleUACContact)
if (!sipAccount.DontMangleEnabled && Regex.Match(m_mangledContactURI.Host, @"(\d+\.){3}\d+").Success)
{
// The Contact URI Host is used by registrars as the contact socket for the user so it needs to be changed to reflect the socket
// the intial request was received on in order to work around NAT. It's no good just relying on private addresses as a lot of User Agents
// determine their public IP but NOT their public port so they send the wrong port in the Contact header.
//logger.Debug("Mangling contact header from " + m_mangledContactURI.Host + " to " + IPSocket.GetSocketString(uacRecvdEndPoint) + ".");
m_mangledContactURI.Host = remoteSIPEndPoint.GetIPEndPoint().ToString();
}
m_expiry = expiry;
}
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, true);
//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;
}
}
/// <summary>
/// Refreshes a binding when the remote network information of the remote or proxy end point has changed.
/// </summary>
public void RefreshBinding(int expiry, SIPEndPoint remoteSIPEndPoint, SIPEndPoint proxySIPEndPoint, SIPEndPoint registrarSIPEndPoint, bool dontMangle)
{
LastUpdate = DateTimeOffset.UtcNow;
RemoteSIPEndPoint = remoteSIPEndPoint;
m_proxySIPEndPoint = proxySIPEndPoint;
m_registrarSIPEndPoint = registrarSIPEndPoint;
RemovalReason = SIPBindingRemovalReason.Unknown;
m_expiry = expiry;
//if (SIPTransport.IsPrivateAddress(sipRequest.Header.Contact[0].ContactURI.Host) && m_mangleUACContact)
if (!dontMangle && Regex.Match(m_mangledContactURI.Host, @"(\d+\.){3}\d+").Success)
{
// The Contact URI Host is used by registrars as the contact socket for the user so it needs to be changed to reflect the socket
// the intial request was received on in order to work around NAT. It's no good just relying on private addresses as a lot of User Agents
// determine their public IP but NOT their public port so they send the wrong port in the Contact header.
//logger.Debug("Mangling contact header from " + m_mangledContactURI.Host + " to " + IPSocket.GetSocketString(uacRecvdEndPoint) + ".");
m_mangledContactURI.Host = remoteSIPEndPoint.GetIPEndPoint().ToString();
}
}
public void GotResponse(SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPResponse sipResponse)
{
FireProxyLogEvent(new SIPMonitorConsoleEvent(SIPMonitorServerTypesEnum.AppServer, SIPMonitorEventTypesEnum.Error, "App Server received a SIP response from " + remoteEndPoint + " that did not match an existing transaction.\n" + sipResponse.ToString(), null));
}
