/// <summary>
/// 直接转发类型的端口监听
/// </summary>
/// <param name="item"></param>
private void ListenPortMapPortWithIp(PortMapItem item)
{
TcpListener listener = null;
EasyOp.Do(() =>
{
listener = new TcpListener(IPAddress.Any, item.LocalPort);
listener.Start();
}, () =>
{
ListenerList.Add(listener);
ListenSt listenSt = new ListenSt();
listenSt.listener = listener;
listenSt.item = item;
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Ip, listenSt);
LogUtils.Info($"端口映射：{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}", false);
}, ex =>
{
LogUtils.Error($"建立端口映射失败 {item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}{Environment.NewLine}{ex}");
EasyOp.Do(() => listener.Stop());
ListenerList.Remove(listener);
});
}, ex =>
{
LogUtils.Error($"建立端口映射失败 {item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}{Environment.NewLine}{ex}");
});
}
/// <summary>
/// 监听消息端口
/// </summary>
private void ListenMessagePort()
{
TcpListener listener = null;
EasyOp.Do(() =>
{
listener = new TcpListener(IPAddress.Any, appCenter.Config.LocalPort);
listener.Start();
LogUtils.Info($"监听服务端口：{appCenter.Config.LocalPort}");
}, () =>
{
ListenerList.Add(listener);
ListenSt listenSt = new ListenSt();
listenSt.listener = listener;
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Client, listenSt);
}, ex =>
{
LogUtils.Error($"监听服务端口发生错误:{Environment.NewLine}{ex}");
EasyOp.Do(() => listener.Stop());
ListenerList.Remove(listener);
});
}, ex =>
{
LogUtils.Error($"服务端口监听失败[{appCenter.Config.LocalPort}]:{Environment.NewLine}{ex}");
});
}
public void AcceptSocket_Client(IAsyncResult ar)
{
ListenSt st = (ListenSt)ar.AsyncState;
TcpListener listener = st.listener;
Socket socket = null;
EasyOp.Do(() =>
{
socket = listener.EndAcceptSocket(ar);
}, () =>
{
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Client, st);
}, exx =>
{
LogUtils.Error($"端口监听失败:{Environment.NewLine}{exx}");
EasyOp.Do(() => listener.Stop());
ListenerList.Remove(listener);
});
P2PTcpClient tcpClient = null;
EasyOp.Do(() =>
{
tcpClient = new P2PTcpClient(socket);
}, () =>
{
LogUtils.Trace($"端口{ appCenter.Config.LocalPort}新连入Tcp：{tcpClient.Client.RemoteEndPoint}");
//接收数据
EasyOp.Do(() =>
{
Global_Func.ListenTcp <ReceivePacket>(tcpClient);
}, ex =>
{
LogUtils.Debug($"准备接收Tcp数据出错：{Environment.NewLine}{ex}");
EasyOp.Do(() => tcpClient?.SafeClose());
});
}, ex =>
{
LogUtils.Debug($"处理新接入Tcp时出错：{Environment.NewLine}{ex}");
EasyOp.Do(() => tcpClient?.SafeClose());
});
}, ex =>
{
LogUtils.Debug($"获取新接入的Tcp连接失败");
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Client, st);
}, exx =>
{
LogUtils.Error($"端口监听失败:{Environment.NewLine}{exx}");
EasyOp.Do(() => listener.Stop());
ListenerList.Remove(listener);
});
});
}
/// <summary>
/// 直接转发类型的端口监听，接收新tcp回调方法
/// </summary>
/// <param name="ar"></param>
public void AcceptSocket_Ip(IAsyncResult ar)
{
ListenSt st = (ListenSt)ar.AsyncState;
TcpListener listener = st.listener;
PortMapItem item = st.item;
Socket socket = null;
try
{
socket = listener.EndAcceptSocket(ar);
}
catch (Exception ex)
{
LogUtils.Error(ex.ToString());
return;
}
listener.BeginAcceptSocket(AcceptSocket_Ip, st);
P2PTcpClient tcpClient = new P2PTcpClient(socket);
P2PTcpClient ipClient = null;
try
{
ipClient = new P2PTcpClient(item.RemoteAddress, item.RemotePort);
}
catch (Exception ex)
{
tcpClient?.SafeClose();
LogUtils.Debug($"建立隧道失败：{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}{Environment.NewLine}{ex}");
}
if (ipClient.Connected)
{
tcpClient.ToClient = ipClient;
ipClient.ToClient = tcpClient;
RelationTcp toRelation = new RelationTcp();
toRelation.readTcp = tcpClient;
toRelation.readSs = tcpClient.GetStream();
toRelation.writeTcp = tcpClient.ToClient;
toRelation.writeSs = tcpClient.ToClient.GetStream();
toRelation.buffer = new byte[P2PGlobal.P2PSocketBufferSize];
RelationTcp fromRelation = new RelationTcp();
fromRelation.readTcp = toRelation.writeTcp;
fromRelation.readSs = toRelation.writeSs;
fromRelation.writeTcp = toRelation.readTcp;
fromRelation.writeSs = toRelation.readSs;
fromRelation.buffer = new byte[P2PGlobal.P2PSocketBufferSize];
StartTransferTcp_Ip(toRelation);
StartTransferTcp_Ip(fromRelation);
}
}
/// <summary>
/// 直接转发类型的端口监听
/// </summary>
/// <param name="item"></param>
private bool ListenPortMapPort_Ip(PortMapItem item)
{
bool ret = true;
TcpListener listener = null;
EasyOp.Do(() =>
{
listener = new TcpListener(string.IsNullOrEmpty(item.LocalAddress) ? IPAddress.Any : IPAddress.Parse(item.LocalAddress), item.LocalPort);
listener.Start();
},
() =>
{
tcpCenter.ListenerList.Add((item.LocalAddress, item.LocalPort), listener);
LogUtils.Info($"添加端口映射成功：{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}", false);
ListenSt listenSt = new ListenSt();
listenSt.listener = listener;
listenSt.item = item;
listener.BeginAcceptSocket(AcceptSocket_Ip, listenSt);
},
/// <summary>
/// 端口映射监听端口的新tcp回调方法
/// </summary>
/// <param name="ar"></param>
public void AcceptSocket_Server(IAsyncResult ar)
{
ListenSt st = (ListenSt)ar.AsyncState;
TcpListener listener = st.listener;
PortMapItem item = st.item;
Socket socket = null;
try
{
//获取当前接入的tcp
socket = listener.EndAcceptSocket(ar);
}
catch (Exception ex)
{
LogUtils.Error(ex.ToString());
return;
}
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Server, st);
}, () =>
{
EasyOp.Do(() =>
{
if (!CreateP2PConnect(item, socket))
{
EasyOp.Do(socket.SafeClose);
}
}, ex =>
{
LogUtils.Debug("处理新tcp连接时发生错误：" + Environment.NewLine + ex.ToString());
});
}, ex =>
{
LogUtils.Error("监听端口发生错误：" + listener.LocalEndpoint.ToString() + Environment.NewLine + ex.ToString());
});
}
/// <summary>
/// 监听需要服务端的端口映射
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private bool ListenPortMapPort_Server(PortMapItem item)
{
TcpListener listener = null;
try
{
listener = new TcpListener(string.IsNullOrEmpty(item.LocalAddress) ? IPAddress.Any : IPAddress.Parse(item.LocalAddress), item.LocalPort);
listener.Start();
}
catch (SocketException ex)
{
LogUtils.Error($"端口映射失败：{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}{Environment.NewLine}{ex.Message}");
return(false);
}
tcpCenter.ListenerList.Add((item.LocalAddress, item.LocalPort), listener);
LogUtils.Info($"端口映射：{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}", false);
ListenSt listenSt = new ListenSt();
listenSt.listener = listener;
listenSt.item = item;
listener.BeginAcceptSocket(AcceptSocket_Server, listenSt);
return(true);
}
/// <summary>
/// 端口映射监听端口的新tcp回调方法
/// </summary>
/// <param name="ar"></param>
public void AcceptSocket_Server(IAsyncResult ar)
{
ListenSt st = (ListenSt)ar.AsyncState;
TcpListener listener = st.listener;
PortMapItem item = st.item;
Socket socket = null;
try
{
//获取当前接入的tcp
socket = listener.EndAcceptSocket(ar);
}
catch (Exception ex)
{
LogUtils.Error(ex.ToString());
return;
}
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Server, st);
}, () =>
{
EasyOp.Do(() =>
{
if (tcpCenter.P2PServerTcp != null && tcpCenter.P2PServerTcp.Connected)
{
P2PTcpClient tcpClient = new P2PTcpClient(socket);
//加入待连接集合
P2PResult result = new P2PResult();
tcpCenter.WaiteConnetctTcp.Add(tcpClient.Token, result);
//tcpCenter.WaiteConnetctTcp.Add(tcpClient.Token, tcpClient);
//发送消息给服务端，开始内网穿透
Send_0x0201_Apply packet = new Send_0x0201_Apply(tcpClient.Token, item.RemoteAddress, item.RemotePort, item.P2PType);
LogUtils.Debug(string.Format("正在建立{0}隧道 token:{1} client:{2} port:{3}", item.P2PType == 0 ? "中转模式" : "P2P模式", tcpClient.Token, item.RemoteAddress, item.RemotePort));
byte[] dataAr = packet.PackData();
EasyOp.Do(() =>
{
tcpCenter.P2PServerTcp.BeginSend(dataAr);
}, () =>
{
//等待指定超时时间后，判断是否连接成功
Monitor.Enter(result.block);
if (Monitor.Wait(result.block, AppConfig.P2PTimeout))
{
if (tcpCenter.WaiteConnetctTcp[tcpClient.Token].IsError)
{
LogUtils.Debug(tcpCenter.WaiteConnetctTcp[tcpClient.Token].ErrorMsg);
tcpClient.SafeClose();
}
else
{
P2PTcpClient destTcp = tcpCenter.WaiteConnetctTcp[tcpClient.Token].Tcp;
tcpClient.IsAuth = destTcp.IsAuth = true;
destTcp.ToClient = tcpClient;
tcpClient.ToClient = destTcp;
if (item.P2PType == 0)
{
Global_Func.ListenTcp <Packet_0x0202>(tcpClient);
LogUtils.Debug($"中转模式隧道，连接成功 token:{tcpClient.Token}");
}
else
{
if (Global_Func.BindTcp(tcpClient, destTcp))
{
LogUtils.Debug($"P2P模式隧道，连接成功 token:{tcpClient.Token}");
}
else
{
LogUtils.Debug($"P2P模式隧道，连接失败 token:{tcpClient.Token}");
EasyOp.Do(tcpClient.SafeClose);
EasyOp.Do(destTcp.SafeClose);
}
}
}
}
else
{
LogUtils.Debug($"建立隧道失败：token:{tcpClient.Token} {item.LocalPort}->{item.RemoteAddress}:{item.RemotePort} {AppConfig.P2PTimeout / 1000}秒无响应，已超时.");
EasyOp.Do(tcpClient.SafeClose);
}
tcpCenter.WaiteConnetctTcp.Remove(tcpClient.Token);
Monitor.Exit(result.block);
//if (tcpCenter.WaiteConnetctTcp.ContainsKey(tcpClient.Token))
//{
// LogUtils.Debug($"建立隧道失败：token:{tcpClient.Token} {item.LocalPort}->{item.RemoteAddress}:{item.RemotePort} {AppConfig.P2PTimeout / 1000}秒无响应，已超时.");
// tcpCenter.WaiteConnetctTcp[tcpClient.Token].tcp?.SafeClose();
// tcpCenter.WaiteConnetctTcp.Remove(tcpClient.Token);
//}
}, ex =>
{
EasyOp.Do(tcpClient.SafeClose);
LogUtils.Debug($"建立隧道失败,无法连接服务器：token:{tcpClient.Token} {item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}.");
});
}
else
{
LogUtils.Debug($"建立隧道失败：未连接到服务器!");
socket.Close();
}
}, ex =>
{
LogUtils.Debug("处理新tcp连接时发生错误：" + Environment.NewLine + ex.ToString());
});
}, ex =>
{
LogUtils.Error("监听端口发生错误：" + listener.LocalEndpoint.ToString() + Environment.NewLine + ex.ToString());
});
}
public void AcceptSocket_Ip(IAsyncResult ar)
{
ListenSt st = (ListenSt)ar.AsyncState;
TcpListener listener = st.listener;
PortMapItem item = st.item;
Socket socket = null;
EasyOp.Do(() =>
{
socket = listener.EndAcceptSocket(ar);
}, () =>
{
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Ip, st);
}, ex =>
{
LogUtils.Error($"端口监听失败:{Environment.NewLine}{ex}");
});
P2PTcpClient tcpClient = null;
EasyOp.Do(() =>
{
tcpClient = new P2PTcpClient(socket);
}, () =>
{
P2PTcpClient ipClient = null;
EasyOp.Do(() =>
{
ipClient = new P2PTcpClient(item.RemoteAddress, item.RemotePort);
}, () =>
{
tcpClient.ToClient = ipClient;
ipClient.ToClient = tcpClient;
RelationTcp toRelation = new RelationTcp();
toRelation.readTcp = tcpClient;
toRelation.writeTcp = tcpClient.ToClient;
toRelation.buffer = new byte[P2PGlobal.P2PSocketBufferSize];
RelationTcp fromRelation = new RelationTcp();
fromRelation.readTcp = toRelation.writeTcp;
fromRelation.writeTcp = toRelation.readTcp;
fromRelation.buffer = new byte[P2PGlobal.P2PSocketBufferSize];
EasyOp.Do(() =>
{
StartTransferTcp_Ip(toRelation);
StartTransferTcp_Ip(fromRelation);
}, ex =>
{
LogUtils.Debug($"建立隧道失败：{Environment.NewLine}{ex}");
EasyOp.Do(() => ipClient.SafeClose());
EasyOp.Do(() => tcpClient.SafeClose());
});
}, ex =>
{
LogUtils.Debug($"建立隧道失败：{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}{Environment.NewLine}{ex}");
EasyOp.Do(() => tcpClient.SafeClose());
});
}, ex =>
{
LogUtils.Debug($"处理新接入Tcp时发生错误：{Environment.NewLine}{ex}");
EasyOp.Do(() => socket?.SafeClose());
});
}, ex =>
{
LogUtils.Debug($"获取新接入的Tcp连接失败：{Environment.NewLine}{ex}");
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_Ip, st);
}, exx =>
{
LogUtils.Error($"端口监听失败:{Environment.NewLine}{exx}");
});
});
}
public void AcceptSocket_ClientName(IAsyncResult ar)
{
ListenSt st = (ListenSt)ar.AsyncState;
TcpListener listener = st.listener;
PortMapItem item = st.item;
Socket socket = null;
EasyOp.Do(() =>
{
socket = listener.EndAcceptSocket(ar);
}, () =>
{
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_ClientName, st);
}, exx =>
{
LogUtils.Error($"端口监听失败:{Environment.NewLine}{exx}");
});
LogUtils.Debug($"开始内网穿透：{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}", false);
P2PTcpClient tcpClient = null;
EasyOp.Do(() =>
{
tcpClient = new P2PTcpClient(socket);
}, () =>
{
string token = tcpClient.Token;
//获取目标tcp
if (clientCenter.TcpMap.ContainsKey(item.RemoteAddress) && clientCenter.TcpMap[item.RemoteAddress].TcpClient.Connected)
{
//加入待连接集合
clientCenter.WaiteConnetctTcp.Add(token, tcpClient);
//发送p2p申请
Models.Send.Send_0x0211 packet = new Models.Send.Send_0x0211(token, item.RemotePort, tcpClient.RemoteEndPoint);
EasyOp.Do(() =>
{
clientCenter.TcpMap[item.RemoteAddress].TcpClient.BeginSend(packet.PackData());
}, () =>
{
Thread.Sleep(appCenter.Config.P2PTimeout);
//如果指定时间内没有匹配成功，则关闭连接
if (clientCenter.WaiteConnetctTcp.ContainsKey(token))
{
LogUtils.Debug($"建立隧道失败{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}，{appCenter.Config.P2PTimeout / 1000}秒无响应，已超时.");
EasyOp.Do(() => tcpClient?.SafeClose());
EasyOp.Do(() => clientCenter.WaiteConnetctTcp[token]?.SafeClose());
clientCenter.WaiteConnetctTcp.Remove(token);
}
}, ex =>
{
LogUtils.Debug($"建立隧道失败{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}，目标客户端已断开连接!");
EasyOp.Do(() => tcpClient?.SafeClose());
if (clientCenter.WaiteConnetctTcp.ContainsKey(token))
{
EasyOp.Do(() => clientCenter.WaiteConnetctTcp[token]?.SafeClose());
clientCenter.WaiteConnetctTcp.Remove(token);
}
});
}
else
{
LogUtils.Debug($"建立隧道失败{item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}，客户端不在线!");
EasyOp.Do(() => tcpClient?.SafeClose());
}
}, ex =>
{
LogUtils.Debug($"处理新接入Tcp时发生错误：{Environment.NewLine}{ex}");
EasyOp.Do(() => socket?.SafeClose());
});
}, ex =>
{
LogUtils.Debug($"获取新接入的Tcp连接失败：{Environment.NewLine}{ex}");
EasyOp.Do(() =>
{
listener.BeginAcceptSocket(AcceptSocket_ClientName, st);
}, exx =>
{
LogUtils.Error($"端口监听失败:{Environment.NewLine}{exx}");
});
});
}
/// <summary>
/// 端口映射监听端口的新tcp回调方法
/// </summary>
/// <param name="ar"></param>
public void AcceptSocket_Server(IAsyncResult ar)
{
ListenSt st = (ListenSt)ar.AsyncState;
TcpListener listener = st.listener;
PortMapItem item = st.item;
Socket socket = null;
try
{
//获取当前接入的tcp
socket = listener.EndAcceptSocket(ar);
}
catch (Exception ex)
{
LogUtils.Error(ex.ToString());
return;
}
try
{
listener.BeginAcceptSocket(AcceptSocket_Server, st);
}
catch (Exception ex)
{
LogUtils.Error("监听端口发生错误：" + listener.LocalEndpoint.ToString() + Environment.NewLine + ex.ToString());
}
try
{
if (tcpCenter.P2PServerTcp != null && tcpCenter.P2PServerTcp.Connected)
{
P2PTcpClient tcpClient = new P2PTcpClient(socket);
//加入待连接集合
tcpCenter.WaiteConnetctTcp.Add(tcpClient.Token, tcpClient);
//发送消息给服务端，开始内网穿透
Send_0x0201_Apply packet = new Send_0x0201_Apply(tcpClient.Token, item.RemoteAddress, item.RemotePort, item.P2PType);
LogUtils.Debug(string.Format("正在建立{0}隧道 token:{1} client:{2} port:{3}", item.P2PType == 0 ? "中转模式" : "P2P模式", tcpClient.Token, item.RemoteAddress, item.RemotePort));
byte[] dataAr = packet.PackData();
EasyOp.Do(() =>
{
tcpCenter.P2PServerTcp.BeginSend(dataAr);
}, () =>
{
//等待指定超时时间后，判断是否连接成功
Thread.Sleep(AppConfig.P2PTimeout);
if (tcpCenter.WaiteConnetctTcp.ContainsKey(tcpClient.Token))
{
LogUtils.Debug($"建立隧道失败：token:{tcpClient.Token} {item.LocalPort}->{item.RemoteAddress}:{item.RemotePort} {AppConfig.P2PTimeout / 1000}秒无响应，已超时.");
tcpCenter.WaiteConnetctTcp[tcpClient.Token]?.SafeClose();
tcpCenter.WaiteConnetctTcp.Remove(tcpClient.Token);
}
}, ex =>
{
EasyOp.Do(tcpClient.SafeClose);
LogUtils.Debug($"建立隧道失败,无法连接服务器：token:{tcpClient.Token} {item.LocalPort}->{item.RemoteAddress}:{item.RemotePort}.");
});
}
else
{
LogUtils.Debug($"建立隧道失败：未连接到服务器!");
socket.Close();
}
}
catch (Exception ex)
{
LogUtils.Debug("处理新tcp连接时发生错误：" + Environment.NewLine + ex.ToString());
}
}
