apps/linker
1
0
Fork 0
mirror of https://github.com/snltty/linker.git synced 2025-10-17 22:50:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

sync

Browse Source
This commit is contained in:
snltty
2024-06-24 17:47:03 +08:00
parent 94a87970e1
commit 47e65958d0
16 changed files with 213 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
linker.libs/linker.libs.csproj
View File

@@ -35,7 +35,4 @@
<PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|net8.0|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
</ItemGroup>
</Project>

49
linker.tunnel/TunnelTransfer.cs
View File

@@ -1,59 +1,56 @@
using linker.tunnel.adapter;
using linker.tunnel.compact;
using linker.tunnel.connection;
using linker.tunnel.transport;
using linker.libs;
using linker.libs.extends;
using Microsoft.Extensions.DependencyInjection;
using System.Collections.Concurrent;
using System.Net.Sockets;
using System.Net;
using System.Reflection;
using linker.tunnel.wanport;
namespace linker.tunnel
{
public sealed class TunnelTransfer
{
private List<ITunnelTransport> transports;
private readonly ServiceProvider serviceProvider;
private readonly TunnelCompactTransfer compactTransfer;
private readonly ITunnelAdapter tunnelMessengerAdapter;
private TunnelWanPortTransfer compactTransfer;
private ITunnelAdapter tunnelAdapter ;
private ConcurrentDictionary<string, bool> connectingDic = new ConcurrentDictionary<string, bool>();
private Dictionary<string, List<Action<ITunnelConnection>>> OnConnected { get; } = new Dictionary<string, List<Action<ITunnelConnection>>>();
public TunnelTransfer(ServiceProvider serviceProvider, TunnelCompactTransfer compactTransfer, ITunnelAdapter tunnelMessengerAdapter)
public TunnelTransfer(TunnelWanPortTransfer compactTransfer, ITunnelAdapter tunnelAdapter)
{
this.serviceProvider = serviceProvider;
this.compactTransfer = compactTransfer;
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
this.tunnelAdapter = tunnelAdapter;
}
/// <summary>
/// 加载打洞协议
/// </summary>
/// <param name="assembs"></param>
public void Load(Assembly[] assembs)
public void Init(TunnelWanPortTransfer compactTransfer, ITunnelAdapter tunnelAdapter, List<ITunnelTransport> transports)
{
IEnumerable<Type> types = ReflectionHelper.GetInterfaceSchieves(assembs.Concat(new Assembly[] { typeof(TunnelTransfer).Assembly }).ToArray(), typeof(ITunnelTransport));
transports = types.Select(c => (ITunnelTransport)serviceProvider.GetService(c)).Where(c => c != null).Where(c => string.IsNullOrWhiteSpace(c.Name) == false).ToList();
this.compactTransfer = compactTransfer;
this.tunnelAdapter = tunnelAdapter;
this.transports = transports;
foreach (var item in transports)
{
item.OnSendConnectBegin = tunnelMessengerAdapter.SendConnectBegin;
item.OnSendConnectFail = tunnelMessengerAdapter.SendConnectFail;
item.OnSendConnectSuccess = tunnelMessengerAdapter.SendConnectSuccess;
item.OnSendConnectBegin = tunnelAdapter.SendConnectBegin;
item.OnSendConnectFail = tunnelAdapter.SendConnectFail;
item.OnSendConnectSuccess = tunnelAdapter.SendConnectSuccess;
item.OnConnected = _OnConnected;
}
var transportItems = tunnelMessengerAdapter.GetTunnelTransports();
var transportItems = tunnelAdapter.GetTunnelTransports();
transportItems = transportItems.Concat(transports.Select(c => new TunnelTransportItemInfo { Label = c.Label, Name = c.Name, ProtocolType = c.ProtocolType.ToString() }))
.Distinct(new TunnelTransportItemInfoEqualityComparer())
.Where(c=> transports.Select(c=>c.Name).Contains(c.Name))
.ToList();
tunnelMessengerAdapter.SetTunnelTransports(transportItems);
tunnelAdapter.SetTunnelTransports(transportItems);
Logger.Instance.Warning($"load tunnel transport:{string.Join(",", transports.Select(c => c.Name))}");
Logger.Instance.Warning($"used tunnel transport:{string.Join(",", transportItems.Where(c => c.Disabled == false).Select(c => c.Name))}");
@@ -103,7 +100,7 @@ namespace linker.tunnel
try
{
foreach (TunnelTransportItemInfo transportItem in tunnelMessengerAdapter.GetTunnelTransports().Where(c => c.Disabled == false))
foreach (TunnelTransportItemInfo transportItem in tunnelAdapter.GetTunnelTransports().Where(c => c.Disabled == false))
{
ITunnelTransport transport = transports.FirstOrDefault(c => c.Name == transportItem.Name);
if (transport == null) continue;
@@ -116,7 +113,7 @@ namespace linker.tunnel
try
{
//获取自己的外网ip
TunnelTransportExternalIPInfo localInfo = await GetLocalInfo();
TunnelTransportWanPortInfo localInfo = await GetLocalInfo();
if (localInfo == null)
{
Logger.Instance.Error($"tunnel {transport.Name} get local external ip fail ");
@@ -124,7 +121,7 @@ namespace linker.tunnel
}
Logger.Instance.Info($"tunnel {transport.Name} got local external ip {localInfo.ToJson()}");
//获取对方的外网ip
TunnelTransportExternalIPInfo remoteInfo = await tunnelMessengerAdapter.GetRemoteExternalIP(remoteMachineId);
TunnelTransportWanPortInfo remoteInfo = await tunnelAdapter.GetRemoteWanPort(remoteMachineId);
if (remoteInfo == null)
{
Logger.Instance.Error($"tunnel {transport.Name} get remote {remoteMachineId} external ip fail ");
@@ -244,7 +241,7 @@ namespace linker.tunnel
/// 获取自己的外网IP，给别人调用
/// </summary>
/// <returns></returns>
public async Task<TunnelTransportExternalIPInfo> GetExternalIP()
public async Task<TunnelTransportWanPortInfo> GetWanPort()
{
return await GetLocalInfo();
}
@@ -252,13 +249,13 @@ namespace linker.tunnel
/// 获取自己的外网IP
/// </summary>
/// <returns></returns>
private async Task<TunnelTransportExternalIPInfo> GetLocalInfo()
private async Task<TunnelTransportWanPortInfo> GetLocalInfo()
{
TunnelCompactIPEndPoint ip = await compactTransfer.GetExternalIPAsync(tunnelMessengerAdapter.LocalIP);
TunnelWanPortEndPoint ip = await compactTransfer.GetWanPortAsync(tunnelAdapter.LocalIP);
if (ip != null)
{
var config = tunnelMessengerAdapter.GetLocalConfig();
return new TunnelTransportExternalIPInfo
var config = tunnelAdapter.GetLocalConfig();
return new TunnelTransportWanPortInfo
{
Local = ip.Local,
Remote = ip.Remote,

12
linker.tunnel/adapter/ITunnelAdapter.cs
View File

@@ -1,4 +1,4 @@
using linker.tunnel.compact;
using linker.tunnel.wanport;
using linker.tunnel.transport;
using System.Net;
using System.Security.Cryptography.X509Certificates;
@@ -8,7 +8,7 @@ namespace linker.tunnel.adapter
public interface ITunnelAdapter
{
/// <summary>
/// 本机局域网IP，用于UDP打洞绑定
/// 本机局域网IP
/// </summary>
public IPAddress LocalIP { get; }
@@ -21,12 +21,12 @@ namespace linker.tunnel.adapter
/// 获取外网端口协议列表
/// </summary>
/// <returns></returns>
public List<TunnelCompactInfo> GetTunnelCompacts();
public List<TunnelWanPortInfo> GetTunnelWanPortCompacts();
/// <summary>
/// 保存外网端口协议列表
/// </summary>
/// <param name="compacts"></param>
public void SetTunnelCompacts(List<TunnelCompactInfo> compacts);
public void SetTunnelWanPortCompacts(List<TunnelWanPortInfo> compacts);
/// <summary>
/// 获取打洞协议列表
@@ -45,11 +45,11 @@ namespace linker.tunnel.adapter
/// <returns></returns>
public NetworkInfo GetLocalConfig();
/// <summary>
/// 获取远端的外网信息，可以在远端调用 TunnelTransfer.GetExternalIP() 发送回来
/// 获取远端的外网信息，可以在远端调用 TunnelTransfer.GetWanPort() 发送回来
/// </summary>
/// <param name="remoteMachineId"></param>
/// <returns></returns>
public Task<TunnelTransportExternalIPInfo> GetRemoteExternalIP(string remoteMachineId);
public Task<TunnelTransportWanPortInfo> GetRemoteWanPort(string remoteMachineId);
/// <summary>
/// 发送开始打洞

83
linker.tunnel/compact/TunnelCompactTransfer.cs
View File

@@ -1,83 +0,0 @@
using linker.tunnel.adapter;
using linker.libs;
using linker.libs.extends;
using Microsoft.Extensions.DependencyInjection;
using System.Diagnostics;
using System.Net;
using System.Reflection;
namespace linker.tunnel.compact
{
/// <summary>
/// 外网端口协议
/// </summary>
public sealed class TunnelCompactTransfer
{
private List<ITunnelCompact> compacts;
private readonly ServiceProvider serviceProvider;
private readonly ITunnelAdapter tunnelMessengerAdapter;
public TunnelCompactTransfer(ServiceProvider serviceProvider, ITunnelAdapter tunnelMessengerAdapter)
{
this.serviceProvider = serviceProvider;
this.tunnelMessengerAdapter = tunnelMessengerAdapter;
}
/// <summary>
/// 加载所有外网端口协议
/// </summary>
/// <param name="assembs"></param>
public void Load(Assembly[] assembs)
{
IEnumerable<Type> types = ReflectionHelper.GetInterfaceSchieves(assembs.Concat(new Assembly[] { typeof(TunnelCompactTransfer).Assembly }).ToArray(), typeof(ITunnelCompact));
compacts = types.Select(c => (ITunnelCompact)serviceProvider.GetService(c)).Where(c => c != null).Where(c => string.IsNullOrWhiteSpace(c.Name) == false).ToList();
Logger.Instance.Warning($"load tunnel compacts:{string.Join(",", compacts.Select(c => c.Name))}");
}
public List<TunnelCompactTypeInfo> GetTypes()
{
return compacts.Select(c => new TunnelCompactTypeInfo { Value = c.Type, Name = c.Type.ToString() }).Distinct(new TunnelCompactTypeInfoEqualityComparer()).ToList();
}
/// <summary>
/// 获取外网端口
/// </summary>
/// <param name="localIP">你的局域网IP</param>
/// <returns></returns>
public async Task<TunnelCompactIPEndPoint> GetExternalIPAsync(IPAddress localIP)
{
var compactItems = tunnelMessengerAdapter.GetTunnelCompacts();
foreach (TunnelCompactInfo item in compactItems)
{
if (item.Disabled || string.IsNullOrWhiteSpace(item.Host)) continue;
ITunnelCompact compact = compacts.FirstOrDefault(c => c.Type == item.Type);
if (compact == null) continue;
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
IPEndPoint server = NetworkHelper.GetEndPoint(item.Host, 3478);
sw.Stop();
if (sw.ElapsedMilliseconds > 1000)
{
Logger.Instance.Warning($"get domain ip time:{sw.ElapsedMilliseconds}ms");
}
TunnelCompactIPEndPoint externalIP = await compact.GetExternalIPAsync(server);
if (externalIP != null)
{
externalIP.Local.Address = localIP;
return externalIP;
}
}
catch (Exception ex)
{
Logger.Instance.Error(ex);
}
}
return null;
}
}
}

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

@@ -54,7 +54,7 @@ namespace linker.tunnel.transport
/// <summary>
/// 网络信息，包括局域网，外网
/// </summary>
public sealed partial class TunnelTransportExternalIPInfo
public sealed partial class TunnelTransportWanPortInfo
{
/// <summary>
/// 我的本地
@@ -112,11 +112,11 @@ namespace linker.tunnel.transport
/// <summary>
/// 我的
/// </summary>
public TunnelTransportExternalIPInfo Local { get; set; }
public TunnelTransportWanPortInfo Local { get; set; }
/// <summary>
/// 对方的
/// </summary>
public TunnelTransportExternalIPInfo Remote { get; set; }
public TunnelTransportWanPortInfo Remote { get; set; }
/// <summary>
/// 事务

26
linker.tunnel/compact/ITunnelCompact.cs → linker.tunnel/wanport/ITunnelWanPort.cs
View File

@@ -1,23 +1,23 @@
using System.Net;
namespace linker.tunnel.compact
namespace linker.tunnel.wanport
{
/// <summary>
/// 外网端口协议
/// </summary>
public interface ITunnelCompact
public interface ITunnelWanPort
{
public string Name { get; }
public TunnelCompactType Type { get; }
public TunnelWanPortType Type { get; }
/// <summary>
/// 获取外网端口
/// </summary>
/// <param name="server">服务端</param>
/// <returns></returns>
public Task<TunnelCompactIPEndPoint> GetExternalIPAsync(IPEndPoint server);
public Task<TunnelWanPortEndPoint> GetAsync(IPEndPoint server);
}
public sealed class TunnelCompactIPEndPoint
public sealed class TunnelWanPortEndPoint
{
/// <summary>
/// 内网
@@ -29,7 +29,7 @@ namespace linker.tunnel.compact
public IPEndPoint Remote { get; set; }
}
public sealed partial class TunnelCompactInfo
public sealed partial class TunnelWanPortInfo
{
/// <summary>
/// 名称
@@ -38,7 +38,7 @@ namespace linker.tunnel.compact
/// <summary>
/// 协议类别
/// </summary>
public TunnelCompactType Type { get; set; }
public TunnelWanPortType Type { get; set; }
/// <summary>
/// 地址
/// </summary>
@@ -49,26 +49,26 @@ namespace linker.tunnel.compact
public bool Disabled { get; set; }
}
public enum TunnelCompactType : byte
public enum TunnelWanPortType : byte
{
Link = 0,
Stun = 1
}
public sealed class TunnelCompactTypeInfo
public sealed class TunnelWanPortTypeInfo
{
public TunnelCompactType Value { get; set; }
public TunnelWanPortType Value { get; set; }
public string Name { get; set; }
}
public sealed class TunnelCompactTypeInfoEqualityComparer : IEqualityComparer<TunnelCompactTypeInfo>
public sealed class TunnelWanPortTypeInfoEqualityComparer : IEqualityComparer<TunnelWanPortTypeInfo>
{
public bool Equals(TunnelCompactTypeInfo x, TunnelCompactTypeInfo y)
public bool Equals(TunnelWanPortTypeInfo x, TunnelWanPortTypeInfo y)
{
return x.Value == y.Value;
}
public int GetHashCode(TunnelCompactTypeInfo obj)
public int GetHashCode(TunnelWanPortTypeInfo obj)
{
return obj.Value.GetHashCode();
}

12
linker.tunnel/compact/TunnelCompactSelfHost.cs → linker.tunnel/wanport/TunnelWanPortLinker.cs
View File

@@ -2,18 +2,18 @@
using System.Net;
using System.Net.Sockets;
namespace linker.tunnel.compact
namespace linker.tunnel.wanport
{
public sealed class TunnelCompactSelfHost : ITunnelCompact
public sealed class TunnelWanPortLinker : ITunnelWanPort
{
public string Name => "默认";
public TunnelCompactType Type => TunnelCompactType.Link;
public TunnelWanPortType Type => TunnelWanPortType.Link;
public TunnelCompactSelfHost()
public TunnelWanPortLinker()
{
}
public async Task<TunnelCompactIPEndPoint> GetExternalIPAsync(IPEndPoint server)
public async Task<TunnelWanPortEndPoint> GetAsync(IPEndPoint server)
{
UdpClient udpClient = new UdpClient(AddressFamily.InterNetwork);
udpClient.Client.Reuse();
@@ -41,7 +41,7 @@ namespace linker.tunnel.compact
IPEndPoint remoteEP = new IPEndPoint(ip, port);
return new TunnelCompactIPEndPoint { Local = udpClient.Client.LocalEndPoint as IPEndPoint, Remote = remoteEP };
return new TunnelWanPortEndPoint { Local = udpClient.Client.LocalEndPoint as IPEndPoint, Remote = remoteEP };
}
catch (Exception)
{

12
linker.tunnel/compact/TunnelCompactStun.cs → linker.tunnel/wanport/TunnelWanPortStun.cs
View File

@@ -3,18 +3,18 @@ using System.Buffers.Binary;
using System.Net;
using System.Net.Sockets;
namespace linker.tunnel.compact
namespace linker.tunnel.wanport
{
public sealed class TunnelCompactStun : ITunnelCompact
public sealed class TunnelWanPortStun : ITunnelWanPort
{
public string Name => "Stun";
public TunnelCompactType Type => TunnelCompactType.Stun;
public TunnelWanPortType Type => TunnelWanPortType.Stun;
public TunnelCompactStun()
public TunnelWanPortStun()
{
}
public async Task<TunnelCompactIPEndPoint> GetExternalIPAsync(IPEndPoint server)
public async Task<TunnelWanPortEndPoint> GetAsync(IPEndPoint server)
{
UdpClient udpClient = new UdpClient(AddressFamily.InterNetwork);
udpClient.Client.Reuse();
@@ -60,7 +60,7 @@ namespace linker.tunnel.compact
ip = new IPAddress(data.Slice(0, 16).Span);
}
return new TunnelCompactIPEndPoint { Local = udpClient.Client.LocalEndPoint as IPEndPoint, Remote = new IPEndPoint(ip, port) };
return new TunnelWanPortEndPoint { Local = udpClient.Client.LocalEndPoint as IPEndPoint, Remote = new IPEndPoint(ip, port) };
}
catch (Exception)

76
linker.tunnel/wanport/TunnelWanPortTransfer.cs Normal file
View File

@@ -0,0 +1,76 @@
using linker.tunnel.adapter;
using linker.libs;
using System.Diagnostics;
using System.Net;
namespace linker.tunnel.wanport
{
/// <summary>
/// 外网端口协议
/// </summary>
public sealed class TunnelWanPortTransfer
{
private List<ITunnelWanPort> tunnelWanPorts;
private ITunnelAdapter tunnelAdapter;
public TunnelWanPortTransfer()
{
}
/// <summary>
/// 加载所有外网端口协议
/// </summary>
/// <param name="assembs"></param>
public void Init(ITunnelAdapter tunnelAdapter, List<ITunnelWanPort> tunnelWanPorts)
{
this.tunnelAdapter = tunnelAdapter;
this.tunnelWanPorts = tunnelWanPorts;
Logger.Instance.Warning($"load tunnel wanport compacts:{string.Join(",", tunnelWanPorts.Select(c => c.Name))}");
}
public List<TunnelWanPortTypeInfo> GetTypes()
{
return tunnelWanPorts.Select(c => new TunnelWanPortTypeInfo { Value = c.Type, Name = c.Type.ToString() }).Distinct(new TunnelWanPortTypeInfoEqualityComparer()).ToList();
}
/// <summary>
/// 获取外网端口
/// </summary>
/// <param name="localIP">你的局域网IP</param>
/// <returns></returns>
public async Task<TunnelWanPortEndPoint> GetWanPortAsync(IPAddress localIP)
{
var tunnelWanPortItems = tunnelAdapter.GetTunnelWanPortCompacts();
foreach (TunnelWanPortInfo item in tunnelWanPortItems)
{
if (item.Disabled || string.IsNullOrWhiteSpace(item.Host)) continue;
ITunnelWanPort tunnelWanPort = tunnelWanPorts.FirstOrDefault(c => c.Type == item.Type);
if (tunnelWanPort == null) continue;
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
IPEndPoint server = NetworkHelper.GetEndPoint(item.Host, 3478);
sw.Stop();
if (sw.ElapsedMilliseconds > 1000)
{
Logger.Instance.Warning($"get domain ip time:{sw.ElapsedMilliseconds}ms");
}
TunnelWanPortEndPoint WanPort = await tunnelWanPort.GetAsync(server);
if (WanPort != null)
{
WanPort.Local.Address = localIP;
return WanPort;
}
}
catch (Exception ex)
{
Logger.Instance.Error(ex);
}
}
return null;
}
}
}

1
linker/linker.csproj
View File

@@ -66,5 +66,6 @@
<ItemGroup>
<PackageReference Include="LiteDB" Version="5.0.17" />
<PackageReference Include="MemoryPack" Version="1.10.0" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
</ItemGroup>
</Project>

10
linker/plugins/tunnel/TunnelAdapter.cs
View File

@@ -4,12 +4,12 @@ using linker.config;
using linker.plugins.tunnel.messenger;
using linker.server;
using linker.tunnel.adapter;
using linker.tunnel.compact;
using linker.tunnel.transport;
using linker.libs;
using MemoryPack;
using System.Net;
using System.Security.Cryptography.X509Certificates;
using linker.tunnel.wanport;
namespace linker.plugins.tunnel
{
@@ -39,11 +39,11 @@ namespace linker.plugins.tunnel
}
}
public List<TunnelCompactInfo> GetTunnelCompacts()
public List<TunnelWanPortInfo> GetTunnelWanPortCompacts()
{
return running.Data.Tunnel.Servers.ToList();
}
public void SetTunnelCompacts(List<TunnelCompactInfo> compacts)
public void SetTunnelWanPortCompacts(List<TunnelWanPortInfo> compacts)
{
running.Data.Tunnel.Servers = compacts.ToArray();
running.Data.Update();
@@ -68,7 +68,7 @@ namespace linker.plugins.tunnel
MachineId = config.Data.Client.Id
};
}
public async Task<TunnelTransportExternalIPInfo> GetRemoteExternalIP(string remoteMachineId)
public async Task<TunnelTransportWanPortInfo> GetRemoteWanPort(string remoteMachineId)
{
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
@@ -78,7 +78,7 @@ namespace linker.plugins.tunnel
});
if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
{
return MemoryPackSerializer.Deserialize<TunnelTransportExternalIPInfo>(resp.Data.Span);
return MemoryPackSerializer.Deserialize<TunnelTransportWanPortInfo>(resp.Data.Span);
}
return null;
}

12
linker/plugins/tunnel/TunnelApiController.cs
View File

@@ -4,12 +4,12 @@ using linker.config;
using linker.plugins.tunnel.messenger;
using linker.server;
using linker.tunnel.adapter;
using linker.tunnel.compact;
using linker.tunnel.transport;
using linker.libs.api;
using linker.libs.extends;
using MemoryPack;
using System.Collections.Concurrent;
using linker.tunnel.wanport;
namespace linker.plugins.tunnel
{
@@ -19,13 +19,13 @@ namespace linker.plugins.tunnel
public sealed class TunnelApiController : IApiClientController
{
private readonly Config config;
private readonly TunnelCompactTransfer compactTransfer;
private readonly TunnelWanPortTransfer compactTransfer;
private readonly ClientSignInState clientSignInState;
private readonly MessengerSender messengerSender;
private readonly TunnelConfigTransfer tunnelConfigTransfer;
private readonly ITunnelAdapter tunnelMessengerAdapter;
public TunnelApiController(Config config, TunnelCompactTransfer compactTransfer, ClientSignInState clientSignInState, MessengerSender messengerSender, TunnelConfigTransfer tunnelConfigTransfer, ITunnelAdapter tunnelMessengerAdapter)
public TunnelApiController(Config config, TunnelWanPortTransfer compactTransfer, ClientSignInState clientSignInState, MessengerSender messengerSender, TunnelConfigTransfer tunnelConfigTransfer, ITunnelAdapter tunnelMessengerAdapter)
{
this.config = config;
this.compactTransfer = compactTransfer;
@@ -68,7 +68,7 @@ namespace linker.plugins.tunnel
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public List<TunnelCompactTypeInfo> GetTypes(ApiControllerParamsInfo param)
public List<TunnelWanPortTypeInfo> GetTypes(ApiControllerParamsInfo param)
{
return compactTransfer.GetTypes();
}
@@ -81,7 +81,7 @@ namespace linker.plugins.tunnel
{
SetServersParamInfo info = param.Content.DeJson<SetServersParamInfo>();
tunnelMessengerAdapter.SetTunnelCompacts(info.List.ToList());
tunnelMessengerAdapter.SetTunnelWanPortCompacts(info.List.ToList());
if (info.Sync)
{
await messengerSender.SendOnly(new MessageRequestWrap
@@ -159,7 +159,7 @@ namespace linker.plugins.tunnel
public sealed class SetServersParamInfo
{
public bool Sync { get; set; }
public TunnelCompactInfo[] List { get; set; } = Array.Empty<TunnelCompactInfo>();
public TunnelWanPortInfo[] List { get; set; } = Array.Empty<TunnelWanPortInfo>();
}
public sealed class SetTransportsParamInfo

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

@@ -3,7 +3,7 @@ using linker.client.config;
using linker.config;
using linker.plugins.tunnel.messenger;
using linker.server;
using linker.tunnel.compact;
using linker.tunnel.wanport;
using MemoryPack;
using System.Collections.Concurrent;
@@ -21,7 +21,7 @@ namespace linker.plugins.tunnel
private ConcurrentDictionary<string, TunnelTransportRouteLevelInfo> configs = new ConcurrentDictionary<string, TunnelTransportRouteLevelInfo>();
public ConcurrentDictionary<string, TunnelTransportRouteLevelInfo> Config => configs;
public TunnelConfigTransfer(Config config, RunningConfig running, ClientSignInState clientSignInState, MessengerSender messengerSender, TunnelCompactTransfer compactTransfer)
public TunnelConfigTransfer(Config config, RunningConfig running, ClientSignInState clientSignInState, MessengerSender messengerSender, TunnelWanPortTransfer compactTransfer)
{
this.config = config;
this.running = running;
@@ -35,11 +35,11 @@ namespace linker.plugins.tunnel
if (running.Data.Tunnel.Servers.Length == 0)
{
running.Data.Tunnel.Servers = new TunnelCompactInfo[]
running.Data.Tunnel.Servers = new TunnelWanPortInfo[]
{
new TunnelCompactInfo{
new TunnelWanPortInfo{
Name="默认",
Type= TunnelCompactType.Link,
Type= TunnelWanPortType.Link,
Disabled = false,
Host = running.Data.Client.Servers.FirstOrDefault().Host
}

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

@@ -3,13 +3,13 @@ using linker.plugins.tunnel.messenger;
using linker.startup;
using linker.tunnel;
using linker.tunnel.adapter;
using linker.tunnel.compact;
using linker.tunnel.transport;
using linker.libs;
using MemoryPack;
using Microsoft.Extensions.DependencyInjection;
using System.Net;
using System.Reflection;
using linker.tunnel.wanport;
namespace linker.plugins.tunnel
{
@@ -30,8 +30,8 @@ namespace linker.plugins.tunnel
public void AddClient(ServiceCollection serviceCollection, Config config, Assembly[] assemblies)
{
//序列化扩展
MemoryPackFormatterProvider.Register(new TunnelCompactInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportExternalIPInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelWanPortInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportWanPortInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportItemInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportInfoFormatter());
@@ -41,17 +41,15 @@ namespace linker.plugins.tunnel
serviceCollection.AddSingleton<TunnelClientMessenger>();
//外网端口协议
serviceCollection.AddSingleton<TunnelCompactTransfer>();
serviceCollection.AddSingleton<TunnelCompactSelfHost>();
serviceCollection.AddSingleton<TunnelCompactStun>();
serviceCollection.AddSingleton<TunnelWanPortTransfer>();
serviceCollection.AddSingleton<TunnelWanPortLinker>();
serviceCollection.AddSingleton<TunnelWanPortStun>();
//打洞协议
serviceCollection.AddSingleton<TunnelTransfer>();
serviceCollection.AddSingleton<TunnelTransportTcpNutssb>();
serviceCollection.AddSingleton<TransportMsQuic>();
serviceCollection.AddSingleton<TransportMsQuic>();
//serviceCollection.AddSingleton<TransportMsQuicTest>();
//serviceCollection.AddSingleton<TransportUdp>();
serviceCollection.AddSingleton<TunnelConfigTransfer>();
serviceCollection.AddSingleton<ITunnelAdapter, TunnelAdapter>();
@@ -67,8 +65,8 @@ namespace linker.plugins.tunnel
public void AddServer(ServiceCollection serviceCollection, Config config, Assembly[] assemblies)
{
MemoryPackFormatterProvider.Register(new TunnelCompactInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportExternalIPInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelWanPortInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportWanPortInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportItemInfoFormatter());
MemoryPackFormatterProvider.Register(new TunnelTransportInfoFormatter());
@@ -77,11 +75,18 @@ namespace linker.plugins.tunnel
public void UseClient(ServiceProvider serviceProvider, Config config, Assembly[] assemblies)
{
TunnelCompactTransfer compack = serviceProvider.GetService<TunnelCompactTransfer>();
compack.Load(assemblies);
ITunnelAdapter tunnelAdapter = serviceProvider.GetService<ITunnelAdapter>();
IEnumerable<Type> types = ReflectionHelper.GetInterfaceSchieves(assemblies.Concat(new Assembly[] { typeof(TunnelWanPortTransfer).Assembly }).ToArray(), typeof(ITunnelWanPort));
List<ITunnelWanPort> compacts = types.Select(c => (ITunnelWanPort)serviceProvider.GetService(c)).Where(c => c != null).Where(c => string.IsNullOrWhiteSpace(c.Name) == false).ToList();
TunnelWanPortTransfer compack = serviceProvider.GetService<TunnelWanPortTransfer>();
compack.Init(tunnelAdapter,compacts);
types = ReflectionHelper.GetInterfaceSchieves(assemblies.Concat(new Assembly[] { typeof(TunnelTransfer).Assembly }).ToArray(), typeof(ITunnelTransport));
List<ITunnelTransport> transports = types.Select(c => (ITunnelTransport)serviceProvider.GetService(c)).Where(c => c != null).Where(c => string.IsNullOrWhiteSpace(c.Name) == false).ToList();
TunnelTransfer tunnel = serviceProvider.GetService<TunnelTransfer>();
tunnel.Load(assemblies);
tunnel.Init(compack, tunnelAdapter, transports);
TunnelConfigTransfer tunnelConfigTransfer = serviceProvider.GetService<TunnelConfigTransfer>();
}

73
linker/plugins/tunnel/config/Config.cs
View File

@@ -1,6 +1,7 @@
using linker.tunnel.compact;
using linker.tunnel.connection;
using linker.tunnel.connection;
using linker.tunnel.wanport;
using linker.tunnel.transport;
using linker.tunnel.wanport;
using LiteDB;
using MemoryPack;
using System.Net;
@@ -17,7 +18,7 @@ namespace linker.client.config
public sealed class TunnelRunningInfo
{
public ObjectId Id { get; set; }
public TunnelCompactInfo[] Servers { get; set; } = Array.Empty<TunnelCompactInfo>();
public TunnelWanPortInfo[] Servers { get; set; } = Array.Empty<TunnelWanPortInfo>();
public int RouteLevelPlus { get; set; } = 0;
public List<TunnelTransportItemInfo> Transports { get; set; } = new List<TunnelTransportItemInfo>();
@@ -51,16 +52,16 @@ namespace linker.config
[MemoryPackable]
public readonly partial struct SerializableTunnelCompactInfo
public readonly partial struct SerializableTunnelWanPortInfo
{
[MemoryPackIgnore]
public readonly TunnelCompactInfo tunnelCompactInfo;
public readonly TunnelWanPortInfo tunnelCompactInfo;
[MemoryPackInclude]
string Name => tunnelCompactInfo.Name;
[MemoryPackInclude]
TunnelCompactType Type => tunnelCompactInfo.Type;
TunnelWanPortType Type => tunnelCompactInfo.Type;
[MemoryPackInclude]
string Host => tunnelCompactInfo.Host;
@@ -69,20 +70,20 @@ namespace linker.config
bool Disabled => tunnelCompactInfo.Disabled;
[MemoryPackConstructor]
SerializableTunnelCompactInfo(string name, TunnelCompactType type, string host, bool disabled)
SerializableTunnelWanPortInfo(string name, TunnelWanPortType type, string host, bool disabled)
{
var tunnelCompactInfo = new TunnelCompactInfo { Name = name, Type = type, Host = host, Disabled = disabled };
var tunnelCompactInfo = new TunnelWanPortInfo { Name = name, Type = type, Host = host, Disabled = disabled };
this.tunnelCompactInfo = tunnelCompactInfo;
}
public SerializableTunnelCompactInfo(TunnelCompactInfo tunnelCompactInfo)
public SerializableTunnelWanPortInfo(TunnelWanPortInfo tunnelCompactInfo)
{
this.tunnelCompactInfo = tunnelCompactInfo;
}
}
public class TunnelCompactInfoFormatter : MemoryPackFormatter<TunnelCompactInfo>
public class TunnelWanPortInfoFormatter : MemoryPackFormatter<TunnelWanPortInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TunnelCompactInfo value)
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TunnelWanPortInfo value)
{
if (value == null)
{
@@ -90,10 +91,10 @@ namespace linker.config
return;
}
writer.WritePackable(new SerializableTunnelCompactInfo(value));
writer.WritePackable(new SerializableTunnelWanPortInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TunnelCompactInfo value)
public override void Deserialize(ref MemoryPackReader reader, scoped ref TunnelWanPortInfo value)
{
if (reader.PeekIsNull())
{
@@ -102,51 +103,51 @@ namespace linker.config
return;
}
var wrapped = reader.ReadPackable<SerializableTunnelCompactInfo>();
var wrapped = reader.ReadPackable<SerializableTunnelWanPortInfo>();
value = wrapped.tunnelCompactInfo;
}
}
[MemoryPackable]
public readonly partial struct SerializableTunnelTransportExternalIPInfo
public readonly partial struct SerializableTunnelTransportWanPortInfo
{
[MemoryPackIgnore]
public readonly TunnelTransportExternalIPInfo tunnelTransportExternalIPInfo;
public readonly TunnelTransportWanPortInfo tunnelTransportWanPortInfo;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPEndPoint Local => tunnelTransportExternalIPInfo.Local;
IPEndPoint Local => tunnelTransportWanPortInfo.Local;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPEndPoint Remote => tunnelTransportExternalIPInfo.Remote;
IPEndPoint Remote => tunnelTransportWanPortInfo.Remote;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress[] LocalIps => tunnelTransportExternalIPInfo.LocalIps;
IPAddress[] LocalIps => tunnelTransportWanPortInfo.LocalIps;
[MemoryPackInclude]
int RouteLevel => tunnelTransportExternalIPInfo.RouteLevel;
int RouteLevel => tunnelTransportWanPortInfo.RouteLevel;
[MemoryPackInclude]
string MachineId => tunnelTransportExternalIPInfo.MachineId;
string MachineId => tunnelTransportWanPortInfo.MachineId;
[MemoryPackInclude]
string MachineName => tunnelTransportExternalIPInfo.MachineName;
string MachineName => tunnelTransportWanPortInfo.MachineName;
[MemoryPackConstructor]
SerializableTunnelTransportExternalIPInfo(IPEndPoint local, IPEndPoint remote, IPAddress[] localIps, int routeLevel, string machineId,string machineName)
SerializableTunnelTransportWanPortInfo(IPEndPoint local, IPEndPoint remote, IPAddress[] localIps, int routeLevel, string machineId,string machineName)
{
var tunnelTransportExternalIPInfo = new TunnelTransportExternalIPInfo { Local = local, Remote = remote, LocalIps = localIps, RouteLevel = routeLevel, MachineId = machineId, MachineName= machineName };
this.tunnelTransportExternalIPInfo = tunnelTransportExternalIPInfo;
var tunnelTransportWanPortInfo = new TunnelTransportWanPortInfo { Local = local, Remote = remote, LocalIps = localIps, RouteLevel = routeLevel, MachineId = machineId, MachineName= machineName };
this.tunnelTransportWanPortInfo = tunnelTransportWanPortInfo;
}
public SerializableTunnelTransportExternalIPInfo(TunnelTransportExternalIPInfo tunnelTransportExternalIPInfo)
public SerializableTunnelTransportWanPortInfo(TunnelTransportWanPortInfo tunnelTransportWanPortInfo)
{
this.tunnelTransportExternalIPInfo = tunnelTransportExternalIPInfo;
this.tunnelTransportWanPortInfo = tunnelTransportWanPortInfo;
}
}
public class TunnelTransportExternalIPInfoFormatter : MemoryPackFormatter<TunnelTransportExternalIPInfo>
public class TunnelTransportWanPortInfoFormatter : MemoryPackFormatter<TunnelTransportWanPortInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TunnelTransportExternalIPInfo value)
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TunnelTransportWanPortInfo value)
{
if (value == null)
{
@@ -154,10 +155,10 @@ namespace linker.config
return;
}
writer.WritePackable(new SerializableTunnelTransportExternalIPInfo(value));
writer.WritePackable(new SerializableTunnelTransportWanPortInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TunnelTransportExternalIPInfo value)
public override void Deserialize(ref MemoryPackReader reader, scoped ref TunnelTransportWanPortInfo value)
{
if (reader.PeekIsNull())
{
@@ -166,8 +167,8 @@ namespace linker.config
return;
}
var wrapped = reader.ReadPackable<SerializableTunnelTransportExternalIPInfo>();
value = wrapped.tunnelTransportExternalIPInfo;
var wrapped = reader.ReadPackable<SerializableTunnelTransportWanPortInfo>();
value = wrapped.tunnelTransportWanPortInfo;
}
}
@@ -244,10 +245,10 @@ namespace linker.config
[MemoryPackInclude, MemoryPackAllowSerialize]
TunnelTransportExternalIPInfo Local => tunnelTransportInfo.Local;
TunnelTransportWanPortInfo Local => tunnelTransportInfo.Local;
[MemoryPackInclude, MemoryPackAllowSerialize]
TunnelTransportExternalIPInfo Remote => tunnelTransportInfo.Remote;
TunnelTransportWanPortInfo Remote => tunnelTransportInfo.Remote;
[MemoryPackInclude]
string TransactionId => tunnelTransportInfo.TransactionId;
@@ -266,7 +267,7 @@ namespace linker.config
[MemoryPackConstructor]
SerializableTunnelTransportInfo(TunnelTransportExternalIPInfo local, TunnelTransportExternalIPInfo remote, string transactionId, TunnelProtocolType transportType, string transportName, TunnelDirection direction, bool ssl)
SerializableTunnelTransportInfo(TunnelTransportWanPortInfo local, TunnelTransportWanPortInfo remote, string transactionId, TunnelProtocolType transportType, string transportName, TunnelDirection direction, bool ssl)
{
var tunnelTransportInfo = new TunnelTransportInfo
{

16
linker/plugins/tunnel/messenger/TunnelMessenger.cs
View File

@@ -3,10 +3,10 @@ using linker.plugins.signin.messenger;
using linker.server;
using linker.tunnel;
using linker.tunnel.adapter;
using linker.tunnel.compact;
using linker.tunnel.transport;
using linker.libs;
using MemoryPack;
using linker.tunnel.wanport;
namespace linker.plugins.tunnel.messenger
{
@@ -27,7 +27,7 @@ namespace linker.plugins.tunnel.messenger
public void Begin(IConnection connection)
{
TunnelTransportInfo tunnelTransportInfo = MemoryPackSerializer.Deserialize<TunnelTransportInfo>(connection.ReceiveRequestWrap.Payload.Span);
TunnelTransportExternalIPInfo local = tunnelTransportInfo.Local;
TunnelTransportWanPortInfo local = tunnelTransportInfo.Local;
tunnelTransportInfo.Local = tunnelTransportInfo.Remote;
tunnelTransportInfo.Remote = local;
@@ -38,7 +38,7 @@ namespace linker.plugins.tunnel.messenger
[MessengerId((ushort)TunnelMessengerIds.Info)]
public async Task Info(IConnection connection)
{
TunnelTransportExternalIPInfo tunnelTransportPortInfo = await tunnel.GetExternalIP();
TunnelTransportWanPortInfo tunnelTransportPortInfo = await tunnel.GetWanPort();
if (tunnelTransportPortInfo != null)
{
connection.Write(MemoryPackSerializer.Serialize(tunnelTransportPortInfo));
@@ -49,7 +49,7 @@ namespace linker.plugins.tunnel.messenger
public void Fail(IConnection connection)
{
TunnelTransportInfo tunnelTransportInfo = MemoryPackSerializer.Deserialize<TunnelTransportInfo>(connection.ReceiveRequestWrap.Payload.Span);
TunnelTransportExternalIPInfo local = tunnelTransportInfo.Local;
TunnelTransportWanPortInfo local = tunnelTransportInfo.Local;
tunnelTransportInfo.Local = tunnelTransportInfo.Remote;
tunnelTransportInfo.Remote = local;
@@ -60,7 +60,7 @@ namespace linker.plugins.tunnel.messenger
public void Success(IConnection connection)
{
TunnelTransportInfo tunnelTransportInfo = MemoryPackSerializer.Deserialize<TunnelTransportInfo>(connection.ReceiveRequestWrap.Payload.Span);
TunnelTransportExternalIPInfo local = tunnelTransportInfo.Local;
TunnelTransportWanPortInfo local = tunnelTransportInfo.Local;
tunnelTransportInfo.Local = tunnelTransportInfo.Remote;
tunnelTransportInfo.Remote = local;
@@ -93,8 +93,8 @@ namespace linker.plugins.tunnel.messenger
[MessengerId((ushort)TunnelMessengerIds.Servers)]
public void Servers(IConnection connection)
{
TunnelCompactInfo[] servers = MemoryPackSerializer.Deserialize<TunnelCompactInfo[]>(connection.ReceiveRequestWrap.Payload.Span);
tunnelMessengerAdapter.SetTunnelCompacts(servers.ToList());
TunnelWanPortInfo[] servers = MemoryPackSerializer.Deserialize<TunnelWanPortInfo[]>(connection.ReceiveRequestWrap.Payload.Span);
tunnelMessengerAdapter.SetTunnelWanPortCompacts(servers.ToList());
}
}
@@ -127,7 +127,7 @@ namespace linker.plugins.tunnel.messenger
await messengerSender.ReplyOnly(new MessageResponseWrap
{
Connection = connection,
Payload = MemoryPackSerializer.Serialize(MemoryPackSerializer.Deserialize<TunnelTransportExternalIPInfo>(result.Result.Data.Span)),
Payload = MemoryPackSerializer.Serialize(MemoryPackSerializer.Deserialize<TunnelTransportWanPortInfo>(result.Result.Data.Span)),
RequestId = requestid,
});
}