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); } } }