public winNetworkSettings(SyncIOServer _server)
{
InitializeComponent();
server = _server;
foreach (var port in server)
{
lbPortList.Items.Add(port);
}
}
public winMain()
{
InitializeComponent();
server = new SyncIOServer(SyncIO.Transport.TransportProtocal.IPv4, RemoteConfig.GetPackager());
server.SetHandler <HandshakePacket>((client, packet) => {
var nsClientInfo = new NSClient(packet.Username, packet.AppID);
client.Tag = nsClientInfo;
client.Send(new HandshakeResponsePacket(true));
});
server.SetDefaultRemoteFunctionAuthCallback((client, func) => {
var FuncInfo = func.Tag as FunctionInfo;
if (FuncInfo == null)
{
return(false);
}
var nsClientInfo = client.Tag as NSClient;
if (nsClientInfo == null)
{
return(false);
}
var succ = nsClientInfo.AppID.Equals(FuncInfo.ID) &&
NetSealAPI.IsValidConnection(FuncInfo.ApiCode, client, nsClientInfo.Username);
if (!succ)
{
client.Disconnect(new AccessViolationException());
}
return(succ);
});
LoadFunctions();
foreach (var port in ConfigLoader.GetPorts())
{
server.ListenTCP(port);
}
var listeningPorts = server.Count();
if (listeningPorts < 1)
{
lblStatus.Content = $"Idle. (listening on {listeningPorts} ports).";
}
else
{
lblStatus.Content = $"listening on {listeningPorts} ports.";
}
}
private void Server_OnClientConnect(SyncIOServer sender, SyncIOConnectedClient client)
{
WriteLog(LogType.Info, $"[{client.ID}] New connection.");
Console.WriteLine($"Enabling GZip compression...");
client.SetCompression(new SyncIOCompressionGZip());
Console.WriteLine($"Enabling rijndael encryption using key {string.Join("", Key.Select(x => x.ToString("X2")))}");
client.SetEncryption(new SyncIOEncryptionAes(Key, IV));
AddClient(client);
UpdateConnectionStatus();
}
private void Setup()
{
lvClients.Columns.AddRange(new List <ColumnHeader>
{
new ColumnHeader {
Name = "colId", Text = "ID", DisplayIndex = 0
},
new ColumnHeader {
Name = "colEndPoint", Text = "EndPoint", DisplayIndex = 1
},
new ColumnHeader {
Name = "colUserPC", Text = "User / Computer", DisplayIndex = 2
},
new ColumnHeader {
Name = "colOS", Text = "OS", DisplayIndex = 3
},
new ColumnHeader {
Name = "colVersion", Text = "Version", DisplayIndex = 4
},
}.ToArray());
_clients = new Dictionary <Guid, ConnectedChatClient>();
_server = new SyncIOServer(TransportProtocol.IPv4, _packer);
_server.OnClientConnect += Server_OnClientConnect;
SetupRpcs();
SetupPacketHandlers();
_server.ListenTCP(Port);
if (!_server.Any())
{
Console.WriteLine("Failed to listen on any ports.");
Application.Exit();
}
Text = "Listening on ";
foreach (var sock in _server)
{
Text += sock.EndPoint.Port.ToString();
sock.OnClose += (sender, err) => WriteLog(LogType.Info, $"[{sender.EndPoint.Port}] Listening socket closed. {err}");
}
UpdateConnectionStatus();
}
public void TestRemoteCalls()
{
var client = new SyncIOClient();
var server = new SyncIOServer();
var Test1 = server.RegisterRemoteFunction("Test1", new Func <string, int>((string string1) => string1.Length));
server.RegisterRemoteFunction("Test2", new Func <string, string>((string string1) => string.Concat(string1.Reverse())));
server.RegisterRemoteFunction("Test3", new Func <string, char>((string string1) => string1.FirstOrDefault()));
Test1.SetAuthFunc((SyncIOConnectedClient requester, RemoteFunctionBind callingFunc) =>
{ //Example of authenticating call to Test1
return(true); //Always allow call
});
var listenSock = server.ListenTCP(6000);
Assert.IsNotNull(listenSock);
client.OnDisconnect += (sCl, err) =>
{
throw new AssertFailedException(err.Message, err);
};
Assert.IsTrue(client.Connect("127.0.0.1", 6000));
Assert.IsTrue(client.WaitForHandshake());
var testParam = "Hello World";
var func1 = client.GetRemoteFunction <int>("Test1");
var func2 = client.GetRemoteFunction <string>("Test2");
var func3 = client.GetRemoteFunction <char>("Test3");
Assert.AreEqual(testParam.Length, func1.CallWait(testParam));
Assert.AreEqual(string.Concat(testParam.Reverse()), func2.CallWait(testParam));
Assert.AreEqual(testParam.FirstOrDefault(), func3.CallWait(testParam));
func1.CallWait(1, 2, 3, 4, 5);
Assert.AreEqual(func1.LastStatus, FunctionResponceStatus.InvalidParameters);
}
public void TestUDP()
{
var packets = 10;
var client = new SyncIOClient();
var server = new SyncIOServer();
object[] sent = new object[] { 1, 2, 3, "hello", "world" };
int receved = 0;
server.SetHandler((SyncIOConnectedClient s, object[] data) =>
{
Assert.AreEqual(client.ID, s.ID);
CollectionAssert.AreEqual(sent, data);
receved++;
});
var sock = server.ListenTCP(55455);
Assert.IsNotNull(sock);
sock.TryOpenUDPConnection();
Assert.IsTrue(sock.HasUDP);
Assert.IsTrue(client.Connect("127.0.0.1", 55455));
Assert.IsTrue(client.WaitForHandshake());
client.TryOpenUDPConnection();
Assert.IsTrue(client.WaitForUDP());
for (int i = 0; i < packets; i++)
{
client.SendUDP(sent);
}
Thread.Sleep(3000); //Wait 3 secodns
Assert.AreEqual(packets, receved);
}
private static void Server()
{
var packer = new Packager(new Type[] {
typeof(SetName),
typeof(ChatMessage)
});
var server = new SyncIOServer(TransportProtocal.IPv4, packer);
var clients = new Dictionary <Guid, ConnectedChatClient>();
var sendToAll = new Action <IPacket>((p) => {
//Send to all clients who have set a name.
foreach (var c in clients.Select(x => x.Value))
{
c.Connection.Send(p);
}
});
var gettime = server.RegisterRemoteFunction("GetTime", new Func <string> (() => {
Console.WriteLine("Time function called");
return(string.Format("It is {0}.", DateTime.Now.ToShortTimeString()));
}));
gettime.SetAuthFunc((c, f) => {
return(clients[c.ID].CanUseTimeCommand);
});
var toggletime = server.RegisterRemoteFunction("toggletime", new Func <string>(() => "\"time\" command has been toggled."));
toggletime.SetAuthFunc((c, f) => {
clients[c.ID].CanUseTimeCommand = !clients[c.ID].CanUseTimeCommand;
return(true);
});
server.OnClientConnect += (SyncIOServer sender, SyncIOConnectedClient client) => {
Console.WriteLine("{0}] New connection", client.ID);
client.OnDisconnect += (c, ex) => {
Console.WriteLine("[{0}] Disconnected: {1}", c.ID, ex.Message);
};
};
server.SetHandler <SetName>((c, p) => {
sendToAll(new ChatMessage($"{p.Name} connected. ({c.ID})"));
clients.Add(c.ID, new ConnectedChatClient(c, p.Name));
});
server.SetHandler <ChatMessage>((c, p) => {
var msg = $"<{clients[c.ID].Name}> {p.Message}";
sendToAll(new ChatMessage(msg));
Console.WriteLine(msg);
});
Console.WriteLine("Closing socket examples:");
//Listen on all of the following ports:
var firstSock = server.ListenTCP(9996); //Add it to a variable for closing example
server.ListenTCP(9997);
server.ListenTCP(9998);
server.ListenTCP(9999);
if (server.Count() < 1)
{
ConsoleExtentions.ErrorAndClose("Failed to listen on any ports.");
}
foreach (var sock in server)
{
Console.WriteLine("Listening on {0}", sock.EndPoint.Port);
sock.OnClose += (sender, err) => {
Console.WriteLine("{0}] Socket closed. {1}", sender.EndPoint.Port, err);
};
}
Console.WriteLine("Closing port {0} and 9998", firstSock.EndPoint.Port);
firstSock.Dispose(); //Either close from var
server[9997].Dispose(); //Or by server index.
foreach (var sock in server)
{
Console.WriteLine("Listening on {0}", sock.EndPoint.Port);
}
Console.WriteLine("Reopening ports in 3 seconds");
Thread.Sleep(3000);
Console.Clear();
//Reopen:
server.ListenTCP(9996);
server.ListenTCP(9997);
foreach (var sock in server)
{
Console.WriteLine("Listening on {0}", sock.EndPoint.Port);
}
while (true)
{
Console.ReadLine();
}
}
public void TestPacketSending()
{
var done = new ManualResetEvent(false);
var packer = new Packager(new Type[] {
typeof(CustomDataSending)
});
var arrPayload = new object[] {
9,
"SyncIOTest",
"Example",
666.333f
};
var cPayload = new CustomDataSending()
{
Num = 5555,
str = "SyncIOTest",
fl = 6666.4444f
};
var server = new SyncIOServer(TransportProtocol.IPv4, packer);
Guid cID = Guid.NewGuid();
server.OnClientConnect += (s, c) =>
{
Console.WriteLine("Connected.");
cID = c.ID;
c.OnDisconnect += (rtcl, err) =>
{
throw new AssertFailedException(err.Message, err);
};
};
server.SetHandler((SyncIOConnectedClient s, object[] dat) =>
{
CollectionAssert.AreEqual(arrPayload, dat);
s.Send(cPayload);
});
var listenSock = server.ListenTCP(9000);
Assert.IsNotNull(listenSock);
var client = new SyncIOClient(TransportProtocol.IPv4, packer);
client.OnDisconnect += (sCl, err) =>
{
throw new AssertFailedException(err.Message, err);
};
client.SetHandler <CustomDataSending>((s, d) =>
{
Assert.AreEqual(cPayload.fl, d.fl);
Assert.AreEqual(cPayload.Num, d.Num);
Assert.AreEqual(cPayload.str, d.str);
done.Set();
});
client.OnHandshake += (s, id, succ) =>
{
Assert.IsTrue(succ);
Thread.Sleep(100); //Wait for server callback to finish
Assert.AreEqual(cID, id);
s.Send(arrPayload);
};
Assert.IsTrue(client.Connect("127.0.0.1", 9000));
Assert.IsTrue(done.WaitOne(10 * 1000));
listenSock.Dispose();
}
