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;
}
