internal void Start()
{
if (_Ssl)
{
_TcpServer = new WatsonTcpServer(
_Ip,
_Port,
_PfxCertificateFile,
_PfxCertificatePassword);
Logger?.Invoke("[MeshServer] Starting TCP server with SSL on IP:port " + _IpPort);
}
else
{
_TcpServer = new WatsonTcpServer(
_Ip,
_Port);
Logger?.Invoke("[MeshServer] Starting TCP server on IP:port " + _IpPort);
}
_TcpServer.AcceptInvalidCertificates = _Settings.AcceptInvalidCertificates;
_TcpServer.MutuallyAuthenticate = _Settings.MutuallyAuthenticate;
_TcpServer.PresharedKey = _Settings.PresharedKey;
_TcpServer.StreamBufferSize = _Settings.StreamBufferSize;
_TcpServer.ClientConnected += MeshServerClientConnected;
_TcpServer.ClientDisconnected += MeshServerClientDisconnected;
_TcpServer.StreamReceived += MeshServerStreamReceived;
_TcpServer.Start();
Logger?.Invoke("[MeshServer] Server started");
}
/// <summary>
/// Start the Watson mesh server.
/// </summary>
public void Start()
{
if (_Self.Ssl)
{
_TcpServer = new WatsonTcpServer(
_Self.Ip,
_Self.Port,
_Self.PfxCertificateFile,
_Self.PfxCertificatePassword);
}
else
{
_TcpServer = new WatsonTcpServer(
_Self.Ip,
_Self.Port);
}
_TcpServer.AcceptInvalidCertificates = _Settings.AcceptInvalidCertificates;
_TcpServer.Debug = _Settings.Debug;
_TcpServer.MutuallyAuthenticate = _Settings.MutuallyAuthenticate;
_TcpServer.PresharedKey = _Settings.PresharedKey;
_TcpServer.ReadDataStream = _Settings.ReadDataStream;
_TcpServer.ReadStreamBufferSize = _Settings.ReadStreamBufferSize;
_TcpServer.ClientConnected = MeshServerClientConnected;
_TcpServer.ClientDisconnected = MeshServerClientDisconnected;
_TcpServer.MessageReceived = MeshServerMessageReceived;
_TcpServer.StreamReceived = MeshServerStreamReceived;
_TcpServer.Start();
}
public exchange(m_xip x_m)
{
this.x_m = x_m ?? throw new ArgumentNullException(nameof(x_m));
server = new WatsonTcpServer(x_m.address, x_m.port);
server.Events.MessageReceived += Events_MessageReceivedAsync;
server.Start();
}
private static void Main()
{
rng = new Random((int)DateTime.Now.Ticks);
data = Common.InitByteArray(65536, 0x00);
Console.WriteLine("Data MD5: " + Common.BytesToHex(Common.Md5(data)));
Console.WriteLine("Starting server");
server = new WatsonTcpServer(null, serverPort)
{
ClientConnected = ServerClientConnected,
ClientDisconnected = ServerClientDisconnected,
MessageReceived = ServerMsgReceived,
};
server.Start();
Thread.Sleep(3000);
Console.WriteLine("Starting clients");
for (int i = 0; i < clientThreads; i++)
{
Console.WriteLine("Starting client " + i);
Task.Run(() => ClientTask());
}
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
}
public void RunServer()
{
connectedUsers = new Dictionary <string, string>();
messageQueue = new Queue <byte[]>();
server = new WatsonTcpServer("192.168.209.7", 9000);
server.ClientConnected = ClientConnected;
server.ClientDisconnected = ClientDisconnected;
server.MessageReceived = MessageReceived;
server.Debug = false;
server.Start();
bool runForever = true;
while (runForever)
{
Console.WriteLine("Command [q]: ");
string userInput = Console.ReadLine();
if (string.IsNullOrEmpty(userInput))
{
continue;
}
switch (userInput)
{
case "q":
runForever = false;
break;
}
}
}
public void Start()
{
UIHandler.PlayColorfulBarAnimation(true);
FileScan(ts.directoryPath);
servH.Start();
UIHandler.WriteLog($"Host started!", Color.Green);
}
private static void Main(string[] args)
{
rng = new Random((int)DateTime.Now.Ticks);
data = InitByteArray(262144, 0x00);
Console.WriteLine("Data MD5: " + BytesToHex(Md5(data)));
Console.WriteLine("Starting in 3 seconds...");
server = new WatsonTcpServer(null, serverPort);
server.ClientConnected += ServerClientConnected;
server.ClientDisconnected += ServerClientDisconnected;
server.MessageReceived += ServerMsgReceived;
server.Start();
Thread.Sleep(3000);
c = new WatsonTcpClient("localhost", serverPort);
c.ServerConnected += ClientServerConnected;
c.ServerDisconnected += ClientServerDisconnected;
c.MessageReceived += ClientMsgReceived;
c.Start();
Console.WriteLine("Press ENTER to exit");
for (int i = 0; i < clientThreads; i++)
{
Task.Run(() => ClientTask());
}
Console.ReadLine();
}
/// <summary>
/// Start the cluster server.
/// </summary>
internal void Start()
{
if (String.IsNullOrEmpty(_CertFile))
{
_WtcpServer = new WatsonTcpServer(_ListenerIp, _ListenerPort);
}
else
{
_WtcpServer = new WatsonTcpServer(_ListenerIp, _ListenerPort, _CertFile, _CertPass);
}
_WtcpServer.Debug = Debug;
_WtcpServer.ReadDataStream = ReadDataStream;
_WtcpServer.ReadStreamBufferSize = ReadStreamBufferSize;
_WtcpServer.AcceptInvalidCertificates = AcceptInvalidCertificates;
_WtcpServer.MutuallyAuthenticate = MutuallyAuthenticate;
_WtcpServer.PresharedKey = PresharedKey;
_WtcpServer.ClientConnected = ClientConnect;
_WtcpServer.ClientDisconnected = ClientDisconnect;
_WtcpServer.MessageReceived = MsgReceived;
_WtcpServer.StreamReceived = StrmReceived;
_WtcpServer.Start();
}
internal void RunTest()
{
using (WatsonTcpServer server = new WatsonTcpServer("127.0.0.1", 10000))
{
server.MessageReceived += Test2ServerMsgRcv;
server.Start();
Stopwatch sw = new Stopwatch();
for (int i = 0; i < _NumClients; i++)
{
Task.Run(() => Test2ClientWorker());
_RunningTasks++;
}
while (_RunningTasks > 0)
{
Console.WriteLine("Waiting on " + _RunningTasks + " running tasks (1 second pause)");
Thread.Sleep(1000);
}
_Stopwatch.Stop();
while (_MessagesProcessing > 0)
{
Console.WriteLine("Waiting on " + _MessagesProcessing + " to complete processing (1 second pause)");
Thread.Sleep(1000);
}
}
Console.WriteLine("");
Console.WriteLine("Results:");
Console.WriteLine(" Number of clients : " + _NumClients);
Console.WriteLine(" Number of messages per client : " + _NumMessages);
Console.WriteLine(" Messages sent successfully : " + _MessagesSentSuccess);
Console.WriteLine(" Messages failed : " + _MessagesSentFailed);
Console.WriteLine(" Bytes sent successfully : " + _BytesSent);
Console.WriteLine(" Bytes received successfully : " + _BytesReceived);
decimal secondsTotal = _Stopwatch.ElapsedMilliseconds / 1000;
if (secondsTotal < 1)
{
secondsTotal = 1;
}
decimal bytesPerSecond = _BytesSent / secondsTotal;
decimal kbPerSecond = bytesPerSecond / 1024;
decimal mbPerSecond = kbPerSecond / 1024;
Console.WriteLine(" Elapsed time (ms) : " + _Stopwatch.ElapsedMilliseconds + "ms");
Console.WriteLine(" Elapsed time (seconds) : " + decimal.Round(secondsTotal, 2) + "s");
Console.WriteLine(" Messages per second : " + decimal.Round(_MessagesSentSuccess / secondsTotal, 2) + "msg/s");
Console.WriteLine(" Bytes per second : " + decimal.Round(bytesPerSecond, 2) + "B/s");
Console.WriteLine(" Kilobytes per second : " + decimal.Round(kbPerSecond, 2) + "kB/s");
Console.WriteLine(" Megabytes per second : " + decimal.Round(mbPerSecond, 2) + "MB/s");
Console.WriteLine("");
}
private void btnIniciarServidor_Click(object sender, RoutedEventArgs e)
{
server = new WatsonTcpServer(txtIp.Text, Convert.ToInt32(txtPorta.Text));
server.Events.ClientConnected += Events_ClientConnected;
server.Events.ClientDisconnected += Events_ClientDisconnected;
server.Events.MessageReceived += Events_MessageReceived;
server.Events.ServerStarted += Events_ServerStarted;
server.Start();
}
public static void ServerBaslat()
{
Log.Debug("Server Başlatılıyor...");
server = new WatsonTcpServer("127.0.0.1", 8163);
server.Events.ServerStarted += ServerBaslatildi;
server.Events.MessageReceived += MesajGeldi;
server.Events.ClientConnected += ClientBaglandi;
server.Events.ClientDisconnected += ClientBaglantisiKesildi;
server.Start();
}
private void bStart_Click(object sender, EventArgs e)
{
try
{
_Server.Start();
}
catch (Exception ex)
{
Logger("Start exception");
Logger(SerializationHelper.SerializeJson(ex, true));
}
Logger("Leaving bStart_Click");
}
public Server()
{
tcpServer = new WatsonTcpServer(NetworkUtil.GetLocalIPAddress(), 8901);
tcpServer.MessageReceived += MessageReceived;
tcpServer.ClientConnected += ClientConnected;
tcpServer.ClientDisconnected += ClientDisconnected;
tcpServer.Start();
uDPNetworking.UDPStartListening();
uDPNetworking.MessageRecieved += UDPMessageReceived;
}
internal void RunTest()
{
using (WatsonTcpServer server = new WatsonTcpServer("127.0.0.1", 10000))
{
server.MessageReceived = Test1ServerMsgRcv;
server.Start();
using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 10000))
{
client.MessageReceived = Test1ClientMsgRcv;
client.Start();
_Stopwatch.Start();
for (int i = 0; i < _NumMessages; i++)
{
if (client.Send(_MsgBytes))
{
_MessageSuccess++;
_BytesSent += _MessageSize;
}
else
{
_MessageFailed++;
}
}
_Stopwatch.Stop();
}
}
Console.WriteLine("");
Console.WriteLine("Results:");
Console.WriteLine(" Messages sent successfully : " + _MessageSuccess);
Console.WriteLine(" Messages failed : " + _MessageFailed);
Console.WriteLine(" Bytes sent successfully : " + _BytesSent);
Console.WriteLine(" Bytes received successfully : " + _BytesReceived);
decimal secondsTotal = _Stopwatch.ElapsedMilliseconds / 1000;
decimal bytesPerSecond = _BytesSent / secondsTotal;
decimal kbPerSecond = bytesPerSecond / 1024;
decimal mbPerSecond = kbPerSecond / 1024;
Console.WriteLine(" Elapsed time (ms) : " + _Stopwatch.ElapsedMilliseconds + "ms");
Console.WriteLine(" Elapsed time (seconds) : " + decimal.Round(secondsTotal, 2) + "s");
Console.WriteLine(" Bytes per second : " + decimal.Round(bytesPerSecond, 2) + "B/s");
Console.WriteLine(" Kilobytes per second : " + decimal.Round(kbPerSecond, 2) + "kB/s");
Console.WriteLine(" Megabytes per second : " + decimal.Round(mbPerSecond, 2) + "MB/s");
Console.WriteLine("");
}
static void Main(string[] args)
{
try
{
var watsonServer = new WatsonTcpServer("127.0.0.1", Port)
{
Compression = CompType,
Logger = Console.WriteLine,
DebugMessages = true
};
watsonServer.MessageReceived += (sender, message) =>
{
Console.WriteLine("Server received message: " + Encoding.UTF8.GetString(message.Data));
watsonServer.Send(message.IpPort, message.Data);
};
watsonServer.Start();
Task.Delay(1000).Wait();
var client = new WatsonTcpClient("127.0.0.1", Port)
{
Compression = CompType,
Logger = Console.WriteLine,
DebugMessages = true
};
client.MessageReceived += (sender, message) =>
{
Console.WriteLine("Client received message: " + Encoding.UTF8.GetString(message.Data));
};
client.Start();
Task.Delay(1000).Wait();
for (int i = 0; i < 10; i++)
{
client.Send("Hello " + i);
Task.Delay(250).Wait();
}
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
static void Main(string[] args)
{
if (args != null && args.Length == 2)
{
_MessageCount = Convert.ToInt32(args[0]);
_EntryCount = Convert.ToInt32(args[1]);
}
_Stopwatches = new Stopwatch[_MessageCount];
using (WatsonTcpServer server = new WatsonTcpServer("127.0.0.1", _ServerPort))
{
// server.Settings.DebugMessages = true;
// server.Settings.Logger = ServerLogger;
server.Events.MessageReceived += ServerMessageReceived;
server.Start();
Console.WriteLine("Server started");
Task.Delay(1000).Wait();
using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", _ServerPort))
{
client.Events.MessageReceived += ClientMessageReceived;
client.Connect();
Console.WriteLine("Client connected to server");
for (int i = 0; i < _MessageCount; i++)
{
Dictionary <object, object> md = new Dictionary <object, object>();
for (int j = 0; j < _EntryCount; j++)
{
Person p = new Person("hello", "world", i.ToString() + "." + j.ToString());
md.Add("person." + i.ToString() + "." + j.ToString(), p);
}
client.Send(i.ToString(), md);
_Stopwatches[i] = new Stopwatch();
_Stopwatches[i].Start();
Console.WriteLine("Client sent message " + i);
}
}
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
}
}
public ServerForm()
{
InitializeComponent();
label1.Text = "";
_Server = new WatsonTcpServer("127.0.0.1", 9000);
// _Server.MaxConnections = 1;
_Server.MessageReceived += OnMessageReceived;
_Server.ClientConnected += OnClientConnected;
_Server.ClientDisconnected += OnClientDisconnected;
_Server.Logger = Logger;
_Server.Start();
Logger("Server started.");
}
private static void Main(string[] args)
{
// Start Socket Server Initialization
WatsonTcpServer server = new WatsonTcpServer(SERVER, Port)
{
ClientConnected = ClientConnected,
ClientDisconnected = ClientDisconnected,
MessageReceived = MessageReceived,
Debug = false
};
server.Start();
// End Socket Server Initialization
// Injection Begin
var spotifyProcess = Extensions.SpotifyProcess;
PayloadInjector sharpDomainInjector = new PayloadInjector(spotifyProcess,
Environment.CurrentDirectory,
"SharpDomain.dll",
Environment.CurrentDirectory,
"SpotifySharper.Injector.dll",
string.Empty);
//PayloadInjector detoursInjector = new PayloadInjector(spotifyProcess,
// Environment.CurrentDirectory,
// "SharpDomain.dll",
// Environment.CurrentDirectory,
// "DetoursDll.dll",
// string.Empty);
spotifyProcess.Inject("DetoursDll.dll");
try
{
sharpDomainInjector.InjectAndForget();
Console.WriteLine($"Successfully injected libs into Spotify (PID: {spotifyProcess?.Id} | Title: {spotifyProcess?.MainWindowTitle})!", Color.Lime);
}
catch (Exception ex)
{
Console.WriteLine(ex, Color.Red);
}
// Injection End
Console.Read();
}
/// <summary>
/// Constructor that initializes Host object based on given TCPSettings.
/// </summary>
/// <param name="c">TCPSettings for Host work.</param>
public Host(TCPSettings c)
{
ts = c;
msBeforeTimeOut = ts.msTimeout;
servH = new WatsonTcpServer(ts.ip, ts.port);
servH.Events.ClientConnected += JoinedConnected;
servH.Events.ClientDisconnected += JoinedDisconnected;
servH.Events.StreamReceived += StreamReceived;
servH.Callbacks.SyncRequestReceived += SyncSolver;
servH.Keepalive.EnableTcpKeepAlives = true;
servH.Keepalive.TcpKeepAliveInterval = 10;
servH.Keepalive.TcpKeepAliveTime = msBeforeTimeOut;
servH.Keepalive.TcpKeepAliveRetryCount = 10;
FileScan(ts.directoryPath);
servH.Start();
UIHandler.WriteLog($"Host started!", Color.Green);
}
//public static AsyncTCPServer.AsyncTCPServer server;
/// <summary>Starts the server.</summary>
/// <param name="_maxPlayers">The maximum players that can be connected simultaneously.</param>
/// <param name="_port">The port to start the server on.</param>
public static void Start(int _maxPlayers, int _port)
{
MaxPlayers = _maxPlayers;
Port = _port;
InitializeServerData();
server = new WatsonTcpServer("0.0.0.0", _port);
server.Events.ExceptionEncountered += Events_ExceptionEncountered;
server.Events.ClientConnected += ClientConnected;
server.Events.ClientDisconnected += ClientDisconnected;
server.Events.MessageReceived += MessageReceived;
server.Start();
/*server = new AsyncTCPServer.AsyncTCPServer(IPAddress.Any, _port);
* server.OnClientConnected += Server_OnClientConnected;
* server.OnClientDisconnected += Server_OnClientDisconnected;
* server.OnReceived += Server_OnReceived;
* server.Start();*/
Debug.Log($"Server started on port {Port}");
}
static void Main(string[] args)
{
using (WatsonTcpServer server = new WatsonTcpServer("127.0.0.1", 8000))
{
server.Events.MessageReceived += ServerMessageReceived;
server.Start();
Task.Delay(1000).Wait();
using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 8000))
{
client.Events.MessageReceived += ClientMessageReceived;
client.Connect();
for (int i = 0; i < 10; i++)
{
Person p = new Person("hello", "world", i);
Dictionary <object, object> md = new Dictionary <object, object>();
md.Add("person", p);
client.Send(("Message " + i), md);
Task.Delay(1000).Wait();
}
}
}
}
private void simpleButton1_Click(object sender, EventArgs e)
{
server.Start();
txtServerDurumu.Appearance.ForeColor = Color.Green;
txtServerDurumu.Text = "Başlatıldı";
}
private static void Main(string[] args)
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
if (!useSsl)
{
server = new WatsonTcpServer(serverIp, serverPort);
}
else
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
acceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", false);
server = new WatsonTcpServer(serverIp, serverPort, certFile, certPass);
server.AcceptInvalidCertificates = acceptInvalidCerts;
server.MutuallyAuthenticate = mutualAuthentication;
}
server.ClientConnected = ClientConnected;
server.ClientDisconnected = ClientDisconnected;
server.MessageReceived = MessageReceived;
server.Debug = debug;
server.Start();
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine();
List <string> clients;
string ipPort;
bool success = false;
if (String.IsNullOrEmpty(userInput))
{
continue;
}
switch (userInput)
{
case "?":
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" list list clients");
Console.WriteLine(" dispose dispose of the connection");
Console.WriteLine(" send send message to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" debug enable/disable debug (currently " + server.Debug + ")");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = server.ListClients();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "dispose":
server.Dispose();
break;
case "send":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.Send(ipPort, Encoding.UTF8.GetBytes(userInput));
Console.WriteLine(success);
break;
case "sendasync":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput)).Result;
Console.WriteLine(success);
break;
case "remove":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
server.DisconnectClient(ipPort);
break;
case "psk":
server.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "debug":
server.Debug = !server.Debug;
Console.WriteLine("Debug set to: " + server.Debug);
break;
default:
break;
}
}
}
private static void Main(string[] args)
{
_ServerIp = InputString("Server IP:", "localhost", false);
_ServerPort = InputInteger("Server port:", 9000, true, false);
_Ssl = InputBoolean("Use SSL:", false);
try
{
if (!_Ssl)
{
_Server = new WatsonTcpServer(_ServerIp, _ServerPort);
}
else
{
_CertFile = InputString("Certificate file:", "test.pfx", false);
_CertPass = InputString("Certificate password:"******"password", false);
_AcceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
_MutualAuth = InputBoolean("Mutually authenticate:", false);
_Server = new WatsonTcpServer(_ServerIp, _ServerPort, _CertFile, _CertPass);
_Server.Settings.AcceptInvalidCertificates = _AcceptInvalidCerts;
_Server.Settings.MutuallyAuthenticate = _MutualAuth;
}
_Server.Events.ClientConnected += ClientConnected;
_Server.Events.ClientDisconnected += ClientDisconnected;
_Server.Events.MessageReceived += MessageReceived;
_Server.Events.ServerStarted += ServerStarted;
_Server.Events.ServerStopped += ServerStopped;
_Server.Callbacks.SyncRequestReceived = SyncRequestReceived;
// _Server.Settings.IdleClientTimeoutSeconds = 10;
// _Server.Settings.PresharedKey = "0000000000000000";
_Server.Settings.Logger = Logger;
_Server.Settings.DebugMessages = _DebugMessages;
_Server.Keepalive.EnableTcpKeepAlives = true;
_Server.Keepalive.TcpKeepAliveInterval = 1;
_Server.Keepalive.TcpKeepAliveTime = 1;
_Server.Keepalive.TcpKeepAliveRetryCount = 3;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return;
}
_Server.Start();
bool runForever = true;
List <string> clients;
string ipPort;
Dictionary <object, object> metadata;
bool success = false;
while (runForever)
{
string userInput = InputString("Command [? for help]:", null, false);
switch (userInput)
{
case "?":
bool listening = (_Server != null ? _Server.IsListening : false);
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" start start listening for connections (listening: " + listening.ToString() + ")");
Console.WriteLine(" stop stop listening for connections (listening: " + listening.ToString() + ")");
Console.WriteLine(" list list clients");
Console.WriteLine(" dispose dispose of the server");
Console.WriteLine(" send send message to client");
Console.WriteLine(" send md send message with metadata to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" sendasync md send message with metadata to a client asynchronously");
Console.WriteLine(" sendandwait send message and wait for a response");
Console.WriteLine(" sendempty send empty message with metadata");
Console.WriteLine(" sendandwait empty send empty message with metadata and wait for a response");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" remove all disconnect all clients");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" stats display server statistics");
Console.WriteLine(" stats reset reset statistics other than start time and uptime");
Console.WriteLine(" debug enable/disable debug");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "start":
_Server.Start();
break;
case "stop":
_Server.Stop();
break;
case "list":
clients = _Server.ListClients().ToList();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "dispose":
_Server.Dispose();
break;
case "send":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
if (!_Server.Send(ipPort, userInput))
{
Console.WriteLine("Failed");
}
break;
case "send10":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Sending " + i);
if (!_Server.Send(ipPort, userInput + "[" + i.ToString() + "]"))
{
Console.WriteLine("Failed");
}
}
break;
case "send md":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
if (!_Server.Send(ipPort, userInput, metadata))
{
Console.WriteLine("Failed");
}
break;
case "send md large":
ipPort = InputString("IP:port:", _LastIpPort, false);
metadata = new Dictionary <object, object>();
for (int i = 0; i < 100000; i++)
{
metadata.Add(i, i);
}
if (!_Server.Send(ipPort, "Hello!", metadata))
{
Console.WriteLine("Failed");
}
break;
case "sendasync":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
success = _Server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput)).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendasync md":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
success = _Server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput), metadata).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendandwait":
SendAndWait();
break;
case "sendempty":
ipPort = InputString("IP:port:", _LastIpPort, false);
metadata = InputDictionary();
if (!_Server.Send(ipPort, "", metadata))
{
Console.WriteLine("Failed");
}
break;
case "sendandwait empty":
SendAndWaitEmpty();
break;
case "remove":
ipPort = InputString("IP:port:", _LastIpPort, false);
_Server.DisconnectClient(ipPort);
break;
case "remove all":
_Server.DisconnectClients();
break;
case "psk":
_Server.Settings.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "stats":
Console.WriteLine(_Server.Statistics.ToString());
break;
case "stats reset":
_Server.Statistics.Reset();
break;
case "debug":
_Server.Settings.DebugMessages = !_Server.Settings.DebugMessages;
Console.WriteLine("Debug set to: " + _Server.Settings.DebugMessages);
break;
default:
break;
}
}
}
static void Main(string[] args)
{
server = new WatsonTcpServer("127.0.0.1", 9000);
server.Events.ClientConnected += ServerClientConnected;
server.Events.ClientDisconnected += ServerClientDisconnected;
server.Events.MessageReceived += ServerMessageReceived;
// server.StreamReceived = ServerStreamReceived;
// server.Debug = true;
server.Start();
client = new WatsonTcpClient("127.0.0.1", 9000);
client.Events.ServerConnected += ServerConnected;
client.Events.ServerDisconnected += ServerDisconnected;
client.Events.MessageReceived += MessageReceived;
// client.Events.StreamReceived = StreamReceived;
// client.Debug = true;
client.Start();
int msgSize = (1024 * 128);
Console.Write("Message size (default 128KB): ");
string userInput = Console.ReadLine();
if (!String.IsNullOrEmpty(userInput))
{
msgSize = Convert.ToInt32(userInput);
}
int msgCount = 4;
Console.Write("Message count (default 4): ");
userInput = Console.ReadLine();
if (!String.IsNullOrEmpty(userInput))
{
msgCount = Convert.ToInt32(userInput);
}
Console.WriteLine("");
Console.WriteLine("---");
Console.WriteLine("Sending messages from client to server...");
for (int i = 0; i < msgCount; i++)
{
string randomString = RandomString(msgSize);
string md5 = Md5(randomString);
Console.WriteLine("Client sending " + msgSize + " bytes: MD5 " + md5);
client.Send(Encoding.UTF8.GetBytes(randomString));
}
Console.WriteLine("");
Console.WriteLine("---");
string ipPort = server.ListClients().ToList()[0];
Console.WriteLine("Sending messages from server to client " + ipPort + "...");
for (int i = 0; i < msgCount; i++)
{
string randomString = RandomString(msgSize);
string md5 = Md5(randomString);
Console.WriteLine("Server sending " + msgSize + " bytes: MD5 " + md5);
server.Send(ipPort, Encoding.UTF8.GetBytes(randomString));
}
Console.WriteLine("");
Console.WriteLine("---");
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
server.Dispose();
client.Dispose();
}
private static void ClientToServer()
{
_Random = new Random((int)DateTime.Now.Ticks);
_DataLargeBytes = InitByteArray(_DataLargeSize, 0x00);
_DataLargeMd5 = BytesToHex(Md5(_DataLargeBytes));
_DataSmallBytes = InitByteArray(_DataSmallSize, 0x00);
_DataSmallMd5 = BytesToHex(Md5(_DataSmallBytes));
Console.WriteLine("Large Data MD5: " + _DataLargeMd5);
Console.WriteLine("Small Data MD5: " + _DataSmallMd5);
Console.WriteLine("Starting in 3 seconds...");
_Server = new WatsonTcpServer(null, _ServerPort);
_Server.Events.ClientConnected += ServerClientConnected;
_Server.Events.ClientDisconnected += ServerClientDisconnected;
if (!_UseStreams)
{
_Server.Events.MessageReceived += ServerMsgReceived;
}
else
{
_Server.Events.StreamReceived += ServerStreamReceived;
}
_Server.Callbacks.SyncRequestReceived = ServerSyncRequestReceived;
_Server.Settings.MaxProxiedStreamSize = _MaxProxiedStreamSize;
_Server.Settings.Logger = Console.WriteLine;
_Server.Settings.DebugMessages = _Debug;
_Server.Start();
Thread.Sleep(2000);
_Client = new WatsonTcpClient("localhost", _ServerPort);
_Client.Events.ServerConnected += ClientServerConnected;
_Client.Events.ServerDisconnected += ClientServerDisconnected;
if (!_UseStreams)
{
_Client.Events.MessageReceived += ClientMsgReceived;
}
else
{
_Client.Events.StreamReceived += ClientStreamReceived;
}
_Client.Callbacks.SyncRequestReceived = ClientSyncRequestReceived;
_Client.Settings.MaxProxiedStreamSize = _MaxProxiedStreamSize;
_Client.Settings.Logger = Console.WriteLine;
_Client.Settings.DebugMessages = _Debug;
_Client.Start();
Thread.Sleep(2000);
Console.WriteLine("Press ENTER to exit");
for (int i = 0; i < _ClientThreads; i++)
{
Console.WriteLine("Starting client thread " + i);
Task.Run(() => ClientTask());
}
Console.WriteLine("Press ENTER after completion to view statistics");
Console.ReadLine();
Console.WriteLine("Success: " + _Success);
Console.WriteLine("Failure: " + _Failure);
}
internal void RunTest()
{
try
{
using (WatsonTcpServer server = new WatsonTcpServer("127.0.0.1", 10000))
{
server.Events.MessageReceived += Test1ServerMsgRcv;
server.Start();
// server.Settings.Logger = ServerLogger;
// server.Debug = true;
using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 10000))
{
client.Events.MessageReceived += Test1ClientMsgRcv;
client.Connect();
_Stopwatch.Start();
for (int i = 0; i < _NumMessages; i++)
{
if (client.Send(_MsgBytes))
{
Interlocked.Increment(ref _MessagesSentSuccess);
Interlocked.Increment(ref _MessagesProcessing);
Interlocked.Add(ref _BytesSent, _MessageSize);
}
else
{
Interlocked.Increment(ref _MessagesSentFailed);
}
}
_Stopwatch.Stop();
decimal secondsTotal = _Stopwatch.ElapsedMilliseconds / 1000;
if (secondsTotal < 1)
{
secondsTotal = 1;
}
Console.WriteLine("Messages sent after " + secondsTotal + " seconds");
while (_MessagesProcessing > 0)
{
Console.WriteLine("Waiting on " + _MessagesProcessing + " to complete processing (1 second pause)");
Thread.Sleep(1000);
}
Console.WriteLine("");
Console.WriteLine("Results:");
Console.WriteLine(" Messages sent successfully : " + _MessagesSentSuccess);
Console.WriteLine(" Messages failed : " + _MessagesSentFailed);
Console.WriteLine(" Bytes sent successfully : " + _BytesSent);
Console.WriteLine(" Bytes received successfully : " + _BytesReceived);
decimal bytesPerSecond = _BytesSent / secondsTotal;
decimal kbPerSecond = bytesPerSecond / 1024;
decimal mbPerSecond = kbPerSecond / 1024;
Console.WriteLine(" Elapsed time sending (ms) : " + _Stopwatch.ElapsedMilliseconds + "ms");
Console.WriteLine(" Elapsed time sending (seconds) : " + decimal.Round(secondsTotal, 2) + "s");
Console.WriteLine(" Send bytes per second : " + decimal.Round(bytesPerSecond, 2) + "B/s");
Console.WriteLine(" Send kilobytes per second : " + decimal.Round(kbPerSecond, 2) + "kB/s");
Console.WriteLine(" Send megabytes per second : " + decimal.Round(mbPerSecond, 2) + "MB/s");
Console.WriteLine("");
}
}
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.ToString());
}
}
private static void Main(string[] args)
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
try
{
if (!useSsl)
{
server = new WatsonTcpServer(serverIp, serverPort);
}
else
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
acceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", false);
server = new WatsonTcpServer(serverIp, serverPort, certFile, certPass);
server.Settings.AcceptInvalidCertificates = acceptInvalidCerts;
server.Settings.MutuallyAuthenticate = mutualAuthentication;
}
server.Events.ClientConnected += ClientConnected;
server.Events.ClientDisconnected += ClientDisconnected;
server.Events.MessageReceived += MessageReceived;
server.Callbacks.SyncRequestReceived = SyncRequestReceived;
// server.Settings.PresharedKey = "0000000000000000";
// server.IdleClientTimeoutSeconds = 10;
server.Settings.Logger = Logger;
server.Settings.DebugMessages = debugMessages;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return;
}
server.Start();
bool runForever = true;
List <string> clients;
string ipPort;
Dictionary <object, object> metadata;
bool success = false;
Console.WriteLine("");
Console.WriteLine("To test timeout recovery, send a message from a client with an integer");
Console.WriteLine("as payload indicating the number of seconds the server should wait");
Console.WriteLine("before responding.");
Console.WriteLine("");
while (runForever)
{
string userInput = InputString("Command [? for help]:", null, false);
switch (userInput)
{
case "?":
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" list list clients");
Console.WriteLine(" dispose dispose of the connection");
Console.WriteLine(" send send message to client");
Console.WriteLine(" send md send message with metadata to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" sendasync md send message with metadata to a client asynchronously");
Console.WriteLine(" sendandwait send message and wait for a response");
Console.WriteLine(" sendempty send empty message with metadata");
Console.WriteLine(" sendandwait empty send empty message with metadata and wait for a response");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" stats display server statistics");
Console.WriteLine(" stats reset reset statistics other than start time and uptime");
Console.WriteLine(" debug enable/disable debug (currently " + server.Settings.DebugMessages + ")");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = server.ListClients().ToList();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "dispose":
server.Dispose();
break;
case "send":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
if (!server.Send(ipPort, userInput))
{
Console.WriteLine("Failed");
}
break;
case "send md":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
if (!server.Send(ipPort, userInput, metadata))
{
Console.WriteLine("Failed");
}
Console.WriteLine(success);
break;
case "send md large":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = new Dictionary <object, object>();
for (int i = 0; i < 100000; i++)
{
metadata.Add(i, i);
}
if (!server.Send(ipPort, "Hello!", metadata))
{
Console.WriteLine("Failed");
}
break;
case "sendasync":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
success = server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput)).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendasync md":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
success = server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput), metadata).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendandwait":
SendAndWait();
break;
case "sendempty":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = InputDictionary();
if (!server.Send(ipPort, "", metadata))
{
Console.WriteLine("Failed");
}
break;
case "sendandwait empty":
SendAndWaitEmpty();
break;
case "remove":
ipPort = InputString("IP:port:", lastIpPort, false);
server.DisconnectClient(ipPort);
break;
case "psk":
server.Settings.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "stats":
Console.WriteLine(server.Statistics.ToString());
break;
case "stats reset":
server.Statistics.Reset();
break;
case "debug":
server.Settings.DebugMessages = !server.Settings.DebugMessages;
Console.WriteLine("Debug set to: " + server.Settings.DebugMessages);
break;
default:
break;
}
}
}
private static void Main(string[] args)
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
if (!useSsl)
{
server = new WatsonTcpServer(serverIp, serverPort);
}
else
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
acceptInvalidCerts = InputBoolean("Accept Invalid Certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", true);
server = new WatsonTcpServer(serverIp, serverPort, certFile, certPass);
server.AcceptInvalidCertificates = acceptInvalidCerts;
server.MutuallyAuthenticate = mutualAuthentication;
}
server.ClientConnected += ClientConnected;
server.ClientDisconnected += ClientDisconnected;
server.StreamReceived += StreamReceived;
server.SyncRequestReceived = SyncRequestReceived;
server.Logger = Logger;
// server.Debug = true;
server.Start();
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine();
byte[] data = null;
MemoryStream ms = null;
Dictionary <object, object> metadata;
bool success = false;
List <string> clients;
string ipPort;
if (String.IsNullOrEmpty(userInput))
{
continue;
}
switch (userInput)
{
case "?":
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" list list clients");
Console.WriteLine(" send send message to client");
Console.WriteLine(" send md send message with metadata to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" sendasync md send message with metadata to a client asynchronously");
Console.WriteLine(" sendandwait send message and wait for a response");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" debug enable/disable debug (currently " + server.DebugMessages + ")");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = server.ListClients().ToList();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "send":
ipPort = InputString("IP:port:", lastIpPort, false);
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.Send(ipPort, data.Length, ms);
Console.WriteLine(success);
break;
case "send md":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = InputDictionary();
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.Send(ipPort, metadata, data.Length, ms);
Console.WriteLine(success);
break;
case "sendasync":
ipPort = InputString("IP:port:", lastIpPort, false);
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.SendAsync(ipPort, data.Length, ms).Result;
Console.WriteLine(success);
break;
case "sendasync md":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = InputDictionary();
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.SendAsync(ipPort, metadata, data.Length, ms).Result;
Console.WriteLine(success);
break;
case "sendandwait":
SendAndWait();
break;
case "remove":
ipPort = InputString("IP:port:", lastIpPort, false);
server.DisconnectClient(ipPort);
break;
case "psk":
server.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "debug":
server.DebugMessages = !server.DebugMessages;
Console.WriteLine("Debug set to: " + server.DebugMessages);
break;
default:
break;
}
}
}
public void StartServer()
{
_server.Start();
}
