public void AcceptCallback(SelectServerSharedBuffer server, Socket listenSock)
{
Socket newSocket = listenSock.Accept();
RpcServerConnectionHandler connection = new RpcServerConnectionHandler(this, newSocket);
server.AddReceiveSocket(newSocket, connection.HandleData);
}
public void DataCallback(SelectServerSharedBuffer server, Socket socket)
{
int bytesReceived;
try
{
bytesReceived = socket.Receive(server.sharedBuffer);
}
catch (SocketException)
{
bytesReceived = -1;
}
if (bytesReceived <= 0)
{
socket.ShutdownSafe();
server.DisposeAndRemoveReceiveSocket(socket);
}
lineParser.Add(server.sharedBuffer, 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();
server.DisposeAndRemoveReceiveSocket(socket);
}
else
{
writer.WriteLine("UnknownCommand '{0}'", line);
writer.WriteLine("Commands: dump, help, exit");
}
SendPrompt();
}
}
public void AcceptCallback(SelectServerSharedBuffer server, Socket listenSock)
{
Socket newSock = listenSock.Accept();
DebugClientData clientData = new DebugClientData(newSock);
server.AddReceiveSocket(newSock, clientData.DataCallback);
clientData.SendPrompt();
}
static void AddRpcServer(SelectServerSharedBuffer selectServer, EndPoint endPoint, RpcServerHandler handler, int backlog)
{
Socket tcpAcceptSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
tcpAcceptSocket.Bind(endPoint);
tcpAcceptSocket.Listen(backlog);
selectServer.AddListenSocket(tcpAcceptSocket, handler.AcceptCallback);
Socket udpSocket = new Socket(endPoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
udpSocket.Bind(endPoint);
selectServer.AddReceiveSocket(udpSocket, handler.DatagramRecvHandler);
}
public void TcpSocketRecvCallback(SelectServerSharedBuffer server, Socket socket)
{
int bytesRead;
try
{
bytesRead = socket.Receive(server.sharedBuffer);
}
catch (SocketException)
{
bytesRead = -1;
}
if (bytesRead <= 0)
{
server.RemoveReceiveSocket(socket);
return;
}
HandleData(socket, server.sharedBuffer, 0, (uint)bytesRead);
}
public void DatagramRecvHandler(SelectServerSharedBuffer server, Socket sock)
{
int bytesReceived = sock.ReceiveFrom(server.sharedBuffer, 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(server.sharedBuffer, 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, ref server.sharedBuffer, null);
return;
}
ISerializer replyParameters;
RpcReply reply = Call(clientString, callMessage.call, server.sharedBuffer, parametersOffset, (uint)bytesReceived, out replyParameters);
if (reply != null)
{
new RpcMessage(callMessage.transmissionID, reply).SendUdp(from, sock, ref server.sharedBuffer, replyParameters);
}
}
public void HandleData(SelectServerSharedBuffer server, Socket sock)
{
int bytesReceived;
try
{
bytesReceived = sock.Receive(server.sharedBuffer);
}
catch (SocketException)
{
bytesReceived = -1;
}
if (bytesReceived <= 0)
{
sock.ShutdownSafe();
server.DisposeAndRemoveReceiveSocket(sock);
return;
}
recordBuilder.HandleData(socket, server.sharedBuffer, 0, (uint)bytesReceived);
}
public void Run(TextWriter selectServerEventLog, IPEndPoint debugServerEndPoint, IPEndPoint npcServerEndPoint,
IPAddress listenIPAddress, Int32 backlog, SharedFileSystem sharedFileSystem,
Int32 portmapPort, Int32 mountPort, Int32 nfsPort, UInt32 readSizeMax, UInt32 suggestedReadSizeMultiple)
{
ByteArrayReference sendBuffer = new ByteArrayReference(4096);
//
// Create Mappings List
//
NamedMapping[] namedMappings = new NamedMapping[] {
new NamedMapping(PortMap.Name, new Mapping(PortMap.ProgramNumber, PortMap2.ProgramVersion, PortMap.IPProtocolTcp, (UInt32)portmapPort)),
new NamedMapping(PortMap.Name, new Mapping(PortMap.ProgramNumber, PortMap2.ProgramVersion, PortMap.IPProtocolUdp, (UInt32)portmapPort)),
new NamedMapping(Mount.Name, new Mapping(Mount.ProgramNumber, Mount1.ProgramVersion, PortMap.IPProtocolTcp, (UInt32)mountPort)),
new NamedMapping(Mount.Name, new Mapping(Mount.ProgramNumber, Mount1.ProgramVersion, PortMap.IPProtocolUdp, (UInt32)mountPort)),
new NamedMapping(Mount.Name, new Mapping(Mount.ProgramNumber, Mount3.ProgramVersion, PortMap.IPProtocolTcp, (UInt32)mountPort)),
new NamedMapping(Mount.Name, new Mapping(Mount.ProgramNumber, Mount3.ProgramVersion, PortMap.IPProtocolUdp, (UInt32)mountPort)),
new NamedMapping(Nfs.Name, new Mapping(Nfs.ProgramNumber, Nfs3.ProgramVersion, PortMap.IPProtocolTcp, (UInt32)nfsPort)),
new NamedMapping(Nfs.Name, new Mapping(Nfs.ProgramNumber, Nfs3.ProgramVersion, PortMap.IPProtocolUdp, (UInt32)nfsPort)),
};
PortMap2Server portMapServer = new PortMap2Server(this, namedMappings, sendBuffer);
Mount1And3Server mountServer = new Mount1And3Server(this, sharedFileSystem, sendBuffer);
Nfs3Server nfsServer = new Nfs3Server(this, sharedFileSystem, sendBuffer, readSizeMax, suggestedReadSizeMultiple);
//
// Create Endpoints
//
if (listenIPAddress == null)
{
listenIPAddress = IPAddress.Any;
}
IPEndPoint portMapEndPoint = new IPEndPoint(listenIPAddress, portmapPort);
IPEndPoint mountEndPoint = new IPEndPoint(listenIPAddress, mountPort);
IPEndPoint nfsEndPoint = new IPEndPoint(listenIPAddress, nfsPort);
selectServer = new SelectServerSharedBuffer(false, new byte[4096]);
AddRpcServer(selectServer, portMapEndPoint, portMapServer, backlog);
AddRpcServer(selectServer, mountEndPoint, mountServer, backlog);
AddRpcServer(selectServer, nfsEndPoint, nfsServer, backlog);
if (debugServerEndPoint != null)
{
Socket tcpAcceptSocket = new Socket(debugServerEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
tcpAcceptSocket.Bind(debugServerEndPoint);
tcpAcceptSocket.Listen(4);
selectServer.AddListenSocket(tcpAcceptSocket, new ControlServer().AcceptCallback);
}
if (npcServerEndPoint != null)
{
#if !WindowsCE
/*
* NpcSelectServerHandler npcServerHandler;
* {
* Nfs3Server.NfsServerManager nfsServerManager = new Nfs3Server.NfsServerManager(nfsServer);
* NpcReflector reflector = new NpcReflector(
* new NpcExecutionObject(nfsServerManager, "Nfs3ServerManager", null, null),
* new NpcExecutionObject(nfsServer, "Nfs3Server", null, null),
* new NpcExecutionObject(portMapServer, "Portmap2Server", null, null),
* new NpcExecutionObject(mountServer, "Mount1And3Server", null, null)
* );
* npcServerHandler = new NpcSelectServerHandler(NpcCallback.Instance, reflector, new DefaultNpcHtmlGenerator("NfsServer", reflector));
* }
*
* Socket tcpAcceptSocket = new Socket(npcServerEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
* tcpAcceptSocket.Bind(npcServerEndPoint);
* tcpAcceptSocket.Listen(4);
*
* selectServer.control.AddListenSocket(tcpAcceptSocket, npcServerHandler.AcceptCallback);
* */
#endif
}
this.serverStartTimeStopwatchTicks = Stopwatch.GetTimestamp();
/*
* selectServer.Run(selectServerEventLog, new byte[1024], tcpListeners.ToArray(),
* new UdpSelectListener[]{
* new UdpSelectListener(portMapEndPoint, portMapServer),
* new UdpSelectListener(mountEndPoint , mountServer),
* new UdpSelectListener(nfsEndPoint , nfsServer),
* }
* );
*/
selectServer.Run();
}
