protected override void HandleInternal(ChannelHandlerContext ctx, RpcInfo info) { RpcCall rpcCall = (RpcCall)info.Header(); MountInterface.MNTPROC mntproc = MountInterface.MNTPROC.FromValue(rpcCall.GetProcedure ()); int xid = rpcCall.GetXid(); byte[] data = new byte[info.Data().ReadableBytes()]; info.Data().ReadBytes(data); XDR xdr = new XDR(data); XDR @out = new XDR(); IPAddress client = ((IPEndPoint)info.RemoteAddress()).Address; if (mntproc == MountInterface.MNTPROC.Null) { @out = NullOp(@out, xid, client); } else { if (mntproc == MountInterface.MNTPROC.Mnt) { // Only do port monitoring for MNT if (!DoPortMonitoring(info.RemoteAddress())) { @out = MountResponse.WriteMNTResponse(Nfs3Status.Nfs3errAcces, @out, xid, null); } else { @out = Mnt(xdr, @out, xid, client); } } else { if (mntproc == MountInterface.MNTPROC.Dump) { @out = Dump(@out, xid, client); } else { if (mntproc == MountInterface.MNTPROC.Umnt) { @out = Umnt(xdr, @out, xid, client); } else { if (mntproc == MountInterface.MNTPROC.Umntall) { Umntall(@out, xid, client); } else { if (mntproc == MountInterface.MNTPROC.Export) { // Currently only support one NFS export IList <NfsExports> hostsMatchers = new AList <NfsExports>(); if (hostsMatcher != null) { hostsMatchers.AddItem(hostsMatcher); @out = MountResponse.WriteExportList(@out, xid, exports, hostsMatchers); } else { // This means there are no valid exports provided. RpcAcceptedReply.GetInstance(xid, RpcAcceptedReply.AcceptState.ProcUnavail, new VerifierNone ()).Write(@out); } } else { // Invalid procedure RpcAcceptedReply.GetInstance(xid, RpcAcceptedReply.AcceptState.ProcUnavail, new VerifierNone ()).Write(@out); } } } } } } ChannelBuffer buf = ChannelBuffers.WrappedBuffer(@out.AsReadOnlyWrap().Buffer()); RpcResponse rsp = new RpcResponse(buf, info.RemoteAddress()); RpcUtil.SendRpcResponse(ctx, rsp); }
protected override bool IsIdempotent(RpcCall call) { // Not required, because cache is turned off return(false); }
/// <summary>Used by GSS</summary> /// <exception cref="System.IO.IOException"/> public virtual byte[] Wrap(RpcCall request, XDR response) { throw new NotSupportedException(); }
internal static void CreatePortmapXDRheader(XDR xdr_out, int procedure) { // Make this a method RpcCall.GetInstance(0, 100000, 2, procedure, new CredentialsNone(), new VerifierNone ()).Write(xdr_out); }
/// <exception cref="System.IO.IOException"/> public abstract Verifier GetVerifer(RpcCall request);
/// <summary>Used by GSS</summary> /// <exception cref="System.IO.IOException"/> public virtual XDR Unwrap(RpcCall request, byte[] data) { throw new NotSupportedException(); }
public void ProcessExited(int exitCode) { var dto = RpcCall.Create(nameof(IDebugEventListener), nameof(ProcessExited), exitCode); _channel.Write(dto); }
public abstract bool ShouldSilentlyDrop(RpcCall request);
public override Verifier GetVerifer(RpcCall request) { return(new VerifierNone()); }
public void ThreadStopped(int threadId, ThreadStopReason reason) { var dto = RpcCall.Create(nameof(IDebugEventListener), nameof(ThreadStopped), threadId, reason); _channel.Write(dto); }
public override bool ShouldSilentlyDrop(RpcCall request) { return(false); }
static void HandleGameData(HazelBinaryReader reader, GameDataType datatype, bool send) { var dir = send ? "SEND" : "RECV"; switch (datatype) { case GameDataType.RpcCall: var RPC = RpcCall.Deserialize(reader); var reciver = EntityTracker.Get(RPC.targetNetId); if (LogRPC) { Console.WriteLine($"[RPC][{RPC.callId}]sent to {reciver?.GetType()?.Name ?? "unknown"} size: {reader.GetBytesLeft()}"); } if (reciver != null) { reciver.HandleRpcCall(RPC.callId, reader); } //DumpToConsole(RPC, LogRPC); //Console.WriteLine($"RPC for type: {RPC} size: {data.body.Length}"); switch (RPC.callId) { case RpcCalls.CheckColor: var CheckColor = CmdCheckColor.Deserialize(reader); DumpToConsole(CheckColor, LogRPC); break; case RpcCalls.CheckName: var CheckName = CmdCheckName.Deserialize(reader); DumpToConsole(CheckName, LogRPC); break; case RpcCalls.CloseDoorsOfType: var CloseDoorsOfType = RpcCloseDoorsOfType.Deserialize(reader); DumpToConsole(CloseDoorsOfType, LogRPC); break; case RpcCalls.EnterVent: var EnterVent = RpcEnterVent.Deserialize(reader); DumpToConsole(EnterVent, LogRPC); break; case RpcCalls.ExitVent: var ExitVent = RpcExitVent.Deserialize(reader); DumpToConsole(ExitVent, LogRPC); break; case RpcCalls.Exiled: var exileid = reader.ReadPackedInt32(); Console.WriteLine("Exile id: " + exileid); break; case RpcCalls.SendChat: var chat = RpcSendChat.Deserialize(reader); LogChatToConsole(RPC.targetNetId.ToString(), chat.text); break; case RpcCalls.SendChatNote: var chatnote = RpcSendChatNote.Deserialize(reader); LogChatToConsole("server", "SendChatNote"); break; case RpcCalls.SetColor: var SetColor = RpcSetColor.Deserialize(reader); DumpToConsole(SetColor, LogRPC); break; case RpcCalls.SetSkin: var skin = RpcSetSkin.Deserialize(reader); DumpToConsole(skin, LogRPC); break; case RpcCalls.SetHat: var hat = RpcSetHat.Deserialize(reader); Console.WriteLine($"Set hat: [{(int)hat.hatId}]{hat.hatId}"); break; case RpcCalls.SetPet: var setpet = RpcSetPet.Deserialize(reader); DumpToConsole(setpet, LogRPC); break; case RpcCalls.SetName: var setname = RpcSetName.Deserialize(reader); DumpToConsole(setname, LogRPC); break; case RpcCalls.SetTasks: var SetTasks = RpcSetTasks.Deserialize(reader); DumpToConsole(SetTasks, LogRPC); break; case RpcCalls.SetInfected: var infected = RpcSetInfected.Deserialize(reader); DumpToConsole(infected); break; case RpcCalls.SetScanner: var SetScanner = RpcSetScanner.Deserialize(reader); DumpToConsole(SetScanner, LogRPC); break; case RpcCalls.AddVote: var addvote = RpcAddVote.Deserialize(reader); DumpToConsole(addvote, LogRPC); break; case RpcCalls.PlayAnimation: var anim = RpcPlayAnimation.Deserialize(reader); DumpToConsole(anim, LogRPC); break; case RpcCalls.CastVote: var castvote = CmdCastVote.Deserialize(reader); DumpToConsole(castvote, LogRPC); break; case RpcCalls.CompleteTask: var complete = RpcCompleteTask.Deserialize(reader); DumpToConsole(complete, LogRPC); break; case RpcCalls.MurderPlayer: var MurderPlayer = RpcMurderPlayer.Deserialize(reader); var player = EntityTracker.Get(MurderPlayer.netId); DumpToConsole(MurderPlayer, LogRPC); break; case RpcCalls.RepairSystem: var RepairSystem = RpcRepairSystem.Deserialize(reader); DumpToConsole(RepairSystem, LogRPC); break; case RpcCalls.ReportDeadBody: var ReportDeadBody = CmdReportDeadBody.Deserialize(reader); DumpToConsole(ReportDeadBody, LogRPC); break; case RpcCalls.SnapTo: var SnapTo = RpcSnapTo.Deserialize(reader); DumpToConsole(SnapTo, LogRPC); break; case RpcCalls.StartMeeting: var StartMeeting = RpcStartMeeting.Deserialize(reader); DumpToConsole(StartMeeting, LogRPC); break; case RpcCalls.VotingComplete: var VotingComplete = RpcVotingComplete.Deserialize(reader); DumpToConsole(VotingComplete, LogRPC); break; case RpcCalls.SetStartCounter: var startcounter = RpcSetStartCounter.Deserialize(reader); DumpToConsole(startcounter, LogRPC); break; case RpcCalls.SyncSettings: var syncsettings = RpcSyncSettings.Deserialize(reader); DumpToConsole(syncsettings, LogRPC); break; //Dont have a message body case RpcCalls.Close: break; //ComponentSpecific - it contains diffrent data depending on what component it's inteded for case RpcCalls.UpdateGameData: var update = RpcUpdateGameData.Deserialize(reader); DumpToConsole(update, LogRPC); break; default: Console.WriteLine($"Unhandled RPC command: " + RPC.callId); break; } if (reader.GetBytesLeft() > 0 && LogNotConsumed) { Console.WriteLine($"[{RPC.callId}]{reader.GetBytesLeft()} bytes not cunsumed"); reader.ReadBytesToEnd(); } break; case GameDataType.Data: var data = Data.Deserialize(reader); InnerNetObject entity; if (!EntityTracker.entities.TryGetValue(data.netId, out entity)) { Console.WriteLine($"Entity missing for id: {data.netId} size: {data.data.Length}"); return; } if (!(entity is CustomNetworkTransform)) { Console.WriteLine($"Recived Data for: {entity.GetType().Name} size: {data.data.Length}"); } entity.Deserialize(new HazelBinaryReader(data.data), false); if (LogMoves && entity is CustomNetworkTransform move) { Console.WriteLine($"[{dir}]Move command player: {move.OwnerId:0000} seq: {move.seq:0000} pos: {move.position} delta: {move.velocity}"); } break; case GameDataType.Spawn: var spawn = Spawn.Deserialize(reader); Console.WriteLine("Spawning: " + spawn.spawnId); switch (spawn.spawnId) { case 0: var shipStatus = new ShipStatus(); shipStatus.OwnerId = spawn.ownerId; shipStatus.NetId = spawn.children[0].netId; shipStatus.Deserialize(new HazelBinaryReader(spawn.children[0].body), true); EntityTracker.Add(shipStatus); break; case 1: var meeting = new MeetingHud(); meeting.OwnerId = spawn.ownerId; meeting.NetId = spawn.children[0].netId; meeting.Deserialize(new HazelBinaryReader(spawn.children[0].body), true); EntityTracker.Add(meeting); break; case 2: var lobby = new LobbyBehaviour(); lobby.OwnerId = spawn.ownerId; lobby.NetId = spawn.children[0].netId; EntityTracker.Add(lobby); break; case 3: var gdc = new GameDataComponent(); gdc.OwnerId = spawn.ownerId; gdc.NetId = spawn.children[0].netId; gdc.Deserialize(new HazelBinaryReader(spawn.children[0].body), true); EntityTracker.Add(gdc); var dummy2 = new DummyComponent(); dummy2.name = "gamedata.dummy1"; dummy2.OwnerId = spawn.ownerId; dummy2.NetId = spawn.children[1].netId; dummy2.Deserialize(new HazelBinaryReader(spawn.children[1].body), true); EntityTracker.Add(dummy2); break; case 4: //player character var player = new PlayerControl(); player.OwnerId = spawn.ownerId; player.NetId = spawn.children[0].netId; player.Deserialize(new HazelBinaryReader(spawn.children[0].body), true); EntityTracker.Add(player); player.dummy1 = new DummyComponent(); player.dummy1.name = "player.dummy1"; player.dummy1.OwnerId = spawn.ownerId; player.dummy1.NetId = spawn.children[1].netId; player.dummy1.Deserialize(new HazelBinaryReader(spawn.children[1].body), true); EntityTracker.Add(player.dummy1); player.transform = new CustomNetworkTransform(); player.transform.OwnerId = spawn.ownerId; player.transform.NetId = spawn.children[2].netId; player.transform.Deserialize(new HazelBinaryReader(spawn.children[2].body), true); EntityTracker.Add(player.transform); DumpToConsole(player); break; case 5: //HeadQuarters var hq = new ShipStatus(); hq.OwnerId = spawn.ownerId; hq.NetId = spawn.children[0].netId; hq.Deserialize(new HazelBinaryReader(spawn.children[0].body), true); EntityTracker.Add(hq); break; case 6: //PlanetMap var polus = new ShipStatus(); polus.OwnerId = spawn.ownerId; polus.NetId = spawn.children[0].netId; polus.Deserialize(new HazelBinaryReader(spawn.children[0].body), true); EntityTracker.Add(polus); break; case 7: //AprilShipStatus default: Console.WriteLine($"Unhandled spawnid: {spawn.spawnId}"); break; } break; case GameDataType.SceneChange: var scene = SceneChange.Deserialize(reader); if (scene.sceneName == "OnlineGame") { //Starting game } DumpToConsole(scene); break; case GameDataType.Despawn: var despawn = Despawn.Deserialize(reader); EntityTracker.entities.Remove(despawn.netId); LogToConsole("Despawn Netid: " + despawn.netId); break; case GameDataType.Ready: var ready = Ready.Deserialize(reader); Console.WriteLine($"Ready: " + ready.playerId); break; case GameDataType.ChangeSettings: var changesettings = ChangeSettings.Deserialize(reader); DumpToConsole(changesettings); break; default: Console.WriteLine($"Unhandled Gamedatatype: {datatype}"); break; } if (reader.GetBytesLeft() > 0 && LogNotConsumed) { Console.WriteLine($"[{datatype}]{reader.GetBytesLeft()} bytes not cunsumed"); reader.ReadBytesToEnd(); } }
public override RpcReply Call(String clientString, RpcCall call, byte[] callParameters, UInt32 callOffset, UInt32 callMaxOffset, out ISerializer replyParameters) { String nfsMethodName; ISerializer callData; Int32 extraPerfoamanceData = -1; Int64 beforeCall = Stopwatch.GetTimestamp(); Boolean printCall = true, printReply = true; switch (call.procedure) { case (UInt32)Nfs3Command.NULL: nfsMethodName = "NULL"; callData = VoidSerializer.Instance; replyParameters = VoidSerializer.Instance; break; case (UInt32)Nfs3Command.GETATTR: nfsMethodName = "GETATTR"; GetFileAttributesCall getFileAttributesCall = new GetFileAttributesCall(callParameters, callOffset, callMaxOffset); callData = getFileAttributesCall.CreateSerializer(); replyParameters = GETATTR(getFileAttributesCall).CreateSerializer(); break; case (UInt32)Nfs3Command.SETATTR: nfsMethodName = "SETATTR"; SetFileAttributesCall setFileAttributesCall = new SetFileAttributesCall(callParameters, callOffset, callMaxOffset); callData = setFileAttributesCall.CreateSerializer(); replyParameters = SETATTR(setFileAttributesCall).CreateSerializer(); break; case (UInt32)Nfs3Command.LOOKUP: nfsMethodName = "LOOKUP"; printReply = false; LookupCall lookupCall = new LookupCall(callParameters, callOffset, callMaxOffset); callData = lookupCall.CreateSerializer(); replyParameters = LOOKUP(lookupCall).CreateSerializer(); break; case (UInt32)Nfs3Command.ACCESS: nfsMethodName = "ACCESS"; AccessCall accessCall = new AccessCall(callParameters, callOffset, callMaxOffset); callData = accessCall.CreateSerializer(); replyParameters = ACCESS(accessCall).CreateSerializer(); break; case (UInt32)Nfs3Command.READ: nfsMethodName = "READ"; printReply = false; ReadCall readCall = new ReadCall(callParameters, callOffset, callMaxOffset); callData = readCall.CreateSerializer(); replyParameters = READ(readCall).CreateSerializer(); extraPerfoamanceData = (Int32)readCall.count; break; case (UInt32)Nfs3Command.WRITE: nfsMethodName = "WRITE"; printCall = false; WriteCall writeCall = new WriteCall(callParameters, callOffset, callMaxOffset); callData = writeCall.CreateSerializer(); replyParameters = WRITE(writeCall).CreateSerializer(); extraPerfoamanceData = (Int32)writeCall.count; break; case (UInt32)Nfs3Command.CREATE: nfsMethodName = "CREATE"; CreateCall createCall = new CreateCall(callParameters, callOffset, callMaxOffset); callData = createCall.CreateSerializer(); replyParameters = CREATE(createCall).CreateSerializer(); break; case (UInt32)Nfs3Command.MKDIR: nfsMethodName = "MKDIR"; MkdirCall mkdirCall = new MkdirCall(callParameters, callOffset, callMaxOffset); callData = mkdirCall.CreateSerializer(); replyParameters = MKDIR(mkdirCall).CreateSerializer(); break; case (UInt32)Nfs3Command.SYMLINK: nfsMethodName = "SYMLINK"; SymLinkCall symLinkCall = new SymLinkCall(callParameters, callOffset, callMaxOffset); callData = symLinkCall.CreateSerializer(); replyParameters = SYMLINK(symLinkCall).CreateSerializer(); break; case (UInt32)Nfs3Command.REMOVE: case (UInt32)Nfs3Command.RMDIR: nfsMethodName = "REMOVE/RMDIR"; RemoveCall removeCall = new RemoveCall(callParameters, callOffset, callMaxOffset); callData = removeCall.CreateSerializer(); replyParameters = REMOVE(removeCall).CreateSerializer(); break; case (UInt32)Nfs3Command.RENAME: nfsMethodName = "RENAME"; RenameCall renameCall = new RenameCall(callParameters, callOffset, callMaxOffset); callData = renameCall.CreateSerializer(); replyParameters = RENAME(renameCall).CreateSerializer(); break; case (UInt32)Nfs3Command.READDIRPLUS: nfsMethodName = "READDIRPLUS"; printReply = false; ReadDirPlusCall readDirPlusCall = new ReadDirPlusCall(callParameters, callOffset, callMaxOffset); callData = readDirPlusCall.CreateSerializer(); replyParameters = READDIRPLUS(readDirPlusCall).CreateSerializer(); break; case (UInt32)Nfs3Command.FSSTAT: nfsMethodName = "FSSTAT"; FileSystemStatusCall fileSystemInfoCall = new FileSystemStatusCall(callParameters, callOffset, callMaxOffset); callData = fileSystemInfoCall.CreateSerializer(); replyParameters = FSSTAT(fileSystemInfoCall).CreateSerializer(); break; case (UInt32)Nfs3Command.FSINFO: nfsMethodName = "FSINFO"; // // Deserialize // FSInfoCall fsInfoCall = new FSInfoCall(callParameters, callOffset, callMaxOffset); callData = fsInfoCall.CreateSerializer(); replyParameters = FSINFO(fsInfoCall).CreateSerializer(); break; case (UInt32)Nfs3Command.COMMIT: nfsMethodName = "COMMIT"; // Since this server does not perform unstable writes at the moment, this function is unnecessary CommitCall commitCall = new CommitCall(callParameters, callOffset, callMaxOffset); callData = commitCall.CreateSerializer(); //replyParameters = Handle(commitCall).CreateSerializer(); CommitReply commitReply = new CommitReply(BeforeAndAfterAttributes.None, null); replyParameters = commitReply.CreateSerializer(); break; default: if (NfsServerLog.warningLogger != null) { NfsServerLog.warningLogger.WriteLine("[{0}] [Warning] client '{1}' sent unknown procedure number {2}", serviceName, clientString, call.procedure); } replyParameters = VoidSerializer.Instance; return(new RpcReply(RpcVerifier.None, RpcAcceptStatus.ProcedureUnavailable)); } Int64 afterCall = Stopwatch.GetTimestamp(); Int64 callStopwatchTicks = afterCall - beforeCall; if (NfsServerLog.rpcCallLogger != null) { NfsServerLog.rpcCallLogger.WriteLine( #if WindowsCE JediTimer.JediTimerPrefix() + #endif "[{0}] {1} {2} => {3} {4:0.00} milliseconds", serviceName, nfsMethodName, printCall ? DataStringBuilder.DataSmallString(callData, NfsServerLog.sharedDataStringBuilder) : "[Call Ommited From Log]", printReply ? DataStringBuilder.DataSmallString(replyParameters, NfsServerLog.sharedDataStringBuilder) : "[Reply Ommited From Log]", callStopwatchTicks.StopwatchTicksAsDoubleMilliseconds()); } else if (NfsServerLog.warningLogger != null) { Double callMilliseconds = callStopwatchTicks.StopwatchTicksAsDoubleMilliseconds(); if (callMilliseconds >= 40) { NfsServerLog.warningLogger.WriteLine( #if WindowsCE JediTimer.JediTimerPrefix() + #endif "[{0}] [Warning] {1} {2} => {3} {4:0.00} milliseconds", serviceName, nfsMethodName, printCall ? DataStringBuilder.DataSmallString(callData, NfsServerLog.sharedDataStringBuilder) : "[Call Ommited From Log]", printReply ? DataStringBuilder.DataSmallString(replyParameters, NfsServerLog.sharedDataStringBuilder) : "[Reply Ommited From Log]", callMilliseconds); } } if (NfsServerLog.performanceLog != null) { NfsServerLog.performanceLog.Log((Nfs3Command)call.procedure, (UInt32)callStopwatchTicks.StopwatchTicksAsMicroseconds(), extraPerfoamanceData); } //servicesManager.PrintPerformance(); return(new RpcReply(RpcVerifier.None)); }
/// <exception cref="System.Exception"/> public override void MessageReceived(ChannelHandlerContext ctx, MessageEvent e) { RpcInfo info = (RpcInfo)e.GetMessage(); RpcCall rpcCall = (RpcCall)info.Header(); int portmapProc = rpcCall.GetProcedure(); int xid = rpcCall.GetXid(); XDR @in = new XDR(info.Data().ToByteBuffer().AsReadOnlyBuffer(), XDR.State.Reading ); XDR @out = new XDR(); if (portmapProc == PmapprocNull) { @out = NullOp(xid, @in, @out); } else { if (portmapProc == PmapprocSet) { @out = Set(xid, @in, @out); } else { if (portmapProc == PmapprocUnset) { @out = Unset(xid, @in, @out); } else { if (portmapProc == PmapprocDump) { @out = Dump(xid, @in, @out); } else { if (portmapProc == PmapprocGetport) { @out = Getport(xid, @in, @out); } else { if (portmapProc == PmapprocGetversaddr) { @out = Getport(xid, @in, @out); } else { Log.Info("PortmapHandler unknown rpc procedure=" + portmapProc); RpcAcceptedReply reply = RpcAcceptedReply.GetInstance(xid, RpcAcceptedReply.AcceptState .ProcUnavail, new VerifierNone()); reply.Write(@out); } } } } } } ChannelBuffer buf = ChannelBuffers.WrappedBuffer(@out.AsReadOnlyWrap().Buffer()); RpcResponse rsp = new RpcResponse(buf, info.RemoteAddress()); RpcUtil.SendRpcResponse(ctx, rsp); }
private int GetTimeoutMs(RpcCall call) => call.TimeoutMs ?? executor.DefaultOptions.TimeoutMs;