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