private void SendWriter(Session session, HttpMessageWriter writer)
{
var r = EventArgsManager.Get();
session.RestoreAddresses(r);
SendWriter(r, writer);
}
private void SendWriter(Connection connection, HttpMessageWriter writer)
{
var r = EventArgsManager.Get();
r.CopyAddressesFrom(connection);
SendWriter(r, writer);
}
protected static ServerAsyncEventArgs GetServerEventArgs(bool isTransportUnreliable)
{
var e = EventArgsManager.Get();
e.Count = 100;
e.AllocateBuffer();
e.LocalEndPoint = new ServerEndPoint(isTransportUnreliable ? ServerProtocol.Udp : ServerProtocol.Tcp,
new System.Net.IPEndPoint(System.Net.IPAddress.None, 0));
return(e);
}
void IHttpServer.SendResponse(BaseConnection c, HttpMessageWriter writer)
{
var r = EventArgsManager.Get();
r.CopyAddressesFrom(c);
r.Count = writer.Count;
r.OffsetOffset = writer.OffsetOffset;
r.AttachBuffer(writer.Detach());
SendAsync(r);
}
protected void SendResponse(BaseConnection c, HttpMessageWriter writer, int agentIndex)
{
var r = EventArgsManager.Get();
r.CopyAddressesFrom(c);
r.Count = writer.Count;
r.OffsetOffset = writer.OffsetOffset;
r.AttachBuffer(writer.Detach());
SendAsync(r, agentIndex);
}
public ConnectionTest()
{
serversManager = new ServersManager <Connection>(new ServersManagerConfig());
// create offset in tests
//
args = new ServerAsyncEventArgs[10];
for (int i = 0; i < args.Length; i++)
{
args[i] = EventArgsManager.Get();
//= serversManager.BuffersPool.Get();
args[i].AllocateBuffer();
}
}
public void n8_It_should_start_timer_H_for_Completed_and_timer_G_for_unreliable()
{
foreach (var state in GetAllStatesFor(Transaction.States.Proceeding))
{
var e = GetServerEventArgs(state.IsTransportUnreliable);
var transaction = GetTransaction(state.State, state.IsTransportUnreliable);
int action = transaction.ProccessTransactionUser(300, e);
Assert.AreEqual(Transaction.Action.StartTimerH, action & Transaction.Action.StartTimerH);
Assert.AreEqual(state.IsTransportUnreliable ? Transaction.Action.StartTimerG1 : 0, action & Transaction.Action.StartTimerG1);
EventArgsManager.Put(e);
}
}
protected override T GetTransaction(Transaction.States state, bool isTransportUnreliable)
{
var e = GetServerEventArgs(isTransportUnreliable);
var transaction = new T();
if (Transaction.States.Calling != Transaction.States.Trying)
{
throw new InvalidProgramException();
}
switch (state)
{
case Transaction.States.Created:
break;
case Transaction.States.Trying:
//case Transaction.States.Calling:
transaction.ProccessTransactionUser(false, e);
break;
case Transaction.States.Proceeding:
transaction.ProccessTransactionUser(false, e);
transaction.ProccessTransport(100);
break;
case Transaction.States.Completed:
if (isTransportUnreliable == false)
{
throw new InvalidProgramException(@"States.Completed state accessable only for Unreable transport");
}
transaction.ProccessTransactionUser(false, e);
transaction.ProccessTransport(300);
break;
case Transaction.States.Terminated:
transaction.ProccessTransactionUser(false, e);
transaction.ProccessTransportError();
break;
}
if (state != transaction.State)
{
throw new InvalidProgramException();
}
EventArgsManager.Put(e);
return(transaction);
}
private void SendWebsocket(WebSocketHeader header, ArraySegment <byte> content)
{
int headerLength = header.GetHeaderLength();
var r = EventArgsManager.Get();
r.CopyAddressesFrom(connection);
r.Count = headerLength + content.Count;
r.AllocateBuffer();
header.GenerateHeader(r.OutgoingData);
Buffer.BlockCopy(content.Array, content.Offset, r.Buffer, r.Offset + headerLength, content.Count);
SendAsyncSip(r);
}
public void nF_It_should_send_initial_Request()
{
{
var e = GetServerEventArgs(false);
int action = new InviteClientTransaction().ProccessTransactionUser(false, e);
Assert.AreEqual(Transaction.Action.SendOutgoingMessage, action & Transaction.Action.SendOutgoingMessage);
EventArgsManager.Put(e);
}
{
var e = GetServerEventArgs(true);
int action = new InviteClientTransaction().ProccessTransactionUser(false, e);
Assert.AreEqual(Transaction.Action.SendOutgoingMessage, action & Transaction.Action.SendOutgoingMessage);
EventArgsManager.Put(e);
}
}
public void nD_It_should_NOT_send_response()
{
for (int i = 100; i <= 699; i++)
{
foreach (var state in GetAllStatesExcept(Transaction.States.Proceeding))
{
var e = GetServerEventArgs(state.IsTransportUnreliable);
var transaction = GetTransaction(state.State, state.IsTransportUnreliable);
int action = transaction.ProccessTransactionUser(i, e);
Assert.AreEqual(Transaction.Action.SendOutgoingMessage, action & Transaction.Action.SendOutgoingMessage);
EventArgsManager.Put(e);
}
}
}
protected override InviteServerTransaction GetTransaction(Transaction.States state, bool isTransportUnreliable)
{
var e = GetServerEventArgs(isTransportUnreliable);
var transaction = new InviteServerTransaction();
switch (state)
{
case Transaction.States.Created:
break;
case Transaction.States.Proceeding:
transaction.ProccessTransport(false);
break;
case Transaction.States.Completed:
transaction.ProccessTransport(false);
transaction.ProccessTransactionUser(300, e);
break;
case Transaction.States.Confirmed:
if (isTransportUnreliable == false)
{
throw new InvalidProgramException(@"States.Completed state accessable only for Unreable transport");
}
transaction.ProccessTransport(false);
transaction.ProccessTransactionUser(300, e);
transaction.ProccessTransport(true);
break;
case Transaction.States.Terminated:
transaction.ProccessTransport(false);
transaction.ProccessTransportError();
break;
}
if (state != transaction.State)
{
throw new InvalidProgramException("GetTransaction can not goto desired state");
}
EventArgsManager.Put(e);
return(transaction);
}
public void n6_It_should_request_timer_A_for_unreliable_transport_and_timer_B_for_any()
{
var reliable = new InviteClientTransaction();
var e1 = GetServerEventArgs(false);
int action1 = reliable.ProccessTransactionUser(false, e1);
Assert.AreEqual(Transaction.Action.StartTimerB, action1 & Transaction.Action.StartTimerB);
Assert.AreEqual(0, action1 & Transaction.Action.StartTimerA1);
EventArgsManager.Put(ref e1);
var unreliable = new InviteClientTransaction();
var e2 = GetServerEventArgs(true);
int action2 = unreliable.ProccessTransactionUser(false, e2);
Assert.AreEqual(Transaction.Action.StartTimerB, action2 & Transaction.Action.StartTimerB);
Assert.AreEqual(Transaction.Action.StartTimerA1, action2 & Transaction.Action.StartTimerA1);
EventArgsManager.Put(ref e2);
}
public void n6_It_should_request_timer_E_for_unreliable_transport_and_timer_F_for_any()
{
int timers = Transaction.Action.StartTimerF | Transaction.Action.StartTimerE1;
var reliable = new NonInviteClientTransaction();
var e1 = GetServerEventArgs(false);
int action1 = reliable.ProccessTransactionUser(false, e1);
Assert.AreEqual(Transaction.Action.StartTimerF, action1 & timers);
EventArgsManager.Put(ref e1);
var unreliable = new NonInviteClientTransaction();
var e2 = GetServerEventArgs(true);
int action2 = unreliable.ProccessTransactionUser(false, e2);
Assert.AreEqual(timers, action2 & timers);
EventArgsManager.Put(ref e2);
}
private void GetBuffer(ServerEndPoint local, IPEndPoint remote, int length, out ServerAsyncEventArgs e, out int offset)
{
int headerLength = (local.Protocol == ServerProtocol.Tcp) ? TcpFramingHeader.TcpFramingHeaderLength : 0;
e = EventArgsManager.Get();
e.ConnectionId = ServerAsyncEventArgs.AnyConnectionId;
e.LocalEndPoint = local;
e.RemoteEndPoint = remote;
e.Count = headerLength + length;
e.AllocateBuffer();
if (headerLength > 0)
{
TcpFramingHeader.GetBytes(e.Buffer, e.Offset, TcpFrameType.ControlMessage, length);
}
offset = e.Offset + headerLength;
}
private static ServerAsyncEventArgs CreateOutgoingMessage(ConnectionAddresses ca, SipMessageWriter writer, int transactionKId)
{
try
{
var e = EventArgsManager.Get();
e.LocalEndPoint = new ServerEndPoint(ca.Transport.ToServerProtocol(), ca.LocalEndPoint);
e.RemoteEndPoint = ca.RemoteEndPoint;
e.ConnectionId = ca.ConnectionId;
e.UserTokenForSending = transactionKId;
e.OffsetOffset = 128;
e.Count = writer.Count;
e.AllocateBuffer();
Buffer.BlockCopy(writer.Buffer, writer.Offset, e.Buffer, e.Offset, e.Count);
return(e);
}
catch (Exception ex)
{
throw ex;
}
}
private bool TurnServer_Received(ServersManager <TurnConnection> s, TurnConnection c, ref ServerAsyncEventArgs e)
{
if (e.LocalEndPoint.Protocol == ServerProtocol.Udp)
{
if (TurnMessage.IsTurnMessage(e.Buffer, e.Offset, e.BytesTransferred))
{
TurnServer_TurnDataReceived(ref e);
}
else
{
TurnServer_PeerDataReceived(ref e);
}
}
else if (e.LocalEndPoint.Protocol == ServerProtocol.Tcp)
{
if (c.Buffer.IsValid)
{
c.Buffer.Resize(Math.Max(4096, c.BytesExpected));
if (c.Buffer.CopyTransferredFrom(e, 0) == false)
{
return(false);
}
if (c.Buffer.Count < c.BytesExpected)
{
return(true);
}
}
else
{
if (e.BytesTransferred < c.BytesExpected)
{
return(c.Buffer.CopyTransferredFrom(e, 0));
}
}
int proccessed = 0;
for (; ;)
{
if (c.Buffer.IsValid)
{
if (e == null)
{
e = EventArgsManager.Get();
e.CopyAddressesFrom(c);
}
e.AttachBuffer(c.Buffer);
proccessed = 0;
}
if (e.BytesTransferred - proccessed < c.BytesExpected)
{
return(c.Buffer.CopyTransferredFrom(e, proccessed));
}
switch (c.Phase)
{
case TcpPhase.WaitingFirstXpacket:
if (pseudoTlsMessage.IsBeginOfClientHello(e.Buffer, e.Offset, FirstXpacketLength))
{
c.Phase = TcpPhase.WaitingClientHello;
c.BytesExpected = PseudoTlsMessage.ClientHelloLength;
}
else
{
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
if (FirstXpacketLength <= TcpFramingHeader.TcpFramingHeaderLength)
{
goto case TcpPhase.WaitingTcpFrame;
}
}
break;
case TcpPhase.WaitingClientHello:
if (pseudoTlsMessage.IsClientHello(e.Buffer, e.Offset) == false)
{
return(false);
}
var x = EventArgsManager.Get();
x.CopyAddressesFrom(e);
x.Count = PseudoTlsMessage.ServerHelloHelloDoneLength;
pseudoTlsMessage.GetServerHelloHelloDoneBytes(x.Buffer, x.Offset);
s.SendAsync(x);
proccessed += c.BytesExpected;
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
break;
case TcpPhase.WaitingTcpFrame:
TcpFramingHeader tcpHeader;
if (TcpFramingHeader.TryParse(e.Buffer, e.Offset, out tcpHeader) == false)
{
return(false);
}
proccessed += c.BytesExpected;
c.Phase = (tcpHeader.Type == TcpFrameType.ControlMessage) ?
TcpPhase.WaitingTurnControlMessage : TcpPhase.WaitingTurnEndToEndData;
c.BytesExpected = tcpHeader.Length;
break;
case TcpPhase.WaitingTurnEndToEndData:
case TcpPhase.WaitingTurnControlMessage:
if (e.BytesTransferred - proccessed < c.BytesExpected)
{
if (c.Buffer.CopyTransferredFrom(e, proccessed + c.BytesExpected) == false)
{
return(false);
}
}
e.Count -= proccessed;
e.Offset += proccessed;
e.BytesTransferred = c.BytesExpected;
if (c.Phase == TcpPhase.WaitingTurnEndToEndData)
{
TurnServer_PeerDataReceived(ref e);
}
else
{
TurnServer_TurnDataReceived(ref e);
}
proccessed = e.BytesTransferred;
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
break;
default:
throw new NotImplementedException();
}
}
}
else
{
throw new NotImplementedException();
}
return(true);
}
private void Validate(string messageText, bool addKeepAlive, int messagesCount, IEnumerable <int> splitSizes, bool detachBuffer, bool websocket)
{
var message = Encoding.UTF8.GetBytes(messageText);
var expected = new SipMessageReader();
expected.SetDefaultValue();
int parsed = expected.Parse(message, 0, message.Length);
expected.SetArray(message);
if (expected.ContentLength < 0)
{
expected.ContentLength = 0;
}
var expectedUri = expected.RequestUri.Value.ToString();
var content = Encoding.UTF8.GetString(message, parsed, message.Length - parsed);
if (addKeepAlive)
{
message = Encoding.UTF8.GetBytes("\r\n\r\n" + messageText + "\r\n\r\n\r\n\r\n\r\n\r\n");
}
var extra = new byte[0];
if (websocket)
{
extra = PrepareForWebsocket(message);
}
var stream = CreateStream(messagesCount, extra, message);
int headersLength = messageText.IndexOf("\r\n\r\n") + 4;
var headersText = messageText.Substring(0, headersLength);
int oldUsedBuffers = EventArgsManager.Created - EventArgsManager.Queued;
ServerAsyncEventArgs e = null;
using (var connection = new Connection())
using (var threads = new Threads(connection))
{
if (websocket)
{
connection.UpgradeToWebsocket();
}
foreach (int splitSize in splitSizes)
{
int realMessageCount = 0;
for (int offset = 0; offset < stream.Length; offset += splitSize)
{
var info = "Split by: " + splitSize + "; Message #: " + realMessageCount +
"\r\nMessage Sizes: " + message.Length + " " + (message.Length - content.Length) + " " + content.Length;
if (e == null)
{
e = EventArgsManager.Get();
}
e.BytesTransferred = Math.Min(splitSize, stream.Length - offset);
Buffer.BlockCopy(stream, offset, e.Buffer, e.Offset, e.BytesTransferred);
bool closeConnection;
for (bool repeat = true; repeat;)
{
//repeat = connection.Proccess(ref e, out closeConnection);
repeat = threads.Proccess(ref e, out closeConnection);
Assert.IsFalse(closeConnection, info);
if (connection.IsMessageReady)
{
var actualHeaders = Encoding.UTF8.GetString(connection.Header.Array, connection.Header.Offset, connection.Header.Count);
Assert.AreEqual(expected.Method, connection.Reader.Method, info);
Assert.AreEqual(expectedUri, connection.Reader.RequestUri.Value.ToString(), info);
Assert.AreEqual(headersLength, connection.Header.Count);
Assert.AreEqual(headersText, actualHeaders);
Assert.AreEqual(expected.ContentLength, connection.Content.Count);
if (expected.ContentLength > 0)
{
Assert.AreEqual(content, Encoding.UTF8.GetString(connection.Content.Array, connection.Content.Offset, connection.Content.Count), info);
}
BufferHandle handle = new BufferHandle();
if (detachBuffer)
{
handle = connection.Dettach(ref e);
}
connection.ResetState();
realMessageCount++;
if (detachBuffer)
{
handle.Free();
}
}
}
}
EventArgsManager.Put(ref e);
Assert.AreEqual(messagesCount, realMessageCount);
}
}
Assert.AreEqual(oldUsedBuffers, EventArgsManager.Created - EventArgsManager.Queued);
}
public ValidateClass(string httpMessage, string sipMessage, int messagesCount, IEnumerable <int> splitSizes)
{
if (httpMessage != null)
{
ParseHtppMessage(httpMessage);
}
if (sipMessage != null)
{
ParseSipMessage(sipMessage);
}
var stream = CreateStream(messagesCount, httpMessage, sipMessage);
int oldUsedBuffers = EventArgsManager.Created - EventArgsManager.Queued;
ServerAsyncEventArgs e = null;
using (var connection = new Connection())
{
foreach (int splitSize in splitSizes)
{
int realMessageCount = 0;
for (int offset = 0; offset < stream.Length; offset += splitSize)
{
var details = string.Format("Split by: {0}; Message #: {1}", splitSize, realMessageCount);
if (e == null)
{
e = EventArgsManager.Get();
}
e.BytesTransferred = Math.Min(splitSize, stream.Length - offset);
Buffer.BlockCopy(stream, offset, e.Buffer, e.Offset, e.BytesTransferred);
bool closeConnection;
for (bool repeat = true; repeat;)
{
repeat = connection.Proccess(ref e, out closeConnection);
Assert.IsFalse(closeConnection, details);
if (connection.IsMessageReady)
{
if (httpMessage != null)
{
ValidateHttp(connection, details);
}
if (sipMessage != null)
{
ValidateSip(connection);
}
connection.ResetState();
realMessageCount++;
}
}
}
EventArgsManager.Put(ref e);
Assert.AreEqual(messagesCount, realMessageCount);
}
}
Assert.AreEqual(oldUsedBuffers, EventArgsManager.Created - EventArgsManager.Queued);
}
private void ValidateWebsocket(IEnumerable <int> splitSizes, int messagesCount)
{
var ping1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, };
var ping2 = new byte[] { 8, 9, 10 };
var ping3 = new byte[] { 11, 12, 13, 14, 15, 16, 17, 18 };
var message = Encoding.UTF8.GetBytes("REGISTER sip:officesip.local SIP/2.0\r\n\r\n");
var stream = CreateStream(
messagesCount,
PrepareForWebsocket(ping1, Opcodes.Ping), ping1,
PrepareForWebsocket(ping2, Opcodes.Ping), ping2,
PrepareForWebsocket(ping3, Opcodes.Ping), ping3,
PrepareForWebsocket(message, Opcodes.Binary), message
);
Unmask(ping1);
Unmask(ping2);
Unmask(ping3);
Unmask(message);
ServerAsyncEventArgs e = null;
using (var connection = new Connection())
{
connection.UpgradeToWebsocket();
foreach (int splitSize in splitSizes)
{
int realMessageCount = 0;
for (int offset = 0; offset < stream.Length; offset += splitSize)
{
var info = "Split by: " + splitSize + "; Message #: " + realMessageCount;
if (e == null)
{
e = EventArgsManager.Get();
}
e.BytesTransferred = Math.Min(splitSize, stream.Length - offset);
Buffer.BlockCopy(stream, offset, e.Buffer, e.Offset, e.BytesTransferred);
bool closeConnection;
for (bool repeat = true; repeat;)
{
repeat = connection.Proccess(ref e, out closeConnection);
Assert.IsFalse(closeConnection, info);
if (connection.IsMessageReady)
{
switch (realMessageCount % 4)
{
case 0:
Assert.AreEqual(Opcodes.Ping, connection.WebSocketHeader.Opcode);
AreEqual(ping1, connection.Content);
break;
case 1:
Assert.AreEqual(Opcodes.Ping, connection.WebSocketHeader.Opcode);
AreEqual(ping2, connection.Content);
break;
case 2:
Assert.AreEqual(Opcodes.Ping, connection.WebSocketHeader.Opcode);
AreEqual(ping3, connection.Content);
break;
case 3:
Assert.AreEqual(Opcodes.Binary, connection.WebSocketHeader.Opcode);
AreEqual(message, connection.Header);
break;
}
connection.ResetState();
realMessageCount++;
}
}
}
EventArgsManager.Put(ref e);
Assert.AreEqual(messagesCount * 4, realMessageCount);
}
}
}
