apps/linker
1
0
Fork 0
mirror of https://github.com/snltty/linker.git synced 2025-10-07 01:52:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

demo

Browse Source
This commit is contained in:
snltty
2024-12-22 16:19:16 +08:00
parent 1343579504
commit c205db2a19
28 changed files with 392 additions and 453 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
linker.messenger.example/Program.cs
View File

@@ -12,7 +12,6 @@ using linker.plugins.tunnel;
using linker.tunnel;
using linker.tunnel.connection;
using linker.tunnel.transport;
using linker.tunnel.wanport;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
@@ -75,34 +74,22 @@ namespace linker.messenger.example
IMessengerSender messengerSender = new MessengerSender();
IMessengerResolver messengerResolver = new MessengerResolver(messengerSender);
//外网端口相关
TunnelWanPortTransfer tunnelWanPortTransfer = new TunnelWanPortTransfer();
tunnelWanPortTransfer.LoadTransports(new List<ITunnelWanPortProtocol> {
new TunnelWanPortProtocolLinkerUdp(),
new TunnelWanPortProtocolLinkerTcp(),
});
//打洞相关
TunnelTransfer tunnelTransfer = new TunnelTransfer();
TunnelExcludeIPTransfer tunnelExcludeIPTransfer = new TunnelExcludeIPTransfer();
//tunnelExcludeIPTransfer.LoadTunnelExcludeIPs(new List<ITunnelExcludeIP>());
TunnelMessengerAdapter tunnelMessengerAdapter = new TunnelMessengerAdapter(messengerSender, tunnelExcludeIPTransfer, serializer, new TunnelMessengerAdapterStore());
TunnelTransfer tunnelTransfer = new TunnelTransfer(tunnelMessengerAdapter);
tunnelTransfer.SetConnectedCallback("default", (connection) =>
{
Console.WriteLine($"打洞成功，收到 {connection.IPEndPoint} {connection.RemoteMachineId} 的连接");
connection.BeginReceive(new TunnelConnectionReceiveCallback(), null);
});
//打洞排除IP
TunnelExcludeIPTransfer tunnelExcludeIPTransfer = new TunnelExcludeIPTransfer();
//
//tunnelExcludeIPTransfer.LoadTunnelExcludeIPs(new List<ITunnelExcludeIP>());
TunnelClientMessenger tunnelClientMessenger = new TunnelClientMessenger(tunnelTransfer, messengerSender, serializer);
TunnelMessengerAdapter tunnelMessengerAdapter = new TunnelMessengerAdapter(messengerSender,
tunnelExcludeIPTransfer, tunnelWanPortTransfer, new TunnelUpnpTransfer(),
tunnelTransfer, serializer, new TunnelMessengerAdapterStore());
//中继相关
IRelayClientStore relayClientStore = new RelayClientStore();
RelayClientTransfer relayClientTransfer = new RelayClientTransfer(relayClientStore);
relayClientTransfer.LoadTransports(new List<IRelayClientTransport> { new RelayClientTransportSelfHost(messengerSender, serializer, relayClientStore) });
RelayClientTransfer relayClientTransfer = new RelayClientTransfer(messengerSender, serializer, relayClientStore);
relayClientTransfer.SetConnectedCallback("default", (connection) =>
{
Console.WriteLine($"中继成功，收到 {connection.IPEndPoint} {connection.RemoteMachineId} 的连接");
@@ -121,11 +108,6 @@ namespace linker.messenger.example
Console.WriteLine($"输入服务端ip端口:");
publicConfigInfo.Host = Console.ReadLine();
publicConfigInfo.RouteLevel = NetworkHelper.GetRouteLevel(publicConfigInfo.Host, out List<IPAddress> ips);
publicConfigInfo.LocalIps = NetworkHelper.GetIPV6().Concat(NetworkHelper.GetIPV4()).ToArray();
Console.WriteLine($"本地IP : {string.Join(",", publicConfigInfo.LocalIps.Select(c => c.ToString()))}");
Console.WriteLine($"外网距离 : {publicConfigInfo.RouteLevel}");
Console.WriteLine($"开始连接服务器");
IPEndPoint server = NetworkHelper.GetEndPoint(publicConfigInfo.Host, 1802);
Socket socket = new Socket(server.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
@@ -162,8 +144,9 @@ namespace linker.messenger.example
publicConfigInfo.SignConnection?.Disponse(6);
return;
}
publicConfigInfo.MachineId = signResp.MachineId;
publicConfigInfo.SignConnection.Id = signResp.MachineId;
Console.WriteLine($"你的id:{signResp.MachineId}");
tunnelTransfer.Refresh();
Console.WriteLine($"去连接吗?，1打洞，2中继:");
string connect = Console.ReadLine();
@@ -181,7 +164,7 @@ namespace linker.messenger.example
break;
case "2":
{
tunnelConnection = await relayClientTransfer.ConnectAsync(publicConfigInfo.MachineId, id, "default");
tunnelConnection = await relayClientTransfer.ConnectAsync(publicConfigInfo.SignConnection.Id, id, "default");
}
break;
default:
@@ -366,10 +349,7 @@ namespace linker.messenger.example
public sealed class PublicConfigInfo
{
public string MachineId { get; set; }
public IConnection SignConnection { get; set; }
public IPAddress[] LocalIps { get; set; }
public int RouteLevel { get; set; }
public X509Certificate2 Certificate { get; set; }
public List<TunnelTransportItemInfo> TunnelTransports { get; set; }
@@ -434,20 +414,23 @@ namespace linker.messenger.example
public sealed class TunnelMessengerAdapterStore : ITunnelMessengerAdapterStore
{
public IConnection SignConnection => Program.publicConfigInfo.SignConnection;
public X509Certificate2 Certificate => Program.publicConfigInfo.Certificate;
public List<TunnelTransportItemInfo> TunnelTransports => Program.publicConfigInfo.TunnelTransports;
public int RouteLevelPlus => 0;
public int PortMapPrivate => 0;
public int PortMapPublic => 0;
public TunnelMessengerAdapterStore()
{
}
public bool SetTunnelTransports(List<TunnelTransportItemInfo> list)
public async Task<List<TunnelTransportItemInfo>> GetTunnelTransports()
{
return true;
return await Task.FromResult(Program.publicConfigInfo.TunnelTransports);
}
public async Task<bool> SetTunnelTransports(List<TunnelTransportItemInfo> list)
{
return await Task.FromResult(true);
}
}

10
linker.messenger.relay/client/RelayClientTransfer.cs
View File

@@ -17,14 +17,12 @@ namespace linker.messenger.relay.client
private Dictionary<string, List<Action<ITunnelConnection>>> OnConnected { get; } = new Dictionary<string, List<Action<ITunnelConnection>>>();
private readonly IRelayClientStore relayClientStore;
public RelayClientTransfer(IRelayClientStore relayClientStore)
public RelayClientTransfer(IMessengerSender messengerSender,ISerializer serializer,IRelayClientStore relayClientStore)
{
this.relayClientStore = relayClientStore;
}
public void LoadTransports(List<IRelayClientTransport> list)
{
Transports = list;
Transports = new List<IRelayClientTransport> {
new RelayClientTransportSelfHost(messengerSender,serializer,relayClientStore),
};
}
/// <summary>

12
linker.messenger.tunnel/ITunnelExcludeIP.cs
View File

@@ -7,16 +7,6 @@ namespace linker.messenger.tunnel
/// </summary>
public interface ITunnelExcludeIP
{
public ExcludeIPItem[] Get();
}
/// <summary>
/// 排除的IP
/// </summary>
public sealed partial class ExcludeIPItem
{
public ExcludeIPItem() { }
public IPAddress IPAddress { get; set; }
public byte Mask { get; set; } = 32;
public List<IPAddress> Get();
}
}

6
linker.messenger.tunnel/TunnelExcludeIPTransfer.cs
View File

@@ -1,4 +1,6 @@
namespace linker.messenger.tunnel
using System.Net;
namespace linker.messenger.tunnel
{
/// <summary>
/// 打洞排除IP
@@ -24,7 +26,7 @@
/// 获取所有实现类的排除IP
/// </summary>
/// <returns></returns>
public List<ExcludeIPItem> Get()
public List<IPAddress> Get()
{
return excludeIPs.SelectMany(c => c.Get()).ToList();
}

2
linker.messenger.tunnel/TunnelMessenger.cs
View File

@@ -29,7 +29,7 @@ namespace linker.messenger.tunnel
tunnelTransportInfo.Local = tunnelTransportInfo.Remote;
tunnelTransportInfo.Remote = local;
tunnel.OnBegin(tunnelTransportInfo);
_ = tunnel.OnBegin(tunnelTransportInfo);
connection.Write(Helper.TrueArray);
}

161
linker.messenger.tunnel/TunnelMessengerAdapter.cs
View File

@@ -1,12 +1,10 @@
using linker.tunnel.transport;
using linker.libs;
using System.Net;
using linker.tunnel.wanport;
using linker.tunnel;
using linker.messenger;
using linker.messenger.tunnel;
using System.Security.Cryptography.X509Certificates;
using linker.libs.extends;
namespace linker.plugins.tunnel
{
@@ -21,118 +19,81 @@ namespace linker.plugins.tunnel
public IConnection SignConnection { get; }
/// <summary>
/// 调整的网络层级
/// 配置的额外网络层级
/// </summary>
public int RouteLevelPlus { get; }
/// <summary>
/// ssl
/// 加密密钥
/// </summary>
public X509Certificate2 Certificate { get; }
/// <summary>
/// 打洞协议列表，按照这个列表去打洞
/// 端口映射内外端口
/// </summary>
public List<TunnelTransportItemInfo> TunnelTransports { get; }
public int PortMapPrivate { get; }
/// <summary>
/// 保存打洞协议列表，因为可能会有新的打洞协议
/// 端口映射外网端口
/// </summary>
public int PortMapPublic { get; }
/// <summary>
/// 获取打洞协议列表
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
public bool SetTunnelTransports(List<TunnelTransportItemInfo> list);
public Task<List<TunnelTransportItemInfo>> GetTunnelTransports();
/// <summary>
/// 保存打洞协议列表
/// </summary>
/// <param name="transports"></param>
public Task<bool> SetTunnelTransports(List<TunnelTransportItemInfo> list);
}
/// <summary>
/// 打洞信标适配
/// </summary>
public class TunnelMessengerAdapter
public class TunnelMessengerAdapter: ITunnelMessengerAdapter
{
public string MachineId => tunnelMessengerAdapterStore.SignConnection?.Id ?? string.Empty;
public int RouteLevelPlus => tunnelMessengerAdapterStore.RouteLevelPlus;
public IPEndPoint ServerHost => tunnelMessengerAdapterStore.SignConnection?.Address ?? null;
public X509Certificate2 Certificate => tunnelMessengerAdapterStore.Certificate;
public int PortMapPrivate => tunnelMessengerAdapterStore.PortMapPrivate;
public int PortMapPublic => tunnelMessengerAdapterStore.PortMapPublic;
private readonly IMessengerSender messengerSender;
private readonly TunnelExcludeIPTransfer excludeIPTransfer;
private readonly TunnelWanPortTransfer tunnelWanPortTransfer;
private readonly TunnelUpnpTransfer tunnelUpnpTransfer;
private readonly TunnelTransfer tunnelTransfer;
private readonly TransportTcpPortMap transportTcpPortMap;
private readonly TransportUdpPortMap transportUdpPortMap;
private readonly ISerializer serializer;
private readonly ITunnelMessengerAdapterStore tunnelMessengerAdapterStore;
public TunnelMessengerAdapter(IMessengerSender messengerSender, TunnelExcludeIPTransfer excludeIPTransfer, TunnelWanPortTransfer tunnelWanPortTransfer, TunnelUpnpTransfer tunnelUpnpTransfer, TunnelTransfer tunnelTransfer, ISerializer serializer,ITunnelMessengerAdapterStore tunnelMessengerAdapterStore)
public TunnelMessengerAdapter(IMessengerSender messengerSender, TunnelExcludeIPTransfer excludeIPTransfer, ISerializer serializer, ITunnelMessengerAdapterStore tunnelMessengerAdapterStore)
{
this.messengerSender = messengerSender;
this.excludeIPTransfer = excludeIPTransfer;
this.tunnelWanPortTransfer = tunnelWanPortTransfer;
this.tunnelUpnpTransfer = tunnelUpnpTransfer;
this.tunnelTransfer = tunnelTransfer;
this.serializer = serializer;
this.tunnelMessengerAdapterStore = tunnelMessengerAdapterStore;
//加载外网端口
tunnelWanPortTransfer.LoadTransports(new List<ITunnelWanPortProtocol>
{
new TunnelWanPortProtocolLinkerUdp(),
new TunnelWanPortProtocolLinkerTcp(),
});
tunnelTransfer.LocalIP = () => tunnelMessengerAdapterStore.SignConnection?.LocalAddress.Address ?? IPAddress.Any; ;
tunnelTransfer.ServerHost = () => tunnelMessengerAdapterStore.SignConnection?.Address ?? null;
tunnelTransfer.Certificate = () => tunnelMessengerAdapterStore.Certificate;
tunnelTransfer.GetTunnelTransports = () => tunnelMessengerAdapterStore.TunnelTransports;
tunnelTransfer.SetTunnelTransports = (transports, update) => tunnelMessengerAdapterStore.SetTunnelTransports(transports);
tunnelTransfer.GetLocalConfig = GetLocalConfig;
tunnelTransfer.GetRemoteWanPort = GetRemoteWanPort;
tunnelTransfer.SendConnectBegin = SendConnectBegin;
tunnelTransfer.SendConnectFail = SendConnectFail;
tunnelTransfer.SendConnectSuccess = SendConnectSuccess;
//加载打洞协议
transportTcpPortMap = new TransportTcpPortMap();
transportUdpPortMap = new TransportUdpPortMap();
tunnelTransfer.LoadTransports(tunnelWanPortTransfer, tunnelUpnpTransfer, new List<ITunnelTransport> {
new TunnelTransportTcpNutssb(),
new TransportMsQuic(),
new TransportTcpP2PNAT(),
transportTcpPortMap,
transportUdpPortMap,
new TransportUdp(),
});
}
private readonly NetworkInfo network = new NetworkInfo();
private NetworkInfo GetLocalConfig()
public async Task<List<IPAddress>> GetExcludeIps()
{
var excludeips = excludeIPTransfer.Get();
NetworkInfo networkInfo = new NetworkInfo { LocalIps= network.LocalIps, MachineId= network.MachineId, RouteLevel=network.RouteLevel+ tunnelMessengerAdapterStore.RouteLevelPlus };
networkInfo.LocalIps = networkInfo.LocalIps.Where(c =>
{
if (c.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
uint ip = NetworkHelper.IP2Value(c);
foreach (var item in excludeips)
{
uint maskValue = NetworkHelper.PrefixLength2Value(item.Mask);
uint ip1 = NetworkHelper.IP2Value(item.IPAddress);
if ((ip & maskValue) == (ip1 & maskValue))
{
return false;
}
}
}
return true;
}).ToArray();
return networkInfo;
return await Task.FromResult(excludeIPTransfer.Get());
}
private async Task<TunnelTransportWanPortInfo> GetRemoteWanPort(TunnelWanPortProtocolInfo info)
public async Task<List<TunnelTransportItemInfo>> GetTunnelTransports()
{
return await tunnelMessengerAdapterStore.GetTunnelTransports();
}
public async Task<bool> SetTunnelTransports(List<TunnelTransportItemInfo> list)
{
return await tunnelMessengerAdapterStore.SetTunnelTransports(list);
}
public async Task<TunnelTransportWanPortInfo> GetRemoteWanPort(TunnelWanPortProtocolInfo info)
{
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
@@ -146,7 +107,8 @@ namespace linker.plugins.tunnel
}
return null;
}
private async Task<bool> SendConnectBegin(TunnelTransportInfo tunnelTransportInfo)
public async Task<bool> SendConnectBegin(TunnelTransportInfo tunnelTransportInfo)
{
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
@@ -156,7 +118,7 @@ namespace linker.plugins.tunnel
}).ConfigureAwait(false);
return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
}
private async Task<bool> SendConnectFail(TunnelTransportInfo tunnelTransportInfo)
public async Task<bool> SendConnectFail(TunnelTransportInfo tunnelTransportInfo)
{
await messengerSender.SendOnly(new MessageRequestWrap
{
@@ -166,7 +128,7 @@ namespace linker.plugins.tunnel
}).ConfigureAwait(false);
return true;
}
private async Task<bool> SendConnectSuccess(TunnelTransportInfo tunnelTransportInfo)
public async Task<bool> SendConnectSuccess(TunnelTransportInfo tunnelTransportInfo)
{
await messengerSender.SendOnly(new MessageRequestWrap
{
@@ -177,40 +139,5 @@ namespace linker.plugins.tunnel
return true;
}
public void RefreshNetwork()
{
TimerHelper.Async(() =>
{
network.RouteLevel = NetworkHelper.GetRouteLevel(tunnelMessengerAdapterStore.SignConnection.Address.ToString(), out List<IPAddress> ips);
network.LocalIps = NetworkHelper.GetIPV6().Concat(NetworkHelper.GetIPV4()).ToArray();
network.MachineId = tunnelMessengerAdapterStore.SignConnection.Id;
});
}
/// <summary>
/// 刷新端口映射，一般来说，端口发生变化，或者网络发生变化就刷新一下
/// </summary>
/// <param name="publicPort"></param>
/// <param name="privatePort"></param>
public void RefreshPortMap(int publicPort, int privatePort)
{
if (privatePort > 0)
{
tunnelUpnpTransfer.SetMap(privatePort, publicPort);
_ = transportTcpPortMap.Listen(privatePort);
_ = transportUdpPortMap.Listen(privatePort);
}
else
{
if (tunnelMessengerAdapterStore.SignConnection != null && tunnelMessengerAdapterStore.SignConnection.Connected)
{
int ip = tunnelMessengerAdapterStore.SignConnection.LocalAddress.Address.GetAddressBytes()[3];
tunnelUpnpTransfer.SetMap(18180 + ip);
_ = transportTcpPortMap.Listen(18180 + ip);
_ = transportUdpPortMap.Listen(18180 + ip);
}
}
}
}
}

