/// <summary>
/// Creates a new instance of a <see cref="WebSocketNetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="listenerType">The listener type of client connection.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The number max of connected clients, the default value is 1000.</param>
public WebSocketNetworkListener(NetworkListenerType listenerType, ushort port, ClientConnectedHandler clientConnectedHandler,
MessageReceivedHandler messageReceivedHandler,
ClientDisconnectedHandler clientDisconnectedHandler,
ushort maxMessageBuffer) : base(port, clientConnectedHandler, messageReceivedHandler, clientDisconnectedHandler, maxMessageBuffer)
{
try
{
//var host = Dns.GetHostEntry(Dns.GetHostName());
//var hostIp = host.AddressList.FirstOrDefault(c => c.AddressFamily == AddressFamily.InterNetwork).ToString();
_listenerType = listenerType;
_httpListener = new HttpListener();
_httpListener.Prefixes.Add($"http://localhost:{port}/");
_httpListener.Prefixes.Add($"http://127.0.0.1:{port}/");
//_httpListener.Prefixes.Add($"http://{hostIp}:{port}/");
_httpListener.Start();
Console.WriteLine($"Starting the WebSocket network listener on port: {port}.");
WaitForConnections();
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpClientContextImp"/> class.
/// </summary>
/// <param name="secured">true if the connection is secured (SSL/TLS)</param>
/// <param name="remoteEndPoint">client that connected.</param>
/// <param name="requestHandler">delegate handling incoming requests.</param>
/// <param name="disconnectHandler">delegate being called when a client disconnectes</param>
/// <param name="stream">Stream used for communication</param>
/// <exception cref="SocketException">If beginreceive fails</exception>
/// <param name="writer">delegate used to write log entries</param>
/// <see cref="RequestReceivedHandler"/>
/// <see cref="ClientDisconnectedHandler"/>
public HttpClientContextImp(bool secured, IPEndPoint remoteEndPoint,
RequestReceivedHandler requestHandler,
ClientDisconnectedHandler disconnectHandler,
Stream stream, ILogWriter writer)
{
Check.Require(requestHandler, "requestHandler");
Check.Require(remoteEndPoint, "remoteEndPoint");
Check.Require(remoteEndPoint.Address, "remoteEndPoint.Address");
Check.Require(stream, "stream");
if (!stream.CanWrite || !stream.CanRead)
throw new ArgumentException("Stream must be writeable and readable.");
_remoteEndPoint = remoteEndPoint;
_log = writer ?? NullLogWriter.Instance;
_parser = new HttpRequestParser(OnRequestCompleted, null);
_secured = secured;
_requestHandler = requestHandler;
_disconnectHandler = disconnectHandler;
_stream = stream;
try
{
_stream.BeginRead(_buffer, 0, BUFFER_SIZE, OnReceive, null);
}
catch (IOException err)
{
_log.Write(this, LogPrio.Debug, err.ToString());
_stream = null;
_disconnectHandler(this, SocketError.ConnectionAborted);
}
}
/// <summary>
/// Creates a new instance of a <see cref="NetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The number max of connected clients, the default value is 1000.</param>
public NetworkListener(ushort port, ClientConnectedHandler clientConnectedHandler,
MessageReceivedHandler messageReceivedHandler,
ClientDisconnectedHandler clientDisconnectedHandler,
ushort maxMessageBuffer)
{
_clientConnectedHandler = clientConnectedHandler;
_messageReceivedHandler = messageReceivedHandler;
_clientDisconnectedHandler = clientDisconnectedHandler;
_maxMessageBuffer = maxMessageBuffer;
}
/// <summary>
/// Called when a client has been disconnected from the server.
/// </summary>
/// <param name="client">The client that has been disconnected.</param>
/// <param name="forced">Indicates if the client disconnection was forced</param>
protected virtual void OnClientDisconnected(IClient client, bool forced)
{
Info(client, Resources.ClientDisconnected);
ClientDisconnectedHandler handler = ClientDisconnected;
if (handler != null)
{
handler(client, forced);
}
}
/// <summary>
/// Called when a client has been disconnected from the server.
/// </summary>
/// <param name="client">The client that has been disconnected.</param>
/// <param name="forced">Indicates if the client disconnection was forced</param>
protected virtual void OnClientDisconnected(IClient client, bool forced)
{
this.Info(client, Cell_Core.ClientDisconnected);
ClientDisconnectedHandler clientDisconnected = this.ClientDisconnected;
if (clientDisconnected == null)
{
return;
}
clientDisconnected(client, forced);
}
/// <summary>
/// Creates a new instance of a <see cref="NetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
public NetworkListener(MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler)
{
try
{
_messageReceivedHandler = messageReceivedHandler;
_clientDisconnectedHandler = clientDisconnectedHandler;
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
/// <summary>
/// Called when a client has been disconnected from the server.
/// </summary>
/// <param name="client">The client that has been disconnected.</param>
/// <param name="forced">Indicates if the client disconnection was forced</param>
protected virtual void OnClientDisconnected(ClientBase client, bool forced)
{
client.Cleanup();
Info(client, Resources.Disconnected);
ClientDisconnectedHandler handler = ClientDisconnected;
if (handler != null)
{
handler(client, forced);
}
}
/// <summary>
/// 断开处理
/// </summary>
/// <param name="client"></param>
/// <param name="forced"></param>
protected virtual void OnClientDisconnected(IClient client, bool forced)
{
ClientDisconnectedHandler handler = ClientDisconnected;
if (handler != null)
{
handler(client, forced);
}
//if (DisConnected != null && client.TcpSocket != null)
//{
// DisConnected(this, new DataEventArgs<string, int>(string.Empty, client.TcpSocket.Handle.ToInt32()));
//}
client.Dispose();
}
/// <summary>
/// Creates a new instance of a <see cref="UDPClient"/>.
/// </summary>
/// <param name="id">The identifier number of connected client.</param>
/// <param name="socketClient">The tcp client from connected client.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The max length of message buffer.</param>
public UDPClient(ushort id, UdpNetworkListener socketClient, EndPoint remoteEndPoint, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler, ushort maxMessageBuffer)
{
try
{
_udpListener = socketClient;
_remoteEndPoint = remoteEndPoint;
_messageReceivedHandler = messageReceivedHandler;
_clientDisconnectedHandler = clientDisconnectedHandler;
Id = id;
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
/// <summary>
/// Creates a new instance of a <see cref="TcpNetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The number max of connected clients, the default value is 1000.</param>
public TcpNetworkListener(ushort port, ClientConnectedHandler clientConnectedHandler,
MessageReceivedHandler messageReceivedHandler,
ClientDisconnectedHandler clientDisconnectedHandler,
ushort maxMessageBuffer) : base(port, clientConnectedHandler, messageReceivedHandler, clientDisconnectedHandler, maxMessageBuffer)
{
try
{
_listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listener.Bind(new IPEndPoint(IPAddress.Any, port));
_listener.Listen(100);
_listener.BeginAccept(new AsyncCallback(OnAccept), null);
Console.WriteLine($"Starting the TCP network listener on port: {port}.");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
//Lets clossssssssse
public void Close()
{
if (isClosed)
{
//Eutils.WriteLine("Error socket is already closed:{0}", Eutils.MESSSAGE_TYPE.ERROR, ID);
return;
}
ClientDisconnectedHandler disEvent = disconnected;
if (disEvent != null)
{
disEvent(this);
}
if (socket != null)
{
socket.Close();//Close!
}
isClosed = true;
}
/// <summary>
/// Creates a new instance of a <see cref="TcpNetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The number max of connected clients, the default value is 1000.</param>
public UdpNetworkListener(ushort port, ClientConnectedHandler clientConnectedHandler,
MessageReceivedHandler messageReceivedHandler,
ClientDisconnectedHandler clientDisconnectedHandler,
ushort maxMessageBuffer) : base(port, clientConnectedHandler, messageReceivedHandler, clientDisconnectedHandler, maxMessageBuffer)
{
try
{
_kingUdpClients = new Dictionary <EndPoint, UDPClient>();
_listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
_listener.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), port));
EndPoint endPointFrom = new IPEndPoint(IPAddress.Any, 0);
byte[] array = new byte[_maxMessageBuffer];
_listener.BeginReceiveFrom(array, 0, _maxMessageBuffer, SocketFlags.None, ref endPointFrom, new AsyncCallback(ReceiveDataCallback), array);
Console.WriteLine($"Starting the UDP network listener on port: {port}.");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
/// <summary>
/// Creates a new instance of a <see cref="Client"/>.
/// </summary>
/// <param name="id">The identifier number of connected client.</param>
/// <param name="socketClient">The tcp client from connected client.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The max length of message buffer.</param>
public Client(ushort id, Socket socketClient, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler, ushort maxMessageBuffer)
{
try
{
_socketClient = socketClient;
_messageReceivedHandler = messageReceivedHandler;
_clientDisconnectedHandler = clientDisconnectedHandler;
_socketClient.ReceiveBufferSize = maxMessageBuffer;
_socketClient.SendBufferSize = maxMessageBuffer;
_buffer = new byte[maxMessageBuffer];
_stream = new NetworkStream(_socketClient);
Id = id;
//IpAddress = _socketClient.Client.RemoteEndPoint.ToString();
_stream.BeginRead(_buffer, 0, _socketClient.ReceiveBufferSize, ReceiveDataCallback, null);
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
/// <summary>
/// Creates a new instance of a <see cref="WSClient"/>.
/// </summary>
/// <param name="id">The identifier number of connected client.</param>
/// <param name="id">The identifier number of connected client.</param>
/// <param name="listenerType">The listener type of client connection.</param>
/// <param name="ws">The websocket connection.</param>
/// <param name="listenerContext">The websocket http listener context.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The max length of message buffer.</param>
public WSClient(ushort id, string remoteEndPoint, NetworkListenerType listenerType, WebSocket ws, HttpListenerContext listenerContext, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler, ushort maxMessageBuffer)
{
try
{
IpAddress = remoteEndPoint;
_webSocket = ws;
_listenerContext = listenerContext;
_listenerType = listenerType;
_buff = new ArraySegment <byte>(new byte[maxMessageBuffer]);
_messageReceivedHandler = messageReceivedHandler;
_clientDisconnectedHandler = clientDisconnectedHandler;
Id = id;
WaitConnection();
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
public void OnClientTimeout(ClientDisconnectedHandler handler)
{
_clientDisconnectedHandler = handler;
}
public void OnClientTimeout(ClientDisconnectedHandler handler)
{
_clientDisconnectedHandler = handler;
}
/// <summary>
/// Creates a new instance of a <see cref="TcpNetworkListener"/>.
/// </summary>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
public TcpNetworkListener(MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler)
: base(messageReceivedHandler, clientDisconnectedHandler)
{
}
public static NetworkListener CreateForType(NetworkListenerType listenerType, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler)
{
if (listenerType == NetworkListenerType.TCP)
{
return(new TcpNetworkListener(messageReceivedHandler, clientDisconnectedHandler));
}
return(new UdpNetworkListener(messageReceivedHandler, clientDisconnectedHandler));
}
