private void TurnServer_PeerDataReceived(ref ServerAsyncEventArgs e) { //lock (syncRoot) { try { Allocation allocation = allocations.GetByPeer(e.LocalEndPoint, e.RemoteEndPoint); if (allocation != null) { allocation.TouchLifetime(); if (allocation.IsActiveDestinationEnabled) { e.LocalEndPoint = allocation.Alocated; e.RemoteEndPoint = allocation.ActiveDestination; e.Count = e.BytesTransferred; e.ConnectionId = ServerAsyncEventArgs.AnyNewConnectionId; peerServer.SendAsync(e); e = null; } } } catch (Exception ex) { logger.WriteWarning(ex.ToString()); } } }
public void ProcessOutgoing(ServerAsyncEventArgs e) { int sessionId = e.ConnectionId; Session session; if (sessions.TryGetValue(sessionId, out session) == false) { // send error } else { lock (session) { if (session.IsConnected) { SendSipEventArgs(e, session); } else { session.AddOutgoingMessage(e); } } } }
public int ProccessTransactionUser(bool isAck, ServerAsyncEventArgs e) { int action = 0; switch (State) { case Transaction.States.Created: action |= Transaction.Action.SendOutgoingMessage; if (e.LocalEndPoint.IsTransportUnreliable()) { eventArgs = e.CreateDeepCopy(); } action |= SetState(Transaction.States.Trying); break; case Transaction.States.Trying: case Transaction.States.Proceeding: case Transaction.States.Completed: case Transaction.States.Terminated: break; } return(action); }
public int ProccessTransactionUser(int statusCode, ServerAsyncEventArgs e) { int action = 0; switch (State) { case Transaction.States.Proceeding: action |= Transaction.Action.SendOutgoingMessage; if (statusCode >= 101 && statusCode <= 199) { CacheMessage(e); } else if (statusCode >= 200 && statusCode <= 299) { action |= SetState(Transaction.States.Terminated); } else if (statusCode >= 300 && statusCode <= 699) { CacheMessage(e); action |= SetState(Transaction.States.Completed); } break; case Transaction.States.Completed: case Transaction.States.Confirmed: case Transaction.States.Terminated: break; } return(action); }
//private bool IsInitialRequest(HttpMessageReader httpReader) //{ // return httpReader.RequestUri.ToString().Contains("connect=1"); //} //private int GetSessionId(HttpMessageReader httpReader) //{ // uint cookie; // if (httpReader.TryGetCookieUInt(cookieName, out cookie)) // return Session.GetSessionId(GetConnectionId(httpReader), (int)cookie); // return -1; //} private void SendSipEventArgs(ServerAsyncEventArgs e, Session session) { session.RestoreAddresses(e); WriteHttpHeader(e); SendAsync(e, true); }
static void ServersManager_Sent(ServersManager <HttpConnection> s, ref ServerAsyncEventArgs e) { if (e.SocketError != SocketError.Success) { Console.WriteLine("Sent error: {0}", e.SocketError.ToString()); } }
private void CacheMessage(ServerAsyncEventArgs e) { if (eventArgs != null) { eventArgs.Dispose(); } eventArgs = e.CreateDeepCopy(); }
private void SendWriter(ServerAsyncEventArgs r, HttpMessageWriter writer) { r.Count = writer.Count; r.OffsetOffset = writer.OffsetOffset; r.AttachBuffer(writer.Detach()); SendAsync(r, false); }
public BufferHandle Dettach(ref ServerAsyncEventArgs e) { ArraySegment <byte> segment1, segment2; base.Dettach(ref e, out segment1, out segment2); return(new BufferHandle(segment1, segment2)); }
public void RestoreAddresses(ServerAsyncEventArgs e) { e.ConnectionId = connectionId; e.LocalEndPoint = localEndPoint; e.RemoteEndPoint = remoteEndPoint; localEndPoint = null; remoteEndPoint = null; }
public int ProccessTransactionUser(int statusCode, ServerAsyncEventArgs e) { int action = 0; switch (State) { case Transaction.States.Trying: action |= Transaction.Action.SendOutgoingMessage; if (statusCode >= 100 && statusCode <= 199) { eventArgs = e.CreateDeepCopy(); SetState(Transaction.States.Proceeding, ref action); } else if (statusCode >= 200 && statusCode <= 699) { if (e.LocalEndPoint.IsTransportUnreliable()) { SetState(Transaction.States.Completed, ref action); } else { SetState(Transaction.States.Terminated, ref action); } } break; case Transaction.States.Proceeding: action |= Transaction.Action.SendOutgoingMessage; if (statusCode >= 200 && statusCode <= 699) { if (e.LocalEndPoint.IsTransportUnreliable()) { eventArgs = e.CreateDeepCopy(); SetState(Transaction.States.Completed, ref action); } else { SetState(Transaction.States.Terminated, ref action); } } break; case Transaction.States.Completed: case Transaction.States.Terminated: break; } return(action); }
public void SendAsyncSip(ServerAsyncEventArgs e) { if (AjaxWebsocket.IsAjax(e)) { ajax.ProcessOutgoing(e); } else { e.UserTokenForSending2 = SipModule; serversManager.SendAsync(e); } }
public ServerAsyncEventArgs GetOutgoingMessage() { ServerAsyncEventArgs e = null; if (outgoingMessages.Count > 0) { e = outgoingMessages[0]; outgoingMessages.RemoveAt(0); } return(e); }
private void DoWork(ServerAsyncEventArgs e, int transactionKId, int action) { if ((action & Transaction.Action.SendOutgoingMessage) > 0) { SendAsync(e); } else { e.Dispose(); } DoWork(transactionKId, action); }
public IncomingMessage(ServerAsyncEventArgs e, SipMessageReader reader, ArraySegment <byte> content) { if (e.LocalEndPoint.Protocol != ServerProtocol.Udp) { throw new ArgumentException(); } ConnectionAddresses = new ConnectionAddresses(Transports.Udp, e.LocalEndPoint, new IPEndPoint(e.RemoteEndPoint.Address, e.RemoteEndPoint.Port), ServerAsyncEventArgs.AnyNewConnectionId); Reader = reader; Content = content; Header = new ArraySegment <byte>(e.Buffer, e.Offset, e.BytesTransferred - content.Count); }
private bool ServersManager_Received(ServersManager <Connection> s, Connection connection1, ref ServerAsyncEventArgs e1) { connection = connection1; e = e1; bool closeConnection = OnReceived(); e1 = e; connection = null; e = null; return(closeConnection); }
private static void WriteHttpHeader(ServerAsyncEventArgs e) { using (var writer = new HttpMessageWriter()) { writer.WriteStatusLine(StatusCodes.OK); writer.WriteContentLength(e.Count); writer.WriteAccessControlHeaders(); writer.WriteCRLF(); e.OffsetOffset -= writer.Count; e.Count += writer.Count; Buffer.BlockCopy(writer.Buffer, writer.Offset, e.Buffer, e.Offset, writer.Count); } }
public int ProccessTransactionUser(int transactionId, ServerAsyncEventArgs e, int statusCode) { int action = 0; lock (sync) { T transaction; if (TryGet(transactionId, out transaction)) { action = transaction.ProccessTransactionUser(statusCode, e); UpdateOrRemove(transaction); } } return(action); }
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; }
public bool Proccess(ref ServerAsyncEventArgs e, out bool closeConnection) { this.e = e; if (index < maxThread) { release[index].Set(); ThreadPool.QueueUserWorkItem(Proccess, index); done.WaitOne(); } else { Proccess(); } index = (index + 1) % (maxThread * 2); e = this.e; closeConnection = this.closeConnection; return(repeat); }
private void ServersManager_Sent(ServersManager <Connection> s, ref ServerAsyncEventArgs e) { if (e.SocketError != SocketError.Success) { Tracer.WriteInformation("Send error"); switch (e.UserTokenForSending2 & 0x000000ff) { case SipModule: SendErrorSip(e.UserTokenForSending); break; case HttpModule: // e.UserTokenForSending2 >> 8 == httpModuleId break; case AjaxModule: ajax.SendError(e.UserTokenForSending); break; } } }
public int ProccessTransactionUser(bool isAck, ServerAsyncEventArgs e) { int action = 0; switch (State) { case Transaction.States.Created: action |= Transaction.Action.SendOutgoingMessage; eventArgs = e.CreateDeepCopy(); action |= SetState(Transaction.States.Calling); break; case Transaction.States.Calling: case Transaction.States.Proceeding: break; case Transaction.States.Completed: if (isAck && IsTransportUnreliable) { if (eventArgs != null) { eventArgs.Dispose(); } eventArgs = e.CreateDeepCopy(); isAckCached = true; } break; case Transaction.States.Terminated: break; } return(action); }
private void TurnServer_TurnDataReceived(ref ServerAsyncEventArgs e) { //lock (syncRoot) { TurnMessage response = null; try { if (true)//(TransactionServer.GetCachedResponse(e, out response) == false) { TurnMessage request = TurnMessage.Parse(e.Buffer, e.Offset, e.BytesTransferred, TurnMessageRfc.MsTurn); if (Authentificater.Process(request, out response)) { Allocation allocation = null; if (request.MsSequenceNumber != null) { allocation = allocations.Get(request.MsSequenceNumber.ConnectionId); } if (allocation != null) { if (request.MsSequenceNumber != null) { response = allocation.GetResponse(request.MsSequenceNumber.SequenceNumber); } } if (response == null) { if (allocation != null) { allocation.TouchLifetime(); } switch (request.MessageType) { case MessageType.AllocateRequest: response = ProcessAllocateRequest(ref allocation, request, e.LocalEndPoint, e.RemoteEndPoint); break; case MessageType.SendRequest: response = ProcessSendRequest(allocation, request, ref e); break; case MessageType.SetActiveDestinationRequest: response = ProcessSetActiveDestinationRequest(allocation, request, e.RemoteEndPoint); break; } if (allocation != null && response != null) { allocation.SetResponse(response); } } } //TransactionServer.CacheResponse(e, response); } } catch (TurnMessageException ex) { response = GetErrorResponse(ex.ErrorCode, e); } catch (TurnServerException ex) { response = GetErrorResponse(ex.ErrorCode, e); } catch (Exception ex) { response = GetErrorResponse(ErrorCode.ServerError, e); logger.WriteError(ex.ToString()); } if (response != null) { SendTurn(response, e.LocalEndPoint, e.RemoteEndPoint); } } }
private void SendAsyncAjax(ServerAsyncEventArgs e, bool sipAjax) { e.UserTokenForSending2 = sipAjax ? SipModule : AjaxModule; serversManager.SendAsync(e); }
private TurnMessage ProcessSendRequest(Allocation allocation, TurnMessage request, ref ServerAsyncEventArgs e) { try { if (allocation == null) { throw new TurnServerException(ErrorCode.NoBinding); } if (request.Data == null || request.DestinationAddress == null) { throw new TurnServerException(ErrorCode.BadRequest); } allocation.Permissions.Permit(request.DestinationAddress.IpEndPoint); e.LocalEndPoint = allocation.Alocated; e.RemoteEndPoint = request.DestinationAddress.IpEndPoint; e.Offset = request.Data.ValueRefOffset; e.Count = request.Data.ValueRefLength; e.ConnectionId = ServerAsyncEventArgs.AnyNewConnectionId; peerServer.SendAsync(e); e = null; } catch (Exception ex) { logger.WriteWarning(ex.ToString()); } // [MS-TURN] The server MUST NOT respond to a client with either // a Send response or a Send error response. return(null); }
public void SendAsyncHttp(ServerAsyncEventArgs e, int httpModuleId) { e.UserTokenForSending2 = HttpModule | (httpModuleId << 8); serversManager.SendAsync(e); }
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); }
public int ProccessTransactionUser(int transactionId, int router, int userData, bool isAck, ServerAsyncEventArgs e) { lock (sync) { var transaction = Add(transactionId, router, userData); int action = transaction.ProccessTransactionUser(isAck, e); UpdateOrRemove(transaction); return(action); } }
private void ServersManager_BeforeSend(ServersManager <Connection> s, Connection c, ServerAsyncEventArgs e) { if (c != null && c.Mode == Connection.Modes.WebSocket) { //c.BeforeSend(e); var header = new WebSocketHeader() { Fin = true, Opcode = websocketOpcode.HasValue ? websocketOpcode.Value : c.WebSocketHeader.Opcode, PayloadLength = e.Count, }; int headerLength = header.GetHeaderLength(); if (e.OffsetOffset < headerLength) { throw new InvalidProgramException(@"TransportLayer.ServersManager_BeforeSend no reserved space for WebSocket header"); } e.OffsetOffset -= headerLength; e.Count += headerLength; header.GenerateHeader(e.OutgoingData); } }
static bool ServersManager_Received(ServersManager <HttpConnection> s, HttpConnection connection, ref ServerAsyncEventArgs e) { bool closeConnection = false, repeat = true; while (repeat) { repeat = connection.Proccess(ref e, out closeConnection); if (connection.IsMessageReady) { httpServer.ProcessIncomingRequest(connection); connection.ResetState(); } } return(!closeConnection); }