70
linker.tunnel/ITunnelMessengerAdapter.cs Normal file
View File

@@ -0,0 +1,70 @@
using linker.tunnel.transport;
using System.Net;
using System.Security.Cryptography.X509Certificates;
namespace linker.tunnel
{
public interface ITunnelMessengerAdapter
{
/// <summary>
/// 连接id
/// </summary>
public string MachineId { get; }
/// <summary>
/// 配置的额外网络层级
/// </summary>
public int RouteLevelPlus { get; }
/// <summary>
/// 服务器地址
/// </summary>
public IPEndPoint ServerHost { get; }
/// <summary>
/// 加密密钥
/// </summary>
public X509Certificate2 Certificate { get; }
/// <summary>
/// 端口映射内外端口
/// </summary>
public int PortMapPrivate { get; }
/// <summary>
/// 端口映射外网端口
/// </summary>
public int PortMapPublic { get; }
/// <summary>
/// 获取远端的外网信息，比如你是A，你要获取B的信息，可以在B调用 TunnelTransfer.GetWanPort() 发送回来
/// </summary>
public Task<TunnelTransportWanPortInfo> GetRemoteWanPort(TunnelWanPortProtocolInfo info);
/// <summary>
/// 发送开始打洞
/// </summary>
public Task<bool> SendConnectBegin(TunnelTransportInfo info);
/// <summary>
/// 发送打洞失败
/// </summary>
public Task<bool> SendConnectFail(TunnelTransportInfo info);
/// <summary>
/// 发送打洞成功
/// </summary>
public Task<bool> SendConnectSuccess(TunnelTransportInfo info);
/// <summary>
/// 获取打洞排除IP
/// </summary>
/// <returns></returns>
public Task<List<IPAddress>> GetExcludeIps();
/// <summary>
/// 获取打洞协议列表
/// </summary>
/// <returns></returns>
public Task<List<TunnelTransportItemInfo>> GetTunnelTransports();
/// <summary>
/// 保存打洞协议列表
/// </summary>
/// <param name="transports"></param>
public Task<bool> SetTunnelTransports(List<TunnelTransportItemInfo> list);
}
}

