/// <summary>
/// Sends a SIP response.
/// </summary>
/// <param name="response">The SIP response (either a response code or SIP message).</param>
/// <param name="responseText">Optional response text.</param>
/// <param name="content">Optional content.</param>
/// <param name="contentType">Optional type of the SIP body contents.</param>
/// <param name="createDialog">if set to <c>true</c> [can create dialog].</param>
public virtual void SendResponse(object response, string responseText = "", string content = "",
string contentType = "", bool createDialog = true)
{
Message responseMessage;
if (Request == null)
{
Debug.Assert(false, String.Format("Invalid request in sending a response"));
return;
}
if (response is int)
{
responseMessage = CreateResponse((int) (response), responseText, content, contentType);
}
else
{
responseMessage = (Message) (response);
}
if (createDialog && CanCreateDialog(Request, responseMessage))
{
if (Request.Headers.ContainsKey("Record-Route"))
{
responseMessage.Headers.Add("Record-Route", Request.Headers["Record-Route"]);
}
if (!responseMessage.Headers.ContainsKey("Contact"))
{
Address contact = new Address(Contact.ToString());
if (contact.Uri.User.Length != 0)
{
contact.Uri.User = ((Address) Request.First("To").Value).Uri.User;
responseMessage.InsertHeader(new Header(contact.ToString(), "Contact"));
}
}
Dialog dialog = Dialog.CreateServer(Stack, Request, responseMessage, Transaction);
Stack.DialogCreated(dialog, this);
Stack.Sending(dialog, responseMessage);
}
else
{
Stack.Sending(this, responseMessage);
}
if (Transaction == null)
{
Stack.Send(responseMessage, responseMessage.Headers["Via"][0].ViaUri.HostPort());
}
else
{
Transaction.SendResponse(responseMessage);
}
}
/// <summary>
/// Creates a SIP request.
/// </summary>
/// <param name="method">The SIP method.</param>
/// <param name="dest">The dest (either Address or string[]).</param>
/// <param name="stateless">if set to <c>true</c> [act as a stateless proxy].</param>
/// <param name="recordRoute">if set to <c>true</c> [record the SIP route].</param>
/// <param name="headers">The SIP headers to use.</param>
/// <param name="route">The route.</param>
/// <returns>Message.</returns>
public Message CreateRequest(string method, object dest, bool stateless = false, bool recordRoute = false,
Dictionary<string, List<Header>> headers = null, List<Header> route = null)
{
if (method != Request.Method)
{
Debug.Assert(false, "method in createRequest must be same as original UAS for proxy");
}
Message request = Request.Dup();
if (!stateless && Transaction == null)
{
Transaction = Transaction.CreateServer(Stack, this, Request, Stack.Transport, Stack.Tag,
false);
}
if (dest.GetType() == typeof(Address))
{
request.Uri = ((Address)dest).Uri.Dup();
}
else if (dest is string[])
{
string[] destArray = (string[])dest;
string scheme = request.Uri.Scheme;
string user = request.Uri.User;
request.Uri = new SIPURI { Scheme = scheme, User = user, Host = destArray[0], Port = int.Parse(destArray[1]) };
}
else
{
Debug.Assert(false, "Dest in Proxy Create Request is not a String or Address");
//else: request.uri = dest.dup()
}
if (request.First("Max-Forwards") != null)
{
object value = request.First("Max-Forwards").Value;
int currentValue = int.Parse(value.ToString());
currentValue = currentValue - 1;
request.InsertHeader(new Header(currentValue.ToString(), "Max-Forwards"));
}
else request.InsertHeader(new Header("70", "Max-Forwards"));
if (recordRoute)
{
Address rr = new Address(Stack.Uri.ToString());
rr.Uri.Parameters["lr"] = null;
rr.MustQuote = true;
request.InsertHeader(new Header(rr.ToString(), "Record-Route"));
}
if (headers != null) request.Headers.Concat(headers).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
if (route != null)
{
route.Reverse();
foreach (Header header in route)
{
request.InsertHeader(header);
}
}
Header viaHeader = Stack.CreateVia();
viaHeader.Attributes["branch"] = Transaction.createProxyBranch(request, false);
request.InsertHeader(viaHeader, "insert");
return request;
}
private static void ContinueRoutingMessage(Message request, Proxy pua, Block block)
{
SIPURI to = request.Uri;
string toID = to.User + "@" + to.Host;
Address from = (Address)(request.First("From").Value);
string fromID = from.Uri.User + "@" + from.Uri.Host;
Address dest = new Address(to.ToString());
Address temp_dest = CheckServiceBlock(request, block, toID, fromID);
if (temp_dest != null)
{
dest = temp_dest;
}
if (dest.ToString().Contains("anonymous.invalid"))
{
Message proxiedMessage = pua.CreateResponse(403, "Forbidden");
pua.SendResponse(proxiedMessage);
}
else
{
Message proxiedMessage = pua.CreateRequest(request.Method, dest, true, true);
proxiedMessage.First("To").Value = dest;
pua.SendRequest(proxiedMessage);
}
}
