private static void InitializeClient() { if (!useSsl) { client = new WatsonTcpClient(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); client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass); client.AcceptInvalidCertificates = acceptInvalidCerts; client.MutuallyAuthenticate = mutualAuthentication; } client.AuthenticationFailure += AuthenticationFailure; client.AuthenticationRequested = AuthenticationRequested; client.AuthenticationSucceeded += AuthenticationSucceeded; client.ServerConnected += ServerConnected; client.ServerDisconnected += ServerDisconnected; client.StreamReceived += StreamReceived; client.Logger = Logger; // client.Debug = true; client.Start(); }
private static void ConnectClient() { if (client != null) { client.Dispose(); } if (!useSsl) { client = new WatsonTcpClient(serverIp, serverPort); } else { client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass); client.AcceptInvalidCertificates = acceptInvalidCerts; client.MutuallyAuthenticate = mutualAuthentication; } client.AuthenticationFailure = AuthenticationFailure; client.AuthenticationRequested = AuthenticationRequested; client.AuthenticationSucceeded = AuthenticationSucceeded; client.ServerConnected = ServerConnected; client.ServerDisconnected = ServerDisconnected; client.MessageReceived = MessageReceived; client.ReadDataStream = true; client.ReadStreamBufferSize = 65536; client.Debug = debug; client.Start(); }
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(); }
public void ConnectToServer() { tcpClient = new WatsonTcpClient(serverip, 8901); tcpClient.MessageReceived += MessageReceived; tcpClient.ServerDisconnected += _ServerDisconnected; try { Console.Out.WriteLine("[Client] Trying to connect to server with ip: " + serverip); tcpClient.Start(); } catch (SocketException e) { Console.Out.WriteLine(e); } if (tcpClient.Connected) { Console.Out.WriteLine("[Client] Connection sucessful"); ServerConnected(this, new EventArgs()); StopUDP(); } else { Console.Out.WriteLine("[Client] Connection failed"); } }
static void InitializeClient() { if (!useSsl) { client = new WatsonTcpClient(serverIp, serverPort); } else { certFile = Common.InputString("Certificate file:", "test.pfx", false); certPass = Common.InputString("Certificate password:"******"password", false); acceptInvalidCerts = Common.InputBoolean("Accept Invalid Certs:", true); mutualAuthentication = Common.InputBoolean("Mutually authenticate:", true); client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass); client.AcceptInvalidCertificates = acceptInvalidCerts; client.MutuallyAuthenticate = mutualAuthentication; } client.AuthenticationFailure = AuthenticationFailure; client.AuthenticationRequested = AuthenticationRequested; client.AuthenticationSucceeded = AuthenticationSucceeded; client.ServerConnected = ServerConnected; client.ServerDisconnected = ServerDisconnected; client.MessageReceived = MessageReceived; client.ReadDataStream = true; client.ReadStreamBufferSize = 65536; // client.Debug = true; client.Start(); }
private static void InitSocketClient() { WatsonTcpClient client = new WatsonTcpClient(SERVER, Port) { ServerConnected = ServerConnected, ServerDisconnected = ServerDisconnected, MessageReceived = MessageReceived, Debug = false }; client.Start(); bool runForever = true; do { if (ObjectQueue.Count > 0 && ObjectQueue.TryDequeue(out var @object)) { if (@object is ColoredMessage) { var coloredMsg = @object as ColoredMessage; client.Send(coloredMsg.Message, coloredMsg.Color); } } Thread.Sleep(100); }while (runForever); }
private void Test2ClientWorker() { try { using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 10000)) { client.MessageReceived += Test2ClientMsgRcv; client.Start(); for (int i = 0; i < _NumMessages; i++) { if (client.Send(_MsgBytes)) { _MessagesSentSuccess++; _MessagesProcessing++; _BytesSent += _MsgBytes.Length; } else { _MessagesSentFailed++; } } } _RunningTasks--; } catch (Exception e) { Console.WriteLine("Exception: " + e.ToString()); } }
static void Main(string[] args) { Task.Run(() => { WatsonTcpClient client = new WatsonTcpClient("10.1.2.3", 1234); // NonExistant Server client.ServerConnected += HandleServerConnected; client.ServerDisconnected += HandleServerDisconnected; client.MessageReceived += HandleMessageReceived; try { Console.WriteLine("Starting Client"); client.Start(); } catch (Exception ex) { Console.WriteLine("Exception: {0}", ex.Message); client.Dispose(); } }); Console.WriteLine("Waiting on NullReferenceException"); Thread.Sleep(10000); }
internal void Start() { string ip = null; int port = -1; Common.ParseIpPort(PeerNode.IpPort, out ip, out port); if (PeerNode.Ssl) { _TcpClient = new WatsonTcpClient( ip, port, PeerNode.PfxCertificateFile, PeerNode.PfxCertificatePassword); Logger?.Invoke("[MeshClient] Starting TCP client with SSL to connect to " + ip + ":" + port); } else { _TcpClient = new WatsonTcpClient( ip, port); Logger?.Invoke("[MeshClient] Starting TCP client to connect to " + ip + ":" + port); } _TcpClient.AcceptInvalidCertificates = _Settings.AcceptInvalidCertificates; _TcpClient.MutuallyAuthenticate = _Settings.MutuallyAuthenticate; _TcpClient.StreamBufferSize = _Settings.StreamBufferSize; _TcpClient.AuthenticationRequested = MeshClientAuthenticationRequested; _TcpClient.AuthenticationSucceeded += MeshClientAuthenticationSucceeded; _TcpClient.AuthenticationFailure += MeshClientAuthenticationFailure; _TcpClient.ServerConnected += MeshClientServerConnected; _TcpClient.ServerDisconnected += MeshClientServerDisconnected; _TcpClient.StreamReceived += MeshClientStreamReceived; try { _TcpClient.Start(); } catch (SocketException) { Task unawaited = Task.Run(() => ReconnectToServer()); ServerDisconnected?.Invoke(this, new ServerConnectionEventArgs(PeerNode)); } catch (Exception e) { Logger?.Invoke("[MeshClient] Client exception: " + Environment.NewLine + Common.SerializeJson(e, true)); Task unawaited = Task.Run(() => ReconnectToServer()); ServerDisconnected?.Invoke(this, new ServerConnectionEventArgs(PeerNode)); } Logger?.Invoke("[MeshClient] Client started"); }
public void ClientStart() { try { client.Start(); } catch (SocketException) { MessageBox.Show("Servis Cevap Vermiyor. Program Kapatılacak"); Application.Exit(); } }
private void Form1_Load(object sender, EventArgs e) { comboBox1.SelectedItem = "Online"; userLabel.Text = usernameShorten(userName); if (!string.IsNullOrEmpty(picAddress)) { userAvatar.Image = Bitmap.FromFile(picAddress); } userColorSys = Color.FromName(userColor); userAvatar.MouseHover += userAvatar_MouseHover; userLabel.MouseHover += userAvatar_MouseHover; bool isConnected = false; while (!isConnected && !demoMode) { try { client.Start(); isConnected = true; } catch (Exception) { DialogResult result = MessageBox.Show("A connection to Xalarwse servers could not be established." + "\nSelect \"Retry\" to reattempt a connection to Xalarwse servers." + "\nSelect \"Cancel\" to cancel reconnection and launch the program in offline (demo) mode. " + "\nYou can always restard the program later from offline (demo) mode.", "Not Connected", MessageBoxButtons.RetryCancel, MessageBoxIcon.Error); if (result == DialogResult.Cancel) { demoMode = true; this.Text = windowName + " (offline mode)"; //reconnectGroupBox.Visible = true; DISABLED } } } }
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 { _Client = new WatsonTcpClient("127.0.0.1", 9000); _Client.Events.MessageReceived += MessageReceived; _Client.Start(); _Client.Send("Hello!"); _Client.Dispose(); } catch (Exception e) { Console.WriteLine(e.ToString()); } }
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()); } }
public void Start(string ip, int port) { try { _client = new WatsonTcpClient(ip, port) { ServerConnected = SuccessfullyСonnected, Debug = false }; _client.Start(); } catch { MessageBox.Show(Properties.Resources.ServerNotAvaible, "Error", MessageBoxButton.OK, MessageBoxImage.Error); _logger.LogError("Server is not available"); } }
private static void ClientTask() { using (WatsonTcpClient client = new WatsonTcpClient("localhost", serverPort)) { client.ServerConnected = ClientServerConnected; client.ServerDisconnected = ClientServerDisconnected; client.MessageReceived = ClientMsgReceived; client.Start(); for (int i = 0; i < numIterations; i++) { Task.Delay(rng.Next(0, 25)).Wait(); client.Send(data); } } Console.WriteLine("[client] finished"); }
private static void InitializeClient() { if (!useSsl) { client = new WatsonTcpClient(serverIp, serverPort); } else { bool provideCertificate = Common.InputBoolean("Do you wish to provide a certificate ? (required for mutual authenication)", true); acceptInvalidCerts = Common.InputBoolean("Accept Invalid Certs:", true); if (provideCertificate) { certFile = Common.InputString("Certificate file:", "test.pfx", false); certPass = Common.InputString("Certificate password:"******"password", false); mutualAuthentication = Common.InputBoolean("Mutually authenticate:", true); client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass) { AcceptInvalidCertificates = acceptInvalidCerts, MutuallyAuthenticate = mutualAuthentication, }; } else { client = new WatsonTcpClient(Mode.Ssl, serverIp, serverPort, null) { AcceptInvalidCertificates = acceptInvalidCerts, }; } } client.AuthenticationFailure = AuthenticationFailure; client.AuthenticationRequested = AuthenticationRequested; client.AuthenticationSucceeded = AuthenticationSucceeded; client.ServerConnected = ServerConnected; client.ServerDisconnected = ServerDisconnected; client.MessageReceived = MessageReceived; client.ReadDataStream = true; client.ReadStreamBufferSize = 65536; // client.Debug = true; client.Start(); }
/// <summary> /// Establish TCP (with or without SSL) connection to the peer server. /// </summary> public void Start() { if (Peer.Ssl) { _TcpClient = new WatsonTcpClient( Peer.Ip, Peer.Port, Peer.PfxCertificateFile, Peer.PfxCertificatePassword); } else { _TcpClient = new WatsonTcpClient( Peer.Ip, Peer.Port); } _TcpClient.AcceptInvalidCertificates = _Settings.AcceptInvalidCertificates; _TcpClient.Debug = _Settings.Debug; _TcpClient.MutuallyAuthenticate = _Settings.MutuallyAuthenticate; _TcpClient.ReadDataStream = _Settings.ReadDataStream; _TcpClient.ReadStreamBufferSize = _Settings.ReadStreamBufferSize; _TcpClient.AuthenticationRequested = MeshClientAuthenticationRequested; _TcpClient.AuthenticationSucceeded = MeshClientAuthenticationSucceeded; _TcpClient.AuthenticationFailure = MeshClientAuthenticationFailure; _TcpClient.ServerConnected = MeshClientServerConnected; _TcpClient.ServerDisconnected = MeshClientServerDisconnected; _TcpClient.StreamReceived = MeshClientStreamReceived; _TcpClient.MessageReceived = MeshClientMessageReceived; try { _TcpClient.Start(); } catch (Exception) { Task.Run(() => MeshClientServerDisconnected()); } }
private void Test2ClientWorker() { using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 10000)) { client.MessageReceived = Test2ClientMsgRcv; client.Start(); for (int i = 0; i < _NumMessages; i++) { if (client.Send(_MsgBytes)) { _MessageSuccess++; _BytesSent += _MsgBytes.Length; } else { _MessageFailed++; } } } _RunningTasks--; }
private void Test2ClientWorker(int clientNum) { try { long msgsSent = 0; long bytesSent = 0; using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 10000)) { client.Events.MessageReceived += Test2ClientMsgRcv; client.Start(); for (int i = 0; i < _NumMessages; i++) { if (client.Send(_MsgBytes)) { msgsSent++; bytesSent += _MsgBytes.Length; Interlocked.Increment(ref _MessagesSentSuccess); Interlocked.Increment(ref _MessagesProcessing); Interlocked.Add(ref _BytesSent, _MsgBytes.Length); } else { Interlocked.Increment(ref _MessagesSentFailed); } } } Interlocked.Decrement(ref _RunningTasks); Console.WriteLine("Client " + clientNum + " finished, sent " + msgsSent + " messages, " + bytesSent + " bytes"); } catch (Exception e) { Console.WriteLine("Exception: " + e.ToString()); } }
private static void ClientTask() { Console.WriteLine("ClientTask entering"); using (WatsonTcpClient client = new WatsonTcpClient("localhost", serverPort)) { client.ServerConnected = ClientServerConnected; client.ServerDisconnected = ClientServerDisconnected; client.MessageReceived = ClientMsgReceived; client.Start(); while (!clientsStarted) { Thread.Sleep(100); } for (int i = 0; i < numIterations; i++) { Task.Delay(rng.Next(0, 1000)).Wait(); client.Send(data); } } Console.WriteLine("[client] finished"); }
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); }
private static void Main(string[] args) { InitializeClient(); bool runForever = true; Dictionary <object, object> metadata; bool success; 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(" send send message to server"); Console.WriteLine(" send md send message with metadata to server"); Console.WriteLine(" sendasync send message to server asynchronously"); Console.WriteLine(" sendasync md send message with metadata to server 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(" status show if client connected"); Console.WriteLine(" dispose dispose of the connection"); Console.WriteLine(" connect connect to the server if not connected"); Console.WriteLine(" reconnect disconnect if connected, then reconnect"); Console.WriteLine(" psk set the preshared key"); Console.WriteLine(" auth authenticate using the preshared key"); Console.WriteLine(" stats display client statistics"); Console.WriteLine(" stats reset reset statistics other than start time and uptime"); Console.WriteLine(" comp set the compression type, currently: " + client.Compression.ToString()); Console.WriteLine(" debug enable/disable debug (currently " + client.DebugMessages + ")"); break; case "q": runForever = false; break; case "cls": Console.Clear(); break; case "send": userInput = InputString("Data:", null, false); if (!client.Send(Encoding.UTF8.GetBytes(userInput))) { Console.WriteLine("Failed"); } break; case "send md": userInput = InputString("Data:", null, false); metadata = InputDictionary(); if (!client.Send(metadata, Encoding.UTF8.GetBytes(userInput))) { Console.WriteLine("Failed"); } break; case "send md large": metadata = new Dictionary <object, object>(); for (int i = 0; i < 100000; i++) { metadata.Add(i, i); } if (!client.Send(metadata, "Hello!")) { Console.WriteLine("Failed"); } break; case "sendasync": userInput = InputString("Data:", null, false); success = client.SendAsync(Encoding.UTF8.GetBytes(userInput)).Result; if (!success) { Console.WriteLine("Failed"); } break; case "sendasync md": userInput = InputString("Data:", null, false); metadata = InputDictionary(); success = client.SendAsync(metadata, Encoding.UTF8.GetBytes(userInput)).Result; if (!success) { Console.WriteLine("Failed"); } break; case "sendandwait": SendAndWait(); break; case "sendempty": metadata = InputDictionary(); success = client.Send(metadata); if (!success) { Console.WriteLine("Failed"); } break; case "sendandwait empty": SendAndWaitEmpty(); break; case "status": if (client == null) { Console.WriteLine("Connected: False (null)"); } else { Console.WriteLine("Connected: " + client.Connected); } break; case "dispose": client.Dispose(); break; case "connect": if (client != null && client.Connected) { Console.WriteLine("Already connected"); } else { client = new WatsonTcpClient(serverIp, serverPort); client.ServerConnected += ServerConnected; client.ServerDisconnected += ServerDisconnected; client.MessageReceived += MessageReceived; client.Start(); } break; case "reconnect": ConnectClient(); break; case "psk": presharedKey = InputString("Preshared key:", "1234567812345678", false); break; case "auth": client.Authenticate(presharedKey); break; case "stats": Console.WriteLine(client.Stats.ToString()); break; case "stats reset": client.Stats.Reset(); break; case "comp": client.Compression = (CompressionType)(Enum.Parse(typeof(CompressionType), InputString("Compression [None|Default|Gzip]:", "None", false))); break; case "debug": client.DebugMessages = !client.DebugMessages; Console.WriteLine("Debug set to: " + client.DebugMessages); break; default: break; } } }
private void button1_Click(object sender, EventArgs e) { _Client.Start(); }
private void MaintainConnection() { while (true) { try { if (_WtcpClient == null) { if (Debug) { Log("Attempting connection to " + _ServerIp + ":" + _ServerPort); } if (String.IsNullOrEmpty(_CertFile)) { _WtcpClient = new WatsonTcpClient(_ServerIp, _ServerPort); } else { _WtcpClient = new WatsonTcpClient(_ServerIp, _ServerPort, _CertFile, _CertPass); } _WtcpClient.Debug = Debug; _WtcpClient.ReadDataStream = false; _WtcpClient.ReadStreamBufferSize = ReadStreamBufferSize; _WtcpClient.AcceptInvalidCertificates = AcceptInvalidCertificates; _WtcpClient.MutuallyAuthenticate = MutuallyAuthenticate; _WtcpClient.AuthenticationRequested = AuthenticationRequested; _WtcpClient.AuthenticationSucceeded = AuthenticationSucceeded; _WtcpClient.AuthenticationFailure = AuthenticationFailed; _WtcpClient.ServerConnected = ServerConnected; _WtcpClient.ServerDisconnected = ServerDisconnected; _WtcpClient.StreamReceived = StreamReceived; _WtcpClient.Start(); } else if (!_WtcpClient.Connected) { if (String.IsNullOrEmpty(_CertFile)) { _WtcpClient = new WatsonTcpClient(_ServerIp, _ServerPort); } else { _WtcpClient = new WatsonTcpClient(_ServerIp, _ServerPort, _CertFile, _CertPass); } _WtcpClient.Debug = Debug; _WtcpClient.ReadDataStream = false; _WtcpClient.ReadStreamBufferSize = ReadStreamBufferSize; _WtcpClient.AcceptInvalidCertificates = AcceptInvalidCertificates; _WtcpClient.MutuallyAuthenticate = MutuallyAuthenticate; _WtcpClient.AuthenticationRequested = AuthenticationRequested; _WtcpClient.AuthenticationSucceeded = AuthenticationSucceeded; _WtcpClient.AuthenticationFailure = AuthenticationFailed; _WtcpClient.ServerConnected = ServerConnected; _WtcpClient.ServerDisconnected = ServerDisconnected; _WtcpClient.StreamReceived = StreamReceived; if (Debug) { Log("Attempting reconnect to " + _ServerIp + ":" + _ServerPort); } _WtcpClient.Start(); } Task.Delay(1000).Wait(); } catch (SocketException) { Log("Unable to connect to peer"); } catch (Exception e) { if (Debug) { LogException("MaintainConnection", e); } } } }
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.Start(); _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()); } }
static void Main(string[] args) { using (server = new WatsonTcpServer(serverHostname, serverPort)) { server.ClientConnected += (s, e) => { Console.WriteLine("Client connected to server: " + e.IpPort); clientIpPort = e.IpPort; }; server.ClientDisconnected += (s, e) => { Console.WriteLine("Client disconnected from server: " + e.IpPort); clientIpPort = null; }; server.MessageReceived += (s, e) => { Console.WriteLine("Server received message from client " + e.IpPort + ": " + Encoding.UTF8.GetString(e.Data)); }; server.SyncRequestReceived = delegate(SyncRequest req) { Console.WriteLine("Server received sync message from client " + req.IpPort + ": " + Encoding.UTF8.GetString(req.Data)); return(new SyncResponse(req, "Here's your response from the server!")); }; server.Logger = ServerLogger; server.Start(); using (client = new WatsonTcpClient(serverHostname, serverPort)) { client.ServerConnected += (s, e) => { Console.WriteLine("Client connected to server"); }; client.ServerDisconnected += (s, e) => { Console.WriteLine("Client disconnected from server"); }; client.MessageReceived += (s, e) => { Console.WriteLine("Client received message from server: " + Encoding.UTF8.GetString(e.Data)); }; client.SyncRequestReceived = delegate(SyncRequest req) { Console.WriteLine("Client received sync message from server: " + Encoding.UTF8.GetString(req.Data)); return(new SyncResponse(req, "Here's your response from the client!")); }; client.Logger = ClientLogger; client.Start(); while (true) { Task.Delay(5000).Wait(); Task.Run(() => ServerTask()); Task.Run(() => ClientTask()); } } } }
public void InitClient() { messageIdentifier = "msg"; usernameIdentifier = "usr"; splitCharacter = '|'; bool validUsername; Regex regex = new Regex("^[a-zA-Z0-9_-]+$"); do { Console.WriteLine("Please enter your username:"******"192.168.209.7", 9000); client.ServerConnected = ServerConnected; client.ServerDisconnected = ServerDisconnected; client.MessageReceived = MessageReceived; client.Debug = false; client.Start(); client.Send(Encoding.UTF8.GetBytes(usernameIdentifier + splitCharacter + clientName)); bool runForever = true; while (runForever) { Console.WriteLine("Command [q cls send auth]: "); string userInput = Console.ReadLine(); if (string.IsNullOrEmpty(userInput)) { continue; } switch (userInput) { case "q": runForever = false; break; case "cls": Console.Clear(); break; case "send": Console.Write("Data: "); userInput = Console.ReadLine(); if (string.IsNullOrEmpty(userInput)) { break; } client.Send(Encoding.UTF8.GetBytes(messageIdentifier + splitCharacter + userInput)); break; case "auth": Console.Write("Preshared key: "); userInput = Console.ReadLine(); if (string.IsNullOrEmpty(userInput)) { break; } client.Authenticate(userInput); 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); InitializeClient(); bool runForever = true; Dictionary <object, object> metadata; bool success; while (runForever) { Console.Write("Command [? for help]: "); string userInput = Console.ReadLine(); byte[] data = null; MemoryStream ms = null; 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(" send send message to server"); Console.WriteLine(" send md send message with metadata to server"); Console.WriteLine(" sendasync send message to server asynchronously"); Console.WriteLine(" sendasync md send message with metadata to server asynchronously"); Console.WriteLine(" status show if client connected"); Console.WriteLine(" dispose dispose of the connection"); Console.WriteLine(" connect connect to the server if not connected"); Console.WriteLine(" reconnect disconnect if connected, then reconnect"); Console.WriteLine(" psk set the preshared key"); Console.WriteLine(" auth authenticate using the preshared key"); Console.WriteLine(" debug enable/disable debug (currently " + client.DebugMessages + ")"); break; case "q": runForever = false; break; case "cls": Console.Clear(); break; case "send": Console.Write("Data: "); userInput = Console.ReadLine(); if (String.IsNullOrEmpty(userInput)) { break; } data = Encoding.UTF8.GetBytes(userInput); ms = new MemoryStream(data); success = client.Send(data.Length, ms); Console.WriteLine(success); break; case "send md": metadata = InputDictionary(); Console.Write("Data: "); userInput = Console.ReadLine(); if (String.IsNullOrEmpty(userInput)) { break; } data = Encoding.UTF8.GetBytes(userInput); ms = new MemoryStream(data); success = client.Send(metadata, data.Length, ms); Console.WriteLine(success); break; case "sendasync": Console.Write("Data: "); userInput = Console.ReadLine(); if (String.IsNullOrEmpty(userInput)) { break; } data = Encoding.UTF8.GetBytes(userInput); ms = new MemoryStream(data); success = client.SendAsync(data.Length, ms).Result; Console.WriteLine(success); break; case "sendasync md": metadata = InputDictionary(); Console.Write("Data: "); userInput = Console.ReadLine(); if (String.IsNullOrEmpty(userInput)) { break; } data = Encoding.UTF8.GetBytes(userInput); ms = new MemoryStream(data); success = client.SendAsync(metadata, data.Length, ms).Result; Console.WriteLine(success); break; case "status": if (client == null) { Console.WriteLine("Connected: False (null)"); } else { Console.WriteLine("Connected: " + client.Connected); } break; case "dispose": client.Dispose(); break; case "connect": if (client != null && client.Connected) { Console.WriteLine("Already connected"); } else { client = new WatsonTcpClient(serverIp, serverPort); client.ServerConnected += ServerConnected; client.ServerDisconnected += ServerDisconnected; client.StreamReceived += StreamReceived; client.Start(); } break; case "reconnect": if (client != null) { client.Dispose(); } client = new WatsonTcpClient(serverIp, serverPort); client.ServerConnected += ServerConnected; client.ServerDisconnected += ServerDisconnected; client.StreamReceived += StreamReceived; client.Start(); break; case "psk": presharedKey = InputString("Preshared key:", "1234567812345678", false); break; case "auth": client.Authenticate(presharedKey); break; case "debug": client.DebugMessages = !client.DebugMessages; Console.WriteLine("Debug set to: " + client.DebugMessages); break; default: break; } } }