private void Disconnect_Completed(Socket socket, ServerAsyncEventArgs e) { for (; ;) { int backlog = Thread.VolatileRead(ref acceptBacklog); if (isRunning && backlog < maxAcceptBacklog) { if (Interlocked.CompareExchange(ref acceptBacklog, backlog + 1, backlog) == backlog) { e.AcceptSocket = socket; try { listener.AcceptAsync(e, Accept_Completed); } catch { EventArgsManager.Put(e); } break; } } else { EventArgsManager.Put(e); break; } } }
protected override bool OnTcpReceived(Connection <C> connection, ref ServerAsyncEventArgs e) { bool result; bool oldConnected = connection.SspiContext.Connected; if (connection.SspiContext.Connected) { result = DecryptData(ref e, connection); } else { result = Handshake(e, connection); } // proccess all data from buffer if TLS connected status was changed // while (result && oldConnected != connection.SspiContext.Connected && connection.SspiContext.Buffer.IsValid) { oldConnected = connection.SspiContext.Connected; ServerAsyncEventArgs nulle = null; if (connection.SspiContext.Connected) { result = DecryptData(ref nulle, connection); } else { result = Handshake(nulle, connection); } } return(result); }
protected override bool OnTcpReceived(Server <C> .Connection <C> connection, ref ServerAsyncEventArgs e) { bool connected = connection.SspiContext.Connected; bool flag; if (connection.SspiContext.Connected) { flag = this.DecryptData(ref e, connection); } else { flag = this.Handshake(e, connection); } while (flag && connected != connection.SspiContext.Connected && connection.SspiContext.Buffer.IsValid) { connected = connection.SspiContext.Connected; ServerAsyncEventArgs ie = null; if (connection.SspiContext.Connected) { flag = this.DecryptData(ref ie, connection); } else { flag = this.Handshake(ie, connection); } } return(flag); }
private void Disconnect_Completed(Socket socket, ServerAsyncEventArgs e) { int num; do { num = Thread.VolatileRead(ref this.acceptBacklog); if (!this.isRunning || num >= this.maxAcceptBacklog) { goto IL_5B; } }while (Interlocked.CompareExchange(ref this.acceptBacklog, num + 1, num) != num); e.AcceptSocket = socket; try { this.listener.AcceptAsync(e, new ServerAsyncEventArgs.CompletedEventHandler(this.Accept_Completed)); return; } catch { EventArgsManager.Put(e); return; } IL_5B: EventArgsManager.Put(e); }
private void Accept_Completed(Socket none, ServerAsyncEventArgs e) { Socket acceptSocket = e.AcceptSocket; SocketError error = e.SocketError; for (; ;) { int backlog = Thread.VolatileRead(ref acceptBacklog); if (isRunning && backlog <= minAcceptBacklog) { e.AcceptSocket = null; listener.AcceptAsync(e, Accept_Completed); break; } else { if (Interlocked.CompareExchange(ref acceptBacklog, backlog - 1, backlog) == backlog) { EventArgsManager.Put(e); break; } } } var connection = CreateConnection(acceptSocket, error); if (connection != null) { NewTcpConnection(connection); } }
private void Connect_Completed(Socket socket1, ServerAsyncEventArgs e) { bool flag = false; Server <C> .Connection <C> connection = null; if (e.SocketError == SocketError.Success) { connection = this.CreateConnection(socket1, e.SocketError); flag = (connection != null); } else { while (e.SocketError == SocketError.AddressAlreadyInUse && !this.connections.TryGetValue(e.RemoteEndPoint, out connection)) { Thread.Sleep(0); if (socket1.ConnectAsync(e)) { return; } if (e.SocketError == SocketError.Success) { connection = this.CreateConnection(socket1, e.SocketError); flag = (connection != null); } } } if (e.SocketError == SocketError.Success && flag) { this.NewTcpConnection(connection); } e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed); e.OnCompleted(socket1); }
private void Accept_Completed(Socket none, ServerAsyncEventArgs e) { Socket acceptSocket = e.AcceptSocket; SocketError socketError = e.SocketError; while (true) { int num = Thread.VolatileRead(ref this.acceptBacklog); if (this.isRunning && num <= this.minAcceptBacklog) { break; } if (Interlocked.CompareExchange(ref this.acceptBacklog, num - 1, num) == num) { goto Block_3; } } e.AcceptSocket = null; this.listener.AcceptAsync(e, new ServerAsyncEventArgs.CompletedEventHandler(this.Accept_Completed)); goto IL_66; Block_3: EventArgsManager.Put(e); IL_66: Server <C> .Connection <C> connection = this.CreateConnection(acceptSocket, socketError); if (connection != null) { this.NewTcpConnection(connection); } }
public void Dettach(ref ServerAsyncEventArgs e, out ArraySegment <byte> segment1, out ArraySegment <byte> segment2) { if (this.readerStorage == HeaderContentConnection.Storage.E) { int num = this.headerData.Count; if (this.contentStorage == this.readerStorage) { num += this.contentData.Count; } segment1 = this.Detach(ref e, num); segment2 = ((this.contentStorage != this.readerStorage) ? this.Dettach(this.contentStorage) : default(ArraySegment <byte>)); return; } segment1 = this.Dettach(this.readerStorage); if (this.contentStorage == this.readerStorage) { segment2 = default(ArraySegment <byte>); return; } if (this.contentStorage == HeaderContentConnection.Storage.E) { segment2 = this.Detach(ref e, this.contentData.Count); return; } segment2 = this.Dettach(this.contentStorage); }
private static void SocketArgs_Completed(object sender, SocketAsyncEventArgs e) { ServerAsyncEventArgs serverAsyncEventArgs = e.UserToken as ServerAsyncEventArgs; serverAsyncEventArgs.bytesTransferred = e.BytesTransferred; serverAsyncEventArgs.Completed(sender as Socket, serverAsyncEventArgs); }
public void ResetState() { this.ready = false; this.headerData = default(ArraySegment <byte>); this.expectedContentLength = 0; this.receivedContentLength = 0; this.contentData = default(ArraySegment <byte>); this.readerStorage = HeaderContentConnection.Storage.None; this.contentStorage = HeaderContentConnection.Storage.None; this.ResetParser(HeaderContentConnection.ResetReason.ResetStateCalled); if (this.buffer1 != null) { this.buffer1UnusedCount = ((this.buffer1.Count <= 0) ? (this.buffer1UnusedCount + 1) : 0); if (this.buffer1.Capacity <= 8192 && this.buffer1UnusedCount < 8) { this.buffer1.Clear(); } else { this.buffer1.Free(); } } if (this.buffer2 != null) { this.buffer2.Free(); } if (this.e1 != null) { this.e1.Dispose(); this.e1 = null; } this.keepAliveRecived = 0; this.state = HeaderContentConnection.StreamState.WaitingHeaders; }
public void Dettach(ref ServerAsyncEventArgs e, out ArraySegment <byte> segment1, out ArraySegment <byte> segment2) { if (readerStorage == Storage.E) { int size = headerData.Count; if (contentStorage == readerStorage) { size += contentData.Count; } segment1 = Detach(ref e, size); segment2 = (contentStorage != readerStorage) ? Dettach(contentStorage) : new ArraySegment <byte>(); } else { segment1 = Dettach(readerStorage); if (contentStorage != readerStorage) { if (contentStorage == Storage.E) { segment2 = Detach(ref e, contentData.Count); } else { segment2 = Dettach(contentStorage); } } else { segment2 = new ArraySegment <byte>(); } } }
private bool Server_Received(Server <C> server, C c, ref ServerAsyncEventArgs e) { bool result; try { if (this.logger.IsEnabled) { this.logger.Write(e, true); } if (this.Received != null) { result = this.Received(this, c, ref e); } else { result = false; } } catch (Exception innerException) { throw new Exception("Error in Received event handler", innerException); } return(result); }
private bool TcpReceiveAsync(Connection <C> connection, ServerAsyncEventArgs e) { PrepareEventArgs(connection, e); try { connection.SpinLock.Enter(); e.SequenceNumber = connection.ReceiveQueue.SequenceNumber; try { if (connection.IsClosed == false) { bool result = connection.Socket.ReceiveAsync(e); connection.ReceiveQueue.SequenceNumber++; return(result); } } finally { connection.SpinLock.Exit(); } } catch (ObjectDisposedException) { } EventArgsManager.Put(ref e); return(true); }
protected void PrepareEventArgs(Connection <C> connection, ServerAsyncEventArgs e) { e.ConnectionId = connection.Id; e.RemoteEndPoint = connection.RemoteEndPoint; e.Completed = Receive_Completed; //e.OffsetOffset = offsetOffset; //e.Count -= offsetOffset; }
public override void SendAsync(ServerAsyncEventArgs e) { var connection = GetTcpConnection(e.RemoteEndPoint); OnBeforeSend(connection, e); base.SendAsync(connection, e); }
public static void ConnectAsync(this Socket socket, ServerAsyncEventArgs e, ServerAsyncEventArgs.CompletedEventHandler handler) { e.Completed = handler; if (socket.ConnectAsync(e) == false) { e.OnCompleted(socket); } }
public static void AcceptAsync(this Socket socket, ServerAsyncEventArgs e, ServerAsyncEventArgs.CompletedEventHandler handler) { e.Completed = handler; if (!socket.AcceptAsync(e)) { e.OnCompleted(socket); } }
public override void SendAsync(ServerAsyncEventArgs e) { base.OnBeforeSend(null, e); e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed); if (!this.socket.SendToAsync(e)) { e.OnCompleted(this.socket); } }
public void RestoreAddresses(ServerAsyncEventArgs e) { e.ConnectionId = connectionId; e.LocalEndPoint = localEndPoint; e.RemoteEndPoint = remoteEndPoint; localEndPoint = null; remoteEndPoint = null; }
private void Receive_Completed(Socket socket, ServerAsyncEventArgs e) { try { Server <C> .Connection <C> connection; this.connections.TryGetValue(e.RemoteEndPoint, out connection); if (connection != null && connection.Socket == socket && connection.Id == e.ConnectionId) { while (true) { if (e != null) { connection.ReceiveQueue.Put(e); e = null; } e = connection.ReceiveQueue.GetCurrent(); if (e == null) { goto IL_D4; } bool flag = true; if (this.isRunning && e.BytesTransferred > 0 && e.SocketError == SocketError.Success) { flag = !this.OnTcpReceived(connection, ref e); } if (flag) { break; } connection.ReceiveQueue.Next(); if (e == null) { e = EventArgsManager.Get(); } else { e.SetDefaultValue(); } if (this.TcpReceiveAsync(connection, e)) { e = null; } } this.connections.Remove(connection.RemoteEndPoint, connection); this.EndTcpConnection(connection); } IL_D4 :; } finally { if (e != null) { EventArgsManager.Put(ref e); } } }
public void SendAsyncSip(ServerAsyncEventArgs e) { if (AjaxWebsocket.IsAjax(e)) ajax.ProcessOutgoing(e); else { e.UserTokenForSending2 = SipModule; serversManager.SendAsync(e); } }
public bool CopyTransferredFrom(ServerAsyncEventArgs e, int skipBytes) { #if DEBUG if (e.Count < skipBytes) { throw new ArgumentOutOfRangeException(); } #endif return(CopyFrom(e.Buffer, e.Offset + skipBytes, e.BytesTransferred - skipBytes)); }
public override void SendAsync(ServerAsyncEventArgs e) { OnBeforeSend(null, e); e.Completed = Send_Completed; if (socket.SendToAsync(e) == false) { e.OnCompleted(socket); } }
public void Put(ServerAsyncEventArgs e) { int num = e.SequenceNumber % this.size; Interlocked.Exchange <ServerAsyncEventArgs>(ref this.queue[num], e); if (this.disposed && Interlocked.Exchange <ServerAsyncEventArgs>(ref this.queue[num], null) != null) { EventArgsManager.Put(e); } }
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); }
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 ServerAsyncEventArgs CreateDeepCopy() { ServerAsyncEventArgs serverAsyncEventArgs = EventArgsManager.Get(); serverAsyncEventArgs.CopyAddressesFrom(this); serverAsyncEventArgs.offsetOffset = this.offsetOffset; serverAsyncEventArgs.count = this.count; serverAsyncEventArgs.AllocateBuffer(); serverAsyncEventArgs.bytesTransferred = this.bytesTransferred; serverAsyncEventArgs.UserTokenForSending = this.UserTokenForSending; System.Buffer.BlockCopy(this.Buffer, this.Offset, serverAsyncEventArgs.Buffer, serverAsyncEventArgs.Offset, serverAsyncEventArgs.Count); return(serverAsyncEventArgs); }
internal void Write(ServerAsyncEventArgs e, bool incomingOutgoing) { try { PcapWriter pcapWriter = this.writer; if (pcapWriter != null) { pcapWriter.Write(e.Buffer, e.Offset, incomingOutgoing ? e.BytesTransferred : e.Count, this.Convert(e.LocalEndPoint.Protocol), incomingOutgoing ? e.RemoteEndPoint : e.LocalEndPoint, incomingOutgoing ? e.LocalEndPoint : e.RemoteEndPoint); } } catch (ObjectDisposedException) { } }
private void Server_BeforeSend(Server <C> server, C c, ServerAsyncEventArgs e) { try { if (this.BeforeSend != null) { this.BeforeSend(this, c, e); } } catch (Exception innerException) { throw new Exception("Error in BeforeSend event handler", innerException); } }
private void Connect_Completed(Socket socket1, ServerAsyncEventArgs e) { bool newConnection = false; Connection <C> connection = null; if (e.SocketError == SocketError.Success) { connection = CreateConnection(socket1, e.SocketError); newConnection = connection != null; } else { while (e.SocketError == SocketError.AddressAlreadyInUse) { if (connections.TryGetValue(e.RemoteEndPoint, out connection)) { break; } Thread.Sleep(0); if (socket1.ConnectAsync(e)) { return; } else { if (e.SocketError == SocketError.Success) { connection = CreateConnection(socket1, e.SocketError); newConnection = connection != null; } } } } if (e.SocketError == SocketError.Success) { if (newConnection) { NewTcpConnection(connection); } } e.Completed = Send_Completed; e.OnCompleted(socket1); }
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; }
public new void Dispose() { base.Dispose(); if (this.buffer1 != null) { this.buffer1.Dispose(); } if (this.buffer2 != null) { this.buffer2.Dispose(); } if (this.e1 != null) { this.e1.Dispose(); this.e1 = null; } }
public void Dispose() { this.disposed = true; ServerAsyncEventArgs serverAsyncEventArgs = null; for (int i = 0; i < this.queue.Length; i++) { if (this.queue[i] != null) { serverAsyncEventArgs = Interlocked.Exchange <ServerAsyncEventArgs>(ref this.queue[i], null); } if (serverAsyncEventArgs != null) { EventArgsManager.Put(ref serverAsyncEventArgs); } } }
private ArraySegment <byte> Detach(ref ServerAsyncEventArgs e, int size) { ServerAsyncEventArgs serverAsyncEventArgs = null; if (e.BytesTransferred > size) { serverAsyncEventArgs = e.CreateDeepCopy(); } ArraySegment <byte> result = e.DetachBuffer(); EventArgsManager.Put(ref e); if (serverAsyncEventArgs != null) { e = serverAsyncEventArgs; } return(result); }
protected void SendAsync(Connection <C> connection, ServerAsyncEventArgs e) { if (connection == null) { if (e.ConnectionId == ServerAsyncEventArgs.AnyNewConnectionId) { try { Socket socket = new Socket(realEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); socket.Bind(realEndPoint); socket.ConnectAsync(e, Connect_Completed); } catch (SocketException ex) { e.Completed = Send_Completed; e.SocketError = ex.SocketErrorCode; e.OnCompleted(null); } } else { e.Completed = Send_Completed; e.SocketError = SocketError.NotConnected; e.OnCompleted(null); } } else { if (e.ConnectionId == ServerAsyncEventArgs.AnyNewConnectionId || e.ConnectionId == ServerAsyncEventArgs.AnyConnectionId || e.ConnectionId == connection.Id) { connection.Socket.SendAsync(e, Send_Completed); } else { e.Completed = Send_Completed; e.SocketError = SocketError.NotConnected; e.OnCompleted(null); } } }
public static void CopyArrayFrom(this ArraySegment<byte> dst, int dstExtraOffset, ServerAsyncEventArgs e) { Buffer.BlockCopy(e.Buffer, e.Offset, dst.Array, dst.Offset + dstExtraOffset, Math.Min(e.Count, dst.Count)); }
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 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 Dettach(ref ServerAsyncEventArgs e, out ArraySegment<byte> segment1, out ArraySegment<byte> segment2) { if (readerStorage == Storage.E) { int size = headerData.Count; if (contentStorage == readerStorage) size += contentData.Count; segment1 = Detach(ref e, size); segment2 = (contentStorage != readerStorage) ? Dettach(contentStorage) : new ArraySegment<byte>(); } else { segment1 = Dettach(readerStorage); if (contentStorage != readerStorage) { if (contentStorage == Storage.E) segment2 = Detach(ref e, contentData.Count); else segment2 = Dettach(contentStorage); } else { segment2 = new ArraySegment<byte>(); } } }
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 ArraySegment<byte> Detach(ref ServerAsyncEventArgs e, int size) { ServerAsyncEventArgs copy = null; if (e.BytesTransferred > size) copy = e.CreateDeepCopy(); var result = e.DetachBuffer(); EventArgsManager.Put(ref e); if (copy != null) e = copy; return result; }
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 void AddOutgoingMessage(ServerAsyncEventArgs e) { outgoingMessages.Add(e); }
public bool Proccess(ref ServerAsyncEventArgs e, out bool closeConnection) { // ---------------------------------------------------------- // | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | // ---------------------------------------------------------- // | e | H | HC | | | | | | | | // | e1 | | | H | HC | H | H | | | | // | Buffer1 | | | | | C | | H | HC | H | // | Buffer2 | | | | | | C | | | C | // ---------------------------------------------------------- closeConnection = false; switch (state) { case StreamState.WaitingHeaders: { int oldBytesProccessed = bytesProccessed; var data = new ArraySegment<byte>(e.Buffer, e.Offset + bytesProccessed, e.BytesTransferred - bytesProccessed); PreProcessRaw(data); var result = Parse(data); switch (result.ParseCode) { case ParseCode.NotEnoughData: { bytesProccessed += data.Count; ResetParser(ResetReason.NotEnoughData); Buffer1.Resize(MaximumHeadersSize); Buffer1.CopyTransferredFrom(e, oldBytesProccessed); state = StreamState.WaitingHeadersContinue; } break; case ParseCode.Error: { closeConnection = true; } break; case ParseCode.Skip: { bytesProccessed += result.Count; } break; case ParseCode.HeaderDone: { bytesProccessed += result.HeaderLength; SetReaderStorage(Storage.E, e.Buffer, e.Offset + oldBytesProccessed, result.HeaderLength); expectedContentLength = result.ContentLength; if (expectedContentLength <= 0) { SetReady(); } else { int bytesLeft = e.BytesTransferred - bytesProccessed; if (bytesLeft >= expectedContentLength) { SetReady(Storage.E, e.Buffer, e.Offset + bytesProccessed, expectedContentLength); bytesProccessed += expectedContentLength; } else { if (expectedContentLength <= e.Count - e.BytesTransferred) { state = StreamState.WaitingMicroBody; } else if (expectedContentLength < MaximumHeadersSize) { if (Buffer1.IsInvalid || Buffer1.Capacity < expectedContentLength) if (Buffer1.Resize(Math.Max(expectedContentLength, MinimumBuffer1Size)) == false) closeConnection = true; if (closeConnection == false) { Buffer1.CopyTransferredFrom(e, bytesProccessed); state = StreamState.WaitingSmallBody; } } else { if (Buffer2.Resize(expectedContentLength) == false) closeConnection = true; else { Buffer2.CopyTransferredFrom(e, bytesProccessed); state = StreamState.WaitingBigBody; } } if (closeConnection == false) { e1 = e; e = null; readerStorage = Storage.E1; } bytesProccessed += bytesLeft; receivedContentLength += bytesLeft; } } } break; } } break; case StreamState.WaitingHeadersContinue: { int count = Math.Min(e.BytesTransferred - bytesProccessed, Buffer1.FreeSize); PreProcessRaw(new ArraySegment<byte>(e.Buffer, e.Offset, e.BytesTransferred - bytesProccessed)); System.Buffer.BlockCopy(e.Buffer, e.Offset, Buffer1.Array, Buffer1.Offset + Buffer1.Count, count); var data = new ArraySegment<byte>(Buffer1.Array, Buffer1.Offset, Buffer1.Count + count); var result = Parse(data); switch (result.ParseCode) { case ParseCode.NotEnoughData: { ResetParser(ResetReason.NotEnoughData); if (data.Count < Buffer1.Capacity) { Buffer1.AddCount(count); bytesProccessed += count; } else { closeConnection = true; } } break; case ParseCode.Error: { closeConnection = true; } break; case ParseCode.Skip: throw new NotImplementedException(); case ParseCode.HeaderDone: { int delta = result.HeaderLength - Buffer1.Count; Buffer1.AddCount(delta); bytesProccessed += delta; SetReaderStorage(Storage.Buffer1, Buffer1.Array, Buffer1.Offset, result.HeaderLength); expectedContentLength = result.ContentLength; if (expectedContentLength <= 0) { SetReady(); } else { int bytesLeft = e.BytesTransferred - bytesProccessed; if (bytesLeft >= expectedContentLength) { SetReady(Storage.E, e.Buffer, e.Offset + bytesProccessed, expectedContentLength); bytesProccessed += expectedContentLength; } else { if (expectedContentLength < Buffer1.FreeSize) { Buffer1.AddCount(bytesLeft); state = StreamState.WaitingSmallBody; } else { if (Buffer2.Resize(expectedContentLength) == false) closeConnection = true; Buffer2.CopyTransferredFrom(e, bytesProccessed); state = StreamState.WaitingBigBody; } bytesProccessed += bytesLeft; receivedContentLength += bytesLeft; } } } break; } } break; case StreamState.WaitingMicroBody: { int count = Math.Min(e.BytesTransferred - bytesProccessed, expectedContentLength - receivedContentLength); var data = new ArraySegment<byte>(e.Buffer, e.Offset + bytesProccessed, count); PreProcessRaw(data); System.Buffer.BlockCopy(data.Array, data.Offset, e1.Buffer, e1.Offset + e1.BytesTransferred, data.Count); //System.Buffer.BlockCopy(e.Buffer, e.Offset + bytesProccessed, // e1.Buffer, e1.Offset + e1.BytesTransferred, count); e1.BytesTransferred += count; receivedContentLength += count; bytesProccessed += count; if (receivedContentLength == expectedContentLength) SetReady(Storage.E1, e1.Buffer, e1.Offset + e1.BytesTransferred - receivedContentLength, receivedContentLength); } break; case StreamState.WaitingSmallBody: { int count = Math.Min(e.BytesTransferred - bytesProccessed, expectedContentLength - receivedContentLength); var data = new ArraySegment<byte>(e.Buffer, e.Offset + bytesProccessed, count); PreProcessRaw(data); Buffer1.CopyFrom(data); //Buffer1.CopyFrom(e.Buffer, e.Offset + bytesProccessed, count); receivedContentLength += count; bytesProccessed += count; if (receivedContentLength == expectedContentLength) SetReady(Storage.Buffer1, Buffer1.Array, Buffer1.Offset + Buffer1.Count - receivedContentLength, receivedContentLength); } break; case StreamState.WaitingBigBody: { int count = Math.Min(e.BytesTransferred - bytesProccessed, expectedContentLength - receivedContentLength); var data = new ArraySegment<byte>(e.Buffer, e.Offset + bytesProccessed, count); PreProcessRaw(data); Buffer2.CopyFrom(data); //Buffer2.CopyFrom(e.Buffer, e.Offset + bytesProccessed, count); receivedContentLength += count; bytesProccessed += count; if (receivedContentLength == expectedContentLength) SetReady(Storage.Buffer2, Buffer2.Array, Buffer2.Offset + Buffer2.Count - receivedContentLength, receivedContentLength); } break; } bool continueProccessing = closeConnection == false && e != null && bytesProccessed < e.BytesTransferred; if (continueProccessing == false) bytesProccessed = 0; return continueProccessing; }
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); } }
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 void SendAsyncHttp(ServerAsyncEventArgs e, int httpModuleId) { e.UserTokenForSending2 = HttpModule | (httpModuleId << 8); serversManager.SendAsync(e); }
static bool ServersManager_Received(ServersManager<BaseConnection2> server, BaseConnection c, ref ServerAsyncEventArgs e) { e.Count = e.BytesTransferred; server.SendAsync(e); e = null; return true; }
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; }
public void ResetState() { ready = false; headerData = new ArraySegment<byte>(); expectedContentLength = 0; receivedContentLength = 0; contentData = new ArraySegment<byte>(); readerStorage = Storage.None; contentStorage = Storage.None; ResetParser(ResetReason.ResetStateCalled); if (buffer1 != null) { buffer1UnusedCount = (buffer1.Count <= 0) ? buffer1UnusedCount + 1 : 0; if (buffer1.Capacity <= MaximumHeadersSize && buffer1UnusedCount < 8) buffer1.Clear(); else buffer1.Free(); } if (buffer2 != null) buffer2.Free(); if (e1 != null) { e1.Dispose(); e1 = null; } keepAliveRecived = 0; state = StreamState.WaitingHeaders; }
private void SendWriter(ServerAsyncEventArgs r, HttpMessageWriter writer) { r.Count = writer.Count; r.OffsetOffset = writer.OffsetOffset; r.AttachBuffer(writer.Detach()); SendAsync(r, false); }
public bool CopyTransferredFrom(ServerAsyncEventArgs e, int skipBytes) { #if DEBUG if (e.Count < skipBytes) throw new ArgumentOutOfRangeException(); #endif return CopyFrom(e.Buffer, e.Offset + skipBytes, e.BytesTransferred - skipBytes); }
//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); }
public BufferHandle Dettach(ref ServerAsyncEventArgs e) { ArraySegment<byte> segment1, segment2; base.Dettach(ref e, out segment1, out segment2); return new BufferHandle(segment1, segment2); }
static void ServersManager_Sent(ServersManager<BaseConnection2> server, ref ServerAsyncEventArgs e) { if (e.SocketError != SocketError.Success) Console.WriteLine("Sent error: {0}", e.SocketError.ToString()); }
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 bool PeerServer_Received(ServersManager<PeerConnection> s, BaseConnection с, ref ServerAsyncEventArgs e) { //lock (syncRoot) { try { Allocation allocation = allocations.Get(e.LocalEndPoint); if (allocation != null) { if (allocation.Permissions.IsPermited(e.RemoteEndPoint)) { allocation.TouchLifetime(); if (allocation.ActiveDestination.IsEqual(e.RemoteEndPoint)) { if (e.LocalEndPoint.Protocol == ServerProtocol.Tcp) { TcpFramingHeader.GetBytes(e.Buffer, e.Offset, TcpFrameType.EndToEndData, e.BytesTransferred); e.Count = e.OffsetOffset + e.BytesTransferred; e.OffsetOffset = 0; } else { e.Count = e.BytesTransferred; } e.LocalEndPoint = allocation.Local; e.RemoteEndPoint = allocation.Reflexive; e.ConnectionId = ServerAsyncEventArgs.AnyConnectionId; turnServer.SendAsync(e); e = null; } else { TurnMessage message = new TurnMessage() { IsAttributePaddingDisabled = true, MessageType = MessageType.DataIndication, TransactionId = TransactionServer.GenerateTransactionId(), MagicCookie = new MagicCookie(), RemoteAddress = new RemoteAddress() { IpAddress = e.RemoteEndPoint.Address, Port = (UInt16)e.RemoteEndPoint.Port, }, Data = new Data() { ValueRef = e.Buffer, ValueRefOffset = e.Offset, ValueRefLength = e.BytesTransferred, }, }; SendTurn(message, allocation.Local, allocation.Reflexive); } } } } catch (Exception ex) { logger.WriteWarning(ex.ToString()); } } return true; }
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 new void Dispose() { base.Dispose(); if (buffer1 != null) buffer1.Dispose(); if (buffer2 != null) buffer2.Dispose(); if (e1 != null) { e1.Dispose(); e1 = null; } }
private void SendAsyncAjax(ServerAsyncEventArgs e, bool sipAjax) { e.UserTokenForSending2 = sipAjax ? SipModule : AjaxModule; serversManager.SendAsync(e); }