189
linker.tunnel/TunnelTransfer.cs
View File

@@ -6,93 +6,49 @@ using System.Collections.Concurrent;
using System.Net.Sockets;
using System.Net;
using linker.tunnel.wanport;
using System.Security.Cryptography.X509Certificates;
namespace linker.tunnel
{
public sealed class TunnelTransfer
{
/// <summary>
/// 本机局域网IP，当然你也可以使用0.0.0.0，但是使用局域网IP会提高打洞成功率
/// </summary>
public Func<IPAddress> LocalIP { get; set; } = () => IPAddress.Any;
/// <summary>
/// 服务器地址
/// </summary>
public Func<IPEndPoint> ServerHost { get; set; } = () => new IPEndPoint(IPAddress.Any, 0);
/// <summary>
/// ssl加密证书，没有证书则无法加密通信
/// </summary>
public Func<X509Certificate2> Certificate { get; set; } = () => null;
/// <summary>
/// 获取打洞协议列表
/// </summary>
/// <returns></returns>
public Func<List<TunnelTransportItemInfo>> GetTunnelTransports { get; set; } = () => new List<TunnelTransportItemInfo>();
/// <summary>
/// 保存打洞协议列表
/// </summary>
/// <param name="transports"></param>
public Action<List<TunnelTransportItemInfo>, bool> SetTunnelTransports { get; set; } = (list, update) => { };
/// <summary>
/// 获取本地网络信息
/// </summary>
/// <returns></returns>
public Func<NetworkInfo> GetLocalConfig { get; set; } = () => new NetworkInfo();
/// <summary>
/// 获取远端的外网信息，比如你是A，你要获取B的信息，可以在B调用 TunnelTransfer.GetWanPort() 发送回来
/// </summary>
public Func<TunnelWanPortProtocolInfo, Task<TunnelTransportWanPortInfo>> GetRemoteWanPort { get; set; } = async (info) => { return await Task.FromResult(new TunnelTransportWanPortInfo()); };
/// <summary>
/// 发送开始打洞
/// </summary>
public Func<TunnelTransportInfo, Task<bool>> SendConnectBegin { get; set; } = async (info) => { return await Task.FromResult(false); };
/// <summary>
/// 发送打洞失败
/// </summary>
public Func<TunnelTransportInfo, Task<bool>> SendConnectFail { get; set; } = async (info) => { return await Task.FromResult(false); };
/// <summary>
/// 发送打洞成功
/// </summary>
public Func<TunnelTransportInfo, Task<bool>> SendConnectSuccess { get; set; } = async (info) => { return await Task.FromResult(false); };
private readonly NetworkInfo networkInfo = new NetworkInfo();
private List<ITunnelTransport> transports;
private TunnelWanPortTransfer tunnelWanPortTransfer;
private TunnelUpnpTransfer TunnelUpnpTransfer;
private TunnelUpnpTransfer tunnelUpnpTransfer;
private ConcurrentDictionary<string, bool> connectingDic = new ConcurrentDictionary<string, bool>();
private uint flowid = 1;
private Dictionary<string, List<Action<ITunnelConnection>>> OnConnected { get; } = new Dictionary<string, List<Action<ITunnelConnection>>>();
public TunnelTransfer()
{
}
/// <summary>
/// 装载打洞协议
/// </summary>
/// <param name="assembs"></param>
public void LoadTransports(TunnelWanPortTransfer tunnelWanPortTransfer, TunnelUpnpTransfer TunnelUpnpTransfer, List<ITunnelTransport> transports)
private readonly ITunnelMessengerAdapter tunnelMessengerAdapter;
public TunnelTransfer(ITunnelMessengerAdapter tunnelMessengerAdapter)
{
this.tunnelWanPortTransfer = tunnelWanPortTransfer;
this.transports = transports;
this.TunnelUpnpTransfer = TunnelUpnpTransfer;
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
TransportUdpPortMap transportUdpPortMap = new TransportUdpPortMap(tunnelMessengerAdapter);
TransportTcpPortMap transportTcpPortMap = new TransportTcpPortMap(tunnelMessengerAdapter);
this.tunnelUpnpTransfer = new TunnelUpnpTransfer(transportUdpPortMap, transportTcpPortMap);
tunnelWanPortTransfer = new TunnelWanPortTransfer();
transports = new List<ITunnelTransport> {
new TransportUdp(tunnelMessengerAdapter),
new TransportTcpP2PNAT(tunnelMessengerAdapter),
new TransportTcpNutssb(tunnelMessengerAdapter),
transportUdpPortMap,
transportTcpPortMap,
new TransportMsQuic(tunnelMessengerAdapter)
};
foreach (var item in transports)
{
item.OnSendConnectBegin = SendConnectBegin;
item.OnSendConnectFail = SendConnectFail;
item.OnSendConnectSuccess = SendConnectSuccess;
item.OnConnected = _OnConnected;
item.SetSSL(Certificate());
}
var transportItems = GetTunnelTransports().ToList();
_ = RebuildTransports();
}
private async Task RebuildTransports()
{
var transportItems = (await tunnelMessengerAdapter.GetTunnelTransports()).ToList();
//有新的协议
var newTransportNames = transports.Select(c => c.Name).Except(transportItems.Select(c => c.Name));
if (newTransportNames.Any())
@@ -143,10 +99,60 @@ namespace linker.tunnel
}
}
SetTunnelTransports(transportItems, true);
await tunnelMessengerAdapter.SetTunnelTransports(transportItems);
LoggerHelper.Instance.Info($"load tunnel transport:{string.Join(",", transports.Select(c => c.Name))}");
}
/// <summary>
/// 刷新一下网络信息，比如路由级别，本机IP等
/// </summary>
public void Refresh()
{
RefreshNetwork();
}
private void RefreshNetwork()
{
TimerHelper.Async(async () =>
{
networkInfo.RouteLevel = NetworkHelper.GetRouteLevel(tunnelMessengerAdapter.ServerHost.ToString(), out List<IPAddress> ips);
networkInfo.LocalIps = NetworkHelper.GetIPV6().Concat(NetworkHelper.GetIPV4()).ToArray();
networkInfo.MachineId = tunnelMessengerAdapter.MachineId;
networkInfo.LocalIp = await GetLocalIP(tunnelMessengerAdapter.ServerHost);
if (tunnelMessengerAdapter.PortMapPrivate > 0)
{
tunnelUpnpTransfer.SetMap(tunnelMessengerAdapter.PortMapPrivate, tunnelMessengerAdapter.PortMapPublic);
}
else
{
if (networkInfo.LocalIp.Equals(IPAddress.Any) == false)
{
int ip = networkInfo.LocalIp.GetAddressBytes()[3];
tunnelUpnpTransfer.SetMap(18180 + ip);
}
}
async Task<IPAddress> GetLocalIP(IPEndPoint server)
{
var socket = new Socket(server.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
await socket.ConnectAsync(server);
return (socket.LocalEndPoint as IPEndPoint).Address;
}
catch (Exception)
{
}
finally
{
socket.SafeClose();
}
return IPAddress.Any;
}
});
}
/// <summary>
/// 设置成功打洞回调
/// </summary>
@@ -200,9 +206,11 @@ namespace linker.tunnel
try
{
foreach (TunnelTransportItemInfo transportItem in GetTunnelTransports().OrderBy(c => c.Order).Where(c => c.Disabled == false))
var _transports = await tunnelMessengerAdapter.GetTunnelTransports();
foreach (TunnelTransportItemInfo transportItem in _transports.OrderBy(c => c.Order).Where(c => c.Disabled == false))
{
ITunnelTransport transport = transports.FirstOrDefault(c => c.Name == transportItem.Name);
transport.SetSSL(tunnelMessengerAdapter.Certificate);
//找不到这个打洞协议，或者是不支持的协议
if (transport == null || (transport.ProtocolType & denyProtocols) == transport.ProtocolType)
{
@@ -228,7 +236,7 @@ namespace linker.tunnel
//获取自己的外网ip
Task<TunnelTransportWanPortInfo> localInfo = GetLocalInfo(wanPortProtocol);
//获取对方的外网ip
Task<TunnelTransportWanPortInfo> remoteInfo = GetRemoteWanPort(new TunnelWanPortProtocolInfo
Task<TunnelTransportWanPortInfo> remoteInfo = tunnelMessengerAdapter.GetRemoteWanPort(new TunnelWanPortProtocolInfo
{
MachineId = remoteMachineId,
ProtocolType = wanPortProtocol
@@ -307,7 +315,7 @@ namespace linker.tunnel
/// 收到对方开始连接的消息
/// </summary>
/// <param name="tunnelTransportInfo"></param>
public void OnBegin(TunnelTransportInfo tunnelTransportInfo)
public async Task OnBegin(TunnelTransportInfo tunnelTransportInfo)
{
if (connectingDic.TryAdd(tunnelTransportInfo.Remote.MachineId, true) == false)
{
@@ -315,13 +323,15 @@ namespace linker.tunnel
}
try
{
ITunnelTransport _transports = transports.FirstOrDefault(c => c.Name == tunnelTransportInfo.TransportName && c.ProtocolType == tunnelTransportInfo.TransportType);
TunnelTransportItemInfo item = GetTunnelTransports().FirstOrDefault(c => c.Name == tunnelTransportInfo.TransportName && c.Disabled == false);
if (_transports != null && item != null)
var _transports = await tunnelMessengerAdapter.GetTunnelTransports();
ITunnelTransport transport = transports.FirstOrDefault(c => c.Name == tunnelTransportInfo.TransportName && c.ProtocolType == tunnelTransportInfo.TransportType);
TunnelTransportItemInfo item = _transports.FirstOrDefault(c => c.Name == tunnelTransportInfo.TransportName && c.Disabled == false);
if (transport != null && item != null)
{
transport.SetSSL(tunnelMessengerAdapter.Certificate);
OnConnectBegin(tunnelTransportInfo);
ParseRemoteEndPoint(tunnelTransportInfo);
_transports.OnBegin(tunnelTransportInfo).ContinueWith((result) =>
_ = transport.OnBegin(tunnelTransportInfo).ContinueWith((result) =>
{
connectingDic.TryRemove(tunnelTransportInfo.Remote.MachineId, out _);
});
@@ -329,7 +339,7 @@ namespace linker.tunnel
else
{
connectingDic.TryRemove(tunnelTransportInfo.Remote.MachineId, out _);
_ = SendConnectFail(tunnelTransportInfo);
_ = tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo);
}
}
catch (Exception ex)
@@ -370,30 +380,39 @@ namespace linker.tunnel
{
return await GetLocalInfo(_info.ProtocolType).ConfigureAwait(false);
}
/// <summary>
/// 获取自己的外网IP
/// </summary>
/// <returns></returns>
private async Task<TunnelTransportWanPortInfo> GetLocalInfo(TunnelWanPortProtocolType tunnelWanPortProtocolType)
{
var config = GetLocalConfig();
if (string.IsNullOrWhiteSpace(config.MachineId))
if (tunnelMessengerAdapter.ServerHost == null || string.IsNullOrWhiteSpace(tunnelMessengerAdapter.MachineId)) return null;
var excludeips = await tunnelMessengerAdapter.GetExcludeIps();
NetworkInfo network = new NetworkInfo
{
LocalIps = networkInfo.LocalIps.Where(c => excludeips.Contains(c) == false).ToArray(),
RouteLevel = networkInfo.RouteLevel + tunnelMessengerAdapter.RouteLevelPlus,
MachineId = tunnelMessengerAdapter.MachineId,
LocalIp = networkInfo.LocalIp,
};
if (string.IsNullOrWhiteSpace(network.MachineId))
{
return null;
}
TunnelWanPortEndPoint ip = await tunnelWanPortTransfer.GetWanPortAsync(ServerHost(), LocalIP(), tunnelWanPortProtocolType).ConfigureAwait(false);
Console.WriteLine(network.ToJson());
TunnelWanPortEndPoint ip = await tunnelWanPortTransfer.GetWanPortAsync(tunnelMessengerAdapter.ServerHost, network.LocalIp, tunnelWanPortProtocolType).ConfigureAwait(false);
if (ip != null)
{
MapInfo portMapInfo = TunnelUpnpTransfer.PortMap ?? new MapInfo { PrivatePort = 0, PublicPort = 0 };
MapInfo portMapInfo = tunnelUpnpTransfer.PortMap ?? new MapInfo { PrivatePort = 0, PublicPort = 0 };
return new TunnelTransportWanPortInfo
{
Local = ip.Local,
Remote = ip.Remote,
LocalIps = config.LocalIps,
RouteLevel = config.RouteLevel,
MachineId = config.MachineId,
LocalIps = network.LocalIps,
RouteLevel = network.RouteLevel,
MachineId = network.MachineId,
PortMapLan = portMapInfo.PrivatePort,
PortMapWan = portMapInfo.PublicPort,
};
@@ -401,6 +420,7 @@ namespace linker.tunnel
return null;
}
private void OnConnecting(TunnelTransportInfo tunnelTransportInfo)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
@@ -411,7 +431,6 @@ namespace linker.tunnel
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Info($"tunnel connecting from {tunnelTransportInfo.Remote.MachineId}->{tunnelTransportInfo.Remote.MachineName}");
}
/// <summary>
/// 连接成功
/// </summary>

15
linker.tunnel/TunnelUpnpTransfer.cs
View File

@@ -1,4 +1,5 @@
using linker.libs;
using linker.tunnel.transport;
using Mono.Nat;
using System.Collections.Concurrent;
@@ -18,11 +19,17 @@ namespace linker.tunnel
public MapInfo PortMap => MapInfo1 ?? MapInfo;
public TunnelUpnpTransfer()
private readonly TransportUdpPortMap transportUdpPortMap;
private readonly TransportTcpPortMap transportTcpPortMap;
public TunnelUpnpTransfer(TransportUdpPortMap transportUdpPortMap,TransportTcpPortMap transportTcpPortMap)
{
this.transportUdpPortMap = transportUdpPortMap;
this.transportTcpPortMap = transportTcpPortMap;
NatUtility.DeviceFound += DeviceFound;
NatUtility.StartDiscovery();
LoopDiscovery();
}
private void LoopDiscovery()
@@ -105,6 +112,9 @@ namespace linker.tunnel
{
MapInfo = new MapInfo { PrivatePort = privatePort, PublicPort = privatePort };
AddMap();
_ = transportTcpPortMap.Listen(privatePort);
_ = transportUdpPortMap.Listen(privatePort);
}
/// <summary>
/// 设置端口映射，内网端口和外网端口不一样
@@ -114,6 +124,9 @@ namespace linker.tunnel
public void SetMap(int privatePort, int publicPort)
{
MapInfo1 = new MapInfo { PrivatePort = privatePort, PublicPort = publicPort };
_ = transportTcpPortMap.Listen(privatePort);
_ = transportUdpPortMap.Listen(privatePort);
}
}

16
linker.tunnel/transport/ITunnelTransport.cs
View File

@@ -45,18 +45,6 @@ namespace linker.tunnel.transport
/// </summary>
public byte Order { get; }
/// <summary>
/// 发送连接开始信息
/// </summary>
public Func<TunnelTransportInfo, Task<bool>> OnSendConnectBegin { get; set; }
/// <summary>
/// 发送连接失败消息
/// </summary>
public Func<TunnelTransportInfo, Task> OnSendConnectFail { get; set; }
/// <summary>
/// 发送连接成功消息
/// </summary>
public Func<TunnelTransportInfo, Task> OnSendConnectSuccess { get; set; }
/// <summary>
/// 收到连接
/// </summary>
@@ -236,6 +224,10 @@ namespace linker.tunnel.transport
/// </summary>
public IPAddress[] LocalIps { get; set; } = Array.Empty<IPAddress>();
/// <summary>
/// 本机网卡IP
/// </summary>
public IPAddress LocalIp { get; set; } = IPAddress.Any;
/// <summary>
/// 本机与外网的距离，通过多少网关，可以通过NetworkHelper.GetRouteLevel 获取
/// </summary>
public int RouteLevel { get; set; }

32
linker.tunnel/transport/TransportMsQuic.cs
View File

@@ -35,22 +35,20 @@ namespace linker.tunnel.transport
public byte Order => 255;
public Func<TunnelTransportInfo, Task<bool>> OnSendConnectBegin { get; set; } = async (info) => { return await Task.FromResult<bool>(false); };
public Func<TunnelTransportInfo, Task> OnSendConnectFail { get; set; } = async (info) => { await Task.CompletedTask; };
public Func<TunnelTransportInfo, Task> OnSendConnectSuccess { get; set; } = async (info) => { await Task.CompletedTask; };
public Action<ITunnelConnection> OnConnected { get; set; } = (state) => { };
private ConcurrentDictionary<int, ListenAsyncToken> stateDic = new ConcurrentDictionary<int, ListenAsyncToken>();
private byte[] authBytes = Encoding.UTF8.GetBytes($"{Helper.GlobalString}.ttl");
private byte[] endBytes = Encoding.UTF8.GetBytes($"{Helper.GlobalString}.end");
private IPEndPoint quicListenEP = null;
public TransportMsQuic()
private readonly ITunnelMessengerAdapter tunnelMessengerAdapter;
public TransportMsQuic(ITunnelMessengerAdapter tunnelMessengerAdapter)
{
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
_ = QuicListen();
}
private X509Certificate2 certificate;
@@ -71,13 +69,13 @@ namespace linker.tunnel.transport
if (QuicListener.IsSupported == false)
{
LoggerHelper.Instance.Warning($"msquic not supported, need win11+,or linux");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
if (certificate == null)
{
LoggerHelper.Instance.Warning($"msquic need ssl");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
}
@@ -85,7 +83,7 @@ namespace linker.tunnel.transport
if (tunnelTransportInfo.Direction == TunnelDirection.Forward)
{
//正向连接
if (await OnSendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
{
return null;
}
@@ -93,7 +91,7 @@ namespace linker.tunnel.transport
ITunnelConnection connection = await ConnectForward(tunnelTransportInfo).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
@@ -104,19 +102,19 @@ namespace linker.tunnel.transport
_ = ListenRemoteConnect(tunnelTransportInfo.BufferSize, tunnelTransportInfo1.Local.Local, quicListenEP, tunnelTransportInfo1);
await Task.Delay(50).ConfigureAwait(false);
BindAndTTL(tunnelTransportInfo1);
if (await OnSendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
{
return null;
}
ITunnelConnection connection = await WaitReverse(tunnelTransportInfo1).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
/// <summary>
@@ -131,13 +129,13 @@ namespace linker.tunnel.transport
if (QuicListener.IsSupported == false)
{
LoggerHelper.Instance.Warning($"msquic not supported, need win11+,or linux");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
if (certificate == null)
{
LoggerHelper.Instance.Warning($"msquic need ssl");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
}
@@ -154,11 +152,11 @@ namespace linker.tunnel.transport
if (connection != null)
{
OnConnected(connection);
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
}
else
{
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
}
}
}

35
linker.tunnel/transport/TransportTcpNutssb.cs
View File

@@ -20,7 +20,7 @@ namespace linker.tunnel.transport
/// B 收到通知，开始监听连接，并且以低TTL方式尝试连接A，这时候A肯定收不到
/// A 正常去连接 B，能连接成功则通道可用
/// </summary>
public sealed class TunnelTransportTcpNutssb : ITunnelTransport
public sealed class TransportTcpNutssb : ITunnelTransport
{
public string Name => "TcpNutssb";
public string Label => "TCP、低TTL";
@@ -36,26 +36,15 @@ namespace linker.tunnel.transport
public byte Order => 2;
/// <summary>
/// 发送开始连接消息
/// </summary>
public Func<TunnelTransportInfo, Task<bool>> OnSendConnectBegin { get; set; } = async (info) => { return await Task.FromResult<bool>(false); };
/// <summary>
/// 发送连接失败消息
/// </summary>
public Func<TunnelTransportInfo, Task> OnSendConnectFail { get; set; } = async (info) => { await Task.CompletedTask; };
/// <summary>
/// 发送连接成功消息
/// </summary>
public Func<TunnelTransportInfo, Task> OnSendConnectSuccess { get; set; } = async (info) => { await Task.CompletedTask; };
/// <summary>
/// 连接成功
/// </summary>
public Action<ITunnelConnection> OnConnected { get; set; } = (state) => { };
public TunnelTransportTcpNutssb()
private readonly ITunnelMessengerAdapter tunnelMessengerAdapter;
public TransportTcpNutssb(ITunnelMessengerAdapter tunnelMessengerAdapter)
{
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
}
private X509Certificate2 certificate;
public void SetSSL(X509Certificate2 certificate)
@@ -73,7 +62,7 @@ namespace linker.tunnel.transport
if (tunnelTransportInfo.Direction == TunnelDirection.Forward)
{
//正向连接
if (await OnSendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
{
return null;
}
@@ -81,7 +70,7 @@ namespace linker.tunnel.transport
ITunnelConnection connection = await ConnectForward(tunnelTransportInfo).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
@@ -91,7 +80,7 @@ namespace linker.tunnel.transport
TunnelTransportInfo tunnelTransportInfo1 = tunnelTransportInfo.ToJsonFormat().DeJson<TunnelTransportInfo>();
_ = StartListen(tunnelTransportInfo1.Local.Local, tunnelTransportInfo1);
BindAndTTL(tunnelTransportInfo1);
if (await OnSendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
{
return null;
}
@@ -99,13 +88,13 @@ namespace linker.tunnel.transport
ITunnelConnection connection = await WaitReverse(tunnelTransportInfo1).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
/// <summary>
@@ -117,7 +106,7 @@ namespace linker.tunnel.transport
if (tunnelTransportInfo.SSL && certificate == null)
{
LoggerHelper.Instance.Error($"{Name}->ssl Certificate not found");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
//正向连接，也就是它要连接我，那我就监听
@@ -137,11 +126,11 @@ namespace linker.tunnel.transport
if (connection != null)
{
OnConnected(connection);
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
}
else
{
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
}
}
}

28
linker.tunnel/transport/TransportTcpP2PNAT.cs
View File

@@ -34,18 +34,6 @@ namespace linker.tunnel.transport
public byte Order => 1;
/// <summary>
/// 发送开始连接消息
/// </summary>
public Func<TunnelTransportInfo, Task<bool>> OnSendConnectBegin { get; set; } = async (info) => { return await Task.FromResult<bool>(false); };
/// <summary>
/// 发送连接失败消息
/// </summary>
public Func<TunnelTransportInfo, Task> OnSendConnectFail { get; set; } = async (info) => { await Task.CompletedTask; };
/// <summary>
/// 发送连接成功消息
/// </summary>
public Func<TunnelTransportInfo, Task> OnSendConnectSuccess { get; set; } = async (info) => { await Task.CompletedTask; };
/// <summary>
/// 连接成功
/// </summary>
@@ -55,8 +43,10 @@ namespace linker.tunnel.transport
private byte[] authBytes = Encoding.UTF8.GetBytes($"{Helper.GlobalString}.ttl");
private byte[] endBytes = Encoding.UTF8.GetBytes($"{Helper.GlobalString}.end");
public TransportTcpP2PNAT()
private readonly ITunnelMessengerAdapter tunnelMessengerAdapter;
public TransportTcpP2PNAT(ITunnelMessengerAdapter tunnelMessengerAdapter)
{
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
}
private X509Certificate2 certificate;
@@ -72,7 +62,7 @@ namespace linker.tunnel.transport
/// <returns></returns>
public async Task<ITunnelConnection> ConnectAsync(TunnelTransportInfo tunnelTransportInfo)
{
if (await OnSendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
{
return null;
}
@@ -83,11 +73,11 @@ namespace linker.tunnel.transport
ITunnelConnection connection = await ConnectForward(tunnelTransportInfo, TunnelMode.Client).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
/// <summary>
@@ -99,18 +89,18 @@ namespace linker.tunnel.transport
if (tunnelTransportInfo.SSL && certificate == null)
{
LoggerHelper.Instance.Error($"{Name}->ssl Certificate not found");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
ITunnelConnection connection = await ConnectForward(tunnelTransportInfo, TunnelMode.Server).ConfigureAwait(false);
if (connection != null)
{
OnConnected(connection);
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
}
else
{
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
}
}

27
linker.tunnel/transport/TransportTcpPortMap.cs
View File

@@ -36,16 +36,15 @@ namespace linker.tunnel.transport
public byte Order => 4;
public Func<TunnelTransportInfo, Task<bool>> OnSendConnectBegin { get; set; } = async (info) => { return await Task.FromResult<bool>(false); };
public Func<TunnelTransportInfo, Task> OnSendConnectFail { get; set; } = async (info) => { await Task.CompletedTask; };
public Func<TunnelTransportInfo, Task> OnSendConnectSuccess { get; set; } = async (info) => { await Task.CompletedTask; };
public Action<ITunnelConnection> OnConnected { get; set; } = (state) => { };
private readonly ConcurrentDictionary<string, TaskCompletionSource<Socket>> distDic = new ConcurrentDictionary<string, TaskCompletionSource<Socket>>();
public TransportTcpPortMap()
private readonly ITunnelMessengerAdapter tunnelMessengerAdapter;
public TransportTcpPortMap(ITunnelMessengerAdapter tunnelMessengerAdapter)
{
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
}
private X509Certificate2 certificate;
public void SetSSL(X509Certificate2 certificate)
@@ -147,7 +146,7 @@ namespace linker.tunnel.transport
return null;
}
//正向连接
if (await OnSendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
{
return null;
}
@@ -155,7 +154,7 @@ namespace linker.tunnel.transport
ITunnelConnection connection = await ConnectForward(tunnelTransportInfo).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
@@ -171,20 +170,20 @@ namespace linker.tunnel.transport
TunnelTransportInfo tunnelTransportInfo1 = tunnelTransportInfo.ToJsonFormat().DeJson<TunnelTransportInfo>();
//等待对方连接，如果连接成功，我会收到一个socket，并且创建一个连接对象，失败的话会超时，那就是null
var task = WaitConnect(tunnelTransportInfo1);
if (await OnSendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
{
return null;
}
ITunnelConnection connection = await task.ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
public async Task OnBegin(TunnelTransportInfo tunnelTransportInfo)
@@ -192,7 +191,7 @@ namespace linker.tunnel.transport
if (tunnelTransportInfo.SSL && certificate == null)
{
LoggerHelper.Instance.Error($"{Name}->ssl Certificate not found");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
//正向连接，等他来连
@@ -202,7 +201,7 @@ namespace linker.tunnel.transport
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Error($"OnBegin WaitConnect 【{Name}】{tunnelTransportInfo.Local.MachineName} port mapping not configured");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
_ = WaitConnect(tunnelTransportInfo).ContinueWith((result) =>
@@ -217,7 +216,7 @@ namespace linker.tunnel.transport
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Error($"OnBegin ConnectForward 【{Name}】{tunnelTransportInfo.Remote.MachineName} port mapping not configured");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
@@ -225,11 +224,11 @@ namespace linker.tunnel.transport
if (connection != null)
{
OnConnected(connection);
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
}
else
{
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
}
}
}

21
linker.tunnel/transport/TransportUdp.cs
View File

@@ -40,9 +40,6 @@ namespace linker.tunnel.transport
public byte Order => 3;
public Func<TunnelTransportInfo, Task<bool>> OnSendConnectBegin { get; set; } = async (info) => { return await Task.FromResult<bool>(false); };
public Func<TunnelTransportInfo, Task> OnSendConnectFail { get; set; } = async (info) => { await Task.CompletedTask; };
public Func<TunnelTransportInfo, Task> OnSendConnectSuccess { get; set; } = async (info) => { await Task.CompletedTask; };
public Action<ITunnelConnection> OnConnected { get; set; } = (state) => { };
@@ -50,8 +47,10 @@ namespace linker.tunnel.transport
private byte[] authBytes = Encoding.UTF8.GetBytes($"{Helper.GlobalString}.ttl");
private byte[] endBytes = Encoding.UTF8.GetBytes($"{Helper.GlobalString}.end");
public TransportUdp()
private readonly ITunnelMessengerAdapter tunnelMessengerAdapter;
public TransportUdp(ITunnelMessengerAdapter tunnelMessengerAdapter)
{
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
}
public void SetSSL(X509Certificate2 certificate)
{
@@ -67,7 +66,7 @@ namespace linker.tunnel.transport
if (tunnelTransportInfo.Direction == TunnelDirection.Forward)
{
//正向连接
if (await OnSendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
{
return null;
}
@@ -75,7 +74,7 @@ namespace linker.tunnel.transport
ITunnelConnection connection = await ConnectForward(tunnelTransportInfo).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
@@ -86,19 +85,19 @@ namespace linker.tunnel.transport
_ = BindListen(tunnelTransportInfo1.Local.Local, tunnelTransportInfo1);
await Task.Delay(50).ConfigureAwait(false);
BindAndTTL(tunnelTransportInfo1);
if (await OnSendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
{
return null;
}
ITunnelConnection connection = await WaitReverse(tunnelTransportInfo1).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
@@ -125,11 +124,11 @@ namespace linker.tunnel.transport
if (connection != null)
{
OnConnected(connection);
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
}
else
{
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
}
}
}

27
linker.tunnel/transport/TransportUdpPortMap.cs
View File

@@ -34,9 +34,6 @@ namespace linker.tunnel.transport
public byte Order => 5;
public Func<TunnelTransportInfo, Task<bool>> OnSendConnectBegin { get; set; } = async (info) => { return await Task.FromResult<bool>(false); };
public Func<TunnelTransportInfo, Task> OnSendConnectFail { get; set; } = async (info) => { await Task.CompletedTask; };
public Func<TunnelTransportInfo, Task> OnSendConnectSuccess { get; set; } = async (info) => { await Task.CompletedTask; };
public Action<ITunnelConnection> OnConnected { get; set; } = (state) => { };
@@ -47,8 +44,10 @@ namespace linker.tunnel.transport
private readonly ConcurrentDictionary<string, TaskCompletionSource<State>> distDic = new ConcurrentDictionary<string, TaskCompletionSource<State>>();
private readonly ConcurrentDictionary<IPEndPoint, ConnectionCacheInfo> connectionsDic = new ConcurrentDictionary<IPEndPoint, ConnectionCacheInfo>(new IPEndPointComparer());
public TransportUdpPortMap()
private readonly ITunnelMessengerAdapter tunnelMessengerAdapter;
public TransportUdpPortMap(ITunnelMessengerAdapter tunnelMessengerAdapter)
{
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
CleanTask();
}
private X509Certificate2 certificate;
@@ -156,7 +155,7 @@ namespace linker.tunnel.transport
return null;
}
//正向连接
if (await OnSendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo).ConfigureAwait(false) == false)
{
return null;
}
@@ -164,7 +163,7 @@ namespace linker.tunnel.transport
ITunnelConnection connection = await ConnectForward(tunnelTransportInfo).ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
@@ -180,20 +179,20 @@ namespace linker.tunnel.transport
TunnelTransportInfo tunnelTransportInfo1 = tunnelTransportInfo.ToJsonFormat().DeJson<TunnelTransportInfo>();
//等待对方连接，如果连接成功，我会收到一个socket，并且创建一个连接对象，失败的话会超时，那就是null
var task = WaitConnect(tunnelTransportInfo1);
if (await OnSendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
if (await tunnelMessengerAdapter.SendConnectBegin(tunnelTransportInfo1).ConfigureAwait(false) == false)
{
return null;
}
ITunnelConnection connection = await task.ConfigureAwait(false);
if (connection != null)
{
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
return connection;
}
}
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return null;
}
public async Task OnBegin(TunnelTransportInfo tunnelTransportInfo)
@@ -201,7 +200,7 @@ namespace linker.tunnel.transport
if (tunnelTransportInfo.SSL && certificate == null)
{
LoggerHelper.Instance.Error($"{Name}->ssl Certificate not found");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
//正向连接，等他来连
@@ -211,7 +210,7 @@ namespace linker.tunnel.transport
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Error($"OnBegin WaitConnect 【{Name}】{tunnelTransportInfo.Local.MachineName} port mapping not configured");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
_ = WaitConnect(tunnelTransportInfo).ContinueWith((result) =>
@@ -226,7 +225,7 @@ namespace linker.tunnel.transport
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Error($"OnBegin ConnectForward 【{Name}】{tunnelTransportInfo.Remote.MachineName} port mapping not configured");
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
return;
}
@@ -234,11 +233,11 @@ namespace linker.tunnel.transport
if (connection != null)
{
OnConnected(connection);
await OnSendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectSuccess(tunnelTransportInfo).ConfigureAwait(false);
}
else
{
await OnSendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
await tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo).ConfigureAwait(false);
}
}
}

1
linker.tunnel/wanport/TunnelWanPortProtocolLinker.cs
View File

@@ -26,6 +26,7 @@ namespace linker.tunnel.wanport
UdpClient udpClient = new UdpClient(AddressFamily.InterNetwork);
udpClient.Client.ReuseBind(new IPEndPoint(localIP, 0));
udpClient.Client.WindowsUdpBug();
udpClient.Connect(server);
byte[] buffer = ArrayPool<byte>.Shared.Rent(1024);
try

19
linker.tunnel/wanport/TunnelWanPortTransfer.cs
View File

@@ -1,5 +1,7 @@
using linker.libs;
using linker.libs.extends;
using System.Net;
using System.Net.Sockets;
namespace linker.tunnel.wanport
{
@@ -8,7 +10,10 @@ namespace linker.tunnel.wanport
/// </summary>
public sealed class TunnelWanPortTransfer
{
private List<ITunnelWanPortProtocol> tunnelWanPorts = new List<ITunnelWanPortProtocol>();
private List<ITunnelWanPortProtocol> tunnelWanPorts = new List<ITunnelWanPortProtocol> {
new TunnelWanPortProtocolLinkerUdp(),
new TunnelWanPortProtocolLinkerTcp()
};
public List<TunnelWanPortProtocolType> Protocols => tunnelWanPorts.Select(p => p.ProtocolType).ToList();
@@ -16,17 +21,6 @@ namespace linker.tunnel.wanport
{
}
/// <summary>
/// 加载所有外网端口协议
/// </summary>
/// <param name="assembs"></param>
public void LoadTransports(List<ITunnelWanPortProtocol> tunnelWanPorts)
{
this.tunnelWanPorts = tunnelWanPorts;
LoggerHelper.Instance.Info($"load tunnel wanport compacts:{string.Join(",", tunnelWanPorts.Select(c => c.Name))}");
}
/// <summary>
/// 获取外网端口
/// </summary>
@@ -51,5 +45,6 @@ namespace linker.tunnel.wanport
}
return null;
}
}
}

9
linker/plugins/client/ClientConfigTransfer.cs
View File

@@ -1,4 +1,5 @@
using linker.config;
using System.Security.Cryptography.X509Certificates;
namespace linker.plugins.client
{
@@ -6,15 +7,21 @@ namespace linker.plugins.client
{
public ClientServerInfo Server => config.Data.Client.Servers[0];
public ClientGroupInfo Group => config.Data.Client.Groups[0];
public ClientCertificateInfo SSL => config.Data.Client.SSL;
public string Id => config.Data.Client.Id;
public string Name => config.Data.Client.Name;
public X509Certificate2 Certificate { get; private set; }
private readonly FileConfig config;
public ClientConfigTransfer(FileConfig config)
{
this.config = config;
string path = Path.GetFullPath(config.Data.Client.SSL.File);
if (File.Exists(path))
{
Certificate = new X509Certificate2(path, config.Data.Client.SSL.Password, X509KeyStorageFlags.Exportable);
}
}
public void SetName(string newName)

2
linker/plugins/messenger/MessengerStartup.cs
View File

@@ -48,7 +48,7 @@ namespace linker.plugins.messenger
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
ClientConfigTransfer clientConfigTransfer = serviceProvider.GetService<ClientConfigTransfer>();
messengerResolver.Initialize(clientConfigTransfer.SSL.File, clientConfigTransfer.SSL.Password);
messengerResolver.Initialize(clientConfigTransfer.Certificate);
MessengerResolverTypesLoader messengerResolverTypesLoader = serviceProvider.GetService<MessengerResolverTypesLoader>();

1
linker/plugins/relay/RelayStartup.cs
View File

@@ -30,7 +30,6 @@ namespace linker.plugins.relay
public void AddClient(ServiceCollection serviceCollection, FileConfig config)
{
serviceCollection.AddSingleton<PlusRelayClientTransportSelfHost>();
serviceCollection.AddSingleton<RelayClientTransfer>();

17
linker/plugins/relay/client/PlusRelayClientStore.cs
View File

@@ -1,5 +1,4 @@
using linker.libs;
using linker.messenger;
using linker.messenger;
using linker.messenger.relay.client;
using linker.messenger.relay.client.transport;
using linker.plugins.client;
@@ -8,15 +7,11 @@ using System.Security.Cryptography.X509Certificates;
namespace linker.plugins.relay.client
{
public sealed class PlusRelayClientTransportSelfHost : RelayClientTransportSelfHost
{
public PlusRelayClientTransportSelfHost(IMessengerSender messengerSender,ISerializer serializer, IRelayClientStore relayClientStore) :base(messengerSender, serializer, relayClientStore) { }
}
public sealed class PlusRelayClientStore : IRelayClientStore
{
public byte Flag => (byte)(ResolverType.Relay);
public X509Certificate2 Certificate => certificate;
public X509Certificate2 Certificate => clientConfigTransfer.Certificate;
public IConnection SigninConnection => clientSignInState.Connection;
@@ -32,16 +27,12 @@ namespace linker.plugins.relay.client
private readonly X509Certificate2 certificate = null;
private readonly RelayClientConfigTransfer relayClientConfigTransfer;
private readonly ClientSignInState clientSignInState;
private readonly ClientConfigTransfer clientConfigTransfer;
public PlusRelayClientStore(RelayClientConfigTransfer relayClientConfigTransfer, ClientSignInState clientSignInState, ClientConfigTransfer clientConfigTransfer)
{
this.relayClientConfigTransfer = relayClientConfigTransfer;
this.clientSignInState = clientSignInState;
string path = Path.GetFullPath(clientConfigTransfer.SSL.File);
if (File.Exists(path))
{
certificate = new X509Certificate2(path, clientConfigTransfer.SSL.Password, X509KeyStorageFlags.Exportable);
}
this.clientConfigTransfer = clientConfigTransfer;
}
}
}

7
linker/plugins/relay/client/RelayClientTypesLoader.cs
View File

@@ -1,6 +1,5 @@
using linker.libs;
using linker.messenger.relay.client;
using linker.messenger.relay.client.transport;
using Microsoft.Extensions.DependencyInjection;
namespace linker.plugins.relay.client
{
@@ -8,11 +7,7 @@ namespace linker.plugins.relay.client
{
public RelayClientTypesLoader(RelayClientTransfer relayTransfer, ServiceProvider serviceProvider)
{
var types = GetSourceGeneratorTypes();
var transports = types.Select(c => (IRelayClientTransport)serviceProvider.GetService(c)).Where(c => c != null).ToList();
relayTransfer.LoadTransports(transports);
LoggerHelper.Instance.Info($"load relay transport:{string.Join(",", transports.Select(c => c.GetType().Name))}");
LoggerHelper.Instance.Info($"load relay transport:{string.Join(",", relayTransfer.Transports.Select(c => c.GetType().Name))}");
}
}
}

30
linker/plugins/tunnel/PlusTunnelMessengerAdapter.cs → linker/plugins/tunnel/PlusTunnelMessengerAdapterStore.cs
View File

@@ -2,19 +2,10 @@
using linker.plugins.client;
using linker.messenger;
using System.Security.Cryptography.X509Certificates;
using linker.tunnel;
namespace linker.plugins.tunnel
{
public sealed class PlusTunnelMessengerAdapter
{
public PlusTunnelMessengerAdapter(ClientSignInState clientSignInState,TunnelConfigTransfer tunnelConfigTransfer, TunnelMessengerAdapter tunnelMessengerAdapter)
{
clientSignInState.NetworkEnabledHandle += (times) => tunnelMessengerAdapter.RefreshPortMap(tunnelConfigTransfer.PortMapLan, tunnelConfigTransfer.PortMapWan);
clientSignInState.NetworkEnabledHandle += (times) => tunnelMessengerAdapter.RefreshNetwork();
tunnelConfigTransfer.OnChanged += () => tunnelMessengerAdapter.RefreshPortMap(tunnelConfigTransfer.PortMapLan, tunnelConfigTransfer.PortMapWan);
}
}
public sealed class PlusTunnelMessengerAdapterStore : ITunnelMessengerAdapterStore
{
public IConnection SignConnection => clientSignInState.Connection;
@@ -22,22 +13,31 @@ namespace linker.plugins.tunnel
public List<TunnelTransportItemInfo> TunnelTransports => tunnelConfigTransfer.Transports;
public int RouteLevelPlus => tunnelConfigTransfer.RouteLevelPlus;
public int PortMapPrivate => tunnelConfigTransfer.PortMapLan;
public int PortMapPublic => tunnelConfigTransfer.PortMapWan;
private readonly ClientSignInState clientSignInState;
private readonly ClientConfigTransfer clientConfigTransfer;
private readonly TunnelConfigTransfer tunnelConfigTransfer;
public PlusTunnelMessengerAdapterStore(ClientSignInState clientSignInState, ClientConfigTransfer clientConfigTransfer, TunnelConfigTransfer tunnelConfigTransfer)
public PlusTunnelMessengerAdapterStore(ClientSignInState clientSignInState, ClientConfigTransfer clientConfigTransfer, TunnelConfigTransfer tunnelConfigTransfer,TunnelTransfer tunnelTransfer)
{
this.clientSignInState = clientSignInState;
this.clientConfigTransfer = clientConfigTransfer;
this.tunnelConfigTransfer = tunnelConfigTransfer;
clientSignInState.NetworkEnabledHandle += (times) => tunnelTransfer.Refresh();
tunnelConfigTransfer.OnChanged += () => tunnelTransfer.Refresh();
}
public bool SetTunnelTransports(List<TunnelTransportItemInfo> list)
public async Task<bool> SetTunnelTransports(List<TunnelTransportItemInfo> list)
{
tunnelConfigTransfer.SetTransports(list);
return true;
return await Task.FromResult(true);
}
public async Task<List<TunnelTransportItemInfo>> GetTunnelTransports()
{
return await Task.FromResult(tunnelConfigTransfer.Transports);
}
}
}

20
linker/plugins/tunnel/TunnelConfigTransfer.cs
View File

@@ -24,31 +24,23 @@ namespace linker.plugins.tunnel
public int PortMapLan => running.Data.Tunnel.PortMapLan;
public int PortMapWan => running.Data.Tunnel.PortMapWan;
public List<TunnelTransportItemInfo> Transports => config.Data.Client.Tunnel.Transports;
public X509Certificate2 Certificate { get; private set; }
public X509Certificate2 Certificate => clientConfigTransfer.Certificate;
private readonly FileConfig config;
private readonly RunningConfig running;
private readonly ClientSignInState clientSignInState;
private readonly IMessengerSender messengerSender;
private readonly TunnelUpnpTransfer upnpTransfer;
private readonly ClientConfigTransfer clientConfigTransfer;
public Action OnChanged { get; set; } = () => { };
public TunnelConfigTransfer(FileConfig config, RunningConfig running, ClientSignInState clientSignInState, IMessengerSender messengerSender, TunnelUpnpTransfer upnpTransfer, ClientConfigTransfer clientConfigTransfer)
public TunnelConfigTransfer(FileConfig config, RunningConfig running, ClientSignInState clientSignInState, IMessengerSender messengerSender, ClientConfigTransfer clientConfigTransfer)
{
this.config = config;
this.running = running;
this.clientSignInState = clientSignInState;
this.messengerSender = messengerSender;
this.upnpTransfer = upnpTransfer;
this.clientConfigTransfer = clientConfigTransfer;
string path = Path.GetFullPath(clientConfigTransfer.SSL.File);
if (File.Exists(path))
{
Certificate = new X509Certificate2(path, clientConfigTransfer.SSL.Password, X509KeyStorageFlags.Exportable);
}
clientSignInState.NetworkEnabledHandle += (times) =>
{
TimerHelper.Async(RefreshRouteLevel);
@@ -77,11 +69,11 @@ namespace linker.plugins.tunnel
/// 修改自己的网关层级信息
/// </summary>
/// <param name="tunnelTransportFileConfigInfo"></param>
public void OnLocalRouteLevel(TunnelTransportRouteLevelInfo tunnelTransportFileConfigInfo)
public void OnLocalRouteLevel(TunnelTransportRouteLevelInfo tunnelTransportRouteLevelInfo)
{
running.Data.Tunnel.RouteLevelPlus = tunnelTransportFileConfigInfo.RouteLevelPlus;
running.Data.Tunnel.PortMapWan = tunnelTransportFileConfigInfo.PortMapWan;
running.Data.Tunnel.PortMapLan = tunnelTransportFileConfigInfo.PortMapLan;
running.Data.Tunnel.RouteLevelPlus = tunnelTransportRouteLevelInfo.RouteLevelPlus;
running.Data.Tunnel.PortMapWan = tunnelTransportRouteLevelInfo.PortMapWan;
running.Data.Tunnel.PortMapLan = tunnelTransportRouteLevelInfo.PortMapLan;
running.Data.Update();
OnChanged();
}

19
linker/plugins/tunnel/TunnelStartup.cs
View File

@@ -1,7 +1,6 @@
using linker.config;
using linker.startup;
using linker.tunnel;
using linker.libs;
using MemoryPack;
using Microsoft.Extensions.DependencyInjection;
using linker.tunnel.wanport;
@@ -26,13 +25,14 @@ namespace linker.plugins.tunnel
public void AddClient(ServiceCollection serviceCollection, FileConfig config)
{
//外网端口协议
serviceCollection.AddSingleton<TunnelWanPortTransfer>();
//打洞协议
serviceCollection.AddSingleton<TunnelTransfer>();
serviceCollection.AddSingleton<TunnelUpnpTransfer>();
serviceCollection.AddSingleton<TunnelExcludeIPTransfer>();
serviceCollection.AddSingleton<TunnelMessengerAdapter>();
//命令接口
serviceCollection.AddSingleton<PlusTunnelClientMessenger>();
serviceCollection.AddSingleton<ITunnelMessengerAdapterStore, PlusTunnelMessengerAdapterStore>();
//序列化扩展
MemoryPackFormatterProvider.Register(new TunnelTransportWanPortInfoFormatter());
@@ -41,18 +41,10 @@ namespace linker.plugins.tunnel
MemoryPackFormatterProvider.Register(new TunnelWanPortProtocolInfoFormatter());
//命令接口
serviceCollection.AddSingleton<PlusTunnelClientMessenger>();
serviceCollection.AddSingleton<ITunnelMessengerAdapterStore, PlusTunnelMessengerAdapterStore>();
serviceCollection.AddSingleton<TunnelMessengerAdapter>();
serviceCollection.AddSingleton<PlusTunnelMessengerAdapter>();
serviceCollection.AddSingleton<TunnelExcludeIPTypesLoader>();
serviceCollection.AddSingleton<TunnelConfigTransfer>();
serviceCollection.AddSingleton<TunnelConfigSyncTransports>();
serviceCollection.AddSingleton<TunnelDecenter>();
//管理接口
serviceCollection.AddSingleton<TunnelApiController>();
}
@@ -77,7 +69,6 @@ namespace linker.plugins.tunnel
TunnelConfigTransfer tunnelConfigTransfer = serviceProvider.GetService<TunnelConfigTransfer>();
ITunnelMessengerAdapterStore tunnelAdapter = serviceProvider.GetService<ITunnelMessengerAdapterStore>();
PlusTunnelMessengerAdapter plusTunnelMessengerAdapter = serviceProvider.GetService<PlusTunnelMessengerAdapter>();
}
public void UseServer(ServiceProvider serviceProvider, FileConfig config)

4
linker/plugins/tuntap/ExcludeIP.cs
View File

@@ -11,10 +11,10 @@ namespace linker.plugins.tuntap
{
this.tuntapConfigTransfer = tuntapConfigTransfer;
}
public ExcludeIPItem[] Get()
public List<IPAddress> Get()
{
//网卡IP不参与打洞
return new ExcludeIPItem[] { new ExcludeIPItem { IPAddress = tuntapConfigTransfer.IP, Mask = 32 } };
return new List<IPAddress> { tuntapConfigTransfer.IP };
}
}

2
version.txt
View File

@@ -1,5 +1,5 @@
v1.6.4
2024-12-21 18:36:44
2024-12-22 16:19:16
1. 优化UI，显示网络计算IP数
2. 修复内网穿透不停止直接删除导致的无法再次添加的问题
3. 优化网卡的端口转发