internal void ConsumeData(NetMessage msg) { byte header; if (!msg.ReadByte(out header)) { return; } MsgType msgType; BroadcastMode broadcast; ReliabilityMode reliability; SubMsgType sub; RpcUtils.ReadHeader(header, out reliability, out broadcast, out msgType, out sub); switch (msgType) { case MsgType.Internal: ProcessInternal(msg); break; case MsgType.Static: ProcessStatic(broadcast, reliability, msg); break; default: Debug.LogWarning($"Unsupported {msg.LengthBytes - 1} byte message of type {msgType} from {this}"); break; } }
internal void ConsumeData(NetMessage msg) { if (!msg.ReadByte(out var header)) { return; } RpcUtils.ReadHeader(header, out var reliability, out var broadcast, out var msgType, out var sub); switch (msgType) { case MsgType.Internal: ProcessInternal(broadcast, reliability, msg); break; case MsgType.Static: ProcessStatic(broadcast, reliability, msg); break; case MsgType.Netview: var info = new NetMessageInfo(broadcast, this) { Reliability = reliability }; Room.NetworkManager.CallRpc(msg, info, sub); break; case MsgType.Stream: Room.NetworkManager.Stream(msg, this); break; default: Debug.LogWarning($"Unsupported {msg.LengthBytes - 1} byte message of type {msgType} from {this}"); break; } }
partial void ImplementationShutdown(string reason) { _acceptEnabled = false; _roomListener.Stop(); _clientListener.Stop(); _shutdownTokenSource.Cancel(); var shutReason = GetMessage(reason.Length * 2 + 6); shutReason.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Owner, MsgType.Internal)); shutReason.Write(DandRRpcs.DisconnectMessage); shutReason.Write(reason); shutReason.WriteSize(); foreach (var room in _rooms.ToArray()) { room.Value.SendTcpReadyMessage(shutReason); } Player[] players; lock (_players) { players = _players.Values; } foreach (var player in players) { player.SendTcpReadyMessage(shutReason); } _tcpRunning = false; }
internal byte[] ProtectPDU(byte[] header, ref byte[] stub_data, int auth_padding_length, int send_sequence_no) { List <SecurityBuffer> buffers = new List <SecurityBuffer>(); buffers.Add(new SecurityBufferInOut(SecurityBufferType.Data | SecurityBufferType.ReadOnly, header)); var stub_data_buffer = new SecurityBufferInOut(SecurityBufferType.Data, stub_data); buffers.Add(stub_data_buffer); buffers.Add(new SecurityBufferInOut(SecurityBufferType.Data | SecurityBufferType.ReadOnly, AuthData.ToArray(TransportSecurity, auth_padding_length, ContextId, new byte[0]))); byte[] signature = new byte[0]; if (TransportSecurity.AuthenticationLevel == RpcAuthenticationLevel.PacketIntegrity) { signature = AuthContext.MakeSignature(buffers, send_sequence_no); } else if (TransportSecurity.AuthenticationLevel == RpcAuthenticationLevel.PacketPrivacy) { signature = AuthContext.EncryptMessage(buffers, SecurityQualityOfProtectionFlags.None, send_sequence_no); stub_data = stub_data_buffer.ToArray(); RpcUtils.DumpBuffer(true, "Send Encrypted Data", stub_data); } if (signature.Length > 0) { RpcUtils.DumpBuffer(true, "Send Signature Data", signature); } return(AuthData.ToArray(TransportSecurity, auth_padding_length, ContextId, signature)); }
internal void AddRoom(Room room) { _rooms[room.Guid] = room; try { RoomAdded?.Invoke(room); } catch (Exception e) { Debug.LogException(e); } //tell all rooms about this room var msg = GetMessage(room.RoomId.Length * 2 + 18); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.RoomAdd); msg.Write(room.RoomId); msg.Write(room.Guid); room.SendMessageToOthers(msg, ReliabilityMode.Ordered); //tell this room about all other rooms msg = GetMessage(1000); // f**k if I know msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.RoomAdd); foreach (var r in _rooms.ToArray()) { msg.Write(r.Value.RoomId); msg.Write(r.Value.Guid); } room.SendMessage(msg, ReliabilityMode.Ordered); }
private JsonRpc GetRpcServer(Stream stream, IResolveAssemblyReferenceTaskHandler handler) { IJsonRpcMessageHandler serverHandler = RpcUtils.GetRarMessageHandler(stream); JsonRpc rpc = new JsonRpc(serverHandler, handler); return(rpc); }
/// <summary> /// serialize the NetUserData over the network to the room that has this player /// </summary> /// <returns>false, if the data was not synchronized (the user isn't in a room, or NetUserData is null)</returns> public bool SynchNetData() { #if DEBUG Debug.Log($"Syncing net data for {this}"); #endif if (NetUserData == null) { return(false); } var msg = Server.GetMessage(NetUserData.AllocSize + 4); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.SyncNetUser); msg.Write(Id); NetUserData.OnSerialize(msg); var room = Room; if (room == null) { NetMessage.RecycleMessage(msg); return(false); } room.SendMessage(msg, ReliabilityMode.Ordered); return(true); }
void SendRoomSwitch(Room room) { _switchToken = Guid.NewGuid(); _switchingToRoom = room.Guid; //todo: tell old room that the player is going to leave. NetMessage rmsg; _oldRoom = _currentRoom; _currentRoom = Guid.Empty; if (Server.TryGetRoom(_oldRoom, out var oldRoom)) { rmsg = Server.GetMessage(4); rmsg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); rmsg.Write(DandRRpcs.ExpectLeavingPlayer); rmsg.Write(Id); oldRoom.SendMessage(rmsg, ReliabilityMode.Ordered); } var pmsg = Server.GetMessage(30 + room.RoomId.Length * 2); pmsg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); pmsg.Write(DandPRpcs.RoomSwitch); pmsg.Write(room.Address); //this is ~4 bytes + 3 bytes pmsg.Write(room.RoomId); pmsg.Write(_switchToken); SendMessage(pmsg, ReliabilityMode.Ordered); }
private RpcClientResponse SendAndReceiveImmediate(int proc_num, Guid objuuid, byte[] ndr_buffer, IReadOnlyCollection <NtObject> handles) { LRPC_IMMEDIATE_REQUEST_MESSAGE req_msg = new LRPC_IMMEDIATE_REQUEST_MESSAGE() { Header = new LRPC_HEADER(LRPC_MESSAGE_TYPE.lmtRequest), BindingId = 0, CallId = CallId++, ProcNum = proc_num, }; if (objuuid != Guid.Empty) { req_msg.ObjectUuid = objuuid; req_msg.Flags |= LRPC_REQUEST_MESSAGE_FLAGS.ObjectUuid; } AlpcMessageType <LRPC_IMMEDIATE_REQUEST_MESSAGE> send_msg = new AlpcMessageType <LRPC_IMMEDIATE_REQUEST_MESSAGE>(req_msg, ndr_buffer); AlpcMessageRaw resp_msg = new AlpcMessageRaw(0x1000); AlpcSendMessageAttributes send_attr = new AlpcSendMessageAttributes(); if (handles.Count > 0) { send_attr.AddHandles(handles); } using (AlpcReceiveMessageAttributes recv_attr = new AlpcReceiveMessageAttributes()) { RpcUtils.DumpBuffer(true, "ALPC Request Immediate", send_msg); _client.SendReceive(AlpcMessageFlags.SyncRequest, send_msg, send_attr, resp_msg, recv_attr, NtWaitTimeout.Infinite); RpcUtils.DumpBuffer(true, "ALPC Response Immediate", resp_msg); RpcClientResponse response = HandleResponse(resp_msg, recv_attr, req_msg.CallId); ClearAttributes(resp_msg, recv_attr); return(response); } }
public async Task Start() { Util.SavePidToFile(_rpcConfig.PidFile); // Create Logger RpcUtils.CreateLogger(_rpcConfig.LogDirectory, _rpcConfig.LogName, _rpcConfig.LogTarget); var type = Type.GetType(_rpcConfig.PluginFullName); var plugin = (IPlugin)Activator.CreateInstance(type); if (!CheckUsage(_rpcConfig, plugin)) { // Load benchmark configuration var configuration = Util.ReadFile(_rpcConfig.PluginConfiguration); IList <IRpcClient> clients = null; if (plugin.NeedAgents(configuration)) { // Create rpc clients clients = CreateRpcClients(_rpcConfig.AgentList); // Check rpc connections await WaitRpcConnectSuccess(clients); } await plugin.Start(configuration, clients); } }
private byte[] ProtectPDU(byte[] header, ref byte[] stub_data, int auth_padding_length) { List <SecurityBuffer> buffers = new List <SecurityBuffer>(); if (_negotiated_auth_type != RpcAuthenticationType.Kerberos) { buffers.Add(new SecurityBufferInOut(SecurityBufferType.Data | SecurityBufferType.ReadOnlyWithChecksum, header)); } var stub_data_buffer = new SecurityBufferInOut(SecurityBufferType.Data, stub_data); buffers.Add(stub_data_buffer); if (_negotiated_auth_type != RpcAuthenticationType.Kerberos) { buffers.Add(new SecurityBufferInOut(SecurityBufferType.Data | SecurityBufferType.ReadOnlyWithChecksum, AuthData.ToArray(_transport_security, auth_padding_length, 0, new byte[0]))); } byte[] signature; if (_transport_security.AuthenticationLevel == RpcAuthenticationLevel.PacketIntegrity) { signature = _auth_context.MakeSignature(buffers, _send_sequence_no); } else { signature = _auth_context.EncryptMessage(buffers, SecurityQualityOfProtectionFlags.None, _send_sequence_no); stub_data = stub_data_buffer.ToArray(); RpcUtils.DumpBuffer(true, "Send Encrypted Data", stub_data); } RpcUtils.DumpBuffer(true, "Send Signature Data", signature); return(AuthData.ToArray(_transport_security, auth_padding_length, 0, signature)); }
internal void ConsumeData(NetMessage msg) { if (Status != ConnectionStatus.Connected) { return; } if (!msg.ReadByte(out var header)) { return; } RpcUtils.ReadHeader(header, out var reliability, out var broadcast, out var msgType, out var sub); switch (msgType) { case MsgType.Internal: ProcessInternal(broadcast, reliability, msg); break; case MsgType.Static: var info = new PlayerMessageInfo(broadcast) { Reliability = reliability }; ProcessStatic(msg, info); break; default: Debug.LogWarning($"Unsupported {msg.LengthBytes - 1} byte message of type {msgType} from {this}"); break; } }
/// <summary> /// Initialises a new service endpoint for the given service type. /// </summary> protected ServiceBase(Type serviceType) { if (serviceType == null) { throw new ArgumentNullException("serviceType"); } if (!serviceType.IsInterface) { throw new ArgumentException(serviceType.FullName + " is not an interface", "serviceType"); } this.serviceType = serviceType; foreach (MethodInfo method in serviceType.GetMethods(BindingFlags.Instance | BindingFlags.Public)) { if (method.IsGenericMethod || method.IsGenericMethodDefinition || method.DeclaringType != serviceType) { continue; } string key = RpcUtils.GetActionName(method); if (actions.ContainsKey(key)) { throw new ArgumentException("Duplicate action \"" + key + "\" found on service-contract " + serviceType.FullName, "serviceContractType"); } actions.Add(key, method); } }
private IResolveAssemblyReferenceTaskHandler GetRpcClient() { ErrorUtilities.VerifyThrowInternalErrorUnreachable(_clientStream != null); IJsonRpcMessageHandler handler = RpcUtils.GetRarMessageHandler(_clientStream); return(JsonRpc.Attach <IResolveAssemblyReferenceTaskHandler>(handler)); }
NetMessage StartMessage(byte rpcId, ReliabilityMode mode, int size) { var msg = _server.GetMessage(size + 2); msg.Write(RpcUtils.GetHeader(mode, BroadcastMode.Server, MsgType.Static)); msg.Write(rpcId); return(msg); }
/// <summary> /// Create a stream to serialize into /// </summary> /// <param name="size"></param> /// <returns></returns> public NetMessage CreateStream(int size) { var msg = Room.RoomGetMessage(size + 3); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Unreliable, BroadcastMode.All, MsgType.Stream)); msg.Write(Id); return(msg); }
internal static NetMessage StartMessage(Room room, byte rpcId, ReliabilityMode mode, int size) { var msg = room.RoomGetMessage(size + 2); msg.Write(RpcUtils.GetHeader(mode, BroadcastMode.Owner, MsgType.Static)); msg.Write(rpcId); return(msg); }
private void EnsureConnected(ConnectionInfo connection) { var msg = GetMessage(2); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandPRpcs.Ping); SendTcpMessage(connection, msg); }
NetMessage StartMessage(byte rpcId, RpcMode mode, int size) { var msg = _room.RoomGetMessage(size + 5); msg.Write(RpcUtils.GetHeader(mode, MsgType.Internal)); msg.Write(RandPRpcs.SceneObjectRpc); msg.Write(NetworkID); msg.Write(rpcId); return(msg); }
NetMessage StartMessage(byte cid, byte rpcId, RpcMode mode, int size) { var msg = Room.RoomGetMessage(size + 5); msg.Write(RpcUtils.GetHeader(mode, MsgType.Netview)); Id.OnSerialize(msg); msg.Write(cid); msg.Write(rpcId); return(msg); }
/// <summary> /// change the player to the specified room /// </summary> /// <param name="roomName"></param> public void ChangeRoom(string roomName) { var msg = Room.ServerGetMessage(roomName.Length * 2 + 2); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.RoomSwitch); msg.Write(Id); msg.Write(roomName); Room.Server.SendMessage(msg, ReliabilityMode.Ordered); }
/// <summary> /// start a message for one specific player /// </summary> /// <param name="cid"></param> /// <param name="rpcId"></param> /// <param name="mode"></param> /// <param name="size"></param> /// <returns></returns> NetMessage StartMessage(byte cid, byte rpcId, ReliabilityMode mode, int size) { var msg = Room.RoomGetMessage(size + 5); //just using "server" because its going to one target that isn't the owner msg.Write(RpcUtils.GetHeader(mode, BroadcastMode.Server, MsgType.Netview)); Id.OnSerialize(msg); msg.Write(cid); msg.Write(rpcId); return(msg); }
private void EnsureConnected() { while (!_shutdownQueued) { Thread.Sleep(5000); var msg = GetMessage(2); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.Ping); SendMessage(msg, ReliabilityMode.Ordered); } }
private void ReturnFuncRpc(byte componentId, byte rpc, Player sender, object ret) { var msg = Room.RoomGetMessage(5 + Room.Serializer.SizeOf(ret)); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Netview, ret is Exception ? SubMsgType.Error : SubMsgType.Reply)); msg.Write(Id); msg.Write(componentId); msg.Write(rpc); Room.Serializer.Serialize(ret is Exception ? (ret as Exception).Message : ret, msg); SendMessage(msg, sender, ReliabilityMode.Ordered); }
public async Task Start() { Util.SavePidToFile(_rpcConfig.PidFile); // Create Logger RpcUtils.CreateLogger(_rpcConfig.LogDirectory, _rpcConfig.LogName, _rpcConfig.LogTarget); // Create Rpc server var server = new RpcServer().Create(_rpcConfig.HostName, _rpcConfig.RpcPort); // Start Rpc server await server.Start(); }
internal NetMessage GetDestroyMessage(NetworkView view, byte destType, byte reasonCode = 0) { var msg = RoomGetMessage(6); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.All, MsgType.Internal)); msg.Write(destType); msg.Write(view.Id.Id); if (reasonCode != 0) { msg.Write(reasonCode); } return(msg); }
partial void ImplDispatchDisconnect(string reason) { var server = Server; if (server != null) { var msg = ServerGetMessage(reason.Length * 2 + 5); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.DisconnectMessage); msg.Write(reason); server.SendMessage(msg, ReliabilityMode.Ordered); } _serverClient.Close(); }
protected internal override void Disconnect(string reason) { var server = Room.Server; if (server != null) { var msg = GetMessage(reason.Length * 2 + 5); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.DisconnectMessage); msg.Write(reason); SendMessage(msg, ReliabilityMode.Ordered); } _serverClient.Close(); }
/// <summary> /// /// </summary> public void SynchNetData() { if (NetUserData == null) { return; } var msg = Room.ServerGetMessage(NetUserData.AllocSize + 4); msg.Write(RpcUtils.GetHeader(ReliabilityMode.Ordered, BroadcastMode.Server, MsgType.Internal)); msg.Write(DandRRpcs.SyncNetUser); msg.Write(Id); NetUserData.OnSerialize(msg); Room.Server.SendMessage(msg, ReliabilityMode.Ordered); }
private Tuple <PDUHeader, byte[]> ReadPDU(int frag_count) { byte[] buffer = _pipe.Read(_max_recv_fragment); RpcUtils.DumpBuffer(true, $"RPC Named Pipe Receive Buffer - Fragment {frag_count}", buffer); MemoryStream stm = new MemoryStream(buffer); BinaryReader reader = new BinaryReader(stm); PDUHeader header = PDUHeader.Read(reader); NdrUnmarshalBuffer.CheckDataRepresentation(header.DataRep); if (header.AuthLength != 0) { throw new NotSupportedException("Named pipe transport doesn't support authentication data."); } return(Tuple.Create(header, reader.ReadAllBytes(header.FragmentLength - PDUHeader.PDU_HEADER_SIZE))); }