static void ReceivedTunnelKey(ref SelectControl selectControl, Socket socket, Byte[] receivedKey) { // // Get Tunnel // if (receivedKey.Length != 4) { Console.WriteLine("{0} Expected tunnel key to be 4 byte but is {1}", DateTime.Now, receivedKey.Length); selectControl.ShutdownDisposeAndRemoveReceiveSocket(socket); return; } Int32 key = (Int32)( (0xFF000000 & (receivedKey[0] << 24)) | (0x00FF0000 & (receivedKey[1] << 16)) | (0x0000FF00 & (receivedKey[2] << 8)) | (0x000000FF & (receivedKey[3]))); DisconnectedTunnel disconnectedTunnel; if (!incompleteTunnels.TryGetValue(key, out disconnectedTunnel)) { Console.WriteLine("{0} Could not find tunnel for key {1}", DateTime.Now, key); selectControl.ShutdownDisposeAndRemoveReceiveSocket(socket); return; } disconnectedTunnel.CompleteTunnel(ref selectControl, socket); }
public void DataRecvHandler(ref SelectControl control, Socket sock, Buf safeBuffer) { Socket otherSocket = (sock == serverSocket) ? clientSocket : serverSocket; int bytesReceived = sock.ReceiveNoThrow(safeBuffer.array, 0, safeBuffer.array.Length, SocketFlags.None); if (bytesReceived <= 0) { if (otherSocket != null) { otherSocket.ShutdownSafe(); } control.RemoveReceiveSocket(sock); return; } if (otherSocket != null) { try { otherSocket.Send(safeBuffer.array, bytesReceived, SocketFlags.None); return; } catch (SocketException) { sock.ShutdownSafe(); control.DisposeAndRemoveReceiveSocket(sock); } } }
static void AcceptCallback(ref SelectControl control, Socket listenSock, Buf safeBuffer) { Socket newSock = listenSock.Accept(); if (log != null) { log.WriteLine("Accepted new client {0}", newSock.SafeRemoteEndPointString()); } Socket clientSideSocket = new Socket(server.GetAddressFamilyForTcp(), SocketType.Stream, ProtocolType.Tcp); BufStruct leftOver = new BufStruct(safeBuffer.array); clientSideSocket.Connect(server, DnsPriority.IPv4ThenIPv6, ProxyConnectOptions.None, ref leftOver); if (leftOver.contentLength > 0) { newSock.Send(leftOver.buf, 0, (int)leftOver.contentLength, SocketFlags.None); if (pcapLogger != null) { //pcapLogger.LogTcpData(leftOver.buf, 0, leftOver.contentLength); } } SelectSocketTunnel tunnel = new SelectSocketTunnel(newSock, clientSideSocket); control.AddReceiveSocket(newSock, tunnel.ReceiveCallback); control.AddReceiveSocket(clientSideSocket, tunnel.ReceiveCallback); }
// Returns true if all headers were found and handled, false otherwise Boolean CheckForEndOfHeadersAndHandle(ref SelectControl selectControl, Socket clientSocket, Byte[] headers, UInt32 alreadyCheckedOffset, UInt32 length) { if (alreadyCheckedOffset >= 7) { alreadyCheckedOffset -= 3; // Check the last 3 chars as well } UInt32 totalLength = length; while (length > alreadyCheckedOffset) { if ( headers[length - 1] == '\n' && (headers[length - 2] == '\n' || (headers[length - 2] == '\r' && headers[length - 3] == '\n' && headers[length - 4] == '\r') )) { this.headersLength = length; GotHeaders(ref selectControl, clientSocket, headers, totalLength); return(true); } length--; } return(false); }
public void InitialReceiveHandler(ref SelectControl selectControl, Socket clientSocket, Buf safeBuffer) { int bytesReceived = clientSocket.Receive(safeBuffer.array); if (bytesReceived <= 0) { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("{0} Closed (no data received)", clientLogString); } selectControl.DisposeAndRemoveReceiveSocket(clientSocket); return; } if (!CheckForEndOfHeadersAndHandle(ref selectControl, clientSocket, safeBuffer.array, 0, (uint)bytesReceived)) { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("{0} Initial socket receive did not contain all headers. Need to copy partial header to a new buffer.", clientLogString); } clientBuffer = new ByteBuilder(InitialClientBufferLength + ((bytesReceived > InitialClientBufferLength) ? (uint)bytesReceived : 0)); Array.Copy(safeBuffer.array, clientBuffer.bytes, bytesReceived); clientBuffer.contentLength = (uint)bytesReceived; selectControl.UpdateHandler(clientSocket, HeaderBuilderHandler); } }
public void CompleteTunnel(ref SelectControl selectControl, Socket socket) { lock (connectedSocket) { if (connectedTunnel != null) { throw new InvalidOperationException("CodeBug: This tunnel has already been completed"); } // // Send all the buffered data // if (bufferLength > 0) { try { socket.Send(buffer.array, 0, bufferLength, SocketFlags.None); } catch (Exception) { selectControl.ShutdownDisposeAndRemoveReceiveSocket(connectedSocket); selectControl.ShutdownDisposeAndRemoveReceiveSocket(socket); return; } } connectedTunnel = new ConnectedTunnel(connectedSocket, socket); selectControl.UpdateHandler(socket, connectedTunnel.BToAHandler); } }
public void AcceptCallback(ref SelectControl control, Socket listenSock, Buf safeBuffer) { Socket newSocket = listenSock.Accept(); RpcServerConnectionHandler connection = new RpcServerConnectionHandler(this, newSocket); control.AddReceiveSocket(newSocket, connection.HandleData); }
public void StartConnect(ref SelectControl control, Buf safeBuffer) { if (accessorSocket != null) { throw new InvalidOperationException("CodeBug: StartConnect called but socket is not null"); } accessorSocket = new Socket(accessorHost.GetAddressFamilyForTcp(), SocketType.Stream, ProtocolType.Tcp); accessorSocket.Blocking = false; if (accessorHost.proxy != null) { throw new NotImplementedException("accessor host through proxy not implemented"); } accessorHost.targetEndPoint.ForceIPResolution(DnsPriority.IPv4ThenIPv6); connectAsyncArgs.RemoteEndPoint = accessorHost.targetEndPoint.ipEndPoint; Console.WriteLine("{0} Connecting to {1}:{2}", DateTime.Now, accessorHost.targetEndPoint.ipOrHost, accessorHost.targetEndPoint.port); if (accessorSocket.ConnectAsync(connectAsyncArgs)) { control.AddConnectSocket(accessorSocket, ConnectHandler); } else { throw new NotImplementedException("immediate connect not implemented"); } }
public static void AcceptProxyClient(ref SelectControl selectControl, Socket listenSocket, Buf safeBuffer) { Socket clientSocket = listenSocket.Accept(); if (clientSocket.Connected) { String clientLogString = clientSocket.SafeRemoteEndPointString(); if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("Listener:{0} new client {1}", ListenPort, clientLogString); } ConnectionInitiator connectionInitiator = new ConnectionInitiator(clientSocket, clientLogString); selectControl.AddReceiveSocket(clientSocket, connectionInitiator.InitialReceiveHandler); } else { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("Listener:{0} new client was accepted but was not connected", ListenPort); } clientSocket.Close(); } }
public void AcceptCallback(ref SelectControl control, Socket listenSock, Buf safeBuffer) { Socket newSock = listenSock.Accept(); DebugClientData clientData = new DebugClientData(newSock); control.AddReceiveSocket(newSock, clientData.DataCallback); clientData.SendPrompt(); }
public void DataCallback(ref SelectControl control, Socket socket, Buf safeBuffer) { int bytesReceived; try { bytesReceived = socket.Receive(safeBuffer.array); } catch (SocketException) { bytesReceived = -1; } if (bytesReceived <= 0) { socket.ShutdownSafe(); control.DisposeAndRemoveReceiveSocket(socket); } lineParser.Add(safeBuffer.array, 0, (uint)bytesReceived); while (true) { String line = lineParser.GetLine(); if (line == null) { break; } if (line[0] == 'd' || line[0] == 'D') { if (NfsServerLog.performanceLog == null) { writer.Write("Cannot dump performance log because it was not enabled"); } else { NfsServerLog.performanceLog.DumpLog(writer); } } else if (line[0] == 'h' || line[0] == 'H') { writer.WriteLine("Commands: dump, help"); } else if (line[0] == 'e' || line[0] == 'E') { socket.ShutdownSafe(); control.DisposeAndRemoveReceiveSocket(socket); } else { writer.WriteLine("UnknownCommand '{0}'", line); writer.WriteLine("Commands: dump, help, exit"); } SendPrompt(); } }
public void AcceptCallback(ref SelectControl control, Socket listenSock, Buf safeBuffer) { Socket newSock = listenSock.Accept(); String clientEndPointString = newSock.SafeRemoteEndPointString(); Console.WriteLine("[{0}] New Connection", clientEndPointString); //clients.Add(socket, newClient); control.AddReceiveSocket(newSock, new HttpToCdpClient(clientEndPointString, newSock, this).TcpRecvHandler); }
public void ReceiveHandler(ref SelectControl selectControl, Socket socket, Buf safeBuffer) { try { int bytesReceived = socket.Receive(safeBuffer.array); if (bytesReceived <= 0) { if (socket == client) { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("{0} > {1} Client Disconnected", clientLogString, serverLogString); } selectControl.DisposeAndRemoveReceiveSocket(client); selectControl.ShutdownIfConnectedDisposeAndRemoveReceiveSocket(server); } else { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("{0} > {1} Server Disconnected", clientLogString, serverLogString); } selectControl.DisposeAndRemoveReceiveSocket(server); selectControl.ShutdownIfConnectedDisposeAndRemoveReceiveSocket(client); } } else { if (socket == client) { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("{0} > {1} {2} bytes", clientLogString, serverLogString, bytesReceived); } server.Send(safeBuffer.array, bytesReceived, SocketFlags.None); } else { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("{0} < {1} {2} bytes", clientLogString, serverLogString, bytesReceived); } client.Send(safeBuffer.array, bytesReceived, SocketFlags.None); } } } catch (Exception) { selectControl.ShutdownIfConnectedDisposeAndRemoveReceiveSocket(client); selectControl.ShutdownIfConnectedDisposeAndRemoveReceiveSocket(server); } }
static void AcceptAndInitiateTunnel(ref SelectControl control, Socket socket, Buf safeBuffer) //(TunnelListenerHandler listener, Socket clientSocket, Buf safeBuffer) { /* * // * // Check if server is connected * // * TmpControlConnection tmpControlConnection = TryGetTmpControlConnection(listener.serverName); * if (tmpControlConnection == null) * { * return null; * } * * Console.WriteLine("{0} [{1}] Received tunnel connection for server '{2}' to connect to target '{3}:{4}'", * DateTime.Now, clientSocket.SafeRemoteEndPointString(), listener.serverName, listener.targetHost, listener.targetPort); * * // * // Generate a tunnel key * // * Int32 randomKey = random.Next(); * * // * // TODO: This would generate an infinite loop if every single key was taken up in the dictionary, * // however, I'm not sure if I should worry about this or not? Maybe there's a better way to do * // this? * // * while (true) * { * if (!incompleteTunnels.ContainsKey(randomKey)) break; * randomKey++; * } * * DisconnectedTunnel disconnectedTunnel = new DisconnectedTunnel(clientSocket); * incompleteTunnels.Add(randomKey, disconnectedTunnel); * * Byte[] tunnelKey = new Byte[4]; * tunnelKey[0] = (Byte)(randomKey >> 24); * tunnelKey[1] = (Byte)(randomKey >> 16); * tunnelKey[2] = (Byte)(randomKey >> 8); * tunnelKey[3] = (Byte)(randomKey ); * * // * // Send Open Tunnel command to TmpServer * // * OpenAccessorTunnelRequest request = new OpenAccessorTunnelRequest(0, * listener.targetHostBytes, listener.targetPort, tunnelKey); * UInt32 commandLength = Tmp.SerializeCommand<OpenAccessorTunnelRequest>(OpenAccessorTunnelRequest.Serializer, * Tmp.ToServerOpenAccessorTunnelRequestID, request, safeBuffer, 0); * tmpControlConnection.dataSender.HandleData(safeBuffer.array, 0, commandLength); * * // * // Create a diconnected tunnel handler * // * return disconnectedTunnel.ConnectedSocketReceiveHandler; */ }
void ConnectHandler(ref SelectControl control, Socket socket, Buf safeBuffer) { throw new NotImplementedException(); if (socket.Connected) { } else { } }
public void Dispose(ref SelectControl selectControl) { if (connectedTunnel != null) { connectedTunnel.Dispose(ref selectControl); } else { selectControl.ShutdownDisposeAndRemoveReceiveSocket(connectedSocket); } }
public void TcpRecvHandler(ref SelectControl control, Socket sock, Buf safeBuffer) { int bytesReceived = sock.ReceiveNoThrow(safeBuffer.array, 0, safeBuffer.array.Length, SocketFlags.None); if (bytesReceived <= 0) { if (serverSocket != null) { serverSocket.ShutdownSafe(); } control.RemoveReceiveSocket(sock); return; } if (serverSocket != null) { try { serverSocket.Send(safeBuffer.array, bytesReceived, SocketFlags.None); return; } catch (SocketException) { sock.ShutdownSafe(); control.DisposeAndRemoveReceiveSocket(sock); return; } } httpHeaderBuilders.Append(Encoding.ASCII.GetString(safeBuffer.array, 0, bytesReceived)); // // Check if you have received all the headers // Int32 totalLength = httpHeaderBuilders.Length; if (totalLength > 3) { if ( httpHeaderBuilders[totalLength - 1] == '\n' && ( (httpHeaderBuilders[totalLength - 2] == '\n') || (httpHeaderBuilders[totalLength - 2] == '\r' && httpHeaderBuilders[totalLength - 3] == '\n' && httpHeaderBuilders[totalLength - 4] == '\r')) ) { String headers = httpHeaderBuilders.ToString(); httpHeaderBuilders = null; HandleHeaders(ref control, sock, headers); } } }
public void ReceiveHandler(ref SelectControl selectControl, Socket socket, Buf safeBuffer) { int bytesRead = socket.ReceiveFrom(safeBuffer.array, ref From); // TODO: Handle disconnects somehow? // Note: make sure that 0 doesn't also mean disconnect if (bytesRead < 0) { throw new InvalidOperationException("Error: udp socket.ReceiveFrom returned negative"); } var now = Stopwatch.GetTimestamp(); if (From.Equals(remoteServerEndPoint)) { List <EndPoint> removeList = null; foreach (var pair in currentClients) { if (pair.Value.expireTime >= now) { Console.WriteLine("Udp Client '{0}' expired", pair.Key.ToString()); if (removeList == null) { removeList = new List <EndPoint>(); } removeList.Add(pair.Key); } else { // Should I update the expire times here? Console.WriteLine("{0} > {1} UDP:{2} bytes", remoteServerEndPoint.ToString(), pair.Key.ToString(), bytesRead); socket.SendTo(safeBuffer.array, bytesRead, SocketFlags.None, pair.Key); } } if (removeList != null) { foreach (var endpoint in removeList) { currentClients.Remove(endpoint); } } } else { currentClients[From] = new EndPointAndLastAccessTime(From, now + udpTimeoutTicks); Console.WriteLine("{0} > {1} UDP:{2} bytes", From.ToString(), remoteServerEndPoint.ToString(), bytesRead); socket.SendTo(safeBuffer.array, bytesRead, SocketFlags.None, remoteServerEndPoint); } }
// TODO: catch and handle exceptions public void HandleAccept(ref SelectControl selectControl, Socket listenSocket, Buf safeBuffer) { Socket newClientSocket = listenSocket.Accept(); Socket newRemoteServerSocket = new Socket(serverHost.directEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); newRemoteServerSocket.ConnectTcpSocketThroughProxy(serverHost); TcpBridge bridge = new TcpBridge(newClientSocket.SafeRemoteEndPointString(), newClientSocket, newRemoteServerSocket.SafeRemoteEndPointString(), newRemoteServerSocket); selectControl.AddReceiveSocket(newClientSocket, bridge.ReceiveHandler); selectControl.AddReceiveSocket(newRemoteServerSocket, bridge.ReceiveHandler); }
static void AcceptCallback(ref SelectControl selectControl, Socket listenSocket, Buf safeBuffer) { Socket clientSocket = listenSocket.Accept(); if (clientSocket.Connected) { String clientLogString = clientSocket.SafeRemoteEndPointString(); Console.WriteLine("[{0}] NewClient", clientLogString); selectControl.AddReceiveSocket(clientSocket, new OpenHttpSocket(clientLogString).HeaderRecvHandler); } else { clientSocket.Close(); } }
// Handler that receives data if all the headers were not in the initial receive void HeaderBuilderHandler(ref SelectControl selectControl, Socket clientSocket, Buf safeBuffer) { int bytesReceived = clientSocket.Receive(safeBuffer.array); if (bytesReceived <= 0) { if (AppLayerProxy.Logger != null) { AppLayerProxy.Logger.WriteLine("{0} Closed ({1} bytes received but did not finish HTTP headers)", clientLogString, clientBuffer.contentLength); } selectControl.DisposeAndRemoveReceiveSocket(clientSocket); return; } clientBuffer.Append(safeBuffer.array, 0, (uint)bytesReceived); CheckForEndOfHeadersAndHandle(ref selectControl, clientSocket, clientBuffer.bytes, 0, clientBuffer.contentLength); }
public static void NpcAcceptCallback(ref SelectControl selectControl, Socket listenSocket, Buf safeBuffer) { Socket clientSocket = listenSocket.Accept(); if (clientSocket.Connected) { String clientLogString = clientSocket.SafeRemoteEndPointString(); var dataHandler = new NpcSocketHandler(clientLogString, NpcServerConsoleLoggerCallback.Instance, NpcReflector, HtmlGenerator); selectControl.AddReceiveSocket(clientSocket, dataHandler.InitialRecvHandler); } else { clientSocket.Close(); } }
// return true to close void Handle(ref SelectControl selectControl, Socket receiveFrom, Socket sendTo, Buf safeBuffer) { Int32 bytesRead = 0; try { bytesRead = receiveFrom.Receive(safeBuffer.array, SocketFlags.None); if (bytesRead > 0) { sendTo.Send(safeBuffer.array, 0, bytesRead, SocketFlags.None); return; } } catch (Exception) { } Dispose(ref selectControl); }
public void TcpSocketRecvCallback(ref SelectControl control, Socket socket, Buf safeBuffer) { int bytesRead; try { bytesRead = socket.Receive(safeBuffer.array); } catch (SocketException) { bytesRead = -1; } if (bytesRead <= 0) { control.RemoveReceiveSocket(socket); return; } HandleData(socket, safeBuffer.array, 0, (uint)bytesRead); }
public void DatagramRecvHandler(ref SelectControl control, Socket sock, Buf safeBuffer) { int bytesReceived = sock.ReceiveFrom(safeBuffer.array, ref from); if (bytesReceived <= 0) { if (bytesReceived < 0) { throw new InvalidOperationException(String.Format("ReceiveFrom on UDP socket returned {0}", bytesReceived)); } return; // TODO: how to handle neg } String clientString = "?"; try { clientString = from.ToString(); } catch (Exception) { } UInt32 parametersOffset; RpcMessage callMessage = new RpcMessage(safeBuffer.array, 0, (uint)bytesReceived, out parametersOffset); if (callMessage.messageType != RpcMessageType.Call) { throw new InvalidOperationException(String.Format("Received an Rpc reply from '{0}' but only expecting Rpc calls", clientString)); } if (!ProgramHeaderSupported(callMessage.call.programHeader)) { new RpcMessage(callMessage.transmissionID, new RpcReply(RpcVerifier.None, RpcAcceptStatus.ProgramUnavailable)).SendUdp(from, sock, safeBuffer, null); return; } ISerializer replyParameters; RpcReply reply = Call(clientString, callMessage.call, safeBuffer.array, parametersOffset, (uint)bytesReceived, out replyParameters); if (reply != null) { new RpcMessage(callMessage.transmissionID, reply).SendUdp(from, sock, safeBuffer, replyParameters); } }
public void SocketReceiverHandler(ref SelectControl selectControl, Socket socket, Buf safeBuffer) { Int32 bytesRead; if (receivedKey == null) { bytesRead = socket.Receive(safeBuffer.array, 1, SocketFlags.None); if (bytesRead <= 0) { CloseHandler(); selectControl.DisposeAndRemoveReceiveSocket(socket); return; } receivedKey = new Byte[safeBuffer.array[0]]; receivedLength = 0; if (socket.Available <= 0) { return; } } if (receivedLength >= receivedKey.Length) { throw new InvalidOperationException("CodeBug: This SocketReceiveHandler should have been set to something else after the receivedKey was completely received"); } bytesRead = socket.Receive(receivedKey, receivedLength, receivedKey.Length - receivedLength, SocketFlags.None); if (bytesRead <= 0) { CloseHandler(); selectControl.DisposeAndRemoveReceiveSocket(socket); return; } receivedLength += (Byte)bytesRead; if (receivedLength >= receivedKey.Length) { TmpAccessorServer.ReceivedTunnelKey(ref selectControl, socket, receivedKey); } }
static void Main(string[] args) { AppLayerProxy.Logger = Console.Out; AppLayerProxy.ErrorLogger = Console.Out; var options = new AppLayerProxyOptions(); var nonOptionArgs = options.Parse(args); if (nonOptionArgs.Count == 0 || options.help.set) { options.PrintUsage(); return; } if (nonOptionArgs.Count > 1) { options.ErrorAndUsage("Expected 1 argument but got {0}", args.Length); return; } if (options.forwardProxy.set) { AppLayerProxy.ForwardProxy = Proxy.ParseProxy(options.forwardProxy.ArgValue, DnsPriority.IPv4ThenIPv6, null); } ListenPort = UInt16.Parse(nonOptionArgs[0]); var listenIP = options.listenIP.ArgValue; SelectServer selectServer = new SelectServer(false, new Buf(8192)); Socket listenSocket = new Socket(listenIP.AddressFamily, SocketType.Stream, ProtocolType.Tcp); listenSocket.Bind(new IPEndPoint(listenIP, ListenPort)); listenSocket.Listen(options.backlog.ArgValue); SelectControl selectControl = new SelectControl(true); selectControl.AddListenSocket(listenSocket, AcceptProxyClient); selectServer.Run(); }
public void HandleData(ref SelectControl control, Socket sock, Buf safeBuffer) { int bytesReceived; try { bytesReceived = sock.Receive(safeBuffer.array); } catch (SocketException) { bytesReceived = -1; } if (bytesReceived <= 0) { sock.ShutdownSafe(); control.DisposeAndRemoveReceiveSocket(sock); return; } recordBuilder.HandleData(socket, safeBuffer.array, 0, (uint)bytesReceived); }
public void ConnectedSocketReceiveHandler(ref SelectControl selectControl, Socket socket, Buf safeBuffer) { // // Check if the connection has been made // if (this.connectedTunnel != null) { selectControl.UpdateHandler(socket, this.connectedTunnel.AToBHandler); this.connectedTunnel.AToBHandler(ref selectControl, socket, safeBuffer); return; } // // Put the data into the byte buffer // if (buffer == null) { buffer = new Buf(256, 256); bufferLength = 0; } else { buffer.EnsureCapacityCopyData(bufferLength + 256); } // // Receive the data into the buffer // Int32 bytesRead = socket.Receive(buffer.array, bufferLength, buffer.array.Length - bufferLength, SocketFlags.None); if (bytesRead > 0) { bufferLength += bytesRead; } else { Dispose(ref selectControl); } }
/* * public void SendCommand(Byte commandID, IReflector reflector, Object command, ByteBuffer sendBuffer) * { * Tmp.SerializeCommand( * Byte[] packet = Tmp.CreateCommandPacket(commandID, reflector, command, 0); * dataSender.HandleData(packet, 0, packet.Length); * } */ /* * void HandleHeartbeat() * { * Console.WriteLine("{0} [{1}] [TmpControl] Got heartbeat", DateTime.Now, remoteEndPoint); * } */ public void SocketReceiverHandler(ref SelectControl selectControl, Socket socket, Buf safeBuffer) { Int32 bytesRead = socket.Receive(safeBuffer.array); if (bytesRead <= 0) { selectControl.DisposeAndRemoveReceiveSocket(socket); Dispose(); return; } //Console.WriteLine("{0} [{1}] [Debug] Got {2} Bytes: {3}", DateTime.Now, remoteEndPoint, bytesRead, safeBuffer.array.ToHexString(0, bytesRead)); if (receiveDataFilter == null) { frameProtocolReceiveHandler.HandleData(safeBuffer.array, 0, (UInt32)bytesRead); } else { receiveDataFilter.FilterTo(frameProtocolReceiveHandler.HandleData, safeBuffer.array, 0, (UInt32)bytesRead); } }