public void SipTcpTransport_TransmitMultiple()
{
// Create two transport instances and send 10K messages from one to
// the other and verify that they got through.
TestTransport transport1 = new TestTransport();
TestTransport transport2 = new TestTransport();
SipRequest sentMsg;
SipRequest recvMsg;
try
{
transport1.Start(new NetworkBinding("127.0.0.1:5311"));
transport2.Start(new NetworkBinding("127.0.0.1:5312"));
for (int i = 0; i < 2500; i++)
{
sentMsg = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
sentMsg.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport1.LocalEndpoint));
sentMsg.AddHeader("Count", i.ToString());
sentMsg.Contents = GetContents(i);
transport1.Send(transport2.LocalEndpoint, sentMsg);
recvMsg = (SipRequest)transport2.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(sentMsg[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual(i.ToString(), recvMsg["Count"].FullText);
CollectionAssert.AreEqual(sentMsg.Contents, recvMsg.Contents);
Assert.AreEqual(transport1.LocalEndpoint.Address, recvMsg.RemoteEndpoint.Address);
// Send a message the other way.
sentMsg = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
sentMsg.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport1.LocalEndpoint));
sentMsg.Contents = GetContents(i);
transport2.Send(transport1.LocalEndpoint, sentMsg);
recvMsg = (SipRequest)transport1.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(sentMsg[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
CollectionAssert.AreEqual(sentMsg.Contents, recvMsg.Contents);
Assert.AreEqual(transport2.LocalEndpoint.Address, recvMsg.RemoteEndpoint.Address);
}
}
finally
{
transport1.Stop();
transport2.Stop();
}
}
public void SipTcpTransport_MultipleChunks()
{
// Transmit a message to a transport in several chunks to make
// sure it can be reassembled properly.
TestTransport transport = new TestTransport();
EnhancedSocket sock = null;
SipRequest msg;
SipRequest recvMsg;
byte[] buf;
try
{
transport.Start(new NetworkBinding("127.0.0.1:5311"));
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Connect("127.0.0.1", 5311);
sock.NoDelay = true;
msg = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
msg.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport.LocalEndpoint));
msg.AddHeader("Count", "0");
msg.Contents = GetContents(25);
buf = msg.ToArray();
for (int i = 0; i < buf.Length; i++)
{
sock.Send(buf, i, 1, SocketFlags.None);
Thread.Sleep(1);
}
recvMsg = (SipRequest)transport.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(msg[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual("0", recvMsg["Count"].FullText);
CollectionAssert.AreEqual(msg.Contents, recvMsg.Contents);
}
finally
{
if (sock != null)
{
sock.Close();
}
transport.Stop();
}
}
public void Request_Basic()
{
SipBasicCore core = null;
SipCoreSettings settings;
SipRequest request;
SipResult result;
string serviceUri;
try
{
settings = new SipCoreSettings();
settings.UserName = "******";
settings.Password = "******";
serviceUri = "sip:" + settings.TransportSettings[0].ExternalBinding.ToString();
core = new SipBasicCore(settings);
core.RequestReceived += new SipRequestDelegate(OnRequest);
core.Start();
request = new SipRequest(SipMethod.Info, serviceUri, null);
request.AddHeader("Test", "OK");
result = core.Request(request);
Assert.AreEqual(SipStatus.OK, result.Status);
}
finally
{
if (core != null)
{
core.Stop();
}
}
}
public void SipMaxForwardsValue_Message()
{
SipRequest message = new SipRequest(SipMethod.Invite, "sip:[email protected]", null);
SipMaxForwardsValue v;
Assert.IsNull(message.GetHeader <SipMaxForwardsValue>(SipHeader.MaxForwards));
message.AddHeader(SipHeader.MaxForwards, new SipMaxForwardsValue(77));
v = message.GetHeader <SipMaxForwardsValue>(SipHeader.MaxForwards);
Assert.IsNotNull(v);
Assert.AreEqual(77, v.Count);
}
public void SipTcpTransport_TransmitSingle()
{
// Create two transport instances and send a message from one to
// the other and verify that it got through.
TestTransport transport1 = new TestTransport();
TestTransport transport2 = new TestTransport();
SipRequest sentMsg;
SipRequest recvMsg;
try
{
transport1.Start(new NetworkBinding("127.0.0.1:5311"));
transport2.Start(new NetworkBinding("127.0.0.1:5312"));
Assert.IsTrue(transport1.IsStreaming);
Assert.AreEqual(SipTransportType.TCP, transport1.TransportType);
sentMsg = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
sentMsg.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport1.LocalEndpoint));
transport1.Send(transport2.LocalEndpoint, sentMsg);
recvMsg = (SipRequest)transport2.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(sentMsg[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual(transport1.LocalEndpoint.Address, recvMsg.RemoteEndpoint.Address);
// Send a message the other way, this one with some content data
sentMsg = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
sentMsg.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport1.LocalEndpoint));
sentMsg.Contents = new byte[] { 0, 1, 2, 3, 4 };
transport2.Send(transport1.LocalEndpoint, sentMsg);
recvMsg = (SipRequest)transport1.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(sentMsg[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
CollectionAssert.AreEqual(new byte[] { 0, 1, 2, 3, 4 }, recvMsg.Contents);
Assert.AreEqual(transport2.LocalEndpoint.Address, recvMsg.RemoteEndpoint.Address);
}
finally
{
transport1.Stop();
transport2.Stop();
}
}
public void SipValue_Message()
{
SipRequest message = new SipRequest(SipMethod.Invite, "sip:[email protected]", null);
SipValue v;
Assert.IsNull(message.GetHeader <SipValue>("Test"));
message.AddHeader("Test", new SipValue("jeff;hello=world"));
v = message.GetHeader <SipValue>("Test");
Assert.IsNotNull(v);
Assert.AreEqual("jeff", v.Text);
Assert.AreEqual("world", v["hello"]);
}
public void SipAuthenticateValue_Message()
{
SipRequest message = new SipRequest(SipMethod.Invite, "sip:[email protected]", null);
SipAuthenticateValue v;
Assert.IsNull(message.GetHeader <SipAuthenticateValue>(SipHeader.WWWAuthenticate));
message.AddHeader(SipHeader.WWWAuthenticate, new SipAuthenticateValue("Digest algorithm=MD5, realm=\"asterisk\", nonce=\"5c9dda7a\""));
v = message.GetHeader <SipAuthenticateValue>(SipHeader.WWWAuthenticate);
Assert.IsNotNull(v);
Assert.AreEqual("MD5", v.Algorithm);
Assert.AreEqual("asterisk", v.Realm);
}
public void SipCSeqValue_Message()
{
SipRequest message = new SipRequest(SipMethod.Invite, "sip:[email protected]", null);
SipCSeqValue v;
Assert.IsNull(message.GetHeader <SipCSeqValue>(SipHeader.CSeq));
message.AddHeader(SipHeader.CSeq, new SipCSeqValue("10 INVITE"));
v = message.GetHeader <SipCSeqValue>(SipHeader.CSeq);
Assert.IsNotNull(v);
Assert.AreEqual("INVITE", v.Method);
Assert.AreEqual("10 INVITE", v.Text);
}
public void SipContactValue_Message()
{
SipRequest message = new SipRequest(SipMethod.Invite, "sip:[email protected]", null);
SipContactValue v;
Assert.IsNull(message.GetHeader <SipContactValue>(SipHeader.Contact));
message.AddHeader(SipHeader.Contact, new SipContactValue("\"Jeff Lill\" <*****@*****.**>;hello=world"));
v = message.GetHeader <SipContactValue>(SipHeader.Contact);
Assert.IsNotNull(v);
Assert.AreEqual("Jeff Lill", v.DisplayName);
Assert.AreEqual("*****@*****.**", v.Uri);
Assert.AreEqual("world", v["hello"]);
}
public void SipViaValue_Message()
{
SipRequest message = new SipRequest(SipMethod.Invite, "sip:[email protected]", null);
SipViaValue v;
Assert.IsNull(message.GetHeader <SipViaValue>("Test"));
message.AddHeader(SipHeader.Via, new SipViaValue("SIP/2.0/UDP 1.2.3.4;received=5.6.7.8"));
v = message.GetHeader <SipViaValue>(SipHeader.Via);
Assert.IsNotNull(v);
Assert.AreEqual(SipTransportType.UDP, v.TransportType);
Assert.AreEqual("1.2.3.4", v.SentBy);
Assert.AreEqual("5.6.7.8", v.Received);
}
public void SipAuthorizationValue_Message()
{
SipRequest message = new SipRequest(SipMethod.Invite, "sip:[email protected]", null);
SipAuthenticateValue vChallenge;
SipAuthorizationValue vResponse;
SipAuthorizationValue v;
vChallenge = new SipAuthenticateValue("Digest realm=\"asterisk\", nonce=\"5c9dda7a\"");
vResponse = new SipAuthorizationValue(vChallenge, "jslill", "q0jsrd7y", "REGISTER", "sip:sip4.vitelity.net");
Assert.IsNull(message.GetHeader <SipAuthorizationValue>(SipHeader.Authorization));
message.AddHeader(SipHeader.Authorization, vResponse);
v = message.GetHeader <SipAuthorizationValue>(SipHeader.Authorization);
Assert.IsNotNull(v);
Assert.AreEqual(vResponse.Response, v.Response);
}
public void SipUdpTransport_TransmitSingle()
{
// Create two transport instances and send a message from one to
// the other and verify that it got through.
TestTransport transport1 = new TestTransport();
TestTransport transport2 = new TestTransport();
SipRequest sentMsg;
SipRequest recvMsg;
try
{
transport1.Start(new NetworkBinding("127.0.0.1:ANY"));
transport2.Start(new NetworkBinding("127.0.0.1:ANY"));
Assert.IsFalse(transport1.IsStreaming);
Assert.AreEqual(SipTransportType.UDP, transport1.TransportType);
sentMsg = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
sentMsg.AddHeader(SipHeader.Via, string.Format("SIP/2.0/UDP {0}", transport1.LocalEndpoint));
transport1.Send(transport2.LocalEndpoint, sentMsg);
recvMsg = (SipRequest)transport2.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(sentMsg[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual(transport1.LocalEndpoint.Address, recvMsg.RemoteEndpoint.Address);
Assert.AreEqual(transport1.LocalEndpoint.Port, recvMsg.RemoteEndpoint.Port);
}
finally
{
transport1.Stop();
transport2.Stop();
}
}
private void Blast(SipTransportType transportType)
{
TestCore serverCore = null;
TestCore clientCore = null;
SipServerAgent serverAgent;
SipClientAgent clientAgent;
SipCoreSettings settings;
SipRequest request;
SipResponse response;
SipResult result;
try
{
// Initialize the test cores
settings = new SipCoreSettings();
settings.TransportSettings = new SipTransportSettings[] {
new SipTransportSettings(SipTransportType.UDP, NetworkBinding.Parse("ANY:5060"), 0),
new SipTransportSettings(SipTransportType.TCP, NetworkBinding.Parse("ANY:5060"), 0)
};
serverCore = new TestCore(settings);
serverAgent = new SipServerAgent(serverCore, serverCore);
serverCore.Start(serverAgent);
serverCore.SetHandler(new SipRequestDelegate(OnRequest));
settings = new SipCoreSettings();
settings.TransportSettings = new SipTransportSettings[] {
new SipTransportSettings(SipTransportType.UDP, NetworkBinding.Parse("ANY:0"), 0),
new SipTransportSettings(SipTransportType.TCP, NetworkBinding.Parse("ANY:0"), 0)
};
clientCore = new TestCore(settings);
clientAgent = new SipClientAgent(clientCore, clientCore);
clientCore.Start(clientAgent);
clientCore.SetHandler(new SipResponseDelegate(OnResponse));
// Do a bunch of requests
for (int i = 0; i < 1000; i++)
{
Clear();
request = new SipRequest(SipMethod.Register, string.Format("sip:127.0.0.1:5060;transport={0}", transportType.ToString().ToLowerInvariant()), null);
request.AddHeader(SipHeader.To, "sip:[email protected]");
request.AddHeader(SipHeader.From, "sip:[email protected]");
request.Contents = new byte[] { (byte)i };
serverOp = ServerOp.OK;
result = clientAgent.Request(request, null);
response = result.Response;
Thread.Sleep(100);
Assert.AreEqual(SipStatus.OK, result.Status);
CollectionAssert.AreEqual(request.Contents, response.Contents);
}
}
finally
{
if (clientCore != null)
{
clientCore.Stop();
}
if (serverCore != null)
{
serverCore.Stop();
}
}
}
private void Provisional(SipTransportType transportType)
{
TestCore serverCore = null;
TestCore clientCore = null;
SipServerAgent serverAgent;
SipClientAgent clientAgent;
SipCoreSettings settings;
SipRequest request;
SipResponse response;
SipResult result;
try
{
// Initialize the test cores
settings = new SipCoreSettings();
settings.TransportSettings = new SipTransportSettings[] {
new SipTransportSettings(SipTransportType.UDP, NetworkBinding.Parse("ANY:5060"), 0),
new SipTransportSettings(SipTransportType.TCP, NetworkBinding.Parse("ANY:5060"), 0)
};
serverCore = new TestCore(settings);
serverAgent = new SipServerAgent(serverCore, serverCore);
serverCore.Start(serverAgent);
serverCore.SetHandler(new SipRequestDelegate(OnRequest));
settings = new SipCoreSettings();
settings.TransportSettings = new SipTransportSettings[] {
new SipTransportSettings(SipTransportType.UDP, NetworkBinding.Parse("ANY:0"), 0),
new SipTransportSettings(SipTransportType.TCP, NetworkBinding.Parse("ANY:0"), 0)
};
clientCore = new TestCore(settings);
clientAgent = new SipClientAgent(clientCore, clientCore);
clientCore.Start(clientAgent);
clientCore.SetHandler(new SipResponseDelegate(OnResponse));
// Verify a transaction with a single provisional response.
//
// I'm also going to verify that setting SipRequest.ViaInstanceParam
// resulted in the "instance" parameter being added to the requests
// Via header.
Clear();
request = new SipRequest(SipMethod.Register, string.Format("sip:127.0.0.1:5060;transport={0}", transportType.ToString().ToLowerInvariant()), null);
request.AddHeader(SipHeader.To, "sip:[email protected]");
request.AddHeader(SipHeader.From, "sip:[email protected]");
serverOp = ServerOp.ProvisionalOK;
result = clientAgent.Request(request, null);
Thread.Sleep(100);
Assert.AreEqual(SipStatus.OK, result.Status);
// Verify the response headers
request = result.Request;
response = result.Response;
Assert.AreEqual(1, requestArgs.Count);
Assert.AreEqual(2, responseArgs.Count);
Assert.AreEqual(SipStatus.Trying, responseArgs[0].Response.Status);
Assert.AreEqual(SipStatus.OK, responseArgs[1].Response.Status);
Assert.AreEqual(request.Headers[SipHeader.To].Text, new SipValue(request.Headers[SipHeader.To].Text).Text);
Assert.IsTrue(string.IsNullOrWhiteSpace(new SipValue(response.Headers[SipHeader.To].Text)["tag"]));
Assert.AreEqual(request.Headers[SipHeader.From].Text, response.Headers[SipHeader.From].Text);
Assert.AreEqual(request.Headers[SipHeader.CallID].Text, response.Headers[SipHeader.CallID].Text);
Assert.AreEqual(request.Headers[SipHeader.CSeq].Text, response.Headers[SipHeader.CSeq].Text);
Assert.AreEqual(request.Headers[SipHeader.Via].Text, response.Headers[SipHeader.Via].Text);
// Verify a transaction with two provisional responses
Clear();
request = new SipRequest(SipMethod.Register, string.Format("sip:127.0.0.1:5060;transport={0}", transportType.ToString().ToLowerInvariant()), null);
request.AddHeader(SipHeader.To, "sip:[email protected]");
request.AddHeader(SipHeader.From, "sip:[email protected]");
serverOp = ServerOp.ProvisionalProvisionalOK;
result = clientAgent.Request(request, null);
Thread.Sleep(100);
Assert.AreEqual(SipStatus.OK, result.Status);
// Verify the response headers
request = result.Request;
response = result.Response;
Assert.AreEqual(1, requestArgs.Count);
Assert.AreEqual(3, responseArgs.Count);
Assert.AreEqual(SipStatus.Trying, responseArgs[0].Response.Status);
Assert.AreEqual("0", responseArgs[0].Response["Test"].Text);
Assert.AreEqual(SipStatus.Trying, responseArgs[1].Response.Status);
Assert.AreEqual("1", responseArgs[1].Response["Test"].Text);
Assert.AreEqual(SipStatus.OK, responseArgs[2].Response.Status);
Assert.AreEqual("2", responseArgs[2].Response["Test"].Text);
Assert.AreEqual(request.Headers[SipHeader.To].Text, new SipValue(request.Headers[SipHeader.To].Text).Text);
Assert.IsTrue(string.IsNullOrWhiteSpace(new SipValue(response.Headers[SipHeader.To].Text)["tag"]));
Assert.AreEqual(request.Headers[SipHeader.From].Text, response.Headers[SipHeader.From].Text);
Assert.AreEqual(request.Headers[SipHeader.CallID].Text, response.Headers[SipHeader.CallID].Text);
Assert.AreEqual(request.Headers[SipHeader.CSeq].Text, response.Headers[SipHeader.CSeq].Text);
Assert.AreEqual(request.Headers[SipHeader.Via].Text, response.Headers[SipHeader.Via].Text);
}
finally
{
if (clientCore != null)
{
clientCore.Stop();
}
if (serverCore != null)
{
serverCore.Stop();
}
}
}
//---------------------------------------------------------------------
// Tests
private void Basic(SipTransportType transportType)
{
TestCore serverCore = null;
TestCore clientCore = null;
SipServerAgent serverAgent;
SipClientAgent clientAgent;
SipCoreSettings settings;
SipRequest request;
SipResponse response;
SipResult result;
try
{
// Initialize the test cores
settings = new SipCoreSettings();
settings.TransportSettings = new SipTransportSettings[] {
new SipTransportSettings(SipTransportType.UDP, NetworkBinding.Parse("ANY:5060"), 0),
new SipTransportSettings(SipTransportType.TCP, NetworkBinding.Parse("ANY:5060"), 0)
};
serverCore = new TestCore(settings);
serverAgent = new SipServerAgent(serverCore, serverCore);
serverCore.Start(serverAgent);
serverCore.SetHandler(new SipRequestDelegate(OnRequest));
settings = new SipCoreSettings();
settings.TransportSettings = new SipTransportSettings[] {
new SipTransportSettings(SipTransportType.UDP, NetworkBinding.Parse("ANY:0"), 0),
new SipTransportSettings(SipTransportType.TCP, NetworkBinding.Parse("ANY:0"), 0)
};
clientCore = new TestCore(settings);
clientAgent = new SipClientAgent(clientCore, clientCore);
clientCore.Start(clientAgent);
clientCore.SetHandler(new SipResponseDelegate(OnResponse));
// Verify a basic Request/OK transaction
Clear();
request = new SipRequest(SipMethod.Register, string.Format("sip:127.0.0.1:5060;transport={0}", transportType.ToString().ToLowerInvariant()), null);
request.AddHeader(SipHeader.To, "sip:[email protected]");
request.AddHeader(SipHeader.From, "sip:[email protected]");
serverOp = ServerOp.OK;
result = clientAgent.Request(request, null);
Thread.Sleep(100);
Assert.AreEqual(SipStatus.OK, result.Status);
// Verify the response headers
request = result.Request;
response = result.Response;
Assert.AreEqual(1, requestArgs.Count);
Assert.AreEqual(1, responseArgs.Count);
Assert.AreEqual(request.Headers[SipHeader.To].Text, new SipValue(request.Headers[SipHeader.To].Text).Text);
Assert.IsTrue(string.IsNullOrWhiteSpace(new SipValue(response.Headers[SipHeader.To].Text)["tag"]));
Assert.AreEqual(request.Headers[SipHeader.From].Text, response.Headers[SipHeader.From].Text);
Assert.AreEqual(request.Headers[SipHeader.CallID].Text, response.Headers[SipHeader.CallID].Text);
Assert.AreEqual(request.Headers[SipHeader.CSeq].Text, response.Headers[SipHeader.CSeq].Text);
Assert.AreEqual(request.Headers[SipHeader.Via].Text, response.Headers[SipHeader.Via].Text);
// Verify that "Max-Forwards: 70" headers were added to the request message.
Assert.AreEqual(SipHelper.MaxForwards, requestArgs[0].Request.GetHeaderText(SipHeader.MaxForwards));
// Verify requests that result in errors.
Clear();
request = new SipRequest(SipMethod.Register, string.Format("sip:127.0.0.1:5060;transport={0}", transportType.ToString().ToLowerInvariant()), null);
request.AddHeader(SipHeader.To, "sip:[email protected]");
request.AddHeader(SipHeader.From, "sip:[email protected]");
serverOp = ServerOp.Error;
result = clientAgent.Request(request, null);
Thread.Sleep(100);
Assert.AreEqual(SipStatus.NotImplemented, result.Status);
// Verify the response headers
request = result.Request;
response = result.Response;
Assert.AreEqual(1, requestArgs.Count);
Assert.AreEqual(1, responseArgs.Count);
Assert.AreEqual(request.Headers[SipHeader.To].Text, new SipValue(request.Headers[SipHeader.To].Text).Text);
Assert.IsTrue(string.IsNullOrWhiteSpace(new SipValue(response.Headers[SipHeader.To].Text)["tag"]));
Assert.AreEqual(request.Headers[SipHeader.From].Text, response.Headers[SipHeader.From].Text);
Assert.AreEqual(request.Headers[SipHeader.CallID].Text, response.Headers[SipHeader.CallID].Text);
Assert.AreEqual(request.Headers[SipHeader.CSeq].Text, response.Headers[SipHeader.CSeq].Text);
Assert.AreEqual(request.Headers[SipHeader.Via].Text, response.Headers[SipHeader.Via].Text);
}
finally
{
if (clientCore != null)
{
clientCore.Stop();
}
if (serverCore != null)
{
serverCore.Stop();
}
}
}
public void SipTcpTransport_MultipleBuffered()
{
// Render two messages into a single buffer and transmit them
// to a TCP transport in a single send. This will result in
// the two messages being processed out of the headerBuf which
// is what we want to test here.
TestTransport transport = new TestTransport();
EnhancedSocket sock = null;
SipRequest msg1, msg2;
SipRequest recvMsg;
byte[] buf;
int cb;
try
{
transport.Start(new NetworkBinding("127.0.0.1:5311"));
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Connect("127.0.0.1", 5311);
msg1 = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
msg1.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport.LocalEndpoint));
msg1.AddHeader("Count", "0");
msg1.Contents = GetContents(0);
msg2 = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
msg2.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport.LocalEndpoint));
msg2.AddHeader("Count", "1");
msg2.Contents = GetContents(0);
buf = Helper.Concat(msg1.ToArray(), msg2.ToArray());
cb = sock.Send(buf);
Assert.AreEqual(buf.Length, cb);
recvMsg = (SipRequest)transport.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(msg1[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual("0", recvMsg["Count"].FullText);
CollectionAssert.AreEqual(msg1.Contents, recvMsg.Contents);
recvMsg = (SipRequest)transport.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(msg2[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual("1", recvMsg["Count"].FullText);
CollectionAssert.AreEqual(msg2.Contents, recvMsg.Contents);
// Try it again, this time with some data.
msg1 = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
msg1.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport.LocalEndpoint));
msg1.AddHeader("Count", "0");
msg1.Contents = GetContents(10);
msg2 = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
msg2.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport.LocalEndpoint));
msg2.AddHeader("Count", "1");
msg2.Contents = GetContents(20);
buf = Helper.Concat(msg1.ToArray(), msg2.ToArray());
cb = sock.Send(buf);
Assert.AreEqual(buf.Length, cb);
recvMsg = (SipRequest)transport.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(msg1[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual("0", recvMsg["Count"].FullText);
CollectionAssert.AreEqual(msg1.Contents, recvMsg.Contents);
recvMsg = (SipRequest)transport.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(msg2[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual("1", recvMsg["Count"].FullText);
CollectionAssert.AreEqual(msg2.Contents, recvMsg.Contents);
// Try it one more time, this time adding a leading CRLF
msg1 = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
msg1.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport.LocalEndpoint));
msg1.AddHeader("Count", "0");
msg1.Contents = GetContents(10);
msg2 = new SipRequest(SipMethod.Register, "sip:[email protected]", SipHelper.SIP20);
msg2.AddHeader(SipHeader.Via, string.Format("SIP/2.0/TCP {0}", transport.LocalEndpoint));
msg2.AddHeader("Count", "1");
msg2.Contents = GetContents(20);
buf = Helper.Concat(new byte[] { 0x0D, 0x0A }, msg1.ToArray(), new byte[] { 0x0D, 0x0A }, msg2.ToArray());
cb = sock.Send(buf);
Assert.AreEqual(buf.Length, cb);
recvMsg = (SipRequest)transport.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(msg1[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual("0", recvMsg["Count"].FullText);
CollectionAssert.AreEqual(msg1.Contents, recvMsg.Contents);
recvMsg = (SipRequest)transport.Receive();
Assert.AreEqual(SipMethod.Register, recvMsg.Method);
Assert.AreEqual("sip:[email protected]", recvMsg.Uri);
Assert.AreEqual(SipHelper.SIP20, recvMsg.SipVersion);
Assert.AreEqual(msg2[SipHeader.Via].FullText, recvMsg[SipHeader.Via].FullText);
Assert.AreEqual("1", recvMsg["Count"].FullText);
CollectionAssert.AreEqual(msg2.Contents, recvMsg.Contents);
}
finally
{
if (sock != null)
{
sock.Close();
}
transport.Stop();
}
}
