private static void SendHandshakeReply(ClientObject client, HandshakeReply enumResponse, string reason)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.HANDSHAKE_REPLY;
int response = (int)enumResponse;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>(response);
mw.Write <string>(reason);
mw.Write <int>(Common.PROTOCOL_VERSION);
mw.Write <string>(Common.PROGRAM_VERSION);
if (response == 0)
{
mw.Write <bool>(Settings.settingsStore.compressionEnabled);
mw.Write <int>((int)Settings.settingsStore.modControl);
if (Settings.settingsStore.modControl != ModControlMode.DISABLED)
{
if (!File.Exists(Server.modFile))
{
Server.GenerateNewModFile();
}
string modFileData = File.ReadAllText(Server.modFile);
mw.Write <string>(modFileData);
}
}
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason)
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <HandshakeReplyMsgData>();
msgData.Response = enumResponse;
msgData.Reason = reason;
if (enumResponse == HandshakeReply.HandshookSuccessfully)
{
msgData.ModControlMode = GeneralSettings.SettingsStore.ModControl;
msgData.ServerStartTime = ServerContext.StartTime;
msgData.PlayerId = client.Id;
if (GeneralSettings.SettingsStore.ModControl != ModControlMode.Disabled)
{
if (!FileHandler.FileExists(ServerContext.ModFilePath))
{
ModFileSystem.GenerateNewModFile();
}
msgData.ModFileData = FileHandler.ReadFile(ServerContext.ModFilePath);
msgData.NumBytes = msgData.ModFileData.Length;
}
}
MessageQueuer.SendToClient <HandshakeSrvMsg>(client, msgData);
}
internal override void InternalDeserialize(NetIncomingMessage lidgrenMsg)
{
base.InternalDeserialize(lidgrenMsg);
Response = (HandshakeReply)lidgrenMsg.ReadInt32();
Reason = lidgrenMsg.ReadString();
ModControl = lidgrenMsg.ReadBoolean();
lidgrenMsg.SkipPadBits();
ServerStartTime = lidgrenMsg.ReadInt64();
ModFileData = lidgrenMsg.ReadString();
}
internal override void InternalDeserialize(NetIncomingMessage lidgrenMsg)
{
base.InternalDeserialize(lidgrenMsg);
Response = (HandshakeReply)lidgrenMsg.ReadInt32();
Reason = lidgrenMsg.ReadString();
ModControlMode = (ModControlMode)lidgrenMsg.ReadInt32();
ServerStartTime = lidgrenMsg.ReadInt64();
PlayerId = GuidUtil.Deserialize(lidgrenMsg);
NumBytes = lidgrenMsg.ReadInt32();
if (ModFileData.Length < NumBytes)
{
ModFileData = new byte[NumBytes];
}
lidgrenMsg.ReadBytes(ModFileData, 0, NumBytes);
}
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason)
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <HandshakeReplyMsgData>();
msgData.Response = enumResponse;
msgData.Reason = reason;
if (enumResponse == HandshakeReply.HandshookSuccessfully)
{
msgData.ModControl = GeneralSettings.SettingsStore.ModControl;
msgData.ServerStartTime = TimeContext.StartTime.Ticks;
if (GeneralSettings.SettingsStore.ModControl)
{
msgData.ModFileData = LunaXmlSerializer.SerializeToXml(ModFileSystem.ModControl);
}
}
MessageQueuer.SendToClient <HandshakeSrvMsg>(client, msgData);
}
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason)
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <HandshakeReplyMsgData>();
msgData.Response = enumResponse;
msgData.Reason = reason;
if (enumResponse == HandshakeReply.HandshookSuccessfully)
{
msgData.ModControl = GeneralSettings.SettingsStore.ModControl;
msgData.ServerStartTime = ServerContext.StartTime;
if (GeneralSettings.SettingsStore.ModControl)
{
msgData.ModFileData = FileHandler.ReadFileText(ServerContext.ModFilePath);
}
}
MessageQueuer.SendToClient <HandshakeSrvMsg>(client, msgData);
}
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason)
{
var messageData = new HandshakeReplyMsgData
{
Response = enumResponse,
Reason = reason
};
if (enumResponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
messageData.ModControlMode = GeneralSettings.SettingsStore.ModControl;
if (GeneralSettings.SettingsStore.ModControl != ModControlMode.DISABLED)
{
if (!FileHandler.FileExists(ServerContext.ModFilePath))
{
ModFileSystem.GenerateNewModFile();
}
messageData.ModFileData = FileHandler.ReadFile(ServerContext.ModFilePath);
}
}
MessageQueuer.SendToClient <HandshakeSrvMsg>(client, messageData);
}
private static void SendHandshakeReply(ClientObject client, HandshakeReply enumResponse, string reason)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.HANDSHAKE_REPLY;
int response = (int)enumResponse;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>(response);
mw.Write<string>(reason);
mw.Write<int>(Common.PROTOCOL_VERSION);
mw.Write<string>(Common.PROGRAM_VERSION);
if (response == 0)
{
mw.Write<int>((int)Settings.settingsStore.modControl);
if (Settings.settingsStore.modControl != ModControlMode.DISABLED)
{
if (!File.Exists(Server.modFile))
{
Server.GenerateNewModFile();
}
string modFileData = File.ReadAllText(Server.modFile);
mw.Write<string>(modFileData);
}
}
newMessage.data = mw.GetMessageBytes();
}
SendToClient(client, newMessage, true);
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
var netTestHelper = new NetworkTestContextHelpers();
context.Services.AddSingleton(netTestHelper);
Configure <NetworkOptions>(o => {
o.ListeningPort = 2001;
o.MaxPeers = 2;
});
context.Services.AddTransient(o =>
{
var mockHandshakeProvider = new Mock <IHandshakeProvider>();
mockHandshakeProvider.Setup(h => h.GetHandshakeAsync()).ReturnsAsync(new Handshake());
return(mockHandshakeProvider.Object);
});
context.Services.AddTransient(sp =>
{
var mockDialer = new Mock <IPeerDialer>();
mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.FakeIpEndpoint)))
.Returns <IPEndPoint>(s =>
{
var peer = GrpcTestPeerHelpers.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint, NetworkTestConstants.FakePubkey);
netTestHelper.AddDialedPeer(peer);
return(Task.FromResult(peer));
});
mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.FakeIpEndpoint2)))
.Returns <IPEndPoint>(s =>
{
var peer = GrpcTestPeerHelpers.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey);
netTestHelper.AddDialedPeer(peer);
return(Task.FromResult(peer));
});
mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.DialExceptionIpEndpoint)))
.Throws <PeerDialException>();
mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.HandshakeWithNetExceptionIp)))
.Returns <IPEndPoint>(s =>
{
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None))
.Throws(new AggregateException());
var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey,
mockClient.Object);
netTestHelper.AddDialedPeer(peer);
return(Task.FromResult(peer));
});
// Incorrect handshake
mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.BadHandshakeIp)))
.Returns <IPEndPoint>((s) =>
{
var handshakeReply = new HandshakeReply {
Error = HandshakeError.InvalidHandshake,
};
var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply),
Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(),
CancellationToken.None)).Returns(handshakeCall);
var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint,
NetworkTestConstants.FakePubkey, mockClient.Object);
netTestHelper.AddDialedPeer(peer);
return(Task.FromResult(peer));
});
// This peer will pass all checks with success.
mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.GoodPeerEndpoint)))
.Returns <IPEndPoint>(s =>
{
var keypair = CryptoHelper.GenerateKeyPair();
var handshakeReply = new HandshakeReply {
Error = HandshakeError.HandshakeOk,
Handshake = netTestHelper.CreateValidHandshake(keypair, 10)
};
var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply),
Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(),
CancellationToken.None)).Returns(handshakeCall);
var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint,
keypair.PublicKey.ToHex(), mockClient.Object);
netTestHelper.AddDialedPeer(peer);
return(Task.FromResult(peer));
});
return(mockDialer.Object);
});
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
Configure <NetworkOptions>(o =>
{
o.ListeningPort = 2001;
o.MaxPeers = 2;
});
context.Services.AddTransient(o =>
{
var mockBlockchainService = new Mock <IBlockchainService>();
var keyPair = CryptoHelper.GenerateKeyPair();
mockBlockchainService.Setup(b => b.GetChainAsync()).ReturnsAsync(new Chain
{
Id = NetworkTestConstants.DefaultChainId
});
mockBlockchainService.Setup(b => b.GetChainId()).Returns(NetworkTestConstants.DefaultChainId);
mockBlockchainService.Setup(b => b.GetBlockHeaderByHashAsync(It.IsAny <Hash>())).ReturnsAsync(
NetworkTestHelper.CreateFakeBlockHeader(NetworkTestConstants.DefaultChainId, 1, keyPair));
return(mockBlockchainService.Object);
});
context.Services.AddTransient(sp =>
{
var mockDialer = new Mock <IPeerDialer>();
mockDialer.Setup(d =>
d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint =>
endPoint.ToString() == NetworkTestConstants.FakeIpEndpoint)))
.Returns <DnsEndPoint>(s =>
{
var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint,
NetworkTestConstants.FakePubkey);
return(Task.FromResult(peer));
});
mockDialer.Setup(d =>
d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint =>
endPoint.ToString() == NetworkTestConstants.FakeIpEndpoint2)))
.Returns <DnsEndPoint>(s =>
{
var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint2,
NetworkTestConstants.FakePubkey);
return(Task.FromResult(peer));
});
mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint =>
endPoint.ToString() == NetworkTestConstants
.DialExceptionIpEndpoint)))
.Returns(Task.FromResult <GrpcPeer>(null));
mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint =>
endPoint.ToString() == NetworkTestConstants.HandshakeWithNetExceptionIp)))
.Returns <DnsEndPoint>(s =>
{
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(),
It.IsAny <DateTime?>(), CancellationToken.None))
.Throws(new AggregateException());
var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint2,
NetworkTestConstants.FakePubkey,
mockClient.Object);
return(Task.FromResult(peer));
});
// Incorrect handshake
mockDialer.Setup(d =>
d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint =>
endPoint.ToString() == NetworkTestConstants.BadHandshakeIp)))
.Returns <DnsEndPoint>((s) =>
{
var handshakeReply = new HandshakeReply();
var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply),
Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(),
() => { });
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(),
It.IsAny <DateTime?>(),
CancellationToken.None)).Returns(handshakeCall);
mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(),
It.IsAny <Metadata>(), It.IsAny <DateTime?>(),
CancellationToken.None)).Throws(new AggregateException());
var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint,
NetworkTestConstants.FakePubkey, mockClient.Object);
return(Task.FromResult(peer));
});
// Incorrect handshake signature
mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint =>
endPoint.ToString() == NetworkTestConstants
.HandshakeWithDataExceptionIp)))
.Returns <string>(async(s) =>
{
var handshakeProvider = context.Services.GetServiceLazy <IHandshakeProvider>().Value;
var handshake = await handshakeProvider.GetHandshakeAsync();
handshake.HandshakeData.Time = null;
var handshakeReply = new HandshakeReply {
Handshake = handshake
};
var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply),
Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(),
() => { });
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(),
It.IsAny <DateTime?>(),
CancellationToken.None)).Returns(handshakeCall);
var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint,
NetworkTestConstants.FakePubkey, mockClient.Object);
return(peer);
});
// This peer will pass all checks with success.
mockDialer.Setup(d =>
d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint =>
endPoint.ToString() == NetworkTestConstants.GoodPeerEndpoint)))
.Returns <DnsEndPoint>(s =>
{
var keyPair = CryptoHelper.GenerateKeyPair();
var handshakeReply = new HandshakeReply
{
Handshake = NetworkTestHelper.CreateValidHandshake(keyPair, 10)
};
var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply),
Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(),
() => { });
var confirmHandshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(new VoidReply()),
Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(),
() => { });
var mockClient = new Mock <PeerService.PeerServiceClient>();
mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(),
It.IsAny <DateTime?>(),
CancellationToken.None)).Returns(handshakeCall);
mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(),
It.IsAny <Metadata>(), It.IsAny <DateTime?>(),
CancellationToken.None)).Returns(confirmHandshakeCall);
var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint,
NetworkTestConstants.FakePubkey, mockClient.Object);
peer.UpdateLastSentHandshake(handshakeReply.Handshake);
return(Task.FromResult(peer));
});
mockDialer.Setup(d => d.DialBackPeerAsync(It.IsAny <DnsEndPoint>(), It.IsAny <Handshake>()))
.Returns <DnsEndPoint, Handshake>((endPoint, handshake) =>
{
if (endPoint.ToString() == NetworkTestConstants.GoodPeerEndpoint)
{
var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.GoodPeerEndpoint,
NetworkTestConstants.FakePubkey);
return(Task.FromResult(peer));
}
return(Task.FromResult <GrpcPeer>(null));
});
return(mockDialer.Object);
});
}
public static void HandleHandshakeResponse(ClientObject client, byte[] messageData)
{
int protocolVersion;
string playerName = "";
string playerPublicKey;
byte[] playerChallangeSignature;
string clientVersion = "";
string reason = "";
Regex regex = new Regex(@"[\""<>|$]"); // Regex to detect quotation marks, and other illegal characters
//0 - Success
HandshakeReply handshakeReponse = HandshakeReply.HANDSHOOK_SUCCESSFULLY;
try
{
using (MessageReader mr = new MessageReader(messageData))
{
protocolVersion = mr.Read <int>();
playerName = mr.Read <string>();
playerPublicKey = mr.Read <string>();
playerChallangeSignature = mr.Read <byte[]>();
clientVersion = mr.Read <string>();
try
{
client.compressionEnabled = mr.Read <bool>();
}
catch
{
//This is safe to ignore. We want to tell people about version mismatches still.
client.compressionEnabled = false;
}
}
}
catch (Exception e)
{
DarkLog.Debug("Error in HANDSHAKE_REQUEST from " + client.playerName + ": " + e);
SendHandshakeReply(client, HandshakeReply.MALFORMED_HANDSHAKE, "Malformed handshake");
return;
}
if (regex.IsMatch(playerName))
{
// Invalid username
handshakeReponse = HandshakeReply.INVALID_PLAYERNAME;
reason = "Invalid username";
}
if (playerName.Contains("/") || playerName.Contains(@"\") || playerName.Contains("\n") || playerName.Contains("\r"))
{
handshakeReponse = HandshakeReply.INVALID_PLAYERNAME;
reason = "Invalid username";
}
if (protocolVersion != Common.PROTOCOL_VERSION)
{
//Protocol mismatch
handshakeReponse = HandshakeReply.PROTOCOL_MISMATCH;
reason = "Protocol mismatch";
}
if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
//Check client isn't already connected
ClientObject testClient = ClientHandler.GetClientByName(playerName);
if (testClient != null)
{
Messages.Heartbeat.Send(testClient);
Thread.Sleep(1000);
}
if (ClientHandler.ClientConnected(testClient))
{
handshakeReponse = HandshakeReply.ALREADY_CONNECTED;
reason = "Client already connected";
}
}
if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
bool reserveKick = false;
//Check the client isn't using a reserved name
if (playerName == "Initial")
{
reserveKick = true;
}
if (playerName == Settings.settingsStore.consoleIdentifier)
{
reserveKick = true;
}
if (reserveKick)
{
handshakeReponse = HandshakeReply.RESERVED_NAME;
reason = "Kicked for using a reserved name";
}
}
if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
//Check the client matches any database entry
string storedPlayerFile = Path.Combine(Server.universeDirectory, "Players", playerName + ".txt");
string storedPlayerPublicKey = "";
if (File.Exists(storedPlayerFile))
{
storedPlayerPublicKey = File.ReadAllText(storedPlayerFile);
if (playerPublicKey != storedPlayerPublicKey)
{
handshakeReponse = HandshakeReply.INVALID_KEY;
reason = "Invalid key for user";
}
else
{
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(1024))
{
rsa.PersistKeyInCsp = false;
rsa.FromXmlString(playerPublicKey);
bool result = rsa.VerifyData(client.challange, CryptoConfig.CreateFromName("SHA256"), playerChallangeSignature);
if (!result)
{
handshakeReponse = HandshakeReply.INVALID_KEY;
reason = "Public/private key mismatch";
}
}
}
}
else
{
try
{
File.WriteAllText(storedPlayerFile, playerPublicKey);
DarkLog.Debug("Client " + playerName + " registered!");
}
catch
{
handshakeReponse = HandshakeReply.INVALID_PLAYERNAME;
reason = "Invalid username";
}
}
}
client.playerName = playerName;
client.publicKey = playerPublicKey;
client.clientVersion = clientVersion;
if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
if (BanSystem.fetch.IsPlayerNameBanned(client.playerName) || BanSystem.fetch.IsIPBanned(client.ipAddress) || BanSystem.fetch.IsPublicKeyBanned(client.publicKey))
{
handshakeReponse = HandshakeReply.PLAYER_BANNED;
reason = "You were banned from the server!";
}
}
if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
if (ClientHandler.GetActiveClientCount() >= Settings.settingsStore.maxPlayers)
{
handshakeReponse = HandshakeReply.SERVER_FULL;
reason = "Server is full";
}
}
if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
if (Settings.settingsStore.whitelisted && !WhitelistSystem.fetch.IsWhitelisted(client.playerName))
{
handshakeReponse = HandshakeReply.NOT_WHITELISTED;
reason = "You are not on the whitelist";
}
}
if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
{
client.authenticated = true;
string devClientVersion = "";
DMPPluginHandler.FireOnClientAuthenticated(client);
if (client.clientVersion.Length == 40)
{
devClientVersion = client.clientVersion.Substring(0, 7);
}
else
{
devClientVersion = client.clientVersion;
}
DarkLog.Normal("Client " + playerName + " handshook successfully, version: " + devClientVersion);
if (!Directory.Exists(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)))
{
Directory.CreateDirectory(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName));
foreach (string file in Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", "Initial")))
{
File.Copy(file, Path.Combine(Server.universeDirectory, "Scenarios", playerName, Path.GetFileName(file)));
}
}
SendHandshakeReply(client, handshakeReponse, "success");
Server.playerCount = ClientHandler.GetActiveClientCount();
Server.players = ClientHandler.GetActivePlayerNames();
DarkLog.Debug("Online players is now: " + Server.playerCount + ", connected: " + ClientHandler.GetClients().Length);
}
else
{
DarkLog.Normal("Client " + playerName + " failed to handshake: " + reason);
SendHandshakeReply(client, handshakeReponse, reason);
}
}
