| public BeginAccept ( AsyncCallback callback, object state ) : IAsyncResult | ||
| callback | AsyncCallback | |
| state | object | |
| return | IAsyncResult | |
public Listener(IPEndPoint ipep)
{
m_Accepted = new Queue<Socket>();
m_AcceptedSyncRoot = ((ICollection)m_Accepted).SyncRoot;
m_Listener = Bind(ipep);
if (m_Listener == null)
{
return;
}
DisplayListener();
#if NewAsyncSockets
m_EventArgs = new SocketAsyncEventArgs();
m_EventArgs.Completed += new EventHandler<SocketAsyncEventArgs>( Accept_Completion );
Accept_Start();
#else
m_OnAccept = OnAccept;
try
{
IAsyncResult res = m_Listener.BeginAccept(m_OnAccept, m_Listener);
}
catch (SocketException ex)
{
NetState.TraceException(ex);
}
catch (ObjectDisposedException)
{ }
#endif
}
private void SetUpServer(int countReintentos = 0)
{
try
{
if (ListenerSocker == null)
{
return;
}
ListenerSocker.Bind(new IPEndPoint(IPAddress.Any, port));
ListenerSocker.Listen(0x7FFFFFFF);
ListenerSocker.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
catch (Exception e)
{
Log.Log.GetLog().Error(this, "SetUpServer", e);
Thread.Sleep(5000);
if (countReintentos > 10)
{
Log.Log.GetLog().Info(this, "Fin Reintentos - SetUpServer - " + countReintentos);
return;
}
Log.Log.GetLog().Info(this, "Reintentando - SetUpServer - " + countReintentos);
SetUpServer(countReintentos + 1);
}
}
//Main
static void Main(string[] args)
{
ILog log = LogManager.GetLogger(typeof(Program)); //Added
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
svrSkt = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
svrSkt.Bind(new IPEndPoint(IPAddress.Any, 2050));
svrSkt.Listen(0xff);
svrSkt.BeginAccept(Listen, null);
Console.CancelKeyPress += (sender, e) =>
{
Console.WriteLine("Saving Please Wait...");
svrSkt.Close();
foreach (var i in RealmManager.Clients.Values.ToArray())
{
i.Save();
i.Disconnect();
}
Console.WriteLine("\nClosing...");
Thread.Sleep(100);
Environment.Exit(0);
};
Console.ForegroundColor = ConsoleColor.Green;
Console.Title = "Server Engine";
Console.WriteLine("Accepting connections at port " + port + ".");
HostPolicyServer();
RealmManager.CoreTickLoop();
}
internal MusSocket(String _musIp, int _musPort, String[] _allowedIps, int backlog)
{
musIp = _musIp;
musPort = _musPort;
allowedIps = new HashSet<String>();
foreach (String ip in _allowedIps)
{
allowedIps.Add(ip);
}
try
{
msSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
msSocket.Bind(new IPEndPoint(IPAddress.Any, musPort));
msSocket.Listen(backlog);
msSocket.BeginAccept(OnEvent_NewConnection, msSocket);
Logging.WriteLine("MUS socket -> READY!", ConsoleColor.Green);
}
catch (Exception e)
{
throw new ArgumentException("Could not set up MUS socket:\n" + e.ToString());
}
}
// (1) Establish The Server
public string Start_A_Server_On(int Port)
{
try
{
IPAddress[] AddressAr = null;
String ServerHostName = "";
try
{
ServerHostName = Dns.GetHostName();
IPHostEntry ipEntry = Dns.GetHostByName(ServerHostName);
AddressAr = ipEntry.AddressList;
}
catch (Exception) { }
if (AddressAr == null || AddressAr.Length < 1)
{
return "Unable to get local address ... Error";
}
Listener_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Listener_Socket.Bind(new IPEndPoint(AddressAr[0], Port));
Listener_Socket.Listen(-1);
Listener_Socket.BeginAccept(new AsyncCallback(EndAccept), Listener_Socket);
return ("Listening On " + AddressAr[0].ToString() + ":" + Port + "... OK");
}
catch (Exception ex) { return ex.Message; }
}
public void ConnectMaster()
{
if (c_Connected && c_Server)
return;
try
{
c_Server = true;
//Console.WriteLine("CM Close Slave");
CloseSlave();
c_Master = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
c_Master.Bind(new IPEndPoint(IPAddress.Any, Data.MultiPort));
c_Master.Listen(4);
c_Master.BeginAccept(new AsyncCallback(OnClientConnect), null);
//Console.WriteLine("Started");
c_Connecting = false;
c_Connected = true;
}
catch (Exception /*e*/)// I HID e to stop warning message.
{
c_Server = false;
//Console.WriteLine(e.Message);
//Console.WriteLine(e.StackTrace);
}
}
private void Form1_Load(object sender, EventArgs e)
{
try
{
//We are using TCP sockets
serverSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
//Assign the any IP of the machine and listen on port number 1000
IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, 1000);
//Bind and listen on the given address
serverSocket.Bind(ipEndPoint);
serverSocket.Listen(4);
//Accept the incoming clients
serverSocket.BeginAccept(new AsyncCallback(OnAccept), null);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SGSserverTCP",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void OnClientConnect(IAsyncResult AcceptAsync)
{
try
{
Socket Sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Sock = ListenerSock.EndAccept(AcceptAsync);
Server ServerSock = new Server(Sock);
//RaiseEvent if event is linked
if (Connected != null)
{
Connected(ServerSock);
}
}
catch
{
}
finally
{
ListenerSock.Dispose();
ListenerSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress hostIP = (Dns.Resolve(IPAddress.Any.ToString())).AddressList[0];
ListenerSock.Bind(new IPEndPoint(hostIP, m_Port));
ListenerSock.Listen(0);
ListenerSock.BeginAccept(new AsyncCallback(OnClientConnect), null);
}
}
public static void OnClientConnect(IAsyncResult asyn)
{
try
{
System.Net.Sockets.Socket workerSocket = m_mainSocket.EndAccept(asyn);
Interlocked.Increment(ref m_clientCount);
m_workerSocketList.Add(workerSocket);
WaitForData(workerSocket, m_clientCount);
string msg = "Client " + m_clientCount + " Connected" + "\n";
if (OutputClientChanged != null)
{
OutputClientChanged(null, msg);
}
m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
}
catch (ObjectDisposedException)
{
System.Diagnostics.Debugger.Log(0, "1", "\n OnClientConnection: Socket has been closed\n");
}
catch (SocketException se)
{
Console.WriteLine(se.Message);
}
}
public void StartServer()
{
try
{
//creez un soclu
listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//se creeza un endpoint pentru server
IPEndPoint ipLocal = new IPEndPoint(IPAddress.Parse(IP), 8888);
//setez endpoint-ul creat
listener.Bind(ipLocal);
//soclul trece in starea de ascultare;coada de asteptare este de 4 clienti
listener.Listen(4);
list = new ArrayList(4);
//incep ascultarea neblocanta a conexiunilor
//orice incercare de conectare va fi tratata de metoda OnClientConnect
listener.BeginAccept(new AsyncCallback(OnClientConnect), null);
//creez delegatul pentru afisarea mesajelor
DelegateShowText = new Action<string, Socket>(ShowText);
//atashez un handler pt schimbarea textului
rt.TextChanged += new System.EventHandler(textChanged);
DelegateSendText = new Action<Socket>(SendText);
}
catch (SocketException se)
{
MessageBox.Show(se.Message);
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello from Console C# Classic HTTP Server");
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
Socket listener = new Socket(SocketType.Stream, ProtocolType.Tcp);
listener.Bind(localEndPoint);
listener.Listen(100);
Console.ReadLine();
while (true)
{
// Set the event to nonsignaled state.
//allDone.Reset();
// Start an asynchronous socket to listen for connections and receive data from the client.
Console.WriteLine("Waiting for a connection...");
// Accept the connection and receive the first 10 bytes of data.
int receivedDataSize = 10;
listener.BeginAccept(receivedDataSize, new AsyncCallback(AcceptReceiveCallback), listener);
// Wait until a connection is made and processed before continuing.
//allDone.WaitOne();
}
}
/// <summary>
/// Create 2 sockets connected to each other, for communication between threads.
/// </summary>
public static Socket[] SocketPair()
{
Socket Listener;
Socket[] Pair = new Socket[2];
// Start the listener side.
IPEndPoint endPoint = new IPEndPoint(IPAddress.Loopback, 0);
Listener = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
Listener.Bind(endPoint);
Listener.Listen(1);
IAsyncResult ServerResult = Listener.BeginAccept(null, null);
// Connect the client to the server.
endPoint = new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)Listener.LocalEndPoint).Port);
Pair[0] = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
IAsyncResult ClientResult = Pair[0].BeginConnect(endPoint, null, null);
// Get the server side socket.
Pair[1] = Listener.EndAccept(ServerResult);
Pair[0].EndConnect(ClientResult);
Listener.Close();
Pair[0].Blocking = false;
Pair[1].Blocking = false;
return Pair;
}
public void StartListen(int port)
{
IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, port);
m_socket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
//bind to local IP Address...
//if ip address is allready being used write to log
try
{
m_socket.Bind(ipLocal);
}
catch(Exception ex)
{
Debug.Fail(ex.ToString(),
string.Format("Can't connect to port {0}!", port));
return;
}
//start listening...
m_socket.Listen(4);
// create the call back for any client connections...
m_socket.BeginAccept(new AsyncCallback(OnClientConnection), null);
}
public static void Main(string[] args)
{
Console.Out.WriteLine("This is the server");
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, listenPort);
Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
while (true)
{
acceptDone.Reset();
Console.Out.WriteLine("Listening on port {0}", listenPort);
listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
acceptDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Listens this instance.
/// </summary>
public void Listen()
{
Listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
Listener.Bind(EndPoint);
Listener.Listen(100);
while (true)
{
// Make the work signal nonsignaled
Done.Reset();
Listener.BeginAccept(AcceptCallback, Listener);
// Wait until we get a connection
Done.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void Bind()
{
try
{
// Load IP/Port settings
if (Settings.Default.IP == "Any")
_address = IPAddress.Any;
else
_address = IPAddress.Parse(Settings.Default.IP);
_port = Settings.Default.Port;
// If the listener isn't null, close before rebinding
if (_listener != null)
_listener.Close();
// Bind to the listening port
_listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listener.Bind(new IPEndPoint(_address, _port));
_listener.Listen(10);
_listener.BeginAccept(new AsyncCallback(OnClientAccept), null);
Logger.Write("Server Ready - Listening for new connections " + _address + ":" + _port + "...");
}
catch (Exception ex)
{
Logger.WriteError("Exception thrown in Server.Start()", ex);
throw;
}
}
private void StartListening()
{
_ListenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_ListenSocket.Bind(new IPEndPoint(IPAddress.Any, _ListenPort));
_ListenSocket.Listen(10);
_ListenSocket.BeginAccept(AcceptCallback, null);
}
public static string StartListen(string IPadress, string portStr)
{
try
{
IPAddress ipAddress = IPAddress.Parse(IPadress);
int port = System.Convert.ToInt32(portStr);
m_mainSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ipLocal = new IPEndPoint(ipAddress, port); //(IPAddress.Any, port);
m_mainSocket.Bind(ipLocal);
m_mainSocket.Listen(4);
m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
isRunning = true;
return(ipLocal.ToString());
}
catch (SocketException se)
{
Console.WriteLine(se.Message);
return(null);
}
}
public static void beginListening()
{
listenS = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenS.Bind(new IPEndPoint(IPAddress.Any, PORT));
listenS.Listen(4);
listenS.BeginAccept(new AsyncCallback(OnCallAccept), null);
}
public bool Host(int port)
{
//Dev View
//Console.WriteLine("Hosting on port " + port);
m_vServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
m_vServerSocket.Bind(new IPEndPoint(IPAddress.Any, port));
m_vServerSocket.Listen(kHostConnectionBacklog);
m_vServerSocket.BeginAccept(new System.AsyncCallback(OnClientConnect), m_vServerSocket);
}
catch (System.Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Exception when attempting to host (" + port + "): " + e);
Console.ResetColor();
m_vServerSocket = null;
return false;
}
return true;
}
/// <summary>
/// 启动服务，打开TCP监听端口
/// </summary>
public void Start()
{
tcpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
// Create a TCP/IP socket.
tcpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
IPEndPoint localEndPoint = null;
//Listen Connection from All IP
localEndPoint = new IPEndPoint(IPAddress.Any, config.LocalPort);
// Bind the socket to the local endpoint and listen for incoming connections.
tcpSocket.Bind(localEndPoint);
tcpSocket.Listen(1024);
// Upload an asynchronous socket to listen for connections.
Logging.Info("ServiceHost started");
tcpSocket.BeginAccept(AcceptCallback, tcpSocket);
}
catch (SocketException ex)
{
Logging.LogUsefulException(ex);
tcpSocket.Close();
throw;
}
}
public static void StartServer()
{
IPAddress ip = IPAddress.Parse("127.0.0.1");
serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
serverSocket.Bind(new IPEndPoint(ip, myProt)); //绑定IP地址：端口
serverSocket.Listen(10); //设定最多10个排队连接请求
Console.WriteLine("启动监听{0}成功\n", serverSocket.LocalEndPoint.ToString());
while (true)
{
allDone.Reset();
serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), serverSocket);
allDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
//通过Clientsoket发送数据
//Thread myThread = new Thread(ListenClientConnect);
//myThread.Start();
Console.ReadLine();
}
private void _acceptConnection()
{
Core.EventLoop.Instance.Push(() =>
{
nativeSocket.BeginAccept(_static_endAccept, this);
});
}
static void Main(string[] args)
{
try
{
svrSkt = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
svrSkt.Bind(new IPEndPoint(IPAddress.Any, 2050));
svrSkt.Listen(0xff);
svrSkt.BeginAccept(Listen, null);
Console.CancelKeyPress += (sender, e) =>
{
Console.WriteLine("Terminating...");
svrSkt.Close();
foreach (var i in RealmManager.Clients.Values.ToArray())
i.Disconnect();
Environment.Exit(0);
};
Console.WriteLine("Listening at port 2050...");
HostPolicyServer();
RealmManager.CoreTickLoop(); //Never returns
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.ToString());
Console.ReadLine();
}
}
private void Accept(IAsyncResult Ar)
{
try
{
var socket = m_Socket.EndAccept(Ar);
lock (Acctpe)
{
Acctpe(new Peer(socket));
}
m_Socket.BeginAccept(Accept, state: null);
}
catch (SocketException se)
{
Singleton <Log> .Instance.WriteInfo(se.ToString());
}
catch (ObjectDisposedException ode)
{
Singleton <Log> .Instance.WriteInfo(ode.ToString());
}
catch (InvalidOperationException ioe)
{
Singleton <Log> .Instance.WriteInfo(ioe.ToString());
}
catch (Exception e)
{
Singleton <Log> .Instance.WriteInfo(e.ToString());
}
}
private static void Main(string[] args)
{
//init
IsRunning = false;
LastTime = 0;
CurrentTime = 0;
Connections = new List<Connection>(Config.MaxPlayers);
DisconnectedConnections = new List<Connection>(Config.MaxPlayers);
try
{
//maakt ipendpoint voor server listening
//luistert naar
var ip = IPAddress.Parse("0.0.0.0");
var iPEndPoint = new IPEndPoint(ip, Config.ServerPort);
_serverListenerSocket = new Socket(iPEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_serverListenerSocket.Bind(iPEndPoint);
_serverListenerSocket.Listen(25);
_serverListenerSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverListenerSocket);
IsRunning = true;
Debugging.WriteLine($"--[{Config.ServerName} started on port {Config.ServerPort}]--", ConsoleColor.Red);
//start de game update thread.
new Thread(new ThreadStart(GameThread)).Start();
}
catch (SocketException ioe)
{
Debugging.WriteLine($"Error: {ioe.Message}", ConsoleColor.Red);
IsRunning = false;
}
}
public void Start()
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(new IPEndPoint(IPAddress.Loopback, this.ListenPort));
socket.Listen(10);
socket.BeginAccept(OnAccept, null);
}
private void start_listening()
{
try
{
if (m_logPath != null)
File.Delete(m_logPath);
// Create the listening socket...
m_mainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, PORT);
// Bind to local IP Address...
m_mainSocket.Bind(ipLocal);
// Start listening...
m_mainSocket.Listen(1000);
// Create the call back for any client connections...
m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
// m_mainSocket.BeginAccept(new AsyncCallback(AcceptCallback), m_mainSocket);
}
catch (Exception se)
{
Environment.Exit(0);
}
}
public Tracker(string configfile)
{
Configuration = new TrackerConfig(configfile);
Logger.Active = Configuration.Log;
peers = new Dictionary<int, Peer>();
rooms = new Dictionary<string, Room>();
// Listening on socket
IPAddress ipAddr = IPAddress.Parse(Configuration.IPAddress);
IPEndPoint ipEndPoint = new IPEndPoint(ipAddr, Configuration.Port);
SocketPermission permission = new SocketPermission(NetworkAccess.Accept, TransportType.Tcp, "", Configuration.Port);
permission.Demand();
try
{
listener = new Socket(ipAddr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
listener.Bind(ipEndPoint);
Console.WriteLine("Listening at IP " + ipEndPoint.Address + " and port " + ipEndPoint.Port + ".");
listener.Listen(Configuration.Backlog);
AsyncCallback aCallback = new AsyncCallback(AcceptCallback);
listener.BeginAccept(aCallback, listener);
}
catch (SocketException exc)
{
Logger.WriteLine(exc);
}
}
/// <summary>
/// Initializes the socket listener for MUS connections and starts listening.
/// </summary>
/// <param name="bindPort">The port where the socket listener should be bound to.</param>
/// <remarks></remarks>
internal static bool Init(int bindPort, string musHost)
{
_Port = bindPort;
_musHost = musHost;
socketHandler = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Out.WriteLine("Starting up asynchronous socket server for MUS connections for port " + bindPort + "...");
try
{
socketHandler.Bind(new IPEndPoint(IPAddress.Any, bindPort));
socketHandler.Listen(25);
socketHandler.BeginAccept(new AsyncCallback(connectionRequest), socketHandler);
Out.WriteLine("Asynchronous socket server for MUS connections running on port " + bindPort);
Out.WriteLine("Listening for MUS connections from " + musHost);
return true;
}
catch
{
Out.WriteError("Error while setting up asynchronous socket server for MUS connections on port " + bindPort);
Out.WriteError("Port " + bindPort + " could be invalid or in use already.");
return false;
}
}
public void Start(IPAddress address, int?port)
{
var localEndPoint = new IPEndPoint(address, port.HasValue ? port.Value : DEFAULT_PORT);
_socket = new System.Net.Sockets.Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
_socket.Bind(localEndPoint);
_socket.Listen(BACKLOG);
Console.WriteLine("Server started. Listening to TCP clients at {0}:{1}", address.ToString(), localEndPoint.Port);
while (true)
{
_event.Reset();
_socket.BeginAccept(new AsyncCallback(AcceptCallback), this);
Console.WriteLine("Waiting for a connection...");
_event.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
internal MusSocket(string musIp, int musPort, IEnumerable<string> allowedIps, int backlog)
{
MusIp = musIp;
MusPort = musPort;
AllowedIps = new HashSet<string>();
foreach (var item in allowedIps) AllowedIps.Add(item);
try
{
Out.WriteLine(
"Starting up asynchronous sockets server for MUS connections for port " +
musPort, "Server.AsyncSocketMusListener");
MsSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
MsSocket.Bind(new IPEndPoint(IPAddress.Any, MusPort));
MsSocket.Listen(backlog);
MsSocket.BeginAccept(OnEvent_NewConnection, MsSocket);
Out.WriteLine(
"Asynchronous sockets server for MUS connections running on port " +
musPort + Environment.NewLine,
"Server.AsyncSocketMusListener");
}
catch (Exception ex)
{
throw new ArgumentException($"No se pudo iniciar el Socket MUS:\n{ex}");
}
}
/// <summary>
/// Initializes the socket listener for game connections and starts listening.
/// </summary>
/// <param name="bindPort">The port where the socket listener should be bound to.</param>
/// <param name="maxConnections">The maximum amount of simultaneous connections.</param>
/// <remarks></remarks>
internal static bool Init(int bindPort, int maxConnections)
{
_Port = bindPort;
_maxConnections = maxConnections;
_activeConnections = new HashSet<int>();
socketHandler = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Out.WriteLine("Starting up asynchronous socket server for game connections for port " + bindPort + "...");
try
{
socketHandler.Bind(new IPEndPoint(IPAddress.Any, bindPort));
socketHandler.Listen(25);
socketHandler.BeginAccept(new AsyncCallback(connectionRequest), socketHandler);
Out.WriteLine("Asynchronous socket server for game connections running on port " + bindPort);
Out.WriteLine("Max simultaneous connections is " + maxConnections);
return true;
}
catch
{
Out.WriteError("Error while setting up asynchronous socket server for game connections on port " + bindPort);
Out.WriteError("Port " + bindPort + " could be invalid or in use already.");
return false;
}
}
private void button_gg_listen_Click(object sender, EventArgs e)
{
Globals.gamedata.GG_IP = textBox_gg_local_ip.Text;
Globals.gamedata.GG_Port = Util.GetInt32(textBox_gg_local_port.Text);
System.Net.IPAddress ipAd = System.Net.IPAddress.Parse(Globals.gamedata.GG_IP);
Globals.GG_Servermode = true;
try
{
// Create the listening socket...
m_mainSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ipLocal = new IPEndPoint(ipAd, Globals.gamedata.GG_Port);
// Bind to local IP Address...
m_mainSocket.Bind(ipLocal);
// Start listening...
m_mainSocket.Listen(4);
// Create the call back for any client connections...
m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
}
catch (SocketException se)
{
MessageBox.Show(se.Message);
}
button_gg_listen.Enabled = false;
Globals.l2net_home.Add_Text(String.Format("Gameguard server started on: {0}:{1}", Globals.gamedata.GG_IP, Globals.gamedata.GG_Port), Globals.Yellow, TextType.BOT);
this.Close();
}
public static void pre_listen()
{
System.Net.IPAddress ipAd = System.Net.IPAddress.Parse(Globals.gamedata.GG_IP);
Globals.GG_Servermode = true;
try
{
// Create the listening socket...
m_mainSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ipLocal = new IPEndPoint(ipAd, Globals.gamedata.GG_Port);
// Bind to local IP Address...
m_mainSocket.Bind(ipLocal);
// Start listening...
m_mainSocket.Listen(4);
// Create the call back for any client connections...
m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
}
catch (SocketException se)
{
MessageBox.Show(se.Message);
}
Globals.l2net_home.Add_Text(String.Format("Gameguard server started on: {0}:{1}", Globals.gamedata.GG_IP, Globals.gamedata.GG_Port), Globals.Yellow, TextType.BOT);
}
void OnNewClient(IAsyncResult _asyncResult)
{
System.Net.Sockets.Socket ClientSocket = ListenSocket.EndAccept(_asyncResult);
ListenSocket.BeginAccept(OnNewClient, null);
SetKeepAlive(ClientSocket, 1000 * 60, 1000);
var NewClient = new TelnetClient {
Socket = ClientSocket
};
if (Clients.ClientConnected(NewClient) == ClientAcceptanceStatus.Rejected)
{
NewClient.WasRejected = true;
ClientSocket.Close();
}
else
{
// We will handle all the echoing echoing echoing
//var echoCommand = new byte[]
//{
// (byte)TelnetControlCodes.IAC,
// (byte)TelnetControlCodes.Will, // TODO: Handle client response denying this request
// (byte)TelnetControlCodes.Echo,
// (byte)TelnetControlCodes.IAC,
// (byte)TelnetControlCodes.Dont,
// (byte)TelnetControlCodes.Echo,
//};
//ClientSocket.Send(echoCommand);
ClientSocket.BeginReceive(NewClient.Storage, 0, 1024, System.Net.Sockets.SocketFlags.Partial, OnData, NewClient);
Console.WriteLine("New telnet client: " + ClientSocket.RemoteEndPoint.ToString());
}
}
public static void StartListening(int port = 11001)
{
IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
IPAddress ipAddress = IPAddress.Parse(LocalSettings.ServerIP);
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
_allDone = new ManualResetEvent(false);
// Create a TCP/IP socket.
Socket listener = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Bind the socket to the local endpoint and listen for incoming connections.
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
while (true)
{
// Set the event to nonsignaled state.
_allDone.Reset();
// Start an asynchronous socket to listen for connections.
listener.BeginAccept(
AcceptCallback,
listener);
// Wait until a connection is made before continuing.
_allDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.WriteLine("\nPress ENTER to continue...");
Console.Read();
}
private void OnConnectRequest(IAsyncResult ar)
{
try
{
System.Net.Sockets.Socket listener = (System.Net.Sockets.Socket)ar.AsyncState;
NewConnection(listener.EndAccept(ar));
listener.BeginAccept(new AsyncCallback(OnConnectRequest), listener);
}
catch { }
}
void StartListeningSocket(IPAddress addr, int port)
{
socket = new System.Net.Sockets.Socket(addr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
socket.Bind(new IPEndPoint(addr, port));
socket.Listen(128);
socket.BeginAccept(AcceptCallback, null);
} catch {
}
}
public void Start(IPAddress address, int port)
{
Listener = new System.Net.Sockets.Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint = new IPEndPoint(address, port);
Listener.Bind(IPEndPoint);
Listener.Listen(100);
Listener.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
void IListenable.Bind(int Port)
{
m_Socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
m_Socket.NoDelay = true;
m_Socket.Bind(new IPEndPoint(IPAddress.Any, Port));
m_Socket.Listen(backlog: 5);
m_Socket.BeginAccept(Accept, state: null);
}
/// <summary>
/// Puts the socket in a listen state.
/// Waiting for connections
/// </summary>
/// <exception cref="Exception">Socket already bound or connected</exception>
public void Listen()
{
if (_socket.IsBound || _socket.Connected)
{
throw new Exception("Unable to listen. Socket already bound or connected.");
}
try
{
CreateEndPoint();
_socket.Bind(IpEndPoint);
_socket.Listen(40);
_socket.BeginAccept(OnAcceptCallback, _socket);
}
catch (Exception e)
{
throw new Exception("Couldn't start the socket (port: " + _port + ") in listening mode.\n" + e.Message);
}
}
//クライアントの接続待ちスタート
private static void StartAccept(System.Net.Sockets.Socket server)
{
while (true)
{
//接続要求待機を開始する
allDone.Reset();
server.BeginAccept(new System.AsyncCallback(AcceptCallback), server);
Console.WriteLine("Waiting for a connection...");
allDone.WaitOne();
}
}
private void OnClientConnect(IAsyncResult result)
{
xConnection conn = new xConnection();
try
{
//Finish accepting the connection
Socket s = (Socket)result.AsyncState;
conn = new xConnection();
conn.socket = s.EndAccept(result);
conn.buffer = new byte[_bufferSize];
lock (_sockets)
{
_sockets.Add(conn);
}
// if (ClientConnected != null)
// ClientConnected();
Console.WriteLine("[SRV] client connected");
//Queue recieving of data from the connection
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveData), conn);
//Queue the accept of the next incomming connection
_serverSocket.BeginAccept(new AsyncCallback(OnClientConnect), _serverSocket);
}
catch (Exception e)
{
if (conn.socket != null)
{
conn.socket.Close();
lock (_sockets)
{
_sockets.Remove(conn);
}
}
//Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
_serverSocket.BeginAccept(new AsyncCallback(OnClientConnect), _serverSocket);
}
}
void AcceptCallback(IAsyncResult ar)
{
try {
var sock = socket.EndAccept(ar);
loop.NonBlockInvoke(delegate {
acceptedCallback(new Socket(loop, sock));
});
socket.BeginAccept(AcceptCallback, null);
} catch {
}
}
void AcceptCallback(IAsyncResult ar)
{
try {
var sock = socket.EndAccept(ar);
Enqueue(delegate {
acceptedCallback(new Socket(Context, sock));
});
} catch {
}
socket.BeginAccept(AcceptCallback, null);
}
private void acceptCallback(IAsyncResult result)
{
xConnection conn = null; // new xConnection();
try {
//Finish accepting the connection
System.Net.Sockets.Socket s = (System.Net.Sockets.Socket)result.AsyncState;
conn = new xConnection();
conn.socket = s.EndAccept(result);
conn.buffer = new byte[_bufferSize];
conn.server = this;
lock (_sockets) {
_sockets.Add(conn);
}
//Queue recieving of data from the connection
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
//Queue the accept of the next incomming connection
_serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket);
} catch (SocketException) {
if (conn.socket != null)
{
conn.socket.Close();
lock (_sockets) {
_sockets.Remove(conn);
}
}
//Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
_serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket);
} catch (Exception) {
if (conn.socket != null)
{
conn.socket.Close();
lock (_sockets) {
_sockets.Remove(conn);
}
}
//Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
_serverSocket.BeginAccept(new AsyncCallback(acceptCallback), _serverSocket);
}
}
private void ListenCallback(IAsyncResult ar)
{
try {
System.Net.Sockets.Socket listener = ar.AsyncState as System.Net.Sockets.Socket;
if (listener == null)
{
//throw (new Exception("Listener Socket no longer exists"));
Exceptions.ErrorLogger.WriteToErrorLog(new Exception("Listener socket no longer exists"), "Listener socket no longer exists");
}
//CErrorLogger.WriteToErrorLog(new Exception("Listen callback hit"), "Listen callback hit");
System.Net.Sockets.Socket client = listener.EndAccept(ar);
if (listening != true)
{
listener.Close();
return;
}
int index = FindOpenIndex();
if (index == -1)
{
Exceptions.ErrorLogger.WriteToErrorLog(new Exception("Server Full"), "Server Full");
client.Close();
}
else
{
clients[index] = client;
connectionCallback(this, new ConnectionRecievedEventArgs(client.RemoteEndPoint, client, index));
DataAsyncState state = new DataAsyncState(bufferSize, client, index);
if (client.Connected)
{
client.BeginReceive(state.Data, 0, bufferSize, SocketFlags.None,
new AsyncCallback(RecieveCallback), state);
}
}
listener.BeginAccept(new AsyncCallback(ListenCallback), listener);
} catch (ObjectDisposedException ex) {
Exceptions.ErrorLogger.WriteToErrorLog(ex, "Disposed exception, server listener.");
serverSocket.BeginAccept(new AsyncCallback(ListenCallback), serverSocket);
return;
} catch (SocketException socketex) {
Exceptions.ErrorLogger.WriteToErrorLog(socketex, "Socket exception, server listener.");
RaiseError(socketex.Message, "", (SocketError)socketex.ErrorCode);
serverSocket.BeginAccept(new AsyncCallback(ListenCallback), serverSocket);
} catch (Exception ex) {
Exceptions.ErrorLogger.WriteToErrorLog(ex, "Normal exception, server listener.");
serverSocket.BeginAccept(new AsyncCallback(ListenCallback), serverSocket);
}
}
public void Listen()
{
ListenSocket = new System.Net.Sockets.Socket(
System.Net.Sockets.AddressFamily.InterNetwork,
System.Net.Sockets.SocketType.Stream,
System.Net.Sockets.ProtocolType.IP);
ListenSocket.Bind(new System.Net.IPEndPoint(0, Port));
ListenSocket.Listen(16);
ListenSocket.BeginAccept(OnNewClient, null);
Console.WriteLine("Listening on port " + Port);
}
internal void OnAcceptReceived(IAsyncResult ar)
{
System.Net.Sockets.Socket sman = (System.Net.Sockets.Socket)ar.AsyncState;
if (sman != null)
{
System.Net.Sockets.Socket newsocket = null;
try
{
newsocket = sman.EndAccept(ar);
}
catch (System.ObjectDisposedException e)
{
System.Diagnostics.Debug.WriteLine("Exception calling EndAccept {0}", e);
return;
}
catch (System.Exception eall)
{
System.Diagnostics.Debug.WriteLine("Exception calling EndAccept - continueing {0}", eall);
}
/// Start a new accept
try
{
sman.BeginAccept(AcceptCallback, sman);
}
catch (SocketException e3) /// winso
{
System.Diagnostics.Debug.WriteLine("Exception calling BeginAccept2 {0}", e3);
}
catch (ObjectDisposedException e4) // socket was closed
{
System.Diagnostics.Debug.WriteLine("Exception calling BeginAccept2 {0}", e4);
}
catch (System.Exception eall)
{
System.Diagnostics.Debug.WriteLine("Exception calling BeginAccept2 {0}", eall);
}
if (newsocket == null)
{
return;
}
System.Diagnostics.Debug.WriteLine("Accepted new socket {0}", newsocket.Handle);
if (OnNewConnection != null)
{
OnNewConnection(newsocket);
}
}
}
public void Start(EnumSessionType sessionType, int port, string moduleIdentifier = null)
{
_sessionType = sessionType;
_moduleIdentifier = moduleIdentifier;
//Setup Listener
var ipEndPoint = new IPEndPoint(IPAddress.Any, port);
_listenerSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listenerSocket.Bind(ipEndPoint);
_listenerSocket.Listen(10);
_listenerSocket.BeginAccept(OnNewConnection, this);
}
public void StartServer()
{
// IPHostEntry localhost = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
IPEndPoint serverEndPoint;
serverEndPoint = new IPEndPoint(IPAddress.Any, PORT);
_serverSocket = new Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_serverSocket.Bind(serverEndPoint);
_serverSocket.Listen(10);
_serverSocket.BeginAccept(new AsyncCallback(OnClientConnect), _serverSocket);
_authorizedClients = ClientUtil.GetClients();
Console.WriteLine("[SRV] server started");
}
/// <summary>
/// 启动监听的端口
/// </summary>
/// <param name="port">要监听的端口号</param>
/// <param name="localaddr">要绑定的ip地址</param>
/// <param name="reuseAddress">是否运行端口复用</param>
public virtual void Start(int port, IPAddress localaddr = null, bool reuseAddress = true)
{
var serverSocketEP = new IPEndPoint(localaddr ?? IPAddress.Any, port);
serverSocket = new Socket(serverSocketEP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
if (reuseAddress)
{
//serverSocket.ExclusiveAddressUse = true;
serverSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
}
serverSocket.Bind(serverSocketEP);
serverSocket.Listen(int.MaxValue);
serverSocket.BeginAccept(AcceptSocketCallback, serverSocket);
IsStart = true;
WriteLog($"服务启动，监听IP:{serverSocketEP.Address}，端口：{port}");
}
private void OnNewConnection(IAsyncResult asyncResult)
{
System.Net.Sockets.Socket client;
try
{
client = _listenerSocket.EndAccept(asyncResult);
} catch (ObjectDisposedException) {
// ignore, happens during shutdown
return;
}
client.NoDelay = true;
_listenerSocket.BeginAccept(OnNewConnection, this);
switch (_sessionType)
{
case EnumSessionType.Telnet:
{
_logger.Info($"Accepting incoming Telnet connection from {client.RemoteEndPoint}...");
var session = new TelnetSession(_host, _logger, client, _configuration, _textVariableService);
_host.AddSession(session);
session.Start();
break;
}
case EnumSessionType.Rlogin:
{
if (((IPEndPoint)client.RemoteEndPoint).Address.ToString() != _configuration.RloginRemoteIP)
{
_logger.Info(
$"Rejecting incoming Rlogin connection from unauthorized Remote Host: {client.RemoteEndPoint}");
client.Close();
return;
}
_logger.Info($"Accepting incoming Rlogin connection from {client.RemoteEndPoint}...");
var session = new RloginSession(_host, _logger, client, _channelDictionary, _configuration, _textVariableService, _moduleIdentifier);
_host.AddSession(session);
session.Start();
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
private void AcceptCallback(IAsyncResult ar)
{
System.Net.Sockets.Socket socket;
try
{
socket = _serverSocket.EndAccept(ar);
_clientSockets.Add(socket);
socket.BeginReceive(_buffer, 0, BufferSize, SocketFlags.None, ReceiveCallback, socket);
Console.WriteLine("Client connected: " + socket.RemoteEndPoint);
_serverSocket.BeginAccept(AcceptCallback, null);
}
catch (Exception e)
{
// Log.Error
}
}
/// <summary>
/// Setup the server
/// </summary>
public void SetupServer()
{
try
{
Console.WriteLine("Setting up server...");
_serverSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, _port));
_serverSocket.Listen(5);
_serverSocket.BeginAccept(AcceptCallback, null);
Console.WriteLine("Server setup complete");
Console.WriteLine("Listening on port: " + _port);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// Start accepting socket connections.
/// </summary>
private void StartAccept()
{
try
{
// Clear last error.
ClearLastError();
do
{
// Set the event to nonsignaled state.
_connAvailable.Reset();
// Do not allow any more clients
// if maximum is reached.
if (_clientCount < _maxNumClients)
{
// Set the event to nonsignaled state.
_connAccept.Reset();
// Create a new client connection handler for the current
// tcp client attempting to connect to the server. Creates
// a new channel from the client to the server.
_socket.BeginAccept(new AsyncCallback(CreateServerContext), _socket);
// Wait until a connection is made and processed before continuing.
_connAccept.WaitOne();
}
else
{
// Blocks the current thread until a
// connection becomes available.
_connAvailable.WaitOne();
}
} while (true);
}
catch (Exception ex)
{
// Stop listening.
StopListening();
SetLastError(ex);
// Trigger the stop listening event.
StopListeningEvent(ex);
}
}
public void OnClientConnect(IAsyncResult asyn)
{
try {
System.Net.Sockets.Socket workerSocket = mainSocket.EndAccept(asyn);
Interlocked.Increment(ref clientCount);
workerSocketList.Add(workerSocket);
// SendMsgToClient(msg, clientCount - 1);
UpdateClientList();
WaitForData(workerSocket, clientCount);
mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
} catch (ObjectDisposedException) {
Console.WriteLine("OnClientConnection: Socket has been closed\n");
} catch (SocketException se) {
Console.WriteLine(se.Message);
}
}
/// <summary>
/// 开启服务端socket监听
/// </summary>
public static void ServerSocketListing(SocketConnectConfig sktconfig)
{
DicSockectConnection.Clear();
_cancellationTocken = new CancellationTokenSource();
if (sktconfig == null)
{
sktconfig = new SocketConnectConfig()
{
ServerSocket = ServerSocketListenner
}
}
;
else if (sktconfig.ServerSocket == null)
{
sktconfig.ServerSocket = ServerSocketListenner;
}
Sktconfig = sktconfig;
try
{
if (SocketConnectionClient.SocketClient != null && SocketConnectionClient.SocketClient.Connected)
{
SocketConnectionClient.SocketClientConnection.Disconnect();
}
SocketConnectionClient.ClientSocketStarting(connection =>
{
ServerSocketClient = (SocketConnection)connection;
SendCurrentConnectionCount();
} //监听打开后，发送当前上位机的连接数目信息
);
ServerSocketListenner.IOControl(IOControlCode.KeepAliveValues, KeepAlive(1, Sktconfig.KeepAliveTime ?? 2 * 60 * 1000, Sktconfig.KeepAliveTime ?? 2 * 60 * 1000), null); //设置心跳检测
ServerSocketListenner.BeginAccept(AcceptCallback, sktconfig);
Task.Run(() => //解决主线程直接调用报错
{
ShowMsg($"socket server listening at {ServerSocketListenner.LocalEndPoint}...");
});
}
catch (SocketException se)
{
SocketException(ServerSocketListenner, se);
}
}
public void StartSocket()
{
int listeningPort = Utils.getUnusedPort(PORT_START, PORT_END);
// Establish the local endpoint for the socket.
// The DNS name of the computer
// running the listener is "IPv4"
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, listeningPort);
// Create a TCP/IP socket.
listener = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Bind the socket to the local endpoint and listen for incoming connections.
try
{
listener.Bind(localEndPoint);
listener.Listen(64); // max 64 listening ports
while (_isRunning)
{
// Set the event to nonsignaled state.
allDone.Reset();
// Start an asynchronous socket to listen for connections.
listener.BeginAccept(
new AsyncCallback(AcceptCallback),
listener);
// Wait until a connection is made before continuing.
allDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
listener.Close();
}
