static void Main(string[] args) { Console.WriteLine(" ___ ___ ___ ___ ___ ___ ___ _______ ________ ________ _______ ________ ___ ___ _______ ________ "); Console.WriteLine(@"|\ \ / /|\ \ |\ \|\ \ / /|\ \|\ ___ \ |\ __ \ |\ ____\|\ ___ \ |\ __ \|\ \ / /|\ ___ \ |\ __ \ "); Console.WriteLine(@"\ \ \/ / | \ \\_\ \ \ \ / / | \ \ \ __/|\ \ \|\ \ \ \ \___|\ \ __/|\ \ \|\ \ \ \ / / | \ __/|\ \ \|\ \ "); Console.WriteLine(@" \ \ / / \ \______ \ \ \/ / / \ \ \ \ \_|/_\ \ _ _\ \ \_____ \ \ \_|/_\ \ _ _\ \ \/ / / \ \ \_|/_\ \ _ _\ "); Console.WriteLine(@" / \/ \|_____|\ \ \ / / \ \ \ \ \_|\ \ \ \\ \| \|____|\ \ \ \_|\ \ \ \\ \\ \ / / \ \ \_|\ \ \ \\ \| "); Console.WriteLine(@" / /\ \ \ \__\ \__/ / \ \__\ \_______\ \__\\ _\ ____\_\ \ \_______\ \__\\ _\\ \__/ / \ \_______\ \__\\ _\ "); Console.WriteLine(@"/__/ /\ __\ \|__|\|__|/ \|__|\|_______|\|__|\|__| |\_________\|_______|\|__|\|__|\|__|/ \|_______|\|__|\|__|"); Console.WriteLine(@"|__|/ \|__| \|_________| "); Task.Factory.StartNew(() => { Console.WriteLine(DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss") + "> Iniciando servidor"); serverUDP = new UDPListener("192.168.0.100", 7172, 1024, Server_OnAcceptHandler, Server_OnReceiveHandler); serverUDP.StartServer(); serverTCP = new TCPListener("192.168.0.100", 7171, 1024, Server_OnAcceptHandler, Server_OnReceiveHandler, Server_OnDisconnectHandler); serverTCP.StartServer(); Console.WriteLine(DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss") + "> Servidor iniciado"); }); while (Console.ReadLine() != "fim") { } ; }
public Dispatcher() { Console.Title = "Dispatcher"; UDPClient udpClient = new UDPClient(); if (udpClient.IsBroadcasterExists()) { Console.WriteLine("****** Диспетчер уже присутствует в сети. ******"); } else { //Console.WriteLine("****** Диспетчер запущен ******"); int tcpport = Convert.ToInt32(ConfigurationManager.AppSettings["dispatcherTCPport"].ToString()); tcpListener = new TCPListener(tcpport); tcpListener.onMessage += handleRequest; tcpListener.StartListen(); Console.WriteLine("TCP слушает по адресу " + tcpListener.Adress); UDPBroadcasterObj = new UDPBroadcaster(8555, "239.254.255.255"); UDPBroadcasterObj.Start(); ShowServers(); } }
static void Main(string[] args) { Console.WriteLine("Connectando com servidor"); TCPListener servertcp = new TCPListener("127.0.0.1", 7171, 1024, Server_OnReceiveHandler); servertcp.Connect(); UDPListener server = new UDPListener("192.168.0.100", 7172, 1024, Server_OnReceiveHandler); for (int i = 0; i < 10; i++) { using (ConWriter writer = new ConWriter(0)) { writer.Send("Teste envia UDP" + i); server.Send(writer); } } string texto = ""; while (texto != "fim") { texto = Console.ReadLine(); ConWriter writer1 = new ConWriter(1); writer1.Send(texto); Console.WriteLine("Tamanho do buffer: " + writer1._buffer.Length); server.Send(writer1); } }
//Method is used to accept incoming connection public void AcceptCallback(IAsyncResult result) { Connection connection = new Connection(); lock (locker) // establish only one connection at time { try { //we try to make a connection connection = new Connection(); connection.tcpClient = TCPListener.EndAcceptTcpClient(result); // Ending accepting the connection // Adding client to connections that are already established Connections.Add(connection); //Handshake based on WebSocket protocol confirmConnectionByHandshake(connection); } catch (ObjectDisposedException e) { Console.WriteLine(e.ToString()); // if anything went wrong } } try { //print that client has connected Console.WriteLine("Client connected: " + ((IPEndPoint)connection.tcpClient.Client.RemoteEndPoint).Address + ":" + ((IPEndPoint)connection.tcpClient.Client.RemoteEndPoint).Port); } catch (Exception) { ///... } try { // start of the async data reading that are being send via TCP protocol connection.tcpClient.GetStream().BeginRead(connection.buffer, 0, connection.buffer.Length, new AsyncCallback(ReadCallBack), connection); } catch (Exception) { try { // If connection is lost print information Console.WriteLine("Connection lost: " + ((IPEndPoint)connection.tcpClient. Client.RemoteEndPoint).Address + ":" + ((IPEndPoint)connection.tcpClient.Client.RemoteEndPoint).Port); //Delete information about the connection disconnect(((IPEndPoint)connection.tcpClient.Client.RemoteEndPoint)); } catch (Exception) { ///... } } // Start async method that waits for accepting another connection TCPListener.BeginAcceptTcpClient(new AsyncCallback(AcceptCallback), null); }
private void AsServer() { DisableBtn(); server = new TCPListener() { Port = 8009 }; server.AcceptCompleted += Server_AcceptCompleted; server.SendCompleted += Server_SendCompleted; server.ReceiveCompleted += Server_ReceiveCompleted; server.DisconnectCompleted += Server_DisconnectCompleted; server.Start(); var t = new Thread(() => { while (true) { Thread.Sleep(2000); int nowCount = server.Count; if (nowCount != lastCount) { AppendText($"客户端数量:{nowCount}"); lastCount = nowCount; } ; } }) { IsBackground = true }; t.Start(); }
private static void TCPConnectAsyncCallback(IAsyncResult asyncResult) { TcpClient client = TCPListener.EndAcceptTcpClient(asyncResult); TCPBeginAcceptClient(); Console.WriteLine($"\n\tServer: {ServerName}, user {client.Client.RemoteEndPoint} is trying to connect..."); for (int count = 1; count < MaxNumPlayers + 1; count++) { if (ClientDictionary[count].tCP.Socket == null) { ClientDictionary[count].tCP.Connect(client); Console.WriteLine($"\tServer: {ServerName}, sent welcome packet to: {count}"); ServerSend.Welcome(count, $"Welcome to {ServerName} server client: {count}", MapName); return; } } for (int count = 1; count < MaxNumPlayers + 1; count++) { if (NotConnectedClients[count].tCP.Socket == null) { NotConnectedClients[count].tCP.Connect(client); ServerSend.ServerIsFullPacket(count); Console.WriteLine($"\n\tThe server is full... {client.Client.RemoteEndPoint} couldn't connect..."); } } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, PedramDbContext dbContext, IServiceProvider serviceProvider) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); dbContext.Database.Migrate(); //this will generate the db if it does not exist } else { app.UseExceptionHandler("/Home/Error"); } app.UseStaticFiles(); app.UseAuthentication(); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); var listener = new TCPListener(9990, serviceProvider.GetService <PedramDbContext>()); listener.AcceptSocket(); var nths = new Thread(CheckMessages); nths.Start(serviceProvider); }
//Passive Mode Data Transfer Listner. private Socket PassiveClientSocket(ref TCPListener clientDataListner, int intPort) { Thread oThread = Thread.CurrentThread; lock (oThread) { try { if (clientDataListner.LocalEndpoint == null) { bool done = false; Socket s = null; try { s = clientDataListner.Accept(); done = true; } catch (Exception e) { } return(s); } else { Socket s = clientDataListner.Accept(); return(s); } } catch (Exception e) { Console.ClientConnect(ClientID, e.StackTrace); } return(null); } }
private void Run() { Thread ClientThread; FTPCommandListner = new TCPListener(21); FTPCommandListner.Start(); try { while (true) { ClientSocket = FTPCommandListner.Accept(); ClientThread = new Thread(new ThreadStart(FTPClientThread)); ClientIP = ClientSocket.RemoteEndpoint.ToString(); //Raise Event ClientID++; onMsgArrived(ClientID, ClientIP); Connected clientConnected = new Connected(Console.Connected); clientConnected(ClientThread, ClientIP); ClientThread.Start(); } } catch (ThreadInterruptedException e) { Thread.CurrentThread.Abort(); } catch (ThreadStopException e) { System.Console.WriteLine("Thread killed"); } }
private void server_Load(object sender, EventArgs e) { listener = new TCPListener(); listener.Port = 1314; listener.ReceiveCompleted += Listener_ReceiveCompleted; listener.Start(); }
/// <summary> /// Add new listener with message collector (character splitter). /// </summary> /// <param name="name">The listener's name.</param> /// <param name="ipAddress">The listener's IP address.</param> /// <param name="port">The listener's tcp port.</param> /// <param name="maxConnections">The number of maximum allowed connections.</param> /// <param name="readBufferSize">The read buffer size for each connection in bytes.</param> /// <param name="connectionTimeOut">The connections time-out in milliseconds. Set to 0 for no time-out.</param> /// <param name="backLog">The number of outstanding connection requests the listener can have.</param> /// <param name="splitter">The message splitter.</param> /// <returns>The listener.</returns> public TCPListener AddListener(string name, IPAddress ipAddress, int port, int maxConnections, int readBufferSize, int connectionTimeOut, int backLog, string splitter) { TCPListener listener = new TCPListener(name, ipAddress, port, maxConnections, readBufferSize, connectionTimeOut, backLog, splitter); listener.SetMyExtasysTCPServer(this); fListeners.Add(listener); return(listener); }
public RefServer() { int tcpPort = Convert.ToInt32(ConfigurationManager.AppSettings["refServerPort"].ToString()); tcpListener = new TCPListener(tcpPort); tcpListener.onMessage += TcpListener_onMessage; tcpListener.StartListen(); dc = new DispatcherClient(MetaData.Roles.server); dc.onFound += dispFound; dc.StartListen(); }
public bool StartServer() { try { Listener = new TCPListener(2211); Listener.SocketAccepted += new TCPListener.SocketAcceptedHandler(Listener_SocketAccepted); Listener.Start(); return(true); } catch (Exception ex) { return(false); } }
static void Main(string[] args) { StormLib.Console.Init(); Trace.Listeners.Add(new ConsoleTraceListener()); Trace.Listeners.Add(new StormLib.Diagnostics.ConsoleTraceListiner()); Trace.WriteLine("Hello World!"); //Load up the configuration file try { SLUM.lib.Config.ServerConfig.LoadConfig(); } catch (MissingResourceExecption ex) { Trace.WriteLine(string.Format("The server could not load the embedded resource. Please check following embedded resource: {0}", ex.Data["ResourceName"])); return; } catch (FileException ex) { Trace.WriteLine(string.Format("The server could not load or create the configuration file. More information: {0}", ex.InnerException.ToString())); return; } catch (InvalidOperationException ex) { Trace.WriteLine(string.Format("An unknown error occurred during deserialization. More information: {0}", ex.InnerException.ToString())); return; } if (SLUM.lib.Config.ServerConfig.Instance.MysqlUser == "{EDIT ME}" || SLUM.lib.Config.ServerConfig.Instance.MysqlPass == "{EDIT ME}") { Trace.WriteLine("Edit the LoginConfig.xml file"); // return; } if (SLUM.lib.Config.ServerConfig.Instance.AcceptAnyAddress) { Trace.WriteLine("Warning: This server is set to accept server connections from any IP address. ANY server with the secrets can connect."); } ModuleInfo.LoadModules(Assembly.GetExecutingAssembly(), true); TCPListener a = TCPListener.Instance; while (true) { Console.Write("$$>"); Console.WriteLine(StormLib.Console.ProcessLine(Console.ReadLine()).Value); } }
/// <summary> /// 创建监听器 /// </summary> /// <param name="id">监听器标识</param> /// <param name="recvsize">接受缓冲区大小</param> /// <param name="protoType">协议类型</param> /// <param name="certificate">安全证书</param> /// <param name="sessionCreateHandler">创建session的委托</param> /// <returns>监听器</returns> public IListener CreateListener(uint id, int recvsize, ProtoType protoType, X509Certificate2 certificate, SessionCreater sessionCreateHandler) { if (NetworkMgr.instance.ContainsListener(id)) { throw new System.Exception("session id already exists"); } IListener listener = null; switch (protoType) { case ProtoType.TCP: if (certificate != null) { TLSListener tlsListener; listener = tlsListener = new TLSListener(id); tlsListener.certificate = certificate; } else { listener = new TCPListener(id); } break; case ProtoType.WebSocket: if (certificate != null) { TLSListener tlsListener; listener = tlsListener = new TLSWSListener(id); tlsListener.certificate = certificate; } else { listener = new WSListener(id); } break; case ProtoType.KCP: listener = new KCPListener(id); break; } if (listener == null) { return(null); } listener.sessionCreater = sessionCreateHandler; listener.recvBufSize = recvsize; NetworkMgr.instance.AddListener(listener); return(listener); }
public WowwoWTelnet() { this._AllowedIPs = TelnetConfig.AllowedTelnetIPs; this._DisallowedIPs = TelnetConfig.DisallowedTelnetIPs; this._IPAddress = TelnetConfig.IPAddress; this._MaxConnections = TelnetConfig.MaxConnections; this._MinAccessLevel = TelnetConfig.MinimumAccessLevel; this._Port = TelnetConfig.TelnetPort; listener = new TCPListener(this._IPAddress, this._Port, this._MaxConnections); listener.BeginConnect += new Server.Konsole.Sockets.TCPListener.ConnectEventHandler(listener_BeginConnect); listener.BeginDisconnect += new Server.Konsole.Sockets.TCPListener.DisconnectEventHandler(listener_BeginDisconnect); listener.BeginRead += new Server.Konsole.Sockets.TCPListener.ReadEventHandler(listener_BeginRead); }
public ChatForm(int port) { InitializeComponent(); backgroundWorker1.WorkerReportsProgress = true; backgroundWorker1.WorkerSupportsCancellation = true; backgroundWorker1.DoWork += backgroundWorker1_DoWork; backgroundWorker1.ProgressChanged += backgroundWorker1_ProgressChanged; backgroundWorker1.RunWorkerCompleted += backgroundWorker1_RunWorkerCompleted; this.port = port; chatListener = new TCPListener(true); object[] portAndListenerAndReply = new object[] { port, chatListener, reply }; backgroundWorker1.RunWorkerAsync(portAndListenerAndReply); }
public bool Stop() { if (IsShuttingDown) { return(false); } try { UDPReciever.Close(); TCPListener.Stop(); IsShuttingDown = true; } catch { //??? } return(IsShuttingDown); }
public static void CloseServer() { try { TCPListener.Stop(); UDPClient.Close(); Console.WriteLine($"\tClosed Server: {ServerName}"); } catch (Exception exception) { Console.WriteLine($"\tError closing Server: {ServerName}...\n{exception}"); } if (MainServerComms.EstablishedConnection) { Environment.Exit(1); } }
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { BackgroundWorker worker = sender as BackgroundWorker; while (!backgroundWorker1.CancellationPending) { Int32 port = int.Parse(e.Argument.ToString()); worker.ReportProgress(0, "Stop listening"); tCPListener = new TCPListener(); var incomingConnections = tCPListener.Listen(port); foreach (string[] dataForUI in incomingConnections) { worker.ReportProgress(1, dataForUI); } } }
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { BackgroundWorker worker = sender as BackgroundWorker; while (!backgroundWorker1.CancellationPending) { object[] portAndListenerAndReply = e.Argument as object[]; Int32 port = int.Parse(portAndListenerAndReply[0].ToString()); chatListener = portAndListenerAndReply[1] as TCPListener; var incomingMessages = chatListener.Listen(port); foreach (string[] dataForUI in incomingMessages) { worker.ReportProgress(1, dataForUI); } } }
public void StartTest() { int port = 8001; TCPListener server = new TCPListener(); TCPClient client = new TCPClient(); server.Port = port; server.Start(); client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), port)); client.Send(Encoding.UTF8.GetBytes("Hello")); bool flag = false; server.ReceiveCompleted += (s, e) => { Debug.WriteLine(e.Data); flag = true; Assert.AreEqual(e.Data, "Hello"); }; while (!flag) { ; } }
/// <summary> /// Dispose /// </summary> public void Dispose() { if (TCPListener != null) { TCPListener.Stop(); TCPListener = null; } if (listenerThread != null) { listenerThread.Join(); listenerThread = null; } lock (serverConnections) { foreach (ServerConnection server_connection in serverConnections) { server_connection.Dispose(); } serverConnections.Clear(); } }
static void Main() { Application.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("en-US");//IMPORTANT Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Idle += new EventHandler(Application_Idle); Form1 window = new Form1(); //window.Show(); tray = window.notifyIcon1; TCPListener listener = new TCPListener(7331); Reload(); while (true) { Update(); System.Threading.Thread.Sleep(10); } //Application.Run(window); }
/// <summary> /// /// </summary> static void TcpDemo() { TCPListener listener = new TCPListener(); TCPClient client = new TCPClient("127.0.0.1"); listener.Start(); client.Start(); client.Send("Hello World"); for (int i = 0; i < 100; i++) { client.Send(getRandomCoords()); } Console.ReadKey(); client.Close(); listener.Close(); }
//Passive Data MODE private int PassiveModePort(ref TCPListener clientDataListner) { Thread oThread = Thread.CurrentThread; lock (oThread) { int intPort = 0; bool done = true; while (done) { intPort = Port(); try { if (clientDataListner != null) { clientDataListner.Stop(); } clientDataListner = new TCPListener(intPort); clientDataListner.Start(); //This Port is free done = false; } catch (Exception e) { //done=false; } } return(intPort); /* * strIPAddress = CStr(wscControl.LocalIP) * strSend = "PORT " & Replace(strIPAddress, ".", ",") * strSend = strSend & "," & intPort \ 256 & "," & (intPort Mod 256) * strSend = strSend & vbCrLf * wscControl.SendData strSend */ } }
public static void SetServerName(string newName, bool save = true) { if (string.IsNullOrWhiteSpace(newName)) { return; } int byteCount = Encoding.UTF8.GetByteCount(newName); if (byteCount > byte.MaxValue) { Logger.LogError("Server name is too long! Max 255 bytes. Has " + byteCount); return; } serverName = newName; TCPListener.UpdateStatusInfo(); Console.Title = serverName; if (save) { Save(); } Logger.Log("Server name is set to '{0}'", serverName); }
public static void SetDataLink(string newLink, bool save = true) { if (string.IsNullOrWhiteSpace(newLink)) { dataLink = null; } else { int byteCount = Encoding.UTF8.GetByteCount(newLink); if (byteCount > byte.MaxValue) { Logger.LogError("Data link is too long! Max 255 bytes! Has " + byteCount); return; } dataLink = newLink; } TCPListener.UpdateDownloadInfo(); if (save) { Save(); } Logger.Log("Data link is set to '{0}'", dataLink); }
static void SetPassword(byte[] newHash, bool save) { if (newHash == null || newHash.Length != 16) { password = null; Password = null; Network.GameServer.ServerInterface.SetIncomingPassword(default(string), 0); Logger.Log("Password removed."); } else { password = newHash; Password = new ReadOnlyCollection <byte>(password); string pwStr = Convert.ToBase64String(password); Network.GameServer.ServerInterface.SetIncomingPassword(pwStr, pwStr.Length); Logger.Log("Password is set."); } TCPListener.UpdateStatusInfo(); if (save) { Save(); } }
private static void TCPBeginAcceptClient() { TCPListener.BeginAcceptTcpClient(new AsyncCallback(TCPConnectAsyncCallback), null); }
public Server(ushort port) { Listener = new TCPListener(); Listener.AcceptCompleted += Listener_AcceptCompleted; Listener.Port = port; }