using System;
|
using System.Threading;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Net;
|
using System.Net.Sockets;
|
using System.Text;
|
using UnityEngine;
|
|
namespace TcpServer
|
{
|
public interface ProtoFilter
|
{
|
void input(byte[] data);
|
|
List<string> swap_msgs();
|
}
|
|
public class SimpleProtocolFilter : ProtoFilter
|
{
|
/* 简单协议过滤器
|
协议按照 [有效数据字节数][有效数据] 这种协议包的格式进行打包和解包
|
[有效数据字节数]长度HEADER_SIZE字节
|
[有效数据]长度有效数据字节数字节
|
本类按照这种方式，顺序从数据流中取出数据进行拼接，一旦接收完一个完整的协议包，就会将协议包返回
|
[有效数据]字段接收到后会按照utf-8进行解码，因为在传输过程中是用utf-8进行编码的
|
所有编解码的操作在该类中完成
|
*/
|
|
private byte[] buf = new byte[0];
|
private int HEADER_SIZE = 4;
|
private List<string> msgs = new List<string>();
|
|
public void input(byte[] data)
|
{
|
buf = Combine(buf, data);
|
|
while (buf.Length > HEADER_SIZE)
|
{
|
int data_size = BitConverter.ToInt32(buf, 0);
|
if (buf.Length >= data_size + HEADER_SIZE)
|
{
|
byte[] data_body = Slice(buf, HEADER_SIZE, data_size + HEADER_SIZE);
|
string content = System.Text.Encoding.Default.GetString(data_body);
|
msgs.Add(content);
|
buf = Slice(buf, data_size + HEADER_SIZE, buf.Length);
|
}
|
else
|
{
|
break;
|
}
|
}
|
}
|
|
public List<string> swap_msgs()
|
{
|
List<string> ret = msgs;
|
msgs = new List<string>();
|
return ret;
|
}
|
|
public byte[] pack(String content)
|
{
|
int len = content.Length;
|
byte[] size = BitConverter.GetBytes(len);
|
if (!BitConverter.IsLittleEndian)
|
{
|
//reverse it so we get little endian.
|
Array.Reverse(size);
|
}
|
byte[] body = System.Text.Encoding.Default.GetBytes(content);
|
byte[] ret = Combine(size, body);
|
return ret;
|
}
|
|
private static byte[] Combine(byte[] first, byte[] second)
|
{
|
byte[] ret = new byte[first.Length + second.Length];
|
Buffer.BlockCopy(first, 0, ret, 0, first.Length);
|
Buffer.BlockCopy(second, 0, ret, first.Length, second.Length);
|
return ret;
|
}
|
|
public byte[] Slice(byte[] source, int start, int end)
|
{
|
int length = end - start;
|
byte[] ret = new byte[length];
|
Array.Copy(source, start, ret, 0, length);
|
return ret;
|
}
|
}
|
|
|
/// <summary>
|
/// 异步TCP服务器
|
/// </summary>
|
public class AsyncTcpServer : IDisposable
|
{
|
#region Fields
|
|
private TcpListener _listener;
|
private ConcurrentDictionary<string, TcpClientState> _clients;
|
private bool _disposed = false;
|
|
#endregion
|
|
#region Ctors
|
|
/// <summary>
|
/// 异步TCP服务器
|
/// </summary>
|
/// <param name="listenPort">监听的端口</param>
|
public AsyncTcpServer(int listenPort)
|
: this(IPAddress.Any, listenPort)
|
{
|
}
|
|
/// <summary>
|
/// 异步TCP服务器
|
/// </summary>
|
/// <param name="localEP">监听的终结点</param>
|
public AsyncTcpServer(IPEndPoint localEP)
|
: this(localEP.Address, localEP.Port)
|
{
|
}
|
|
/// <summary>
|
/// 异步TCP服务器
|
/// </summary>
|
/// <param name="localIPAddress">监听的IP地址</param>
|
/// <param name="listenPort">监听的端口</param>
|
public AsyncTcpServer(IPAddress localIPAddress, int listenPort)
|
{
|
this.Address = localIPAddress;
|
this.Port = listenPort;
|
this.Encoding = Encoding.Default;
|
|
_clients = new ConcurrentDictionary<string, TcpClientState>();
|
|
_listener = new TcpListener(Address, Port);
|
// _listener.AllowNatTraversal(true);
|
}
|
|
#endregion
|
|
#region Properties
|
|
/// <summary>
|
/// 服务器是否正在运行
|
/// </summary>
|
public bool IsRunning { get; private set; }
|
|
/// <summary>
|
/// 监听的IP地址
|
/// </summary>
|
public IPAddress Address { get; private set; }
|
|
/// <summary>
|
/// 监听的端口
|
/// </summary>
|
public int Port { get; private set; }
|
|
/// <summary>
|
/// 通信使用的编码
|
/// </summary>
|
public Encoding Encoding { get; set; }
|
|
#endregion
|
|
#region Server
|
|
/// <summary>
|
/// 启动服务器
|
/// </summary>
|
/// <returns>异步TCP服务器</returns>
|
public AsyncTcpServer Start()
|
{
|
Debug.Log("start server");
|
return Start(10);
|
}
|
|
/// <summary>
|
/// 启动服务器
|
/// </summary>
|
/// <param name="backlog">服务器所允许的挂起连接序列的最大长度</param>
|
/// <returns>异步TCP服务器</returns>
|
public AsyncTcpServer Start(int backlog)
|
{
|
if (IsRunning)
|
return this;
|
|
IsRunning = true;
|
|
_listener.Start(backlog);
|
ContinueAcceptTcpClient(_listener);
|
|
return this;
|
}
|
|
/// <summary>
|
/// 停止服务器
|
/// </summary>
|
/// <returns>异步TCP服务器</returns>
|
public AsyncTcpServer Stop()
|
{
|
if (!IsRunning)
|
return this;
|
|
try
|
{
|
_listener.Stop();
|
|
foreach (var client in _clients.Values)
|
{
|
client.TcpClient.Client.Disconnect(false);
|
}
|
_clients.Clear();
|
}
|
catch (ObjectDisposedException ex)
|
{
|
Debug.LogException(ex);
|
}
|
catch (SocketException ex)
|
{
|
Debug.LogException(ex);
|
}
|
|
IsRunning = false;
|
|
return this;
|
}
|
|
private void ContinueAcceptTcpClient(TcpListener tcpListener)
|
{
|
try
|
{
|
tcpListener.BeginAcceptTcpClient(new AsyncCallback(HandleTcpClientAccepted), tcpListener);
|
}
|
catch (ObjectDisposedException ex)
|
{
|
Debug.LogException(ex);
|
}
|
catch (SocketException ex)
|
{
|
Debug.LogException(ex);
|
}
|
}
|
|
#endregion
|
|
#region Receive
|
|
private void HandleTcpClientAccepted(IAsyncResult ar)
|
{
|
if (!IsRunning)
|
return;
|
|
TcpListener tcpListener = (TcpListener)ar.AsyncState;
|
|
TcpClient tcpClient = tcpListener.EndAcceptTcpClient(ar);
|
if (!tcpClient.Connected)
|
return;
|
|
byte[] buffer = new byte[tcpClient.ReceiveBufferSize];
|
SimpleProtocolFilter prot = new SimpleProtocolFilter();
|
TcpClientState internalClient = new TcpClientState(tcpClient, buffer, prot);
|
|
// add client connection to cache
|
string tcpClientKey = internalClient.TcpClient.Client.RemoteEndPoint.ToString();
|
_clients.AddOrUpdate(tcpClientKey, internalClient, (n, o) =>
|
{
|
return internalClient;
|
});
|
RaiseClientConnected(tcpClient);
|
|
// begin to read data
|
NetworkStream networkStream = internalClient.NetworkStream;
|
ContinueReadBuffer(internalClient, networkStream);
|
|
// keep listening to accept next connection
|
ContinueAcceptTcpClient(tcpListener);
|
}
|
|
private void HandleDatagramReceived(IAsyncResult ar)
|
{
|
if (!IsRunning)
|
return;
|
|
try
|
{
|
TcpClientState internalClient = (TcpClientState)ar.AsyncState;
|
if (!internalClient.TcpClient.Connected)
|
return;
|
|
NetworkStream networkStream = internalClient.NetworkStream;
|
|
int numberOfReadBytes = 0;
|
try
|
{
|
// if the remote host has shutdown its connection,
|
// read will immediately return with zero bytes.
|
numberOfReadBytes = networkStream.EndRead(ar);
|
}
|
catch (Exception ex)
|
{
|
Debug.LogException(ex);
|
numberOfReadBytes = 0;
|
}
|
|
if (numberOfReadBytes == 0)
|
{
|
// connection has been closed
|
TcpClientState internalClientToBeThrowAway;
|
string tcpClientKey = internalClient.TcpClient.Client.RemoteEndPoint.ToString();
|
_clients.TryRemove(tcpClientKey, out internalClientToBeThrowAway);
|
RaiseClientDisconnected(internalClient.TcpClient);
|
return;
|
}
|
|
// received byte and trigger event notification
|
var receivedBytes = new byte[numberOfReadBytes];
|
Array.Copy(internalClient.Buffer, 0, receivedBytes, 0, numberOfReadBytes);
|
// input bytes into protofilter
|
internalClient.Prot.input(receivedBytes);
|
RaiseDatagramReceived(internalClient, receivedBytes);
|
// RaisePlaintextReceived(internalClient.TcpClient, receivedBytes);
|
|
// continue listening for tcp datagram packets
|
ContinueReadBuffer(internalClient, networkStream);
|
}
|
catch (InvalidOperationException ex)
|
{
|
Debug.LogException(ex);
|
}
|
}
|
|
private void ContinueReadBuffer(TcpClientState internalClient, NetworkStream networkStream)
|
{
|
try
|
{
|
networkStream.BeginRead(internalClient.Buffer, 0, internalClient.Buffer.Length, HandleDatagramReceived, internalClient);
|
}
|
catch (ObjectDisposedException ex)
|
{
|
Debug.LogException(ex);
|
}
|
}
|
|
#endregion
|
|
#region Events
|
|
/// <summary>
|
/// 接收到数据报文事件
|
/// </summary>
|
public event EventHandler<TcpDatagramReceivedEventArgs<byte[]>> DatagramReceived;
|
/// <summary>
|
/// 接收到数据报文明文事件
|
/// </summary>
|
public event EventHandler<TcpDatagramReceivedEventArgs<string>> PlaintextReceived;
|
|
private void RaiseDatagramReceived(TcpClientState sender, byte[] datagram)
|
{
|
if (DatagramReceived != null)
|
{
|
DatagramReceived(this, new TcpDatagramReceivedEventArgs<byte[]>(sender, datagram));
|
}
|
}
|
|
private void RaisePlaintextReceived(TcpClientState sender, byte[] datagram)
|
{
|
if (PlaintextReceived != null)
|
{
|
PlaintextReceived(this, new TcpDatagramReceivedEventArgs<string>(sender, this.Encoding.GetString(datagram, 0, datagram.Length)));
|
}
|
}
|
|
/// <summary>
|
/// 与客户端的连接已建立事件
|
/// </summary>
|
public event EventHandler<TcpClientConnectedEventArgs> ClientConnected;
|
/// <summary>
|
/// 与客户端的连接已断开事件
|
/// </summary>
|
public event EventHandler<TcpClientDisconnectedEventArgs> ClientDisconnected;
|
|
private void RaiseClientConnected(TcpClient tcpClient)
|
{
|
if (ClientConnected != null)
|
{
|
ClientConnected(this, new TcpClientConnectedEventArgs(tcpClient));
|
}
|
}
|
|
private void RaiseClientDisconnected(TcpClient tcpClient)
|
{
|
if (ClientDisconnected != null)
|
{
|
ClientDisconnected(this, new TcpClientDisconnectedEventArgs(tcpClient));
|
}
|
}
|
|
#endregion
|
|
#region Send
|
|
private void GuardRunning()
|
{
|
if (!IsRunning)
|
throw new InvalidProgramException("This TCP server has not been started yet.");
|
}
|
|
/// <summary>
|
/// 发送报文至指定的客户端
|
/// </summary>
|
/// <param name="tcpClient">客户端</param>
|
/// <param name="datagram">报文</param>
|
public void Send(TcpClient tcpClient, byte[] datagram)
|
{
|
GuardRunning();
|
|
if (tcpClient == null)
|
throw new ArgumentNullException("tcpClient");
|
|
if (datagram == null)
|
throw new ArgumentNullException("datagram");
|
|
try
|
{
|
NetworkStream stream = tcpClient.GetStream();
|
if (stream.CanWrite)
|
{
|
stream.BeginWrite(datagram, 0, datagram.Length, HandleDatagramWritten, tcpClient);
|
}
|
}
|
catch (ObjectDisposedException ex)
|
{
|
Debug.LogException(ex);
|
}
|
}
|
|
/// <summary>
|
/// 发送报文至指定的客户端
|
/// </summary>
|
/// <param name="tcpClient">客户端</param>
|
/// <param name="datagram">报文</param>
|
public void Send(TcpClient tcpClient, string datagram)
|
{
|
Send(tcpClient, this.Encoding.GetBytes(datagram));
|
}
|
|
/// <summary>
|
/// 发送报文至所有客户端
|
/// </summary>
|
/// <param name="datagram">报文</param>
|
public void SendToAll(byte[] datagram)
|
{
|
GuardRunning();
|
|
foreach (var client in _clients.Values)
|
{
|
Send(client.TcpClient, datagram);
|
}
|
}
|
|
/// <summary>
|
/// 发送报文至所有客户端
|
/// </summary>
|
/// <param name="datagram">报文</param>
|
public void SendToAll(string datagram)
|
{
|
GuardRunning();
|
|
SendToAll(this.Encoding.GetBytes(datagram));
|
}
|
|
private void HandleDatagramWritten(IAsyncResult ar)
|
{
|
try
|
{
|
((TcpClient)ar.AsyncState).GetStream().EndWrite(ar);
|
}
|
catch (ObjectDisposedException ex)
|
{
|
Debug.LogException(ex);
|
}
|
catch (InvalidOperationException ex)
|
{
|
Debug.LogException(ex);
|
}
|
catch (IOException ex)
|
{
|
Debug.LogException(ex);
|
}
|
}
|
|
/// <summary>
|
/// 发送报文至指定的客户端
|
/// </summary>
|
/// <param name="tcpClient">客户端</param>
|
/// <param name="datagram">报文</param>
|
public void SyncSend(TcpClient tcpClient, byte[] datagram)
|
{
|
GuardRunning();
|
|
if (tcpClient == null)
|
throw new ArgumentNullException("tcpClient");
|
|
if (datagram == null)
|
throw new ArgumentNullException("datagram");
|
|
try
|
{
|
NetworkStream stream = tcpClient.GetStream();
|
if (stream.CanWrite)
|
{
|
stream.Write(datagram, 0, datagram.Length);
|
}
|
}
|
catch (ObjectDisposedException ex)
|
{
|
Debug.LogException(ex);
|
}
|
}
|
|
/// <summary>
|
/// 发送报文至指定的客户端
|
/// </summary>
|
/// <param name="tcpClient">客户端</param>
|
/// <param name="datagram">报文</param>
|
public void SyncSend(TcpClient tcpClient, string datagram)
|
{
|
SyncSend(tcpClient, this.Encoding.GetBytes(datagram));
|
}
|
|
/// <summary>
|
/// 发送报文至所有客户端
|
/// </summary>
|
/// <param name="datagram">报文</param>
|
public void SyncSendToAll(byte[] datagram)
|
{
|
GuardRunning();
|
|
foreach (var client in _clients.Values)
|
{
|
SyncSend(client.TcpClient, datagram);
|
}
|
}
|
|
/// <summary>
|
/// 发送报文至所有客户端
|
/// </summary>
|
/// <param name="datagram">报文</param>
|
public void SyncSendToAll(string datagram)
|
{
|
GuardRunning();
|
|
SyncSendToAll(this.Encoding.GetBytes(datagram));
|
}
|
|
#endregion
|
|
#region IDisposable Members
|
|
/// <summary>
|
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
|
/// </summary>
|
public void Dispose()
|
{
|
Dispose(true);
|
GC.SuppressFinalize(this);
|
}
|
|
/// <summary>
|
/// Releases unmanaged and - optionally - managed resources
|
/// </summary>
|
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
|
/// <c>false</c> to release only unmanaged resources.</param>
|
protected virtual void Dispose(bool disposing)
|
{
|
if (!this._disposed)
|
{
|
if (disposing)
|
{
|
try
|
{
|
Stop();
|
|
if (_listener != null)
|
{
|
_listener = null;
|
}
|
}
|
catch (SocketException ex)
|
{
|
Debug.LogException(ex);
|
}
|
}
|
|
_disposed = true;
|
}
|
}
|
|
#endregion
|
}
|
}
|
