/// <summary>
/// Analyzes the login package to see if it is a valid login. If it is, then login the client.
/// </summary>
private void ProcessLoginPackage(ServerSideClient client, Package package)
{
// The client does not have its name yet. Use the name provided by its login attempt.
LoginContent loginContent = LoginContent.Deserialize(package.Content);
var reason = GetRefuseReason(loginContent.ClientName);
// Here I am not rejecting the user and we will send the package out for
// further processing.
if (reason == ConnectionRefusedReason.None)
{
client.Name = loginContent.ClientName;
client.Status = ClientStatus.LoggedIn;
BroadcastPackageAsync(package);
client.TimeStampLogin();
clientNames.Add(client.Name);
OnClientLoggedIn(client.Name);
}
else
{
var args = new ConnectionRefusedContent(reason, loginContent.ClientName);
// Here I am rejecting the user, we will send the reject message to the appropriate client
var pkgResp = new Package(BaseCommand.ConnectionRefused, args.Serialize());
client.SendPackageAsync(pkgResp);
clientNames.Remove(client.Name);
clients.Remove(client);
client.Socket.Shutdown(SocketShutdown.Both);
client.Dispose();
OnConnectionRefused(args);
}
}
/// <summary>
/// Sends the specified package asynchronously to all connected clients except the specified one.
/// </summary>
/// <param name="package">The <see cref="Package"/> to send to the clients.</param>
/// <param name="excludeClient">The client to exclude from the broadcast</param>
/// <param name="mustBeLoggedIn">Whether the package is sent to all connected clients or
/// just the ones that are logged in.</param>
protected void BroadcastPackageAsync(Package package, ServerSideClient excludeClient, bool mustBeLoggedIn = true)
{
foreach (ServerSideClient client in clients)
{
if (mustBeLoggedIn && client.Status != ClientStatus.LoggedIn)
{
continue;
}
if (client != excludeClient)
{
client.SendPackageAsync(package);
}
}
}
private void AcceptCallback(IAsyncResult AR)
{
if (enabled)
{
Socket socket = serverSocket.EndAccept(AR);
UiContext.Default.Invoke(() =>
{
ServerSideClient client = new ServerSideClient(socket);
clients.Add(client);
client.PackageReceived = OnPackageReceivedCore;
serverSocket.BeginAccept(AcceptCallback, null);
});
}
}
private void OnPackageReceivedCore(ServerSideClient client, Package e)
{
switch ((BaseCommand)e.Command)
{
case BaseCommand.ClientNames: SendClientNames(client); break;
case BaseCommand.Logout:
clients.Remove(client);
BroadcastPackageAsync(e, client);
clientNames.Remove(client.Name);
client.Dispose();
OnClientLoggedOut(LogoutContent.Deserialize(e.Content));
break;
case BaseCommand.Login: ProcessLoginPackage(client, e); break;
case BaseCommand.Sync:
Synchronize(client);
break;
}
OnPackageReceived(client, e);
}
/// <summary>
/// Sends synchronization data to the specified client.
/// </summary>
/// <param name="client">The client to send sync data to.</param>
protected virtual void Synchronize(ServerSideClient client)
{
SendClientNames(client);
}
/// <summary>
/// Sends the names of all of the clients which are logged in to a specified client.
/// </summary>
/// <param name="client">The client to send the names to.</param>
private void SendClientNames(ServerSideClient client)
{
var contents = new ClientNamesContent(clients.Select(c => c.Name).ToArray());
client.SendPackageAsync((int)BaseCommand.ClientNames, contents);
}
/// <summary> /// When a client receives an entire package, this method is to be used to process it. /// </summary> protected abstract void OnPackageReceived(ServerSideClient client, Package package);
