1 /// <summary>
2 /// 打洞服务端，非常的简单，接收两个连接并且转发给对方；
3 /// </summary>
4 public class ServerListener : IServerListener
5 {
6 IPEndPoint EndPoint { get; set; }
7 //消息委托
8 public delegate void EventMsg(object sender, string e);
9 public static object obj = new object();
10 //通知消息
11 public event EventMsg NoticeMsg;
12 //接收事件
13 public event EventMsg ReceivedMsg;
14 /// <summary>
15 /// 上次链接的
16 /// </summary>
17 private Socket Previous;
18 public ServerListener(IPEndPoint endpoint)
19 {
20 this.EndPoint = endpoint;
21 }
22 private Socket listener;
23 public void Start()
24 {
25 this.listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
26 var connectArgs = new SocketAsyncEventArgs();
27 listener.Bind(EndPoint);
28 listener.Listen(2);
29 EndPoint = (IPEndPoint)listener.LocalEndPoint;
30 connectArgs.Completed += OnAccept;
31 //是否同步就完成了，同步完成需要自己触发
32 if (!listener.AcceptAsync(connectArgs))
33 OnAccept(listener, connectArgs);
34 }
35 byte[] bytes = new byte[400];
36 private void OnAccept(object sender, SocketAsyncEventArgs e)
37 {
38 Socket socket = null;
39 try
40 {
41 var remoteEndPoint1 = e.AcceptSocket.RemoteEndPoint.ToString();
42 NoticeMsg?.Invoke(sender, $"客户端：{remoteEndPoint1}连接上我了！\r\n");
43 SocketAsyncEventArgs readEventArgs = new SocketAsyncEventArgs();
44 readEventArgs.Completed += OnSocketReceived;
45 readEventArgs.UserToken = e.AcceptSocket;
46 readEventArgs.SetBuffer(bytes, 0, 400);
47 if (!e.AcceptSocket.ReceiveAsync(readEventArgs))
48 OnSocketReceived(e.AcceptSocket, readEventArgs);
49 lock (obj)
50 {
51 socket = e.AcceptSocket;
52 //上次有链接并且链接还”健在“
53 if (Previous == null||! Previous.Connected)
54 {
55 Previous = e.AcceptSocket;
56 }
57 else
58 {
59 //Previous.SendAsync()..?
60 Previous.Send(Encoding.UTF8.GetBytes(remoteEndPoint1 + "_1"));
61 socket.Send(Encoding.UTF8.GetBytes(Previous.RemoteEndPoint.ToString() + "_2"));
62 NoticeMsg?.Invoke(sender, $"已经通知双方！\r\n");
63 Previous = null;
64 }
65 }
66
67 e.AcceptSocket = null;
68 if (e.SocketError != SocketError.Success)
69 throw new SocketException((int)e.SocketError);
70
71 if(!listener.AcceptAsync(e))
72 OnAccept(listener, e);
73 }
74 catch
75 {
76 socket?.Close();
77 }
78
79 }
80 public void Close()
81 {
82 using (listener)
83 {
84 // listener.Shutdown(SocketShutdown.Both);
85 listener.Close();
86 }
87 //throw new NotImplementedException();
88 }
89 /// <summary>
90 /// 此处留有一个小BUG，接收的字符串大于400的时候会有问题；可以参考客户端修改
91 /// </summary>
92 public void OnSocketReceived(object sender, SocketAsyncEventArgs e)
93 {
94 Socket socket = e.UserToken as Socket;
95 var remoteEndPoint = socket.RemoteEndPoint.ToString();
96 try
97 {
98 if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
99 {
100
101 ReceivedMsg?.Invoke(sender, $"收到：{remoteEndPoint}发来信息：{Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred)}\r\n");
102
103 }
104 else
105 {
106 socket?.Close();
107 NoticeMsg?.Invoke(sender, $"链接：{remoteEndPoint}释放啦！\r\n");
108 return;
109 }
110 if (!socket.ReceiveAsync(e))
111 OnSocketReceived(socket, e);
112 }
113 catch
114 {
115 socket?.Close();
116 }
117
118 //{
119 // if (!((Socket)sender).AcceptAsync(e))
120 // OnSocketReceived(sender, e);
121 //}
122 //catch
123 //{
124 // return;
125 //}
126 }
127 }
public class StateObject
{
public Socket workSocket = null;
public const int BufferSize = 100;
public byte[] buffer = new byte[BufferSize];
public List<byte> buffers = new List<byte>();
//是不是和服务器的链接
public bool IsServerCon = false;
}
/// <summary>
/// 打洞节点客户端 实现的功能：
/// 连接服务器获取对方节点ip
/// 请求对方ip（打洞）
/// 根据条件判断是监听连接还是监听等待连接
/// </summary>
public class PeerClient : IPeerClient
{
//ManualResetEvent xxxxDone = new ManualResetEvent(false);
//Semaphore
/// <summary>
/// 当前链接
/// </summary>
public Socket Client { get;private set; }
#region 服务端
public string ServerHostName { get;private set; }
public int ServerPort { get; private set; }
#endregion
#region 接收和通知事件
public delegate void EventMsg(object sender, string e);
//接收事件
public event EventMsg ReceivedMsg;
//通知消息
public event EventMsg NoticeMsg;
#endregion
//本地绑定的节点
private IPEndPoint LocalEP;
public PeerClient(string hostname, int port)
{
Client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.ServerHostName = hostname;
this.ServerPort = port;
}
/// <summary>
/// 初始化客户端（包括启动）
/// </summary>
public void Init()
{
try
{
Client.Connect(ServerHostName, ServerPort);
}
catch (SocketException ex)
{
NoticeMsg?.Invoke(Client, $"连接服务器失败！{ex}！\r\n");
throw;
}
catch (Exception ex)
{
NoticeMsg?.Invoke(Client, $"连接服务器失败！{ex}！\r\n");
throw;
}
NoticeMsg?.Invoke(Client, $"连接上服务器了！\r\n");
var _localEndPoint = Client.LocalEndPoint.ToString();
LocalEP = new IPEndPoint(IPAddress.Parse(_localEndPoint.Split(':')[0])
, int.Parse(_localEndPoint.Split(':')[1]));
Receive(Client);
}
private void Receive(Socket client)
{
try
{
StateObject state = new StateObject();
state.workSocket = client;
state.IsServerCon = true;
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
catch (Exception e)
{
NoticeMsg?.Invoke(Client, $"接收消息出错了{e}！\r\n");
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try
{
var state = (StateObject)ar.AsyncState;
Socket _client = state.workSocket;
//因为到这边的经常Connected 还是true
//if (!_client.Connected)
//{
// _client.Close();
// return;
//}
SocketError error = SocketError.Success;
int bytesRead = _client.EndReceive(ar,out error);
if (error == SocketError.ConnectionReset)
{
NoticeMsg?.Invoke(Client, $"链接已经释放！\r\n");
_client.Close();
_client.Dispose();
return;
}
if (SocketError.Success!= error)
{
throw new SocketException((int)error);
}
var arr = state.buffer.AsQueryable().Take(bytesRead).ToArray();
state.buffers.AddRange(arr);
if (bytesRead >= state.buffer.Length)
{
_client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
////state.buffers.CopyTo(state.buffers.Count, state.buffer, 0, bytesRead);
//_client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
// new AsyncCallback(ReceiveCallback), state);
}
else
{
var _msg = Encoding.UTF8.GetString(state.buffers.ToArray());
ReceivedMsg?.Invoke(_client, _msg);
if (state.IsServerCon)
{
_client.Shutdown(SocketShutdown.Both);
_client.Close();
int retryCon = _msg.Contains("_1") ? 1 : 100;
_msg = _msg.Replace("_1", "").Replace("_2", "");
TryConnection(_msg.Split(':')[0], int.Parse(_msg.Split(':')[1]), retryCon);
return;
}
state = new StateObject();
state.IsServerCon = false;
state.workSocket = _client;
_client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
}
catch (SocketException ex)
{
//10054
NoticeMsg?.Invoke(Client, $"链接已经释放！{ex}！\r\n");
}
catch (Exception e)
{
NoticeMsg?.Invoke(Client, $"接收消息出错了2{e}！\r\n");
}
}
/// <summary>
/// 打洞或者尝试链接
/// </summary>
private void TryConnection(string remoteHostname, int remotePort,int retryCon)
{
Client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
var _iPRemotePoint = new IPEndPoint(IPAddress.Parse(remoteHostname), remotePort);
Client.Bind(LocalEP);
System.Threading.Thread.Sleep(retryCon==1?1:3*1000);
for (int i = 0; i < retryCon; i++)
{
try
{
Client.Connect(_iPRemotePoint);
NoticeMsg?.Invoke(Client, $"已经连接上：{remoteHostname}:{remotePort}！\r\n");
StateObject state = new StateObject();
state.workSocket = Client;
state.IsServerCon = false;
Client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
return;
}
catch
{
NoticeMsg?.Invoke(Client, $"尝试第{i+1}次链接：{remoteHostname}:{remotePort}！\r\n");
}
}
if (retryCon==1)
{
Listening(LocalEP.Port);
return;
}
NoticeMsg?.Invoke(Client, $"尝试了{retryCon}次都没有办法连接到：{remoteHostname}:{remotePort}，凉了！\r\n");
}
/// <summary>
/// 如果连接不成功，因为事先有打洞过了，根据条件监听 等待对方连接来
/// </summary>
private void Listening(int Port)
{
try
{
Client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
Client.Bind(new IPEndPoint(IPAddress.Any, Port));
Client.Listen((int)SocketOptionName.MaxConnections);
NoticeMsg?.Invoke(Client, $"开始侦听断开等待链接过来！\r\n");
StateObject state = new StateObject();
state.IsServerCon = false;
var _socket = Client.Accept();//只有一个链接 不用BeginAccept
Client.Close();//关系现有侦听
Client = _socket;
state.workSocket = Client;
NoticeMsg?.Invoke(Client, $"接收到来自{Client.RemoteEndPoint}的连接！\r\n");
Client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
catch (Exception ex)
{
NoticeMsg?.Invoke(Client, $"监听出错了{ex}凉了！\r\n");
}
//scoket.send
}
/// <summary>
/// 本例子只存在一个成功的链接，对成功的连接发送消息！
/// </summary>
/// <param name="strMsg"></param>
public void Send(string strMsg)
{
byte[] bytes = Encoding.UTF8.GetBytes(strMsg);
Client.BeginSend(bytes, 0, bytes.Length, 0,
new AsyncCallback(SendCallback), Client);
}
private void SendCallback(IAsyncResult ar)
{
try
{
Socket _socket = (Socket)ar.AsyncState;
//if(ar.IsCompleted)
_socket.EndSend(ar);
}
catch (Exception e)
{
NoticeMsg?.Invoke(Client, $"发送消息出错了{e}！\r\n");
}
}
}
