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