public Nfs3Server(RpcServicesManager servicesManager, SharedFileSystem sharedFileSystem, Buf sendBuffer,
UInt32 readSizeMax, UInt32 suggestedReadSizeMultiple)
: base("Nfs3", sendBuffer)
{
this.servicesManager = servicesManager;
this.sharedFileSystem = sharedFileSystem;
this.fileContents.array = new Byte[readSizeMax];
this.suggestedReadSizeMultiple = suggestedReadSizeMultiple;
}
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)
{
Buf sendBuffer = new Buf(4096);
Buf recvBuffer = new Buf(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 SelectServer(false, recvBuffer);
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.control.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();
}
static void Main(String[] args)
{
#if WindowsCE
try
{
#endif
NfsServerLog.stopwatchTicksBase = Stopwatch.GetTimestamp();
NfsServerProgramOptions options = new NfsServerProgramOptions();
List <String> nonOptionArguments = options.Parse(args);
if (nonOptionArguments.Count < 2)
{
options.ErrorAndUsage("Expected at least 2 non-option arguments but got '{0}'", nonOptionArguments.Count);
return;
}
if (nonOptionArguments.Count % 2 == 1)
{
options.ErrorAndUsage("Expected an even number of non-option arguments but got {0}", nonOptionArguments.Count);
}
//
//
RootShareDirectory[] rootShareDirectories = new RootShareDirectory[nonOptionArguments.Count / 2];
for (int i = 0; i < rootShareDirectories.Length; i++)
{
String localSharePath = nonOptionArguments[2 * i];
String remoteShareName = nonOptionArguments[2 * i + 1];
rootShareDirectories[i] = new RootShareDirectory(localSharePath, remoteShareName);
}
//
// Options not exposed via command line yet
//
Int32 mountListenPort = 59733;
Int32 backlog = 4;
UInt32 readSizeMax = 65536;
UInt32 suggestedReadSizeMultiple = 4096;
//
// Listen IP Address
//
IPAddress listenIPAddress = options.listenIPAddress.ArgValue;
//
// Debug Server
//
IPEndPoint debugServerEndPoint = !options.debugListenPort.set ? null :
new IPEndPoint(listenIPAddress, options.debugListenPort.ArgValue);
//
// Npc Server
//
IPEndPoint npcServerEndPoint = !options.npcListenPort.set ? null :
new IPEndPoint(listenIPAddress, options.npcListenPort.ArgValue);
//
// Logging Options
//
#if WindowsCE
JediTimer.printJediTimerPrefix = options.jediTimer.set;
#endif
if (options.performanceLog.set)
{
if (options.performanceLog.ArgValue.Equals("internal", StringComparison.CurrentCultureIgnoreCase))
{
NfsServerLog.performanceLog = new InternalPerformanceLog();
if (!options.debugListenPort.set)
{
options.ErrorAndUsage("Invalid option combination: you cannot set '-i internal' unless you also set -d <port>");
return;
}
}
else
{
try
{
FileStream fileStream = new FileStream(options.performanceLog.ArgValue, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
NfsServerLog.performanceLog = new WriterPerformanceLog(fileStream);
}
catch (Exception e)
{
Console.WriteLine("Failed to create performance log file '{0}'", options.performanceLog.ArgValue);
throw e;
}
}
}
TextWriter selectServerEventsLog = null;
if (options.logLevel.ArgValue != LogLevel.None)
{
TextWriter logWriter;
if (options.logFile.set)
{
logWriter = new StreamWriter(new FileStream(options.logFile.ArgValue, FileMode.Create, FileAccess.Write, FileShare.Read));
}
else
{
logWriter = Console.Out;
}
NfsServerLog.sharedFileSystemLogger = (options.logLevel.ArgValue >= LogLevel.Info) ? logWriter : null;
NfsServerLog.rpcCallLogger = (options.logLevel.ArgValue >= LogLevel.Info) ? logWriter : null;
NfsServerLog.warningLogger = (options.logLevel.ArgValue >= LogLevel.Warning) ? logWriter : null;
NfsServerLog.npcEventsLogger = (options.logLevel.ArgValue >= LogLevel.Info) ? logWriter : null;
RpcPerformanceLog.rpcMessageSerializationLogger = (options.logLevel.ArgValue >= LogLevel.Info) ? logWriter : null;
selectServerEventsLog = (options.logLevel.ArgValue >= LogLevel.All) ? logWriter : null;
}
//
// Permissions
//
ModeFlags defaultDirectoryPermissions =
ModeFlags.OtherExecute | ModeFlags.OtherWrite | ModeFlags.OtherRead |
ModeFlags.GroupExecute | ModeFlags.GroupWrite | ModeFlags.GroupRead |
ModeFlags.OwnerExecute | ModeFlags.OwnerWrite | ModeFlags.OwnerRead;
/*ModeFlags.SaveSwappedText | ModeFlags.SetUidOnExec | ModeFlags.SetGidOnExec;*/
ModeFlags defaultFilePermissions =
ModeFlags.OtherExecute | ModeFlags.OtherWrite | ModeFlags.OtherRead |
ModeFlags.GroupExecute | ModeFlags.GroupWrite | ModeFlags.GroupRead |
ModeFlags.OwnerExecute | ModeFlags.OwnerWrite | ModeFlags.OwnerRead;
/*ModeFlags.SaveSwappedText | ModeFlags.SetUidOnExec | ModeFlags.SetGidOnExec;*/
IPermissions permissions = new ConstantPermissions(defaultDirectoryPermissions, defaultFilePermissions);
IFileIDsAndHandlesDictionary fileIDDictionary = new FreeStackFileIDDictionary(512, 512, 4096, 1024);
SharedFileSystem sharedFileSystem = new SharedFileSystem(fileIDDictionary, permissions, rootShareDirectories);
new RpcServicesManager().Run(
selectServerEventsLog,
debugServerEndPoint,
npcServerEndPoint,
listenIPAddress,
backlog, sharedFileSystem,
Ports.PortMap, mountListenPort, Ports.Nfs,
readSizeMax, suggestedReadSizeMultiple);
#if WindowsCE
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
#endif
}
public Mount1And3Server(RpcServicesManager servicesManager, SharedFileSystem sharedFileSystem, Buf sendBuffer)
: base("Mount3", sendBuffer)
{
this.servicesManager = servicesManager;
this.sharedFileSystem = sharedFileSystem;
}
