/// <summary>
/// Creates the server side dialog.
/// </summary>
/// <param name="stack">The stack.</param>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
/// <param name="transaction">The transaction.</param>
/// <returns>Dialog.</returns>
public static Dialog CreateServer(SIPStack stack, Message request, Message response, Transaction transaction)
{
Dialog d = new Dialog(stack, request, true)
{
Request = request
};
if (request.Headers.ContainsKey("Record-Route"))
{
d.RouteSet = request.Headers["Record-Route"];
foreach (Header h in d.RouteSet)
{
h.Name = "Route";
}
}
// TODO: Handle multicast addresses
// TODO: Handle tls / secure sip
d.LocalSeq = 0;
d.RemoteSeq = request.First("CSeq").Number;
d.CallID = request.First("Call-ID").Value.ToString();
d.LocalTag = response.First("To").Attributes["tag"];
d.RemoteTag = request.First("From").Attributes["tag"];
d.LocalParty = new Address(request.First("To").Value.ToString());
d.RemoteParty = new Address(request.First("From").Value.ToString());
d.RemoteTarget = new SIPURI(((Address)(request.First("Contact").Value)).Uri.ToString());
// TODO: retransmission timer for 2xx in UAC
stack.Dialogs[d.CallID] = d;
return(d);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SIPLib.SIP.Proxy"/> class.
/// </summary>
/// <param name="stack">The SIP stack to use.</param>
/// <param name="request">The incoming request to proxy.</param>
/// <param name="server">if set to <c>true</c> [server].</param>
public Proxy(SIPStack stack, Message request, bool server)
: base(stack, request, server)
{
if (request == null)
{
Debug.Assert(false, "Cannot create Proxy without incoming request");
}
}
/// <summary>
/// Creates a SIP stack.
/// </summary>
/// <param name="app">The associated sip application.</param>
/// <param name="username">The username representing this SIP endpoint.</param>
/// <param name="proxyIp">The proxy ip if any.</param>
/// <param name="proxyPort">The proxy port if any.</param>
/// <returns>SIPStack.</returns>
public static SIPStack CreateStack(SIPApp app,string username, string proxyIp = null, int proxyPort = -1)
{
SIPStack myStack = new SIPStack(app) {Uri = {User = username}};
if (proxyIp != null)
{
myStack.ProxyHost = proxyIp;
myStack.ProxyPort = (proxyPort == -1) ? 5060 : proxyPort;
}
return myStack;
}
private static SIPStack CreateStack(SIPApp app, string proxyIp = null, int proxyPort = -1)
{
SIPStack myStack = new SIPStack(app);
if (proxyIp != null)
{
myStack.ProxyHost = proxyIp;
myStack.ProxyPort = (proxyPort == -1) ? 5060 : proxyPort;
}
return myStack;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SIPLib.SIP.Dialog"/> class.
/// </summary>
/// <param name="stack">The SIP stack currently being used.</param>
/// <param name="request">The request.</param>
/// <param name="server">If set to <c>true</c> then set the relevant useragent properties for a server.</param>
/// <param name="transaction">The transaction.</param>
public Dialog(SIPStack stack, Message request, bool server, Transaction transaction = null)
: base(stack, request, server)
{
Servers = new List <Transaction>();
Clients = new List <Transaction>();
_id = "";
if (transaction != null)
{
transaction.App = this;
}
}
/// <summary>
/// Creates a client transaction
/// </summary>
/// <param name="stack">The SIP stack to use.</param>
/// <param name="app">The associated useragent / application.</param>
/// <param name="request">The SIP request.</param>
/// <param name="transport">A TransportInfo object representing transmission medium.</param>
/// <param name="remote">The remote.</param>
/// <returns>Transaction.</returns>
public static Transaction CreateClient(SIPStack stack, UserAgent app, Message request, TransportInfo transport,
string remote)
{
Transaction t;
lock (stack.TransactionLock)
{
if (request.Method == "INVITE")
{
t = new InviteClientTransaction(app);
}
else
{
t = new ClientTransaction(app);
}
t.Stack = stack;
t.App = app;
t.Request = request;
t.Transport = transport;
t.Remote = remote;
if (request.Headers.ContainsKey("Via") && request.First("Via").Attributes.ContainsKey("branch"))
{
t.Branch = request.First("Via").Attributes["branch"];
}
else
{
t.Branch = CreateBranch(request, false);
}
t.ID = CreateId(t.Branch, request.Method);
stack.Transactions[t.ID] = t;
if (request.Method == "INVITE")
{
((InviteClientTransaction)t).Start();
}
else
{
((ClientTransaction)t).Start();
}
}
return(t);
}
/// <summary>
/// Creates the client side dialog.
/// </summary>
/// <param name="stack">The stack.</param>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
/// <param name="transaction">The transaction.</param>
/// <returns>Dialog.</returns>
public static Dialog CreateClient(SIPStack stack, Message request, Message response, Transaction transaction)
{
Dialog d = new Dialog(stack, request, false)
{
Request = request
};
if (response.Headers.ContainsKey("Record-Route"))
{
d.RouteSet = response.Headers["Record-Route"];
d.RouteSet.Reverse();
foreach (Header h in d.RouteSet)
{
h.Name = "Route";
}
}
d.LocalSeq = request.First("CSeq").Number;
d.RemoteSeq = 0;
d.CallID = request.First("Call-ID").Value.ToString();
d.LocalTag = request.First("From").Attributes["tag"];
d.RemoteTag = response.First("To").Attributes["tag"];
d.LocalParty = new Address(request.First("From").Value.ToString());
d.RemoteParty = new Address(request.First("To").Value.ToString());
if (response.Headers.ContainsKey("Contact"))
{
d.RemoteTarget = new SIPURI(((Address)(response.First("Contact").Value)).Uri.ToString());
}
else
{
d.RemoteTarget = new SIPURI(((Address)(response.First("To").Value)).Uri.ToString());
}
try
{
stack.Dialogs[d.CallID] = d;
}
catch (Exception)
{
Debug.Assert(false, "Error assiging callID to stack dialog list");
}
return(d);
}
/// <summary>
/// Creates a server transaction
/// </summary>
/// <param name="stack">The SIP stack to use.</param>
/// <param name="app">The associated useragent / application.</param>
/// <param name="request">The SIP request.</param>
/// <param name="transport">A TransportInfo object representing transmission medium.</param>
/// <param name="tag">The tag.</param>
/// <param name="start">Not used.</param>
/// <returns>Transaction.</returns>
public static Transaction CreateServer(SIPStack stack, UserAgent app, Message request, TransportInfo transport,
string tag, Boolean start = true)
{
Transaction t;
if (request.Method == "INVITE")
{
t = new InviteServerTransaction(app);
}
else
{
t = new ServerTransaction(app);
}
t.Stack = stack;
t.App = app;
t.Request = request;
t.Transport = transport;
t.Tag = tag;
t.Remote = request.First("Via").ViaUri.HostPort();
if (request.Headers.ContainsKey("Via") && request.First("Via").Attributes.ContainsKey("branch"))
{
t.Branch = request.First("Via").Attributes["branch"];
}
else
{
t.Branch = CreateBranch(request, true);
}
t.ID = CreateId(t.Branch, request.Method);
stack.Transactions[t.ID] = t;
if (request.Method == "INVITE")
{
((InviteServerTransaction)t).Start();
}
else
{
((ServerTransaction)t).Start();
}
return(t);
}
/// <summary> /// Stub to alert on cancellation. /// </summary> /// <param name="ua">The ua.</param> /// <param name="request">The request.</param> /// <param name="sipStack">The sip stack.</param> public abstract void Cancelled(UserAgent ua, Message request, SIPStack sipStack);
/// <summary>
/// Allows logging / alerting on the creation of a dialog.
/// </summary>
/// <param name="dialog">The dialog.</param>
/// <param name="ua">The ua.</param>
/// <param name="stack">The stack.</param>
public override void DialogCreated(Dialog dialog, UserAgent ua, SIPStack stack)
{
this.CallUA = dialog;
_log.Info("New dialog created");
}
/// <summary> /// Stub to handle the authentication of the specified ua. /// </summary> /// <param name="ua">The ua.</param> /// <param name="header">The header.</param> /// <param name="sipStack">The sip stack.</param> /// <returns>System.String[].</returns> public abstract string[] Authenticate(UserAgent ua, Header header, SIPStack sipStack);
public override void Send(string data, string ip, int port, SIPStack stack)
{
IPAddress[] addresses = Dns.GetHostAddresses(ip);
IPEndPoint dest = new IPEndPoint(addresses[0], port);
EndPoint destEP = dest;
byte[] sendData = Encoding.ASCII.GetBytes(data);
string remoteHost = ((IPEndPoint)destEP).Address.ToString();
string remotePort = ((IPEndPoint)destEP).Port.ToString();
stack.Transport.Socket.BeginSendTo(sendData, 0, sendData.Length, SocketFlags.None, destEP, SendDataCB, destEP);
System.Threading.ThreadPool.QueueUserWorkItem(delegate
{
if (RawSentEvent != null)
{
RawSentEvent(this, new RawEventArgs(data, new[] { remoteHost, remotePort }, true));
}
if (SipSentEvent != null)
{
SipSentEvent(this, new SipMessageEventArgs(new Message(data)));
};
}, null);
}
public override string[] Authenticate(UserAgent ua, Header header, SIPStack sipStack)
{
throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SIPLib.SIP.Proxy"/> class.
/// </summary>
/// <param name="stack">The SIP stack to use.</param>
/// <param name="request">The incoming request to proxy.</param>
/// <param name="server">if set to <c>true</c> [server].</param>
public Proxy(SIPStack stack, Message request, bool server)
: base(stack, request, server)
{
if (request == null) Debug.Assert(false, "Cannot create Proxy without incoming request");
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SIPLib.SIP.UserAgent" /> class.
/// </summary>
/// <param name="stack">The SIP stack associated with this UA.</param>
/// <param name="request">An optional SIP request.</param>
/// <param name="server">if set to <c>true</c> [act as a user agent server].</param>
public UserAgent(SIPStack stack, Message request = null, bool server = false)
{
Stack = stack;
//this.app = stack.app;
Request = request;
if (server)
{
Server = true;
}
else
{
Server = (request == null);
}
Transaction = null;
CancelRequest = null;
if ((request != null) && (request.Headers.ContainsKey("Call-ID")))
{
CallID = (string) request.Headers["Call-ID"][0].Value;
}
else
{
CallID = stack.NewCallId();
}
if ((request != null) && (request.Headers.ContainsKey("From")))
{
RemoteParty = (Address) request.Headers["From"][0].Value;
}
else
{
RemoteParty = null;
}
if ((request != null) && (request.Headers.ContainsKey("To")))
{
LocalParty = (Address) request.Headers["To"][0].Value;
}
else
{
LocalParty = null;
}
LocalTag = stack.Tag + _random.Next(0, 2147483647).ToString();
RemoteTag = stack.Tag + _random.Next(0, 2147483647).ToString();
if ((request != null) && (request.Headers.ContainsKey("Subject")))
{
Subject = (string) request.Headers["Subject"][0].Value;
}
else
{
Subject = "";
}
MaxForwards = 70;
RouteSet = new List<Header>();
LocalTarget = null;
RemoteTarget = null;
RemoteCandidates = null;
LocalSeq = 0;
RemoteSeq = 0;
Contact = new Address(stack.Uri.ToString());
if (LocalParty != null)
{
if (LocalParty.Uri.User.Length > 0)
{
Contact.Uri.User = LocalParty.Uri.User;
}
}
Autoack = true;
Auth = new Dictionary<string, string>();
}
/// <summary> /// Stub to create a SIP server user agent. /// </summary> /// <param name="request">The request.</param> /// <param name="uri">The URI.</param> /// <param name="sipStack">The sip stack.</param> /// <returns>UserAgent.</returns> public abstract UserAgent CreateServer(Message request, SIPURI uri, SIPStack sipStack);
public override string[] Authenticate(UserAgent ua, Header header, SIPStack stack)
{
return new[] { Username + "@" + Realm, Password };
}
/// <summary>
/// Function used to determine how to handle a received request.
/// </summary>
/// <param name="ua">The ua.</param>
/// <param name="request">The request.</param>
/// <param name="stack">The stack.</param>
public override void ReceivedRequest(UserAgent ua, Message request, SIPStack stack)
{
_log.Info("Received request with method " + request.Method.ToUpper());
_log.Debug("\n\n" + request.ToString());
switch (request.Method.ToUpper())
{
case "INVITE":
{
// Auto accepts any SIP INVITE request
_log.Info("Generating 200 OK response for INVITE");
Message m = ua.CreateResponse(200, "OK");
ua.SendResponse(m);
break;
}
case "CANCEL":
{
break;
}
case "ACK":
{
break;
}
case "BYE":
{
break;
}
case "MESSAGE":
{
// Logs any received request
_log.Info("MESSAGE: " + request.Body);
// Can also echo back any received message for testing purposes
//Address from = (Address) request.first("From").value;
//this.Message(from.uri.ToString(), request.body);
break;
}
case "OPTIONS":
case "REFER":
case "SUBSCRIBE":
case "NOTIFY":
case "PUBLISH":
case "INFO":
default:
{
_log.Info("Request with method " + request.Method.ToUpper() + " is unhandled");
break;
}
}
}
/// <summary>
/// Virtual function to pass received message to real function.
/// </summary>
/// <param name="t">The transaction.</param>
/// <param name="message">The SIP message.</param>
/// <param name="SIPStack">The SIP stack.</param>
internal virtual void ReceivedRequest(Transaction t, Message message, SIPStack SIPStack)
{
ReceivedRequest(t, message);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SIPLib.SIP.UserAgent" /> class.
/// </summary>
/// <param name="stack">The SIP stack associated with this UA.</param>
/// <param name="request">An optional SIP request.</param>
/// <param name="server">if set to <c>true</c> [act as a user agent server].</param>
public UserAgent(SIPStack stack, Message request = null, bool server = false)
{
Stack = stack;
//this.app = stack.app;
Request = request;
if (server)
{
Server = true;
}
else
{
Server = (request == null);
}
Transaction = null;
CancelRequest = null;
if ((request != null) && (request.Headers.ContainsKey("Call-ID")))
{
CallID = (string)request.Headers["Call-ID"][0].Value;
}
else
{
CallID = stack.NewCallId();
}
if ((request != null) && (request.Headers.ContainsKey("From")))
{
RemoteParty = (Address)request.Headers["From"][0].Value;
}
else
{
RemoteParty = null;
}
if ((request != null) && (request.Headers.ContainsKey("To")))
{
LocalParty = (Address)request.Headers["To"][0].Value;
}
else
{
LocalParty = null;
}
LocalTag = stack.Tag + _random.Next(0, 2147483647).ToString();
RemoteTag = stack.Tag + _random.Next(0, 2147483647).ToString();
if ((request != null) && (request.Headers.ContainsKey("Subject")))
{
Subject = (string)request.Headers["Subject"][0].Value;
}
else
{
Subject = "";
}
MaxForwards = 70;
RouteSet = new List <Header>();
LocalTarget = null;
RemoteTarget = null;
RemoteCandidates = null;
LocalSeq = 0;
RemoteSeq = 0;
Contact = new Address(stack.Uri.ToString());
if (LocalParty != null)
{
if (LocalParty.Uri.User.Length > 0)
{
Contact.Uri.User = LocalParty.Uri.User;
}
}
Autoack = true;
Auth = new Dictionary <string, string>();
}
/// <summary>
/// Virtual function to pass received message to real function.
/// </summary>
/// <param name="t">The transaction.</param>
/// <param name="message">The SIP message.</param>
/// <param name="SIPStack">The SIP stack.</param>
internal virtual void ReceivedRequest(Transaction t, Message message, SIPStack SIPStack)
{
ReceivedRequest(t, message);
}
/// <summary>
/// Function used to determine how to handle a received response.
/// </summary>
/// <param name="ua">The ua.</param>
/// <param name="response">The response.</param>
/// <param name="stack">The stack.</param>
public override void ReceivedResponse(UserAgent ua, Message response, SIPStack stack)
{
_log.Info("Received response with code " + response.ResponseCode + " " + response.ResponseText);
_log.Debug("\n\n" + response.ToString());
switch (response.ResponseCode)
{
case 180:
{
break;
}
case 200:
{
break;
}
case 401:
{
_log.Error("Transaction layer did not handle registration - APP received 401");
//UserAgent ua = new UserAgent(this.stack, null, false);
//ua.authenticate(response, transaction);
break;
}
default:
{
_log.Info("Response code of " + response.ResponseCode + " is unhandled ");
}
break;
}
}
/// <summary> /// Stub to create timers. /// </summary> /// <param name="obj">The obj.</param> /// <param name="sipStack">The sip stack.</param> /// <returns>Timer.</returns> public abstract Timer CreateTimer(UserAgent obj, SIPStack sipStack);
public override Timer CreateTimer(UserAgent app, SIPStack stack)
{
return new Timer(app);
}
public override UserAgent CreateServer(Message request, SIPURI uri, SIPStack stack)
{
if (request.Method != "CANCEL")
{
return new Proxy(Stack, request, true);
}
else return null;
}
public override void ReceivedRequest(UserAgent ua, Message request, SIPStack stack)
{
Log.Info("Received request with method " + request.Method.ToUpper());
Log.Debug("\n\n" + request.ToString());
if (RequestRecvEvent != null)
{
RequestRecvEvent(this, new SipMessageEventArgs(request, ua));
}
}
/// <summary> /// Stub to alert on creation of a dialog. /// </summary> /// <param name="dialog">The dialog.</param> /// <param name="ua">The ua.</param> /// <param name="sipStack">The sip stack.</param> public abstract void DialogCreated(Dialog dialog, UserAgent ua, SIPStack sipStack);
/// <summary>
/// Sends the data to the destination host and destination port
/// </summary>
/// <param name="finalData">The final data.</param>
/// <param name="destinationHost">The destination host.</param>
/// <param name="destinationPort">The destination port.</param>
/// <param name="stack">The stack.</param>
public override void Send(string finalData, string destinationHost, int destinationPort, SIPStack stack)
{
IPAddress[] addresses = System.Net.Dns.GetHostAddresses(destinationHost);
IPEndPoint dest = new IPEndPoint(addresses[0], destinationPort);
EndPoint destEP = (EndPoint)dest;
byte[] send_data = ASCIIEncoding.ASCII.GetBytes(finalData);
stack.Transport.Socket.BeginSendTo(send_data, 0, send_data.Length, SocketFlags.None, destEP, new AsyncCallback(this.SendDataCB), destEP);
}
public override UserAgent CreateServer(Message request, SIPURI uri, SIPStack stack)
{
if (request.Method == "INVITE")
{
return new UserAgent(Stack, request);
}
return null;
}
/// <summary> /// Stub to receive a request. /// </summary> /// <param name="ua">The ua.</param> /// <param name="request">The request.</param> /// <param name="sipStack">The sip stack.</param> public abstract void ReceivedRequest(UserAgent ua, Message request, SIPStack sipStack);
public override void DialogCreated(Dialog dialog, UserAgent ua, SIPStack stack)
{
Useragents.Remove(ua);
Useragents.Add(dialog);
Log.Info("New dialog created");
}
/// <summary> /// Stub to receive a response. /// </summary> /// <param name="ua">The ua.</param> /// <param name="response">The response.</param> /// <param name="sipStack">The sip stack.</param> public abstract void ReceivedResponse(UserAgent ua, Message response, SIPStack sipStack);
public override void ReceivedResponse(UserAgent ua, Message response, SIPStack stack)
{
Log.Info("Received response with code " + response.ResponseCode + " " + response.ResponseText);
Log.Debug("\n\n" + response.ToString());
if (ResponseRecvEvent != null)
{
ResponseRecvEvent(this, new SipMessageEventArgs(response));
}
}
/// <summary> /// Stub to actually send data. /// </summary> /// <param name="finalData">The final data.</param> /// <param name="destinationHost">The destination host.</param> /// <param name="destinationPort">The destination port.</param> /// <param name="sipStack">The sip stack.</param> public abstract void Send(string finalData, string destinationHost, int destinationPort, SIPStack sipStack);
public override void Sending(UserAgent ua, Message message, SIPStack stack)
{
if (Helpers.IsRequest(message))
{
Log.Info("Sending request with method " + message.Method);
}
else
{
Log.Info("Sending response with code " + message.ResponseCode);
}
Log.Debug("\n\n" + message.ToString());
//TODO: Allow App to modify message before it gets sent?;
}
/// <summary> /// Stub to alert on sending of a SIP message. /// </summary> /// <param name="ua">The ua.</param> /// <param name="message">The message.</param> /// <param name="sipStack">The sip stack.</param> public abstract void Sending(UserAgent ua, Message message, SIPStack sipStack);
public override void Cancelled(UserAgent ua, Message request, SIPStack stack)
{
throw new NotImplementedException();
}
/// <summary>
/// Authenticates the specified ua, using the specified username and password.
/// Your own method to retrieve the users username and password should be placed in this method.
/// </summary>
/// <param name="ua">The ua.</param>
/// <param name="header">The header.</param>
/// <param name="stack">The stack.</param>
/// <returns>System.String[].</returns>
public override string[] Authenticate(UserAgent ua, Header header, SIPStack stack)
{
string username = "******";
string realm = "open-ims.test";
string password = "******";
return new string[] { username + "@" + realm, password };
}
