public async Task <bool> Authenticate(DarkRiftClient client)
{
authSuccessToken = new TaskCompletionSource <ushort>();
using (var writer = DarkRiftWriter.Create())
{
using (var message = Message.Create((ushort)MasterServerNoReplyTags.AuthRequest, writer))
{
client.SendMessage(message, SendMode.Reliable);
client.MessageReceived += SendPassword;
await Task.Yield();
Task.WaitAny(Task.Delay(config.AuthRequestDelay), authSuccessToken.Task);
if (authSuccessToken.Task.IsCompletedSuccessfully)
{
if (authSuccessToken.Task.Result != (ushort)MasterServerAuthReplies.Success)
{
throw new DRAuthException("Authentication failed");
}
return(authSuccessToken.Task.Result == (ushort)MasterServerAuthReplies.Success);
}
else
{
authSuccessToken = null;
throw new DRAuthException("Authentication Timed Out..");
}
}
}
}
private async Task StartAuth(DarkRiftClient client)
{
for (int i = 0; i < config.AuthRequestTries; i++)
{
authenticated = false;
try
{
var res = await Authenticate(client);
if (res)
{
authenticated = true;
break;
}
if (i == config.AuthRequestTries - 1)
{
throw new Exception("Authentication failed multiple times");
}
}
catch (DRAuthException e)
{
Console.WriteLine(e.ToString());
break;
}
}
}
public void GivenClientsThatFailToConnect(int numberOfClients)
{
for (int i = 0; i < numberOfClients; i++)
{
DarkRiftClient client = new DarkRiftClient();
try
{
client.Connect(
new BichannelClientConnection(
IPAddress.Loopback,
4296, // Don't want to be able to connect so any port is fine
true
)
);
Assert.Fail("Did not expect client to connect successfully.");
}
catch (SocketException)
{
// Expected
}
world.AddClient(client);
}
}
public bool StartClient(string address, int port)
{
if (IsClientStarted)
{
return(false);
}
clientEventQueue.Clear();
Client = new DarkRiftClient();
Client.Disconnected += Client_Disconnected;
Client.MessageReceived += Client_MessageReceived;
if (address.Equals("localhost"))
{
address = "127.0.0.1";
}
Client.ConnectInBackground(IPAddress.Parse(address), port, IPVersion.IPv4, (exception) =>
{
if (exception != null)
{
UnityEngine.Debug.LogException(exception);
clientEventQueue.Enqueue(new TransportEventData()
{
type = ENetworkEvent.ErrorEvent,
socketError = SocketError.ConnectionRefused,
});
}
else
{
clientEventQueue.Enqueue(new TransportEventData()
{
type = ENetworkEvent.ConnectEvent,
});
}
});
return(true);
}
public void WhenAClientConnectsAndImmedtiatelySendsAMessages()
{
DarkRiftClient client = new DarkRiftClient();
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write("Hello");
using Message message = Message.Create(0, writer);
client.Connect(
new BichannelClientConnection(
IPAddress.Loopback,
world.GetServer(0).ClientManager.Port,
world.GetServer(0).NetworkListenerManager.GetNetworkListenersByType <AbstractBichannelListener>()[0].UdpPort,
true
)
);
bool success = client.SendMessage(message, SendMode.Reliable);
Assert.IsTrue(success);
}
world.AddClient(client);
#if DEBUG
// We've just requested a load of objects that wont be returned until we close
// UDP receive TCP receive in client; TCP receive in server
performanceSteps.ExpectedUnaccountedForSocketAsyncEventArgs += 3;
#endif
messageAssertions.ExpectMessageOnServer(new ReceivedMessage("Hello", client.ID, 0, 0, SendMode.Reliable));
}
private void Awake()
{
_dispatcher = new Dispatcher(true);
_darkRiftClient = new DarkRiftClient();
_darkRiftClient.MessageReceived += Client_MessageReceived;
_darkRiftClient.Disconnected += Client_Disconnected;
}
/// <summary>
/// Extension shorthand for sending empty unreliable messages.
/// </summary>
/// <param name="client">Client to which this should be sent.</param>
/// <param name="tag"></param>
public static void SendEmptyMessageUnreliable(this DarkRiftClient client, ushort tag)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
using (DarkRift.Message msg = DarkRift.Message.Create(tag, writer))
client.SendMessage(msg, SendMode.Unreliable);
}
}
/// <summary>
/// Extension shorthand for sending empty unreliable messages.
/// </summary>
/// <param name="client">Client to which this should be sent.</param>
/// <param name="tag"></param>
public static void SendEmptyMessageUnreliable <TTag>(this DarkRiftClient client, TTag tag)
where TTag : struct, Enum, IConvertible
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
using (DarkRift.Message msg = DarkRift.Message.Create(Convert.ToUInt16(tag), writer))
client.SendMessage(msg, SendMode.Unreliable);
}
}
void Awake()
{
client = new DarkRiftClient(maxCachedWriters, maxCachedReaders, maxCachedMessages, maxCachedSocketAsyncEventArgs, maxCachedActionDispatcherTasks);
//Setup dispatcher
Dispatcher = new Dispatcher(true);
//Setup routing for events
Client.MessageReceived += Client_MessageReceived;
Client.Disconnected += Client_Disconnected;
}
/// <summary>
/// Connect a client with our client connection to the given server.
/// </summary>
/// <returns>The created client.</returns>
private DarkRiftClient ConnectClient(DarkRiftServer server)
{
NetworkClientConnection1 connection = new NetworkClientConnection1(IPAddress.Loopback, server.NetworkListenerManager.GetNetworkListenerByName("ListenerUnderTest").Port);
DarkRiftClient client = new DarkRiftClient();
client.Connect(connection);
return(client);
}
private void Shutdown()
{
if (this.client != null)
{
this.client.MessageReceived -= Client_MessageReceived;
this.client.Disconnected -= Client_Disconnected;
this.client.Disconnect();
this.client.Dispose();
this.client = null;
}
}
/// <summary>
/// Extension shorthand for sending reliable messages.
/// </summary>
/// <typeparam name="TTag">Type of the message that inherits from IMessage & IDarkRiftSerializable</typeparam>
/// <param name="client">Client to which this should be sent.</param>
/// <param name="message">Message object</param>
public static void SendMessageReliable <TTag>(this DarkRiftClient client, IDarkRiftMessage <TTag> message)
where TTag : struct, Enum, IConvertible
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(message);
using (DarkRift.Message msg = DarkRift.Message.Create(Convert.ToUInt16(message.Tag), writer))
client.SendMessage(msg, SendMode.Reliable);
}
}
void Awake()
{
ObjectCacheSettings = objectCacheSettings.ToObjectCacheSettings();
client = new DarkRiftClient(ObjectCacheSettings);
//Setup dispatcher
Dispatcher = new Dispatcher(true);
//Setup routing for events
Client.MessageReceived += Client_MessageReceived;
Client.Disconnected += Client_Disconnected;
}
public void TestClientCanConnectToServer()
{
// GIVEN a running server
DarkRiftServer server = StartServer();
// WHEN I connect a client
DarkRiftClient client = ConnectClient(server);
// THEN the client is connected
Assert.AreEqual(ConnectionState.Connected, client.ConnectionState);
// AND the server contains one client
Assert.AreEqual(1, server.ClientManager.Count);
}
public void Initialize()
{
#pragma warning disable CS0618 // Type or member is obsolete
ObjectCacheSettings = objectCacheSettings.ToClientObjectCacheSettings();
Client = new DarkRiftClient(ObjectCacheSettings);
#pragma warning restore CS0618 // Type or member is obsolete
//Setup dispatcher
Dispatcher = new Dispatcher(true);
//Setup routing for events
Client.MessageReceived += Client_MessageReceived;
Client.Disconnected += Client_Disconnected;
}
public RoomPlugin(PluginLoadData pluginLoadData) : base(pluginLoadData)
{
MasterIpAddress = IPAddress.Parse(pluginLoadData.Settings.Get(nameof(MasterIpAddress)));
MasterPort = Convert.ToInt32(pluginLoadData.Settings.Get(nameof(MasterPort)));
IsPublic = Convert.ToBoolean(pluginLoadData.Settings.Get(nameof(IsPublic)));
SpawnCode = pluginLoadData.Settings.Get(nameof(SpawnCode));
SpawnTaskID = Convert.ToInt32(pluginLoadData.Settings.Get(nameof(SpawnTaskID)));
MaxPlayers = Convert.ToInt32(pluginLoadData.Settings.Get(nameof(MaxPlayers)));
WorldName = pluginLoadData.Settings.Get(nameof(WorldName));
RoomName = pluginLoadData.Settings.Get(nameof(RoomName));
Region = pluginLoadData.Settings.Get(nameof(Region));
AssignedPort = Convert.ToInt32(pluginLoadData.Settings.Get(nameof(AssignedPort)));
MachineIp = pluginLoadData.Settings.Get(nameof(MachineIp));
_client = new DarkRiftClient();
_pendingAccessValidations = new Dictionary <int, IClient>();
}
void IClientTransportLayer.Connect(string connectionString)
{
if (this.client != null)
{
this.Shutdown();
}
this.client = new DarkRiftClient(this.objectCacheSettings);
this.client.MessageReceived += Client_MessageReceived;
this.client.Disconnected += Client_Disconnected;
this.client.Connect(IPAddress.Parse("127.0.0.1"), 9999, IPVersion.IPv4);
if (this.client.ConnectionState == ConnectionState.Connected)
{
this.events.Enqueue(new ClientEvent {
EventType = ClientEventType.ConnectionOpened
});
}
}
private DarkRiftClient GetNewClient()
{
if (this.client == null)
{
var client = new DarkRiftClient();
var ep = IPEndPoint.Parse(connectionAddress);
try
{
client.Connect(ep.Address, ep.Port, IPVersion.IPv4);
if (client.ConnectionState == ConnectionState.Connected)
{
this.client = client;
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
return(this.client);
}
public void GivenConnectedClientsOverIPv6(int numberOfClients)
{
for (int i = 0; i < numberOfClients; i++)
{
DarkRiftClient client = new DarkRiftClient();
client.Connect(
new BichannelClientConnection(
IPAddress.IPv6Loopback,
world.GetServer(0).ClientManager.Port,
world.GetServer(0).NetworkListenerManager.GetNetworkListenersByType <AbstractBichannelListener>()[0].UdpPort,
true
)
);
world.AddClient(client);
#if DEBUG
// We've just requested a load of objects that wont be returned until we close
// UDP receive TCP receive in client; TCP receive in server
performanceSteps.ExpectedUnaccountedForSocketAsyncEventArgs += 3;
#endif
}
}
public SpawnerClient()
{
_freePorts = new Queue <int>();
MasterIpAddress = IPAddress.Parse(Settings.Default.MasterIpAddress);
MasterPort = Convert.ToInt32(Settings.Default.MasterPort);
SpawnerIpAddress = Settings.Default.SpawnerIpAddress;
SpawnerStartPort = Settings.Default.SpawnerStartPort;
MaxProcesses = Settings.Default.MaxProcesses;
ExecutablePath = Settings.Default.ExecutablePath;
Region = Settings.Default.Region;
AutoStartSpawner = Settings.Default.AutoStartSpawner;
CreateRoomWindow = Settings.Default.CreateRoomWindow;
ConfigPath = Settings.Default.ConfigPath;
UseShellExecute = Settings.Default.UseShellExecute;
UseMono = Settings.Default.UseMono;
_client = new DarkRiftClient();
_client.ConnectInBackground(MasterIpAddress, MasterPort, IPVersion.IPv4, OnConnectedToMaster);
}
public async Task <DarkRiftClient> GetDarkriftClient()
{
if (this.client != null)
{
return(this.client);
}
var client = GetNewClient();
if (client != null)
{
await StartAuth(client);
if (authenticated)
{
this.client = client;
OnClientConnected?.Invoke(client);
client.MessageReceived += OnClientMessageReceived;
client.Disconnected += OnClientDisconnected;
return(client);
}
}
return(null);
}
/// <summary>
/// Adds a new client to the world.
/// </summary>
/// <param name="client">The client to add.</param>
public void AddClient(DarkRiftClient client)
{
clients.Add(client.ID, client);
client.MessageReceived += ClientMessageReceived;
}
private NetworkingManager()
{
client = new DarkRiftClient();
}
private void ClientDisconnected(object sender, DisconnectedEventArgs e)
{
client = null;
authenticated = false;
}
