public override bool Excute()
{
int tokenLength = m_data.ReadInt32();
string token = m_data.ReadBytes(tokenLength).ToStringUnicode();
int mapPort = m_data.ReadInt32();
if (Global.AllowPort.Contains(mapPort))
{
P2PTcpClient portClient = new P2PTcpClient("127.0.0.1", mapPort);
P2PTcpClient serverClient = new P2PTcpClient(Global.ServerAddress, Global.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
Models.Send.P2PortApplyResponse sendPacket = new Models.Send.P2PortApplyResponse(token);
int length = serverClient.Client.Send(sendPacket.PackData());
Debug.WriteLine($"Port2P请求有效，{portClient.LocalEndPoint}->{serverClient.LocalEndPoint}");
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <Models.Recieve.Port2PPacket>(portClient); });
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <Models.Recieve.P2PortPacket>(serverClient); });
}
else
{
Debug.WriteLine("Port2P请求无效，关闭连接");
m_tcpClient.Close();
}
return(true);
}
public override bool Excute()
{
try
{
string token = BinaryUtils.ReadString(m_data);
int mapPort = BinaryUtils.ReadInt(m_data);
string remoteEndPoint = BinaryUtils.ReadString(m_data);;
if (Global.AllowPortList.Any(t => t.Match(mapPort, m_tcpClient.ClientName)))
{
P2PTcpClient portClient = new P2PTcpClient("127.0.0.1", mapPort);
P2PTcpClient serverClient = new P2PTcpClient(Global.ServerAddress, Global.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
Models.Send.Send_0x0211 sendPacket = new Models.Send.Send_0x0211(token);
int length = serverClient.Client.Send(sendPacket.PackData());
LogUtils.Info($"命令：0x0211 内网穿透Tcp绑定：{portClient.RemoteEndPoint}->{serverClient.RemoteEndPoint}->{remoteEndPoint}");
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <Models.Receive.Packet_0x0212>(portClient); });
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <Models.Receive.Packet_ToPort>(serverClient); });
}
else
{
LogUtils.Warning($"命令：0x0211 无权限，端口:{mapPort}");
m_tcpClient.Close();
}
}
catch (Exception ex)
{
LogUtils.Warning($"命令：0x0211 错误：{Environment.NewLine} {ex}");
}
return(true);
}
public override bool Excute()
{
bool ret = true;
LogUtils.Trace($"开始处理消息：0x0211");
string token = BinaryUtils.ReadString(m_data);
bool isSuccess = true;
string msg = "";
if (m_data.PeekChar() >= 0)
{
isSuccess = BinaryUtils.ReadBool(m_data);
msg = BinaryUtils.ReadString(m_data);
}
if (isSuccess)
{
if (clientCenter.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient client = clientCenter.WaiteConnetctTcp[token];
clientCenter.WaiteConnetctTcp.Remove(token);
client.IsAuth = m_tcpClient.IsAuth = true;
client.ToClient = m_tcpClient;
m_tcpClient.ToClient = client;
LogUtils.Debug($"命令：0x0211 已绑定内网穿透（2端）通道 {client.RemoteEndPoint}->{m_tcpClient.RemoteEndPoint}");
//监听client
EasyOp.Do(() => Global_Func.ListenTcp <Packet_0x0212>(client), ex =>
{
LogUtils.Debug($"命令：0x0211 绑定内网穿透（2端）通道失败，目标Tcp连接已断开");
ret = false;
});
}
else
{
LogUtils.Debug($"命令：0x0211 绑定内网穿透（2端）通道失败，绑定超时");
ret = false;
}
}
else
{
//失败消息是客户端与服务端的通讯tcp发送的，不能关闭tcp连接
LogUtils.Debug($"命令：0x0211 From 客户端：{msg} token:{token}");
if (clientCenter.WaiteConnetctTcp.ContainsKey(token))
{
//关闭源tcp
P2PTcpClient client = clientCenter.WaiteConnetctTcp[token];
EasyOp.Do(() => {
client?.SafeClose();
});
clientCenter.WaiteConnetctTcp.Remove(token);
}
ret = true;
}
return(ret);
}
/// <summary>
/// 监听连接外部程序的端口
/// </summary>
public void ListenPort()
{
EasyOp.Do(() =>
{
// 监听端口
Global_Func.ListenTcp <Packet_0x0202>(m_tcpClient.ToClient);
}, ex =>
{
Utils.LogUtils.Debug($"命令：0x0201 隧道连接失败,源Tcp连接已断开：{Environment.NewLine}{ex}");
EasyOp.Do(m_tcpClient.SafeClose);
});
}
public override bool Excute()
{
int step = m_data.ReadInt32();
if (step == 2)
{
bool isDestClient = m_data.ReadBoolean();
int tokenLength = m_data.ReadInt32();
string token = m_data.ReadBytes(tokenLength).ToStringUnicode();
Models.Send.P2PApplyRequest sendPacket = new Models.Send.P2PApplyRequest(token);
if (isDestClient)
{
Debug.WriteLine("P2P第二步2：接收到P2P服务端命令，创建连接.");
int port = m_data.ReadInt32();
P2PTcpClient portClient = new P2PTcpClient("127.0.0.1", port);
P2PTcpClient serverClient = new P2PTcpClient(Global.ServerAddress, Global.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
serverClient.Client.Send(sendPacket.PackData());
Debug.WriteLine("P2P第三步2：向服务端发送tcp已连接消息.");
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <RecievePacket>(serverClient); });
}
else
{
if (Global.WaiteConnetctTcp.ContainsKey(token))
{
Debug.WriteLine("P2P第二步1：接收到P2P服务端命令，创建连接.");
P2PTcpClient portClient = Global.WaiteConnetctTcp[token];
Global.WaiteConnetctTcp.Remove(token);
P2PTcpClient serverClient = new P2PTcpClient(Global.ServerAddress, Global.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
serverClient.Client.Send(sendPacket.PackData());
Debug.WriteLine("P2P第三步1：向服务端发送tcp已连接消息.");
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <RecievePacket>(serverClient); });
}
else
{
Debug.WriteLine("P2P第二步：接收到P2P服务端命令，但tcp已超时.");
}
}
}
else if (step == 4)
{
Debug.WriteLine("P2P第四步：启动p2p转发服务.");
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <P2PPacket>(m_tcpClient.ToClient); });
}
return(true);
}
/// <summary>
/// 从发起端创建与服务器的tcp连接
/// </summary>
/// <param name="token"></param>
public void CreateTcpFromSource(string token)
{
Utils.LogUtils.Debug($"命令：0x0201 正尝试建立中转模式隧道token:{token}");
if (tcpCenter.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient portClient = tcpCenter.WaiteConnetctTcp[token];
tcpCenter.WaiteConnetctTcp.Remove(token);
P2PTcpClient serverClient = null;
EasyOp.Do(() =>
{
serverClient = new P2PTcpClient(appCenter.ServerAddress, appCenter.ServerPort);
}, () =>
{
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
EasyOp.Do(() =>
{
serverClient.BeginSend(sendPacket.PackData());
}, () =>
{
EasyOp.Do(() =>
{
Global_Func.ListenTcp <ReceivePacket>(serverClient);
Utils.LogUtils.Debug($"命令：0x0201 中转模式隧道,隧道建立并连接成功 token:{token}");
}, ex =>
{
Utils.LogUtils.Debug($"命令：0x0201 中转模式隧道,隧道建立失败 token:{token}：{Environment.NewLine} {ex}");
EasyOp.Do(serverClient.SafeClose);
EasyOp.Do(portClient.SafeClose);
});
}, ex =>
{
Utils.LogUtils.Debug($"命令：0x0201 中转模式隧道,隧道建立失败 token:{token}：{Environment.NewLine} 隧道被服务器强制断开");
EasyOp.Do(portClient.SafeClose);
});
}, ex =>
{
Utils.LogUtils.Debug($"命令：0x0201 中转模式隧道,无法连接服务器 token:{token}：{Environment.NewLine}{ex}");
EasyOp.Do(portClient.SafeClose);
});
}
else
{
LogUtils.Debug($"命令：0x0201 接收到建立中转模式隧道命令，但已超时. token:{token}");
}
}
public void CreateTcpFromSource_DirectConnect(string token)
{
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
Utils.LogUtils.Debug($"命令：0x0201 正尝试建立P2P模式隧道 token:{token}");
if (tcpCenter.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient serverClient = new P2PTcpClient();
serverClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
EasyOp.Do(() =>
{
serverClient.Connect(appCenter.ServerAddress, appCenter.ServerPort);
}, () =>
{
serverClient.IsAuth = true;
serverClient.UpdateEndPoint();
EasyOp.Do(() =>
{
serverClient.BeginSend(sendPacket.PackData());
},
() =>
{
EasyOp.Do(() =>
{
Global_Func.ListenTcp <ReceivePacket>(serverClient);
LogUtils.Debug($"命令：0x0201 P2P模式隧道，已连接到服务器，等待下一步操作 token:{token}");
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道，服务器连接被强制断开 token:{token}：{Environment.NewLine}{ex}");
tcpCenter.WaiteConnetctTcp.Remove(token);
EasyOp.Do(serverClient.SafeClose);
});
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道，隧道打洞失败 token:{token}：{Environment.NewLine} 隧道被服务器强制断开");
tcpCenter.WaiteConnetctTcp.Remove(token);
});
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道，无法连接服务器 token:{token}：{Environment.NewLine}{ex}");
tcpCenter.WaiteConnetctTcp.Remove(token);
});
}
else
{
LogUtils.Debug($"命令：0x0201 接收到建立P2P模式隧道命令，但已超时. token:{token}");
}
}
public void CreateTcpFromDest_DirectConnect(string token)
{
int port = BinaryUtils.ReadInt(data);
Utils.LogUtils.Debug($"命令：0x0201 正尝试建立P2P模式隧道 token:{token}");
P2PTcpClient serverClient = new P2PTcpClient();
serverClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
EasyOp.Do(() =>
{
serverClient.Connect(appCenter.ServerAddress, appCenter.ServerPort);
},
() =>
{
serverClient.IsAuth = true;
serverClient.P2PLocalPort = port;
serverClient.UpdateEndPoint();
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
EasyOp.Do(() =>
{
serverClient.BeginSend(sendPacket.PackData());
},
() =>
{
EasyOp.Do(() =>
{
Global_Func.ListenTcp <ReceivePacket>(serverClient);
LogUtils.Debug($"命令：0x0201 P2P模式隧道，已连接到服务器，等待下一步操作 token:{token}");
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道，服务器连接被强制断开 token:{token}：{Environment.NewLine}{ex}");
EasyOp.Do(serverClient.Close);
});
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道，隧道打洞失败 token:{token}：{Environment.NewLine} 隧道被服务器强制断开");
});
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道，无法连接服务器 token:{token}：{Environment.NewLine}{ex}");
});
}
public void CreateTcpFromSource_DirectConnect(string token)
{
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
Utils.LogUtils.Info($"命令：0x0201 正尝试内网穿透（P2P模式）token:{token}");
if (TcpCenter.Instance.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient serverClient = new P2PTcpClient();
serverClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
serverClient.Connect(ConfigCenter.Instance.ServerAddress, ConfigCenter.Instance.ServerPort);
serverClient.IsAuth = true;
serverClient.UpdateEndPoint();
serverClient.Client.Send(sendPacket.PackData());
AppCenter.Instance.StartNewTask(() => { Global_Func.ListenTcp <ReceivePacket>(serverClient); });
}
else
{
LogUtils.Warning($"命令：0x0201 接收到内网穿透（P2P模式）命令，但已超时. token:{token}");
}
}
/// <summary>
/// 从发起端创建与服务器的tcp连接
/// </summary>
/// <param name="token"></param>
public void CreateTcpFromSource(string token)
{
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
if (Global.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient portClient = Global.WaiteConnetctTcp[token];
Global.WaiteConnetctTcp.Remove(token);
P2PTcpClient serverClient = new P2PTcpClient(Global.ServerAddress, Global.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
serverClient.Client.Send(sendPacket.PackData());
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <ReceivePacket>(serverClient); });
}
else
{
LogUtils.Warning($"【P2P】命令：0x0201 接收到P2P命令，但已超时.");
}
}
/// <summary>
/// 从发起端创建与服务器的tcp连接
/// </summary>
/// <param name="token"></param>
protected virtual void CreateTcpFromSource(string token)
{
Utils.LogUtils.Debug($"命令：0x0201 正尝试建立中转模式隧道token:{token}");
if (tcpCenter.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient serverClient = null;
EasyOp.Do(() =>
{
serverClient = new P2PTcpClient(appCenter.ServerAddress, appCenter.ServerPort);
}, () =>
{
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
EasyOp.Do(() =>
{
serverClient.BeginSend(sendPacket.PackData());
}, () =>
{
EasyOp.Do(() =>
{
tcpCenter.WaiteConnetctTcp[token].Tcp = serverClient;
Global_Func.ListenTcp <ReceivePacket>(serverClient);
//Utils.LogUtils.Debug($"命令：0x0201 中转模式隧道,隧道建立并连接成功 token:{token}");
}, ex =>
{
tcpCenter.WaiteConnetctTcp[token].ErrorMsg = $"命令：0x0201 中转模式隧道,隧道建立失败 token:{token}：{Environment.NewLine} {ex}";
tcpCenter.WaiteConnetctTcp[token].PulseBlock();
});
}, ex =>
{
tcpCenter.WaiteConnetctTcp[token].ErrorMsg = $"命令：0x0201 中转模式隧道,隧道建立失败 token:{token}：{Environment.NewLine} 隧道被服务器强制断开";
tcpCenter.WaiteConnetctTcp[token].PulseBlock();
});
}, ex =>
{
tcpCenter.WaiteConnetctTcp[token].ErrorMsg = $"命令：0x0201 中转模式隧道,无法连接服务器 token:{token}：{Environment.NewLine}{ex}";
tcpCenter.WaiteConnetctTcp[token].PulseBlock();
});
}
else
{
LogUtils.Debug($"命令：0x0201 接收到建立中转模式隧道命令，但已超时. token:{token}");
}
}
/// <summary>
/// 从发起端创建与服务器的tcp连接
/// </summary>
/// <param name="token"></param>
public void CreateTcpFromSource(string token)
{
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
Utils.LogUtils.Info($"命令：0x0201 正尝试内网穿透（转发模式）token:{token}");
if (TcpCenter.Instance.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient portClient = TcpCenter.Instance.WaiteConnetctTcp[token];
TcpCenter.Instance.WaiteConnetctTcp.Remove(token);
P2PTcpClient serverClient = new P2PTcpClient(ConfigCenter.Instance.ServerAddress, ConfigCenter.Instance.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
serverClient.Client.Send(sendPacket.PackData());
AppCenter.Instance.StartNewTask(() => { Global_Func.ListenTcp <ReceivePacket>(serverClient); });
}
else
{
LogUtils.Warning($"命令：0x0201 接收到内网穿透（转发模式）命令，但已超时. token:{token}");
}
}
public void CreateTcpFromDest_DirectConnect(string token)
{
try
{
int port = BinaryUtils.ReadInt(data);
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
Utils.LogUtils.Info($"命令：0x0201 正尝试内网穿透(P2P模式) token:{token}");
P2PTcpClient serverClient = new P2PTcpClient();
serverClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
serverClient.Connect(ConfigCenter.Instance.ServerAddress, ConfigCenter.Instance.ServerPort);
serverClient.IsAuth = true;
serverClient.P2PLocalPort = port;
serverClient.UpdateEndPoint();
serverClient.Client.Send(sendPacket.PackData());
AppCenter.Instance.StartNewTask(() => { Global_Func.ListenTcp <ReceivePacket>(serverClient); });
}
catch (Exception ex)
{
LogUtils.Error($"命令：0x0201 尝试内网穿透(P2P模式) 发生错误：{Environment.NewLine}{ex.Message}");
}
}
/// <summary>
/// 从目标端创建与服务器的tcp连接
/// </summary>
/// <param name="token"></param>
public void CreateTcpFromDest(string token)
{
try
{
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
Utils.LogUtils.Info($"命令：0x0201 正在绑定内网穿透（3端）通道 token:{token}");
int port = BinaryUtils.ReadInt(data);
PortMapItem destMap = ConfigCenter.Instance.PortMapList.FirstOrDefault(t => t.LocalPort == port && string.IsNullOrEmpty(t.LocalAddress));
P2PTcpClient portClient = null;
if (destMap != null)
{
if (destMap.MapType == PortMapType.ip)
{
portClient = new P2PTcpClient(destMap.RemoteAddress, destMap.RemotePort);
}
else
{
portClient = new P2PTcpClient("127.0.0.1", port);
}
}
else
{
portClient = new P2PTcpClient("127.0.0.1", port);
}
P2PTcpClient serverClient = new P2PTcpClient(ConfigCenter.Instance.ServerAddress, ConfigCenter.Instance.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
serverClient.Client.Send(sendPacket.PackData());
AppCenter.Instance.StartNewTask(() => { Global_Func.ListenTcp <ReceivePacket>(serverClient); });
}
catch (Exception ex)
{
LogUtils.Error($"命令：0x0201 绑定内网穿透（3端）通道错误：{Environment.NewLine}{ex.Message}");
}
}
/// <summary>
/// 从目标端创建与服务器的tcp连接
/// </summary>
/// <param name="token"></param>
public void CreateTcpFromDest(string token)
{
try
{
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
int port = BinaryUtils.ReadInt(m_data);
PortMapItem destMap = Global.PortMapList.FirstOrDefault(t => t.LocalPort == port && string.IsNullOrEmpty(t.LocalAddress));
P2PTcpClient portClient = null;
if (destMap != null)
{
if (destMap.MapType == PortMapType.ip)
{
portClient = new P2PTcpClient(destMap.RemoteAddress, destMap.RemotePort);
}
else
{
portClient = new P2PTcpClient("127.0.0.1", port);
}
}
else
{
portClient = new P2PTcpClient("127.0.0.1", port);
}
P2PTcpClient serverClient = new P2PTcpClient(Global.ServerAddress, Global.ServerPort);
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
serverClient.Client.Send(sendPacket.PackData());
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <ReceivePacket>(serverClient); });
}
catch (Exception ex)
{
LogUtils.Error($"【P2P】命令：0x0201 错误：{Environment.NewLine}{ex.ToString()}");
}
}
public override bool Excute()
{
int tokenLength = m_data.ReadInt32();
string token = m_data.ReadBytes(tokenLength).ToStringUnicode();
if (Global.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient client = Global.WaiteConnetctTcp[token];
Global.WaiteConnetctTcp.Remove(token);
client.IsAuth = m_tcpClient.IsAuth = true;
client.ToClient = m_tcpClient;
m_tcpClient.ToClient = client;
Debug.WriteLine($"[服务器]转发{client.RemoteEndPoint}->{m_tcpClient.RemoteEndPoint}");
//监听client
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <Port2PPacket>(client); });
}
else
{
m_tcpClient.Close();
throw new Exception("连接已关闭");
}
return(true);
}
public override bool Excute()
{
int tokenLength = m_data.ReadInt32();
string token = m_data.ReadBytes(tokenLength).ToStringUnicode();
if (ClientCenter.Instance.WaiteConnetctTcp.ContainsKey(token))
{
P2PTcpClient client = ClientCenter.Instance.WaiteConnetctTcp[token];
ClientCenter.Instance.WaiteConnetctTcp.Remove(token);
client.IsAuth = m_tcpClient.IsAuth = true;
client.ToClient = m_tcpClient;
m_tcpClient.ToClient = client;
LogUtils.Debug($"命令：0x0211 已绑定内网穿透（2端）通道 {client.RemoteEndPoint}->{m_tcpClient.RemoteEndPoint}");
//监听client
AppCenter.Instance.StartNewTask(() => { Global_Func.ListenTcp <Packet_0x0212>(client); });
}
else
{
m_tcpClient.SafeClose();
throw new Exception("绑定内网穿透（2端）通道失败，目标Tcp连接已断开");
}
return(true);
}
public override bool Excute()
{
LogUtils.Trace($"开始处理消息：0x0211");
string token = BinaryUtils.ReadString(data);
int mapPort = BinaryUtils.ReadInt(data);
string remoteEndPoint = BinaryUtils.ReadString(data);
bool isError = true;
if (appCenter.AllowPortList.Any(t => t.Match(mapPort, m_tcpClient.ClientName)))
{
P2PTcpClient portClient = null;
EasyOp.Do(() => { portClient = new P2PTcpClient("127.0.0.1", mapPort); }, () =>
{
P2PTcpClient serverClient = null;
EasyOp.Do(() =>
{
serverClient = new P2PTcpClient(appCenter.ServerAddress, appCenter.ServerPort);
}, () =>
{
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
Models.Send.Send_0x0211 sendPacket = new Models.Send.Send_0x0211(token, true, "");
LogUtils.Debug($"命令：0x0211 正在绑定内网穿透（2端）通道 {portClient.RemoteEndPoint}->服务器->{remoteEndPoint}{Environment.NewLine}token:{token} ");
EasyOp.Do(() =>
{
serverClient.BeginSend(sendPacket.PackData());
}, () =>
{
EasyOp.Do(() =>
{
Global_Func.ListenTcp <Models.Receive.Packet_0x0212>(portClient);
Global_Func.ListenTcp <Models.Receive.Packet_ToPort>(serverClient);
isError = false;
LogUtils.Debug($"命令：0x0211 成功绑定内网穿透（2端）通道 {portClient.RemoteEndPoint}->服务器->{remoteEndPoint}{Environment.NewLine}token:{token} ");
}, ex =>
{
LogUtils.Debug($"命令：0x0211 接收数据发生错误:{Environment.NewLine}{ex}");
EasyOp.Do(() => { portClient?.SafeClose(); });
EasyOp.Do(() => { serverClient?.SafeClose(); });
SendError(token, $"客户端发生异常，{ex.Message}");
});
}, ex =>
{
LogUtils.Debug($"命令：0x0211 无法连接服务器:{Environment.NewLine}{ex}");
EasyOp.Do(() => { portClient?.SafeClose(); });
EasyOp.Do(() => { serverClient?.SafeClose(); });
SendError(token, $"向服务端发送数据失败");
});
}, ex =>
{
LogUtils.Debug($"命令：0x0211 无法连接服务器:{Environment.NewLine}{ex}");
EasyOp.Do(() => { portClient?.SafeClose(); });
SendError(token, $"无法建立到服务端的tcp连接");
});
}, ex =>
{
LogUtils.Debug($"命令：0x0211 建立tcp连接[127.0.0.1:{mapPort}]失败:{Environment.NewLine}{ex}");
SendError(token, $"目标端口{mapPort}连接失败！");
});
}
else
{
LogUtils.Debug($"命令：0x0211 已拒绝服务端连接本地端口[{mapPort}]，不在AllowPort配置项的允许范围内");
SendError(token, $"无权限访问端口{mapPort}，请配置AllowPort");
}
return(true);
}
/// <summary>
/// 从目标端创建与服务器的tcp连接
/// </summary>
/// <param name="token"></param>
public void CreateTcpFromDest(string token)
{
Utils.LogUtils.Debug($"命令：0x0201 正在连接中转模式隧道通道 token:{token}");
int port = BinaryUtils.ReadInt(data);
PortMapItem destMap = appCenter.PortMapList.FirstOrDefault(t => t.LocalPort == port && string.IsNullOrEmpty(t.LocalAddress));
P2PTcpClient portClient = null;
EasyOp.Do(() =>
{
if (destMap != null)
{
if (destMap.MapType == PortMapType.ip)
{
portClient = new P2PTcpClient(destMap.RemoteAddress, destMap.RemotePort);
}
else
{
portClient = new P2PTcpClient("127.0.0.1", port);
}
}
else
{
portClient = new P2PTcpClient("127.0.0.1", port);
}
}, () =>
{
P2PTcpClient serverClient = null;
EasyOp.Do(() =>
{
serverClient = new P2PTcpClient(appCenter.ServerAddress, appCenter.ServerPort);
}, () =>
{
portClient.IsAuth = serverClient.IsAuth = true;
portClient.ToClient = serverClient;
serverClient.ToClient = portClient;
Models.Send.Send_0x0201_Bind sendPacket = new Models.Send.Send_0x0201_Bind(token);
EasyOp.Do(() =>
{
serverClient.BeginSend(sendPacket.PackData());
}, () =>
{
EasyOp.Do(() =>
{
Global_Func.ListenTcp <ReceivePacket>(serverClient);
Utils.LogUtils.Debug($"命令：0x0201 中转模式隧道，连接成功 token:{token}");
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道,连接失败 token:{token}：{Environment.NewLine}{ex}");
EasyOp.Do(portClient.SafeClose);
EasyOp.Do(portClient.SafeClose);
});
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道,连接失败 token:{token}：{Environment.NewLine}{ex}");
EasyOp.Do(portClient.SafeClose);
});
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道,连接失败 token:{token}：{Environment.NewLine}{ex}");
EasyOp.Do(portClient.SafeClose);
});
}, ex =>
{
LogUtils.Debug($"命令：0x0201 P2P模式隧道,连接目标端口失败 token{token}：{Environment.NewLine}{ex}");
});
}
/// <summary>
/// 监听连接外部程序的端口
/// </summary>
public void ListenPort()
{
// 监听端口
AppCenter.Instance.StartNewTask(() => { Global_Func.ListenTcp <Packet_0x0202>(m_tcpClient.ToClient); });
}
/// <summary>
/// 监听连接外部程序的端口
/// </summary>
public void ListenPort()
{
// 监听端口
Global.TaskFactory.StartNew(() => { Global_Func.ListenTcp <Packet_0x0202>(m_tcpClient.ToClient); });
}
