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

sync

Browse Source
This commit is contained in:
snltty
2025-01-01 19:01:07 +08:00
parent ec8e407cde
commit 0ad8e6ebfa
199 changed files with 5788 additions and 12035 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
.github/workflows/nuget.yml vendored
View File

@@ -22,24 +22,60 @@ jobs:
- name: Build
run: |
dotnet build ./linker.libs -c release
dotnet build ./linker.tunnel -c release
dotnet build ./linker.tun -c release
dotnet build ./linker.messenger -c release
dotnet build ./linker.messenger.relay -c release
dotnet build ./linker.messenger.signin -c release
dotnet build ./linker.messenger.tunnel -c release
dotnet build ./linker.messenger.access -c release
dotnet build ./linker.messenger.action -c release
dotnet build ./linker.messenger.api -c release
dotnet build ./linker.messenger.channel -c release
dotnet build ./linker.messenger.decenter -c release
dotnet build ./linker.messenger.entry -c release
dotnet build ./linker.messenger.exroute -c release
dotnet build ./linker.messenger.flow -c release
dotnet build ./linker.messenger.forward -c release
dotnet build ./linker.messenger.listen -c release
dotnet build ./linker.messenger.logger -c release
dotnet build ./linker.messenger.pcp -c release
dotnet build ./linker.messenger.relay -c release
dotnet build ./linker.messenger.serializer.memorypack -c release
dotnet build ./linker.messenger.sforward -c release
dotnet build ./linker.messenger.signin -c release
dotnet build ./linker.messenger.socks5 -c release
dotnet build ./linker.messenger.store.file -c release
dotnet build ./linker.messenger.sync -c release
dotnet build ./linker.messenger.tunnel -c release
dotnet build ./linker.messenger.tuntap -c release
dotnet build ./linker.messenger.updater -c release
dotnet build ./linker.tun -c release
dotnet build ./linker.tunnel -c release
- name: Pack
run: |
dotnet pack ./linker.libs -c release
dotnet pack ./linker.tunnel -c release
dotnet pack ./linker.tun -c release
dotnet pack ./linker.messenger -c release
dotnet pack ./linker.messenger.relay -c release
dotnet pack ./linker.messenger.signin -c release
dotnet pack ./linker.messenger.tunnel -c release
dotnet pack ./linker.messenger.access -c release
dotnet pack ./linker.messenger.action -c release
dotnet pack ./linker.messenger.api -c release
dotnet pack ./linker.messenger.channel -c release
dotnet pack ./linker.messenger.decenter -c release
dotnet pack ./linker.messenger.entry -c release
dotnet pack ./linker.messenger.exroute -c release
dotnet pack ./linker.messenger.flow -c release
dotnet pack ./linker.messenger.forward -c release
dotnet pack ./linker.messenger.listen -c release
dotnet pack ./linker.messenger.logger -c release
dotnet pack ./linker.messenger.pcp -c release
dotnet pack ./linker.messenger.relay -c release
dotnet pack ./linker.messenger.serializer.memorypack -c release
dotnet pack ./linker.messenger.sforward -c release
dotnet pack ./linker.messenger.signin -c release
dotnet pack ./linker.messenger.socks5 -c release
dotnet pack ./linker.messenger.store.file -c release
dotnet pack ./linker.messenger.sync -c release
dotnet pack ./linker.messenger.tunnel -c release
dotnet pack ./linker.messenger.tuntap -c release
dotnet pack ./linker.messenger.updater -c release
dotnet pack ./linker.tun -c release
dotnet pack ./linker.tunnel -c release
- name: Install Nuget
uses: nuget/setup-nuget@v1
@@ -48,11 +84,29 @@ jobs:
- name: Push
run: |
nuget push ./linker.tunnel/bin/release/linker.tunnel.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.libs/bin/release/linker.libs.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.tun/bin/release/linker.tun.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.relay.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.signin.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.tunnel.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.access.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.action.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.api.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.channel.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.decenter.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.entry.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.exroute.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.flow.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.forward.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.listen.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.logger.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.pcp.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.relay.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.serializer.memorypack.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.sforward.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.signin.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.socks5.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.store.file.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.sync.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.tunnel.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.tuntap.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.messenger/bin/release/linker.messenger.updater.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.tun/bin/release/linker.tun.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol
nuget push ./linker.tunnel/bin/release/linker.tunnel.1.6.4.nupkg -Source https://api.nuget.org/v3/index.json -SkipDuplicate -ApiKey ${{ secrets.NUGET_KEY }} -NoSymbol

1
linker.messenger.access/AccessApiController.cs
View File

@@ -2,6 +2,7 @@
using linker.libs.extends;
using linker.libs;
using linker.messenger.signin;
using linker.messenger.api;
namespace linker.messenger.access
{

1
linker.messenger.access/AccessDecenter.cs
View File

@@ -1,4 +1,5 @@
using linker.libs;
using linker.messenger.api;
using linker.messenger.decenter;
using linker.messenger.signin;

1
linker.messenger.access/AccessMessenger.cs
View File

@@ -1,4 +1,5 @@
using linker.libs;
using linker.messenger.api;
using linker.messenger.signin;
namespace linker.messenger.access

4
linker.messenger.access/Entry.cs
View File

@@ -1,6 +1,4 @@
using linker.libs;
using linker.libs.web;
using linker.messenger.access;
using linker.messenger.access;
using linker.messenger.decenter;
using Microsoft.Extensions.DependencyInjection;
namespace linker.messenger.api

1
linker.messenger.access/linker.messenger.access.csproj
View File

@@ -36,6 +36,5 @@
<ProjectReference Include="..\linker.messenger.decenter\linker.messenger.decenter.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
<ProjectReference Include="..\linker.signin\linker.messenger.signin.csproj" />
</ItemGroup>
</Project>

4
linker.messenger.action/ActionApiController.cs
View File

@@ -1,5 +1,6 @@
using linker.libs.api;
using linker.libs.extends;
using linker.messenger.api;
namespace linker.messenger.action
{
@@ -13,12 +14,13 @@ namespace linker.messenger.action
}
[Access(AccessValue.Action)]
public bool SetArgs(ApiControllerParamsInfo param)
{
actionStore.SetActionArg(param.Content);
return true;
}
[Access(AccessValue.Action)]
public bool SetServerArgs(ApiControllerParamsInfo param)
{
actionStore.SetActionArgs(param.Content.DeJson<Dictionary<string, string>>());

18
linker.messenger.action/Entry.cs
View File

@@ -1,4 +1,7 @@
using linker.messenger.action;
using linker.messenger.relay.server.validator;
using linker.messenger.sforward.server.validator;
using linker.messenger.signin.args;
using Microsoft.Extensions.DependencyInjection;
namespace linker.messenger.api
{
@@ -10,15 +13,16 @@ namespace linker.messenger.api
serviceCollection.AddSingleton<ActionTransfer>();
serviceCollection.AddSingleton<SignInArgsAction>();
serviceCollection.AddSingleton<RelayValidatorAction>();
serviceCollection.AddSingleton<SForwardValidatorAction>();
return serviceCollection;
}
public static ServiceProvider UseActionClient(this ServiceProvider serviceProvider)
{
ApiServer apiServer=serviceProvider.GetService<ApiServer>();
IApiServer apiServer = serviceProvider.GetService<IApiServer>();
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<ActionApiController>() });
SignInArgsTransfer signInArgsTransfer = serviceProvider.GetService<SignInArgsTransfer>();
signInArgsTransfer.AddArgs(new List<ISignInArgs> { serviceProvider.GetService<SignInArgsAction>() });
return serviceProvider;
}
@@ -32,6 +36,14 @@ namespace linker.messenger.api
}
public static ServiceProvider UseActionServer(this ServiceProvider serviceProvider)
{
SignInArgsTransfer signInArgsTransfer = serviceProvider.GetService<SignInArgsTransfer>();
signInArgsTransfer.AddArgs(new List<ISignInArgs> { serviceProvider.GetService<SignInArgsAction>() });
RelayServerValidatorTransfer relayServerValidatorTransfer = serviceProvider.GetService<RelayServerValidatorTransfer>();
relayServerValidatorTransfer.AddValidators(new List<IRelayServerValidator> { serviceProvider.GetService<RelayValidatorAction>() });
SForwardValidatorTransfer sForwardValidatorTransfer = serviceProvider.GetService<SForwardValidatorTransfer>();
sForwardValidatorTransfer.AddValidators(new List<ISForwardValidator> { serviceProvider.GetService<SForwardValidatorAction>() });
return serviceProvider;
}
}

2
linker.messenger.action/IActionStore.cs
View File

@@ -2,7 +2,7 @@
{
public sealed class ActionInfo
{
public string Arg { get; set; }
public string Arg { get; set; } = string.Empty;
public Dictionary<string, string> Args { get; set; } = new Dictionary<string, string>();
}
public interface IActionStore

2
linker.messenger.action/SignInArgsAction.cs
View File

@@ -1,5 +1,7 @@
using linker.libs.extends;
using linker.messenger.relay.server.validator;
using linker.messenger.sforward;
using linker.messenger.sforward.server.validator;
using linker.messenger.signin;
using linker.messenger.signin.args;
using System.Net;

2
linker.messenger.action/linker.messenger.action.csproj
View File

@@ -34,8 +34,8 @@
<ProjectReference Include="..\linker.libs\linker.libs.csproj" />
<ProjectReference Include="..\linker.messenger.api\linker.messenger.api.csproj" />
<ProjectReference Include="..\linker.messenger.relay\linker.messenger.relay.csproj" />
<ProjectReference Include="..\linker.messenger.sforward\linker.messenger.sforward.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
<ProjectReference Include="..\linker.signin\linker.messenger.signin.csproj" />
</ItemGroup>
</Project>

18
linker.messenger.api/ApiServer.cs
View File

@@ -1,4 +1,5 @@
using linker.libs.api;
using linker.libs;
using linker.libs.api;
using System.Reflection;
namespace linker.messenger.api
@@ -8,8 +9,10 @@ namespace linker.messenger.api
/// </summary>
public sealed partial class ApiServer : libs.api.ApiServer, IApiServer
{
public ApiServer()
private readonly IAccessStore accessStore;
public ApiServer(IAccessStore accessStore)
{
this.accessStore = accessStore;
}
/// <summary>
@@ -19,6 +22,8 @@ namespace linker.messenger.api
{
Type voidType = typeof(void);
LoggerHelper.Instance.Info($"add api {string.Join(",", list.Select(c => c.GetType().Name))}");
foreach (IApiController obj in list)
{
Type type = obj.GetType();
@@ -30,14 +35,14 @@ namespace linker.messenger.api
{
bool istask = method.ReturnType.GetProperty("IsCompleted") != null && method.ReturnType.GetMethod("GetAwaiter") != null;
bool isTaskResult = method.ReturnType.GetProperty("Result") != null;
/*
ClientApiAccessAttribute accessAttr = method.GetCustomAttribute<ClientApiAccessAttribute>();
AccessAttribute accessAttr = method.GetCustomAttribute<AccessAttribute>();
ulong access = 0;
if (accessAttr != null)
{
access = (ulong)accessAttr.Value;
}
*/
plugins.TryAdd(key, new PluginPathCacheInfo
{
IsVoid = method.ReturnType == voidType,
@@ -54,8 +59,7 @@ namespace linker.messenger.api
}
private bool HasAccess(ulong access)
{
return true;
//return accessTransfer.HasAccess((ClientApiAccess)access);
return accessStore.HasAccess((AccessValue)access);
}
}
}

2
linker.messenger.access/Config.cs → linker.messenger.api/Config.cs
View File

@@ -1,4 +1,4 @@
namespace linker.messenger.access
namespace linker.messenger.api
{
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
public sealed class AccessAttribute : Attribute

8
linker.messenger.api/Entry.cs
View File

@@ -14,17 +14,19 @@ namespace linker.messenger.api
public static ServiceProvider UseApiClient(this ServiceProvider serviceProvider)
{
IApiStore apiStore = serviceProvider.GetService<IApiStore>();
if (apiStore.Info.ApiPort > 0)
IAccessStore accessStore = serviceProvider.GetService<IAccessStore>();
if (apiStore.Info.ApiPort > 0 && accessStore.HasAccess(AccessValue.Api))
{
LoggerHelper.Instance.Info($"start client api server");
LoggerHelper.Instance.Info($"start client api");
IApiServer server = serviceProvider.GetService<IApiServer>();
server.Websocket(apiStore.Info.ApiPort, apiStore.Info.ApiPassword);
LoggerHelper.Instance.Warning($"client api listen:{apiStore.Info.ApiPort}");
LoggerHelper.Instance.Warning($"client api password:{apiStore.Info.ApiPassword}");
}
if (apiStore.Info.WebPort > 0)
if (apiStore.Info.WebPort > 0 && accessStore.HasAccess(AccessValue.Web))
{
LoggerHelper.Instance.Info($"start client web");
IWebServer webServer = serviceProvider.GetService<IWebServer>();
webServer.Start(apiStore.Info.WebPort, apiStore.Info.WebRoot);
LoggerHelper.Instance.Warning($"client web listen:{apiStore.Info.WebPort}");

2
linker.messenger.access/IAccessStore.cs → linker.messenger.api/IAccessStore.cs
View File

@@ -1,4 +1,4 @@
namespace linker.messenger.access
namespace linker.messenger.api
{
public interface IAccessStore
{

1
linker.messenger.decenter/DecenterClientTransfer.cs
View File

@@ -27,6 +27,7 @@ namespace linker.messenger.decenter
public void AddDecenters(List<IDecenter> list)
{
LoggerHelper.Instance.Info($"add decenter {string.Join(",", list.Select(c => c.GetType().Name))}");
syncs = syncs.Concat(list).Distinct().ToList();
}

1
linker.messenger.decenter/linker.messenger.decenter.csproj
View File

@@ -33,7 +33,6 @@
<ItemGroup>
<ProjectReference Include="..\linker.libs\linker.libs.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.signin\linker.messenger.signin.csproj" />
</ItemGroup>
</Project>

145
linker.messenger.entry/LinkerMessengerEntry.cs Normal file
View File

@@ -0,0 +1,145 @@
using linker.messenger.api;
using linker.messenger.decenter;
using linker.messenger.exroute;
using linker.messenger.flow;
using linker.messenger.forward;
using linker.messenger.listen;
using linker.messenger.logger;
using Microsoft.Extensions.DependencyInjection;
using linker.messenger.pcp;
using linker.messenger.relay;
using linker.messenger.sforward;
using linker.messenger.signin;
using linker.messenger.socks5;
using linker.messenger.sync;
using linker.messenger.tunnel;
using linker.messenger.tuntap;
using linker.messenger.updater;
using linker.messenger.store.file;
using linker.messenger.serializer.memorypack;
using linker.libs;
namespace linker.messenger.entry
{
public static class LinkerMessengerEntry
{
private static ServiceCollection serviceCollection;
private static ServiceProvider serviceProvider;
private static OperatingManager inited = new OperatingManager();
private static OperatingManager builded = new OperatingManager();
/// <summary>
/// 开始初始化
/// </summary>
/// <returns></returns>
public static void Initialize()
{
if (inited.StartOperation() == false) return;
serviceCollection = new ServiceCollection();
serviceCollection
//日志
.AddLoggerClient()
//api接口和web
.AddApiClient()
//路由排除
.AddExRoute()
//服务器监听
.AddListen()
//权限
.AddAccessClient().AddAccessServer()
//自定义验证
.AddActionClient().AddActionServer()
//数据同步
.AddDecenterClient().AddDecenterServer()
//端口转发
.AddForwardClient().AddForwardServer()
//pcp
.AddPcpClient().AddPcpServer()
//中继
.AddRelayClient().AddRelayServer()
//服务器穿透
.AddSForwardClient().AddSForwardServer()
//登录
.AddSignInClient().AddSignInServer()
//socks5
.AddSocks5Client().AddSocks5Server()
//同步
.AddSyncClient().AddSyncServer()
//打洞
.AddTunnelClient().AddTunnelServer()
//虚拟网卡
.AddTuntapClient().AddTuntapServer()
//更新
.AddUpdaterClient().AddUpdaterServer()
//流量统计
.AddFlowClient().AddFlowServer()
//信标
.AddMessenger()
//持久化，文件
.AddStoreFile()
//序列化 MemoryPack
.AddSerializerMemoryPack();
}
/// <summary>
/// 注入
/// </summary>
/// <typeparam name="TService"></typeparam>
public static void AddService<TService>() where TService : class
{
serviceCollection.AddSingleton<TService>();
}
/// <summary>
/// 注入
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImplementation"></typeparam>
public static void AddService<TService, TImplementation>() where TService : class where TImplementation : class, TService
{
serviceCollection.AddSingleton<TService, TImplementation>();
}
/// <summary>
/// 运行起来
/// </summary>
/// <returns></returns>
public static void Build()
{
if (builded.StartOperation() == false) return;
serviceProvider = serviceCollection.BuildServiceProvider();
serviceProvider.UseMessenger().UseStoreFile().UseSerializerMemoryPack();
ICommonStore commonStore = serviceProvider.GetService<ICommonStore>();
if ((commonStore.Modes & CommonModes.Server) == CommonModes.Server)
{
serviceProvider.UseAccessServer().UseActionServer().UseDecenterServer().UseForwardServer().UsePcpServer().UseRelayServer().UseSForwardServer().UseSignInServer().UseSocks5Server().UseSyncServer().UseTunnelServer().UseTuntapServer().UseUpdaterServer().UseFlowServer();
serviceProvider.UseListen();
}
if ((commonStore.Modes & CommonModes.Client) == CommonModes.Client)
{
serviceProvider.UseLoggerClient().UseApiClient().UseExRoute().UseAccessClient().UseActionClient().UseDecenterClient().UseForwardClient().UsePcpClient().UseRelayClient().UseSForwardClient().UseSocks5Client().UseSyncClient().UseTunnelClient().UseTuntapClient().UseUpdaterClient().UseFlowClient();
serviceProvider.UseSignInClient();
}
}
/// <summary>
/// 获取服务
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <returns></returns>
public static TService GetService<TService>() where TService : class
{
return serviceProvider.GetService<TService>();
}
}
}

24
linker.messenger.entry/linker.messenger.entry.csproj
View File

@@ -30,4 +30,28 @@
<DebugSymbols>false</DebugSymbols>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\linker.messenger.access\linker.messenger.access.csproj" />
<ProjectReference Include="..\linker.messenger.action\linker.messenger.action.csproj" />
<ProjectReference Include="..\linker.messenger.api\linker.messenger.api.csproj" />
<ProjectReference Include="..\linker.messenger.channel\linker.messenger.channel.csproj" />
<ProjectReference Include="..\linker.messenger.decenter\linker.messenger.decenter.csproj" />
<ProjectReference Include="..\linker.messenger.exroute\linker.messenger.exroute.csproj" />
<ProjectReference Include="..\linker.messenger.flow\linker.messenger.flow.csproj" />
<ProjectReference Include="..\linker.messenger.forward\linker.messenger.forward.csproj" />
<ProjectReference Include="..\linker.messenger.listen\linker.messenger.listen.csproj" />
<ProjectReference Include="..\linker.messenger.logger\linker.messenger.logger.csproj" />
<ProjectReference Include="..\linker.messenger.pcp\linker.messenger.pcp.csproj" />
<ProjectReference Include="..\linker.messenger.relay\linker.messenger.relay.csproj" />
<ProjectReference Include="..\linker.messenger.serializer.memorypack\linker.messenger.serializer.memorypack.csproj" />
<ProjectReference Include="..\linker.messenger.sforward\linker.messenger.sforward.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger.socks5\linker.messenger.socks5.csproj" />
<ProjectReference Include="..\linker.messenger.store.file\linker.messenger.store.file.csproj" />
<ProjectReference Include="..\linker.messenger.sync\linker.messenger.sync.csproj" />
<ProjectReference Include="..\linker.messenger.tunnel\linker.messenger.tunnel.csproj" />
<ProjectReference Include="..\linker.messenger.tuntap\linker.messenger.tuntap.csproj" />
<ProjectReference Include="..\linker.messenger.updater\linker.messenger.updater.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
</ItemGroup>
</Project>

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

@@ -1,540 +0,0 @@
using linker.libs;
using linker.libs.extends;
using linker.messenger.relay.client;
using linker.messenger.relay.client.transport;
using linker.messenger.relay.messenger;
using linker.messenger.relay.server;
using linker.messenger.relay.server.caching;
using linker.messenger.relay.server.validator;
using linker.messenger.signin;
using linker.messenger.signin.args;
using linker.messenger.tunnel;
using linker.plugins.tunnel;
using linker.tunnel;
using linker.tunnel.connection;
using linker.tunnel.transport;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography.X509Certificates;
using System.Text;
namespace linker.messenger.example
{
internal class Program
{
public static PublicConfigInfo publicConfigInfo = new PublicConfigInfo
{
Certificate = new X509Certificate2("./snltty.pfx", "oeq9tw1o"),
TunnelTransports = new List<TunnelTransportItemInfo>
{
new TunnelTransportItemInfo{ BufferSize=3, Disabled=false, DisableReverse=false, DisableSSL=false, Name="udp", Order=1, ProtocolType= TunnelProtocolType.Udp.ToString(), Reverse=true, SSL=true },
// new TunnelTransportItemInfo{ BufferSize=3, Disabled=false, DisableReverse=false, DisableSSL=false, Name="UdpPortMap", Order=2, ProtocolType= TunnelProtocolType.Udp.ToString(), Reverse=true, SSL=true },
new TunnelTransportItemInfo{ BufferSize=3, Disabled=false, DisableReverse=false, DisableSSL=false, Name="TcpP2PNAT", Order=3, ProtocolType= TunnelProtocolType.Tcp.ToString(), Reverse=true, SSL=true },
// new TunnelTransportItemInfo{ BufferSize=3, Disabled=false, DisableReverse=false, DisableSSL=false, Name="TransportUdpPortMap", Order=4, ProtocolType= TunnelProtocolType.Tcp.ToString(), Reverse=true, SSL=true },
// new TunnelTransportItemInfo{ BufferSize=3, Disabled=false, DisableReverse=false, DisableSSL=false, Name="TcpPortMap", Order=5, ProtocolType= TunnelProtocolType.Tcp.ToString(), Reverse=true, SSL=true },
}
};
static async Task Main(string[] args)
{
LoggerConsole();
Console.WriteLine($"输入server 或者 client:");
string type = Console.ReadLine();
if (type == "server")
{
Server();
}
else
{
await Client();
}
Console.ReadLine();
}
public sealed class TunnelConnectionReceiveCallback : ITunnelConnectionReceiveCallback
{
public async Task Closed(ITunnelConnection connection, object state)
{
Console.WriteLine($"{(connection.Type == TunnelType.P2P ? "打洞" : "中继")}关闭，收到 {connection.IPEndPoint} {connection.RemoteMachineId} 的关闭");
await Task.CompletedTask;
}
public async Task Receive(ITunnelConnection connection, ReadOnlyMemory<byte> data, object state)
{
Console.WriteLine($"{(connection.Type == TunnelType.P2P ? "打洞" : "中继")}数据，收到 {connection.IPEndPoint} {connection.RemoteMachineId} 的数据:{data.Span.GetString()}");
await Task.CompletedTask;
}
}
private static async Task Client()
{
//序列化
ISerializer serializer = new Serializer();
//信标发送和接受
IMessengerSender messengerSender = new MessengerSender();
IMessengerResolver messengerResolver = new MessengerResolver(messengerSender);
//打洞相关
TunnelClientExcludeIPTransfer tunnelExcludeIPTransfer = new TunnelClientExcludeIPTransfer();
//tunnelExcludeIPTransfer.LoadTunnelExcludeIPs(new List<ITunnelExcludeIP>());
TunnelClientMessengerAdapter tunnelMessengerAdapter = new TunnelClientMessengerAdapter(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);
});
TunnelClientMessenger tunnelClientMessenger = new TunnelClientMessenger(tunnelTransfer, messengerSender, serializer);
//中继相关
IRelayClientStore relayClientStore = new RelayClientStore();
RelayClientTransfer relayClientTransfer = new RelayClientTransfer(messengerSender, serializer, relayClientStore);
relayClientTransfer.SetConnectedCallback("default", (connection) =>
{
Console.WriteLine($"中继成功，收到 {connection.IPEndPoint} {connection.RemoteMachineId} 的连接");
connection.BeginReceive(new TunnelConnectionReceiveCallback(), null);
});
RelayClientMessenger relayClientMessenger = new RelayClientMessenger(relayClientTransfer, serializer);
//加载这些信标处理器
messengerResolver.AddMessenger(new List<IMessenger>
{
tunnelClientMessenger,
relayClientMessenger
});
//加载登录参数
SignInArgsTransfer signInArgsTransfer = new SignInArgsTransfer();
signInArgsTransfer.AddArgs(new List<ISignInArgs> {
new MySignInArgs()
});
Dictionary<string, string> argsDic = new Dictionary<string, string>();
await signInArgsTransfer.Invoke(string.Empty, argsDic);
Console.WriteLine($"输入服务端ip端口:");
publicConfigInfo.Host = Console.ReadLine();
Console.WriteLine($"开始连接服务器");
IPEndPoint server = NetworkHelper.GetEndPoint(publicConfigInfo.Host, 1802);
Socket socket = new Socket(server.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.KeepAlive();
await socket.ConnectAsync(server).WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
publicConfigInfo.SignConnection = await messengerResolver.BeginReceiveClient(socket, true, (byte)ResolverType.Messenger).ConfigureAwait(false);
Console.WriteLine($"开始登录");
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = publicConfigInfo.SignConnection,
MessengerId = (ushort)SignInMessengerIds.SignIn_V_1_3_1,
Timeout = 2000,
Payload = serializer.Serialize(new SignInfo
{
MachineName = Dns.GetHostName(),
MachineId = string.Empty,
Version = VersionHelper.version,
Args = argsDic,
GroupId = "default"
})
}).ConfigureAwait(false);
if (resp.Code != MessageResponeCodes.OK)
{
Console.WriteLine($"登录失败 : {resp.Code}");
publicConfigInfo.SignConnection?.Disponse(6);
return;
}
SignInResponseInfo signResp = serializer.Deserialize<string>(resp.Data.Span).DeJson<SignInResponseInfo>();
if (signResp.Status == false)
{
Console.WriteLine($"登录失败 : {signResp.Msg}");
publicConfigInfo.SignConnection?.Disponse(6);
return;
}
publicConfigInfo.SignConnection.Id = signResp.MachineId;
Console.WriteLine($"你的id:{signResp.MachineId}");
tunnelTransfer.Refresh();
//获取在线列表，其它功能，参照 SignInServerMessenger 里的方法serializer.Deserialize 什么，就传什么
resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = publicConfigInfo.SignConnection,
MessengerId = (ushort)SignInMessengerIds.List,
Timeout = 2000,
Payload = serializer.Serialize(new SignInListRequestInfo
{
Asc = true,
Page = 1,
Size = 10
})
}).ConfigureAwait(false);
if (resp.Code == MessageResponeCodes.OK)
{
Console.WriteLine($"当前在线 : {serializer.Deserialize<SignInListResponseInfo>(resp.Data.Span).List.ToJson()}");
}
Console.WriteLine($"去连接吗?，1打洞，2中继:");
string connect = Console.ReadLine();
Console.WriteLine($"输入对方id:");
string id = Console.ReadLine();
ITunnelConnection tunnelConnection = null;
switch (connect)
{
case "1":
{
Console.WriteLine($"正在打洞.......");
tunnelConnection = await tunnelTransfer.ConnectAsync(id, "default", TunnelProtocolType.None);
Console.WriteLine($"打洞==》{(tunnelConnection == null ? "失败" : "成功")}");
}
break;
case "2":
{
Console.WriteLine($"正在中继.......");
tunnelConnection = await relayClientTransfer.ConnectAsync(publicConfigInfo.SignConnection.Id, id, "default");
Console.WriteLine($"中继==》{(tunnelConnection == null ? "失败" : "成功")}");
}
break;
default:
break;
}
if (tunnelConnection != null)
{
for (int i = 0; i < 10; i++)
{
string msg = $"hello {i}";
Console.WriteLine($"发送:{msg}");
var msgBytes = msg.ToBytes();
//首部4字节存长度，剩下的才是真实数据
byte[] bytes = new byte[4 + msgBytes.Length];
msgBytes.Length.ToBytes(bytes);
msgBytes.AsMemory().CopyTo(bytes.AsMemory(4));
await tunnelConnection.SendAsync(bytes);
await Task.Delay(1000);
}
}
}
private static void Server()
{
Console.WriteLine($"输入服务端端口:");
publicConfigInfo.Port = int.Parse(Console.ReadLine());
//序列化
ISerializer serializer = new Serializer();
//信标发送和接受
IMessengerSender messengerSender = new MessengerSender();
IMessengerResolver messengerResolver = new MessengerResolver(messengerSender);
messengerResolver.Initialize(publicConfigInfo.Certificate);
MessengerResolverResolver messengerResolverResolver = new MessengerResolverResolver(messengerResolver);
//登录相关
SignInArgsTransfer signInArgsTransfer = new SignInArgsTransfer();
signInArgsTransfer.AddArgs(new List<ISignInArgs> {
new MySignInArgs()
});
ISignInServerStore signInStore = new SignInStore();
SignInServerCaching signCaching = new SignInServerCaching(signInStore, signInArgsTransfer);
SignInServerMessenger signInServerMessenger = new SignInServerMessenger(messengerSender, signCaching, serializer);
//打洞相关
TunnelServerExternalResolver tunnelExternalResolver = new TunnelServerExternalResolver();
TunnelServerMessenger tunnelServerMessenger = new TunnelServerMessenger(messengerSender, signCaching, serializer);
//中继相关
IRelayServerMasterStore relayServerMasterStore = new RelayServerMasterStore();
IRelayServerNodeStore relayServerNodeStore = new RelayServerNodeStore();
RelayServerNodeTransfer relayServerNodeTransfer = new RelayServerNodeTransfer(serializer, relayServerNodeStore, relayServerMasterStore);
RelayServerResolver relayServerResolver = new RelayServerResolver(relayServerNodeTransfer, serializer);
IRelayServerCaching relayServerCaching = new RelayServerCachingMemory(serializer);
RelayServerMasterTransfer relayServerMasterTransfer = new RelayServerMasterTransfer(relayServerCaching, serializer, relayServerMasterStore);
RelayServerReportResolver relayServerReportResolver = new RelayServerReportResolver(relayServerMasterTransfer);
//自定义中继验证
RelayServerValidatorTransfer relayServerValidatorTransfer = new RelayServerValidatorTransfer();
//relayServerValidatorTransfer.LoadValidators(new List<IRelayServerValidator> { });
RelayServerMessenger relayServerMessenger = new RelayServerMessenger(messengerSender, signCaching, serializer, relayServerMasterTransfer, relayServerValidatorTransfer);
//加载信标处理器
messengerResolver.AddMessenger(new List<IMessenger>
{
signInServerMessenger,
tunnelServerMessenger,
relayServerMessenger
});
//加载消息分发器
ResolverTransfer resolverTransfer = new ResolverTransfer();
resolverTransfer.AddResolvers(new List<IResolver> {
messengerResolverResolver,
tunnelExternalResolver,
relayServerReportResolver,
relayServerResolver
});
//TCP
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(new IPEndPoint(IPAddress.Any, publicConfigInfo.Port));
socket.Listen(int.MaxValue);
TimerHelper.Async(async () =>
{
while (true)
{
var client = await socket.AcceptAsync();
_ = resolverTransfer.BeginReceive(client);
}
});
//UDP
Socket socketUdp = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socketUdp.Bind(new IPEndPoint(IPAddress.Any, publicConfigInfo.Port));
socketUdp.WindowsUdpBug();
TimerHelper.Async(async () =>
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, IPEndPoint.MinPort);
byte[] buffer = new byte[1 * 1024 * 1024];
while (true)
{
try
{
SocketReceiveFromResult result = await socketUdp.ReceiveFromAsync(buffer, SocketFlags.None, endPoint).ConfigureAwait(false);
IPEndPoint ep = result.RemoteEndPoint as IPEndPoint;
_ = resolverTransfer.BeginReceive(socketUdp, ep, buffer.AsMemory(0, result.ReceivedBytes));
}
catch (Exception ex)
{
LoggerHelper.Instance.Error(ex);
break;
}
}
});
}
private static void LoggerConsole()
{
LoggerHelper.Instance.OnLogger += (model) =>
{
ConsoleColor currentForeColor = Console.ForegroundColor;
switch (model.Type)
{
case LoggerTypes.DEBUG:
Console.ForegroundColor = ConsoleColor.Blue;
break;
case LoggerTypes.INFO:
Console.ForegroundColor = ConsoleColor.White;
break;
case LoggerTypes.WARNING:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LoggerTypes.ERROR:
Console.ForegroundColor = ConsoleColor.Red;
break;
default:
break;
}
string line = $"[{model.Type,-7}][{model.Time:yyyy-MM-dd HH:mm:ss}]:{model.Content}";
Console.WriteLine(line);
Console.ForegroundColor = currentForeColor;
};
}
}
public sealed class MyRelayServerValidator : IRelayServerValidator
{
/// <summary>
/// 验证，服务端会调用
/// </summary>
/// <param name="relayInfo">中继参数</param>
/// <param name="fromMachine">来源客户端</param>
/// <param name="toMachine">目标客户端</param>
/// <returns></returns>
public async Task<string> Validate(RelayInfo relayInfo, SignCacheInfo fromMachine, SignCacheInfo toMachine)
{
//返回空字符串，表示成功，不空为错误信息则登录失败
return await Task.FromResult(string.Empty);
}
}
public sealed class MySignInArgs : ISignInArgs
{
/// <summary>
/// 客户端调用
/// </summary>
/// <param name="host"></param>
/// <param name="args"></param>
/// <returns></returns>
public async Task<string> Invoke(string host, Dictionary<string, string> args)
{
//在这里加入你喜欢的数据
//返回空字符串，表示成功，不空为错误信息
return await Task.FromResult(string.Empty);
}
/// <summary>
/// 服务端调用
/// </summary>
/// <param name="signInfo">本次登录的信息</param>
/// <param name="cache">如果以前登录过就有信息，否则MachineId为空</param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public async Task<string> Validate(SignInfo signInfo, SignCacheInfo cache)
{
//在这里进行你的验证
//返回空字符串，表示成功，不空为错误信息则登录失败
return await Task.FromResult(string.Empty);
}
}
public sealed class PublicConfigInfo
{
public IConnection SignConnection { get; set; }
public X509Certificate2 Certificate { get; set; }
public List<TunnelTransportItemInfo> TunnelTransports { get; set; }
public string Host { get; set; }
public int Port { get; set; } = 12345;
}
/// <summary>
/// 中继的客户端存储库
/// </summary>
public sealed class RelayClientStore : IRelayClientStore
{
public X509Certificate2 Certificate => Program.publicConfigInfo.Certificate;
public IConnection SigninConnection => Program.publicConfigInfo.SignConnection;
public string SecretKey => string.Empty;
public bool Disabled => false;
public bool SSL => true;
public RelayClientType RelayType => RelayClientType.Linker;
}
/// <summary>
/// 中继节点信息存储库
/// </summary>
public sealed class RelayServerNodeStore : IRelayServerNodeStore
{
public int ServicePort => Program.publicConfigInfo.Port;
public RelayServerNodeInfo Node => new RelayServerNodeInfo { };
public void Confirm()
{
}
public void SetMaxGbTotalLastBytes(ulong value)
{
}
public void SetMaxGbTotalMonth(int month)
{
}
}
/// <summary>
/// 中继主机信息存储库
/// </summary>
public sealed class RelayServerMasterStore : IRelayServerMasterStore
{
public RelayServerMasterInfo Master => new RelayServerMasterInfo { SecretKey = "snltty" };
}
/// <summary>
/// 自定义打洞的存储库
/// </summary>
public sealed class TunnelMessengerAdapterStore : ITunnelClientStore
{
public IConnection SignConnection => Program.publicConfigInfo.SignConnection;
public X509Certificate2 Certificate => Program.publicConfigInfo.Certificate;
public int RouteLevelPlus => 0;
public int PortMapPrivate => 0;
public int PortMapPublic => 0;
public TunnelMessengerAdapterStore()
{
}
public async Task<List<TunnelTransportItemInfo>> GetTunnelTransports()
{
return await Task.FromResult(Program.publicConfigInfo.TunnelTransports);
}
public async Task<bool> SetTunnelTransports(List<TunnelTransportItemInfo> list)
{
return await Task.FromResult(true);
}
}
/// <summary>
/// 自定义序列化
/// </summary>
public sealed class Serializer : ISerializer
{
public T Deserialize<T>(ReadOnlySpan<byte> buffer)
{
return buffer.GetString().DeJson<T>();
}
public byte[] Serialize<T>(T value)
{
return value.ToJson().ToBytes();
}
}
/// <summary>
/// 自定义登录持久化存储
/// </summary>
public sealed class SignInStore : ISignInServerStore
{
public void Confirm()
{
}
public bool Delete(string id)
{
return true;
}
public SignCacheInfo Find(string id)
{
return null;
}
public IEnumerable<SignCacheInfo> Find()
{
return new List<SignCacheInfo>();
}
public string Insert(SignCacheInfo value)
{
return string.Empty;
}
public string NewId()
{
return Guid.NewGuid().ToString();
}
public bool Update(SignCacheInfo value)
{
return true;
}
}
}

27
linker.messenger.example/linker.messenger.example.csproj
View File

@@ -1,27 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<EnablePreviewFeatures>true</EnablePreviewFeatures>
<Version>1.6.4</Version>
<AssemblyVersion>1.6.4</AssemblyVersion>
<FileVersion>1.6.4</FileVersion>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\linker.messenger.relay\linker.messenger.relay.csproj" />
<ProjectReference Include="..\linker.messenger.tunnel\linker.messenger.tunnel.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
<ProjectReference Include="..\linker.signin\linker.messenger.signin.csproj" />
</ItemGroup>
<ItemGroup>
<None Update="snltty.pfx">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
</Project>

BIN
linker.messenger.example/snltty.pfx
View File

Binary file not shown.

4
linker.messenger.exroute/ExRouteTransfer.cs
View File

@@ -1,4 +1,5 @@
using System.Net;
using linker.libs;
using System.Net;
namespace linker.messenger.exroute
{
@@ -12,6 +13,7 @@ namespace linker.messenger.exroute
public void AddExRoutes(List<IExRoute> list)
{
LoggerHelper.Instance.Info($"add exroute {string.Join(",", list.Select(c => c.GetType().Name))}");
excludes = excludes.Concat(list).Distinct().ToList();
}

78
linker.messenger.flow/Entry.cs Normal file
View File

@@ -0,0 +1,78 @@
using linker.messenger.api;
using linker.messenger.flow.messenger;
using linker.messenger.relay.server;
using linker.messenger.tunnel;
using linker.plugins.sforward.proxy;
using Microsoft.Extensions.DependencyInjection;
namespace linker.messenger.flow
{
public static class Entry
{
public static ServiceCollection AddFlowClient(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<FlowApiController>();
serviceCollection.AddSingleton<FlowTransfer>();
serviceCollection.AddSingleton<MessengerFlow>();
serviceCollection.AddSingleton<IMessengerResolver, MessengerResolverFlow>();
serviceCollection.AddSingleton<IMessengerSender, MessengerSenderFlow>();
return serviceCollection;
}
public static ServiceProvider UseFlowClient(this ServiceProvider serviceProvider)
{
IApiServer apiServer = serviceProvider.GetService<IApiServer>();
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<FlowApiController>() });
FlowTransfer flowTransfer = serviceProvider.GetService<FlowTransfer>();
flowTransfer.AddFlows(new List<IFlow> { serviceProvider.GetService<MessengerFlow>() });
return serviceProvider;
}
public static ServiceCollection AddFlowServer(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<FlowMessenger>();
serviceCollection.AddSingleton<FlowTransfer>();
serviceCollection.AddSingleton<FlowResolver>();
serviceCollection.AddSingleton<MessengerFlow>();
serviceCollection.AddSingleton<IMessengerResolver, MessengerResolverFlow>();
serviceCollection.AddSingleton<IMessengerSender, MessengerSenderFlow>();
serviceCollection.AddSingleton<RelayFlow>();
serviceCollection.AddSingleton<RelayServerResolver, RelayResolverFlow>();
serviceCollection.AddSingleton<RelayReportFlow>();
serviceCollection.AddSingleton<RelayServerReportResolver, RelayReportResolverFlow>();
serviceCollection.AddSingleton<ExternalFlow>();
serviceCollection.AddSingleton<TunnelServerExternalResolver, ExternalResolverFlow>();
serviceCollection.AddSingleton<SForwardFlow>();
serviceCollection.AddSingleton<SForwardProxy, SForwardProxyFlow>();
return serviceCollection;
}
public static ServiceProvider UseFlowServer(this ServiceProvider serviceProvider)
{
FlowTransfer flowTransfer = serviceProvider.GetService<FlowTransfer>();
flowTransfer.AddFlows(new List<IFlow> {
serviceProvider.GetService<MessengerFlow>(),
serviceProvider.GetService<RelayFlow>(),
serviceProvider.GetService<RelayReportFlow>(),
serviceProvider.GetService<ExternalFlow>(),
serviceProvider.GetService<SForwardFlow>(),
});
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<FlowMessenger>() });
ResolverTransfer resolverTransfer = serviceProvider.GetService<ResolverTransfer>();
resolverTransfer.AddResolvers(new List<IResolver> { serviceProvider.GetService<FlowResolver>() });
return serviceProvider;
}
}
}

2
linker/plugins/flow/ExternalFlow.cs → linker.messenger.flow/ExternalFlow.cs
View File

@@ -1,5 +1,5 @@
using linker.messenger.tunnel;
namespace linker.plugins.flow
namespace linker.messenger.flow
{
public sealed class ExternalFlow : IFlow
{

57
linker/plugins/flow/FlowClientApiController.cs → linker.messenger.flow/FlowApiController.cs
View File

@@ -1,35 +1,28 @@
using linker.libs.api;
using linker.config;
using linker.serializer;
using linker.client.config;
using linker.plugins.client;
using linker.plugins.capi;
using linker.plugins.flow.messenger;
using linker.libs;
using linker.libs.api;
using linker.libs.extends;
using linker.plugins.relay.client;
using linker.plugins.sforward;
using linker.messenger;
using linker.messenger.api;
using linker.messenger.flow.messenger;
using linker.messenger.relay.client;
using linker.messenger.sforward.client;
using linker.messenger.signin;
namespace linker.plugins.flow
namespace linker.messenger.flow
{
public sealed class FlowClientApiController : IApiClientController
public sealed class FlowApiController : IApiController
{
private readonly IMessengerSender messengerSender;
private readonly SignInClientState signInClientState;
private readonly FileConfig config;
private readonly RunningConfig runningConfig;
private readonly RelayClientConfigTransfer relayClientConfigTransfer;
private readonly SForwardTransfer sForwardTransfer;
public FlowClientApiController(IMessengerSender messengerSender, SignInClientState signInClientState, FileConfig config, RunningConfig runningConfig, RelayClientConfigTransfer relayClientConfigTransfer, SForwardTransfer sForwardTransfer)
private readonly IRelayClientStore relayClientStore;
private readonly ISForwardClientStore sForwardClientStore;
private readonly ISerializer serializer;
public FlowApiController(IMessengerSender messengerSender, SignInClientState signInClientState, IRelayClientStore relayClientStore, ISForwardClientStore sForwardClientStore, ISerializer serializer)
{
this.messengerSender = messengerSender;
this.signInClientState = signInClientState;
this.config = config;
this.runningConfig = runningConfig;
this.relayClientConfigTransfer = relayClientConfigTransfer;
this.sForwardTransfer = sForwardTransfer;
this.relayClientStore = relayClientStore;
this.sForwardClientStore = sForwardClientStore;
this.serializer = serializer;
}
public async Task<FlowInfo> GetFlows(ApiControllerParamsInfo param)
@@ -41,7 +34,7 @@ namespace linker.plugins.flow
});
if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
{
return Serializer.Deserialize<FlowInfo>(resp.Data.Span);
return serializer.Deserialize<FlowInfo>(resp.Data.Span);
}
return new FlowInfo();
}
@@ -54,45 +47,45 @@ namespace linker.plugins.flow
});
if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
{
return Serializer.Deserialize<Dictionary<ushort, FlowItemInfo>>(resp.Data.Span);
return serializer.Deserialize<Dictionary<ushort, FlowItemInfo>>(resp.Data.Span);
}
return new Dictionary<ushort, FlowItemInfo>();
}
[ClientApiAccessAttribute(ClientApiAccess.SForwardFlow)]
[Access(AccessValue.SForwardFlow)]
public async Task<SForwardFlowResponseInfo> GetSForwardFlows(ApiControllerParamsInfo param)
{
SForwardFlowRequestInfo info = param.Content.DeJson<SForwardFlowRequestInfo>();
info.SecretKey = sForwardTransfer.SecretKey;
info.SecretKey = sForwardClientStore.SecretKey;
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)FlowMessengerIds.SForward,
Payload = Serializer.Serialize(info)
Payload = serializer.Serialize(info)
});
if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
{
return Serializer.Deserialize<SForwardFlowResponseInfo>(resp.Data.Span);
return serializer.Deserialize<SForwardFlowResponseInfo>(resp.Data.Span);
}
return new SForwardFlowResponseInfo();
}
[ClientApiAccessAttribute(ClientApiAccess.RelayFlow)]
[Access(AccessValue.RelayFlow)]
public async Task<RelayFlowResponseInfo> GetRelayFlows(ApiControllerParamsInfo param)
{
RelayFlowRequestInfo info = param.Content.DeJson<RelayFlowRequestInfo>();
info.SecretKey = relayClientConfigTransfer.Server.SecretKey;
info.SecretKey = relayClientStore.Server.SecretKey;
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)FlowMessengerIds.Relay,
Payload = Serializer.Serialize(info)
Payload = serializer.Serialize(info)
});
if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
{
return Serializer.Deserialize<RelayFlowResponseInfo>(resp.Data.Span);
return serializer.Deserialize<RelayFlowResponseInfo>(resp.Data.Span);
}
return new RelayFlowResponseInfo();
}

3
linker/plugins/flow/FlowResolver.cs → linker.messenger.flow/FlowResolver.cs
View File

@@ -1,13 +1,12 @@
using linker.libs;
using linker.libs.extends;
using linker.messenger;
using linker.messenger.signin;
using System.Buffers;
using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
namespace linker.plugins.flow
namespace linker.messenger.flow
{
public sealed class FlowResolver : IResolver, IFlow
{

9
linker/plugins/flow/FlowTransfer.cs → linker.messenger.flow/FlowTransfer.cs
View File

@@ -1,4 +1,6 @@
namespace linker.plugins.flow
using linker.libs;
namespace linker.messenger.flow
{
public sealed class FlowTransfer
{
@@ -7,9 +9,10 @@
{
}
public void LoadFlows(List<IFlow> flows)
public void AddFlows(List<IFlow> list)
{
this.flows = flows;
LoggerHelper.Instance.Info($"add flow {string.Join(",", list.Select(c => c.GetType().Name))}");
this.flows = this.flows.Concat(list).Distinct().ToList();
}
public Dictionary<string, FlowItemInfo> GetFlows()

9
linker/plugins/flow/IFlow.cs → linker.messenger.flow/IFlow.cs
View File

@@ -1,7 +1,6 @@
using MemoryPack;
using System.Text.Json.Serialization;
using System.Text.Json.Serialization;
namespace linker.plugins.flow
namespace linker.messenger.flow
{
public interface IFlow
{
@@ -10,17 +9,15 @@ namespace linker.plugins.flow
public string FlowName { get; }
}
[MemoryPackable]
public partial class FlowItemInfo
{
public ulong ReceiveBytes { get; set; }
public ulong SendtBytes { get; set; }
[MemoryPackIgnore, JsonIgnore]
[JsonIgnore]
public string FlowName { get; set; }
}
[MemoryPackable]
public sealed partial class FlowInfo
{
public Dictionary<string, FlowItemInfo> Items { get; set; }

6
linker/plugins/flow/MessengerFlow.cs → linker.messenger.flow/MessengerFlow.cs
View File

@@ -1,12 +1,10 @@
using linker.messenger;
namespace linker.plugins.flow
namespace linker.messenger.flow
{
public sealed class MessengerResolverFlow : MessengerResolver
{
private readonly MessengerFlow messengerFlow;
public MessengerResolverFlow(IMessengerSender sender, MessengerFlow messengerFlow) : base(sender)
public MessengerResolverFlow(IMessengerSender sender, MessengerFlow messengerFlow,IMessengerStore messengerStore) : base(sender, messengerStore)
{
this.messengerFlow = messengerFlow;
}

14
linker/plugins/flow/RelayFlow.cs → linker.messenger.flow/RelayFlow.cs
View File

@@ -1,9 +1,8 @@
using linker.libs;
using linker.messenger.relay.server;
using MemoryPack;
using System.Text.Json.Serialization;
namespace linker.plugins.flow
namespace linker.messenger.flow
{
public sealed class RelayReportFlow : IFlow
{
@@ -37,7 +36,7 @@ namespace linker.plugins.flow
public sealed class RelayResolverFlow : RelayServerResolver
{
private readonly RelayFlow relayFlow;
public RelayResolverFlow(RelayFlow relayFlow, RelayServerNodeTransfer relayServerNodeTransfer,ISerializer serializer) : base(relayServerNodeTransfer, serializer)
public RelayResolverFlow(RelayFlow relayFlow, RelayServerNodeTransfer relayServerNodeTransfer, ISerializer serializer) : base(relayServerNodeTransfer, serializer)
{
this.relayFlow = relayFlow;
}
@@ -184,7 +183,6 @@ namespace linker.plugins.flow
}
}
[MemoryPackable]
public sealed partial class RelayFlowItemInfo : FlowItemInfo
{
public ulong DiffReceiveBytes { get; set; }
@@ -192,21 +190,18 @@ namespace linker.plugins.flow
public string FromName { get; set; }
public string ToName { get; set; }
[MemoryPackIgnore]
public string GroupId { get; set; }
[MemoryPackIgnore, JsonIgnore]
[JsonIgnore]
public ulong OldReceiveBytes { get; set; }
[MemoryPackIgnore, JsonIgnore]
[JsonIgnore]
public ulong OldSendtBytes { get; set; }
}
[MemoryPackable]
public sealed partial class RelayFlowRequestInfo
{
public string Key { get; set; } = string.Empty;
[MemoryPackIgnore]
public string GroupId { get; set; } = string.Empty;
public string SecretKey { get; set; } = string.Empty;
public int Page { get; set; } = 1;
@@ -228,7 +223,6 @@ namespace linker.plugins.flow
Asc = 1,
}
[MemoryPackable]
public sealed partial class RelayFlowResponseInfo
{
public int Page { get; set; }

12
linker/plugins/flow/SForwardFlow.cs → linker.messenger.flow/SForwardFlow.cs
View File

@@ -1,9 +1,8 @@
using linker.libs;
using linker.plugins.sforward.proxy;
using MemoryPack;
using System.Text.Json.Serialization;
namespace linker.plugins.flow
namespace linker.messenger.flow
{
public sealed class SForwardProxyFlow: SForwardProxy
{
@@ -125,28 +124,24 @@ namespace linker.plugins.flow
}
}
[MemoryPackable]
public sealed partial class SForwardFlowItemInfo : FlowItemInfo
{
public ulong DiffReceiveBytes { get; set; }
public ulong DiffSendtBytes { get; set; }
public string Key { get; set; }
[MemoryPackIgnore]
public string GroupId { get; set; }
[MemoryPackIgnore, JsonIgnore]
[ JsonIgnore]
public ulong OldReceiveBytes { get; set; }
[MemoryPackIgnore, JsonIgnore]
[ JsonIgnore]
public ulong OldSendtBytes { get; set; }
}
[MemoryPackable]
public sealed partial class SForwardFlowRequestInfo
{
public string Key { get; set; } = string.Empty;
[MemoryPackIgnore]
public string GroupId { get; set; } = string.Empty;
public string SecretKey { get; set; } = string.Empty;
@@ -169,7 +164,6 @@ namespace linker.plugins.flow
Asc = 1,
}
[MemoryPackable]
public sealed partial class SForwardFlowResponseInfo
{
public int Page { get; set; }

42
linker.messenger.flow/linker.messenger.flow.csproj Normal file
View File

@@ -0,0 +1,42 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net8.0</TargetFrameworks>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>disable</Nullable>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<PublishAot>false</PublishAot>
<JsonSerializerIsReflectionEnabledByDefault>true</JsonSerializerIsReflectionEnabledByDefault>
<EnablePreviewFeatures>True</EnablePreviewFeatures>
<Title>linker messenger flow</Title>
<Authors>snltty</Authors>
<Company>snltty</Company>
<Description>linker messenger flow</Description>
<Copyright>snltty</Copyright>
<PackageProjectUrl>https://github.com/snltty/linker</PackageProjectUrl>
<RepositoryUrl>https://github.com/snltty/linker</RepositoryUrl>
<PackageReleaseNotes>linker messenger flow</PackageReleaseNotes>
<Version>1.6.4</Version>
<AssemblyVersion>1.6.4</AssemblyVersion>
<FileVersion>1.6.4</FileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>full</DebugType>
<DebugSymbols>true</DebugSymbols>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>none</DebugType>
<DebugSymbols>false</DebugSymbols>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\linker.libs\linker.libs.csproj" />
<ProjectReference Include="..\linker.messenger.relay\linker.messenger.relay.csproj" />
<ProjectReference Include="..\linker.messenger.sforward\linker.messenger.sforward.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger.tunnel\linker.messenger.tunnel.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
</ItemGroup>
</Project>

40
linker/plugins/flow/messenger/FlowMessenger.cs → linker.messenger.flow/messenger/FlowMessenger.cs
View File

@@ -1,11 +1,9 @@
using linker.config;
using linker.messenger;
using linker.libs;
using linker.messenger.relay.server;
using linker.messenger.sforward.server;
using linker.messenger.signin;
using linker.plugins.relay.server;
using linker.plugins.sforward;
using linker.serializer;
namespace linker.plugins.flow.messenger
namespace linker.messenger.flow.messenger
{
public sealed class FlowMessenger : IMessenger
{
@@ -14,22 +12,22 @@ namespace linker.plugins.flow.messenger
private readonly SForwardFlow sForwardFlow;
private readonly RelayFlow relayFlow;
private readonly SignInServerCaching signCaching;
private readonly FileConfig fileConfig;
private readonly RelayServerConfigTransfer relayServerConfigTransfer;
private readonly SForwardServerConfigTransfer sForwardServerConfigTransfer;
private readonly IRelayServerStore relayServerStore;
private readonly ISForwardServerStore sForwardServerStore;
private readonly ISerializer serializer;
private DateTime start = DateTime.Now;
public FlowMessenger(FlowTransfer flowTransfer, MessengerFlow messengerFlow, SForwardFlow sForwardFlow, RelayFlow relayFlow, SignInServerCaching signCaching, FileConfig fileConfig, RelayServerConfigTransfer relayServerConfigTransfer, SForwardServerConfigTransfer sForwardServerConfigTransfer)
public FlowMessenger(FlowTransfer flowTransfer, MessengerFlow messengerFlow, SForwardFlow sForwardFlow, RelayFlow relayFlow, SignInServerCaching signCaching, IRelayServerStore relayServerStore, ISForwardServerStore sForwardServerStore, ISerializer serializer)
{
this.flowTransfer = flowTransfer;
this.messengerFlow = messengerFlow;
this.sForwardFlow = sForwardFlow;
this.relayFlow = relayFlow;
this.signCaching = signCaching;
this.fileConfig = fileConfig;
this.relayServerConfigTransfer = relayServerConfigTransfer;
this.sForwardServerConfigTransfer = sForwardServerConfigTransfer;
this.relayServerStore = relayServerStore;
this.sForwardServerStore = sForwardServerStore;
this.serializer = serializer;
}
[MessengerId((ushort)FlowMessengerIds.List)]
@@ -46,22 +44,22 @@ namespace linker.plugins.flow.messenger
Start = start,
Now = DateTime.Now,
};
connection.Write(Serializer.Serialize(serverFlowInfo));
connection.Write(serializer.Serialize(serverFlowInfo));
}
[MessengerId((ushort)FlowMessengerIds.Messenger)]
public void Messenger(IConnection connection)
{
connection.Write(Serializer.Serialize(messengerFlow.GetFlows()));
connection.Write(serializer.Serialize(messengerFlow.GetFlows()));
}
[MessengerId((ushort)FlowMessengerIds.SForward)]
public void SForward(IConnection connection)
{
sForwardFlow.Update();
SForwardFlowRequestInfo info = Serializer.Deserialize<SForwardFlowRequestInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardFlowRequestInfo info = serializer.Deserialize<SForwardFlowRequestInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (sForwardServerConfigTransfer.SecretKey == info.SecretKey)
if (sForwardServerStore.SecretKey == info.SecretKey)
{
info.GroupId = string.Empty;
}
@@ -77,15 +75,15 @@ namespace linker.plugins.flow.messenger
}
}
connection.Write(Serializer.Serialize(sForwardFlow.GetFlows(info)));
connection.Write(serializer.Serialize(sForwardFlow.GetFlows(info)));
}
[MessengerId((ushort)FlowMessengerIds.Relay)]
public void Relay(IConnection connection)
{
relayFlow.Update();
RelayFlowRequestInfo info = Serializer.Deserialize<RelayFlowRequestInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (relayServerConfigTransfer.SecretKey == info.SecretKey)
RelayFlowRequestInfo info = serializer.Deserialize<RelayFlowRequestInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (relayServerStore.SecretKey == info.SecretKey)
{
info.GroupId = string.Empty;
}
@@ -101,7 +99,7 @@ namespace linker.plugins.flow.messenger
}
}
connection.Write(Serializer.Serialize(relayFlow.GetFlows(info)));
connection.Write(serializer.Serialize(relayFlow.GetFlows(info)));
}
}

2
linker/plugins/flow/messenger/FlowMessengerIds.cs → linker.messenger.flow/messenger/FlowMessengerIds.cs
View File

@@ -1,4 +1,4 @@
namespace linker.plugins.flow.messenger
namespace linker.messenger.flow.messenger
{
public enum FlowMessengerIds : ushort
{

36
linker/plugins/forward/config/Config.cs → linker.messenger.forward/Config.cs
View File

@@ -1,22 +1,9 @@
using LiteDB;
using MemoryPack;
using System.Net;
using System.Text.Json.Serialization;
namespace linker.client.config
using System.Net;
namespace linker.messenger.forward
{
public sealed partial class RunningConfigInfo
{
/// <summary>
/// 端口转发配置
/// </summary>
public List<ForwardInfo> Forwards { get; set; } = new List<ForwardInfo>();
}
/// <summary>
/// 端口转发配置
/// </summary>
[MemoryPackable]
public sealed partial class ForwardInfo
{
public ForwardInfo() { }
@@ -34,7 +21,6 @@ namespace linker.client.config
/// <summary>
/// 本地绑定IP
/// </summary>
[MemoryPackAllowSerialize]
public IPAddress BindIPAddress { get; set; } = IPAddress.Any;
/// <summary>
/// 本地监听端口
@@ -43,7 +29,6 @@ namespace linker.client.config
/// <summary>
/// 目标设备服务
/// </summary>
[MemoryPackAllowSerialize]
public IPEndPoint TargetEP { get; set; }
/// <summary>
/// 已启动
@@ -63,8 +48,23 @@ namespace linker.client.config
/// </summary>
public string TargetMsg { get; set; }
[JsonIgnore, BsonIgnore, MemoryPackIgnore]
public bool Proxy { get; set; }
}
public sealed partial class ForwardAddForwardInfo
{
public string MachineId { get; set; }
public ForwardInfo Data { get; set; }
}
public sealed partial class ForwardRemoveForwardInfo
{
public string MachineId { get; set; }
public uint Id { get; set; }
}
public sealed partial class ForwardCountInfo
{
public string MachineId { get; set; }
public int Count { get; set; }
}
}

57
linker.messenger.forward/Entry.cs Normal file
View File

@@ -0,0 +1,57 @@
using linker.messenger.api;
using linker.messenger.decenter;
using linker.messenger.forward.proxy;
using Microsoft.Extensions.DependencyInjection;
namespace linker.messenger.forward
{
public static class Entry
{
public static ServiceCollection AddForwardClient(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<ForwardApiController>();
serviceCollection.AddSingleton<ForwardTransfer>();
serviceCollection.AddSingleton<ForwardClientMessenger>();
serviceCollection.AddSingleton<ForwardDecenter>();
serviceCollection.AddSingleton<ForwardProxy>();
return serviceCollection;
}
public static ServiceProvider UseForwardClient(this ServiceProvider serviceProvider)
{
IApiServer apiServer = serviceProvider.GetService<IApiServer>();
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<ForwardApiController>() });
ForwardTransfer forwardTransfer = serviceProvider.GetService<ForwardTransfer>();
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<ForwardClientMessenger>() });
DecenterClientTransfer decenterClientTransfer = serviceProvider.GetService<DecenterClientTransfer>();
decenterClientTransfer.AddDecenters(new List<IDecenter> { serviceProvider.GetService<ForwardDecenter>() });
ForwardProxy forwardProxy= serviceProvider.GetService<ForwardProxy>();
return serviceProvider;
}
public static ServiceCollection AddForwardServer(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<ForwardServerMessenger>();
return serviceCollection;
}
public static ServiceProvider UseForwardServer(this ServiceProvider serviceProvider)
{
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<ForwardServerMessenger>() });
return serviceProvider;
}
}
}

46
linker/plugins/forward/ForwardApiController.cs → linker.messenger.forward/ForwardApiController.cs
View File

@@ -1,42 +1,36 @@
using linker.libs.api;
using linker.libs.extends;
using linker.client.config;
using System.Net;
using linker.libs;
using linker.plugins.forward.proxy;
using linker.tunnel.connection;
using System.Collections.Concurrent;
using linker.plugins.forward.messenger;
using linker.serializer;
using linker.plugins.client;
using linker.plugins.capi;
using linker.plugins.messenger;
using linker.config;
using linker.plugins.access;
using linker.messenger;
using linker.messenger.signin;
using linker.messenger.forward.proxy;
using linker.messenger.api;
namespace linker.plugins.forward
namespace linker.messenger.forward
{
public sealed class ForwardClientApiController : IApiClientController
public sealed class ForwardApiController : IApiController
{
private readonly ForwardTransfer forwardTransfer;
private readonly ForwardProxy forwardProxy;
private readonly IMessengerSender messengerSender;
private readonly SignInClientState signInClientState;
private readonly AccessTransfer accessTransfer;
private readonly IAccessStore accessStore;
private readonly ISignInClientStore signInClientStore;
private readonly ForwardDecenter forwardDecenter;
private readonly ISerializer serializer;
public ForwardClientApiController(ForwardTransfer forwardTransfer, ForwardProxy forwardProxy, IMessengerSender messengerSender, SignInClientState signInClientState, AccessTransfer accessTransfer, ISignInClientStore signInClientStore, ForwardDecenter forwardDecenter)
public ForwardApiController(ForwardTransfer forwardTransfer, ForwardProxy forwardProxy, IMessengerSender messengerSender, SignInClientState signInClientState, IAccessStore accessStore, ISignInClientStore signInClientStore, ForwardDecenter forwardDecenter, ISerializer serializer)
{
this.forwardTransfer = forwardTransfer;
this.forwardProxy = forwardProxy;
this.messengerSender = messengerSender;
this.signInClientState = signInClientState;
this.accessTransfer = accessTransfer;
this.accessStore = accessStore;
this.signInClientStore = signInClientStore;
this.forwardDecenter = forwardDecenter;
this.serializer = serializer;
}
public ConnectionListInfo Connections(ApiControllerParamsInfo param)
@@ -53,7 +47,7 @@ namespace linker.plugins.forward
return new ConnectionListInfo { HashCode = version };
}
[ClientApiAccessAttribute(ClientApiAccess.TunnelRemove)]
[Access(AccessValue.TunnelRemove)]
public void RemoveConnection(ApiControllerParamsInfo param)
{
forwardProxy.RemoveConnection(param.Content);
@@ -91,20 +85,20 @@ namespace linker.plugins.forward
{
if (param.Content == signInClientStore.Id)
{
if (accessTransfer.HasAccess(ClientApiAccess.ForwardShowSelf) == false) return new List<ForwardInfo>();
if (accessStore.HasAccess(AccessValue.ForwardShowSelf) == false) return new List<ForwardInfo>();
return forwardTransfer.Get();
}
if (accessTransfer.HasAccess(ClientApiAccess.ForwardShowOther) == false) return new List<ForwardInfo>();
if (accessStore.HasAccess(AccessValue.ForwardShowOther) == false) return new List<ForwardInfo>();
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)ForwardMessengerIds.GetForward,
Payload = Serializer.Serialize(param.Content)
Payload = serializer.Serialize(param.Content)
});
if (resp.Code == MessageResponeCodes.OK)
{
return Serializer.Deserialize<List<ForwardInfo>>(resp.Data.Span);
return serializer.Deserialize<List<ForwardInfo>>(resp.Data.Span);
}
return new List<ForwardInfo>();
}
@@ -119,16 +113,16 @@ namespace linker.plugins.forward
ForwardAddForwardInfo info = param.Content.DeJson<ForwardAddForwardInfo>();
if (info.MachineId == signInClientStore.Id)
{
if (accessTransfer.HasAccess(ClientApiAccess.ForwardSelf) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardSelf) == false) return false;
return forwardTransfer.Add(info.Data);
}
if (accessTransfer.HasAccess(ClientApiAccess.ForwardOther) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardOther) == false) return false;
return await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)ForwardMessengerIds.AddClientForward,
Payload = Serializer.Serialize(info)
Payload = serializer.Serialize(info)
});
}
@@ -142,16 +136,16 @@ namespace linker.plugins.forward
ForwardRemoveForwardInfo info = param.Content.DeJson<ForwardRemoveForwardInfo>();
if (info.MachineId == signInClientStore.Id)
{
if (accessTransfer.HasAccess(ClientApiAccess.ForwardSelf) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardSelf) == false) return false;
return forwardTransfer.Remove(info.Id);
}
if (accessTransfer.HasAccess(ClientApiAccess.ForwardOther) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardOther) == false) return false;
return await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)ForwardMessengerIds.RemoveClientForward,
Payload = Serializer.Serialize(info)
Payload = serializer.Serialize(info)
});
}
}

22
linker/plugins/forward/ForwardDecenter.cs → linker.messenger.forward/ForwardDecenter.cs
View File

@@ -1,46 +1,48 @@
using linker.libs;
using linker.messenger.decenter;
using linker.messenger.signin;
using linker.plugins.client;
using linker.serializer;
using System.Collections.Concurrent;
namespace linker.plugins.forward
namespace linker.messenger.forward
{
public sealed class ForwardDecenter:IDecenter
public sealed class ForwardDecenter : IDecenter
{
public string Name => "forward";
public VersionManager SyncVersion { get; } = new VersionManager();
public VersionManager DataVersion { get; } = new VersionManager();
public ConcurrentDictionary<string, int> CountDic { get; }= new ConcurrentDictionary<string, int>();
public ConcurrentDictionary<string, int> CountDic { get; } = new ConcurrentDictionary<string, int>();
private readonly ISignInClientStore signInClientStore;
private readonly ForwardTransfer forwardTransfer;
public ForwardDecenter(ISignInClientStore signInClientStore, ForwardTransfer forwardTransfer)
private readonly ISerializer serializer;
public ForwardDecenter(ISignInClientStore signInClientStore, ForwardTransfer forwardTransfer, ISerializer serializer)
{
this.signInClientStore = signInClientStore;
this.forwardTransfer = forwardTransfer;
this.serializer = serializer;
forwardTransfer.OnReset += CountDic.Clear;
forwardTransfer.OnChanged += SyncVersion.Add;
}
public Memory<byte> GetData()
{
CountInfo info = new CountInfo { MachineId = signInClientStore.Id, Count = forwardTransfer.Count };
ForwardCountInfo info = new ForwardCountInfo { MachineId = signInClientStore.Id, Count = forwardTransfer.Count };
CountDic.AddOrUpdate(info.MachineId, info.Count, (a, b) => info.Count);
DataVersion.Add();
return Serializer.Serialize(info);
return serializer.Serialize(info);
}
public void SetData(Memory<byte> data)
{
CountInfo info = Serializer.Deserialize<CountInfo>(data.Span);
ForwardCountInfo info = serializer.Deserialize<ForwardCountInfo>(data.Span);
CountDic.AddOrUpdate(info.MachineId, info.Count, (a, b) => info.Count);
DataVersion.Add();
}
public void SetData(List<ReadOnlyMemory<byte>> data)
{
List<CountInfo> list = data.Select(c => Serializer.Deserialize<CountInfo>(c.Span)).ToList();
List<ForwardCountInfo> list = data.Select(c => serializer.Deserialize<ForwardCountInfo>(c.Span)).ToList();
foreach (var info in list)
{
CountDic.AddOrUpdate(info.MachineId, info.Count, (a, b) => info.Count);

46
linker/plugins/forward/messenger/ForwardMessenger.cs → linker.messenger.forward/ForwardMessenger.cs
View File

@@ -1,21 +1,19 @@
using linker.client.config;
using linker.messenger;
using linker.libs;
using linker.messenger.signin;
using linker.serializer;
using MemoryPack;
namespace linker.plugins.forward.messenger
namespace linker.messenger.forward
{
public sealed class ForwardServerMessenger : IMessenger
{
private readonly IMessengerSender sender;
private readonly SignInServerCaching signCaching;
public ForwardServerMessenger(IMessengerSender sender, SignInServerCaching signCaching)
private readonly ISerializer serializer;
public ForwardServerMessenger(IMessengerSender sender, SignInServerCaching signCaching, ISerializer serializer)
{
this.sender = sender;
this.signCaching = signCaching;
this.serializer = serializer;
}
/// <summary>
@@ -25,7 +23,7 @@ namespace linker.plugins.forward.messenger
[MessengerId((ushort)ForwardMessengerIds.GetForward)]
public void GetForward(IConnection connection)
{
string machineId = Serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
string machineId = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(machineId, out SignCacheInfo cacheTo) && signCaching.TryGet(connection.Id, out SignCacheInfo cacheFrom) && cacheFrom.GroupId == cacheTo.GroupId)
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
@@ -56,7 +54,7 @@ namespace linker.plugins.forward.messenger
[MessengerId((ushort)ForwardMessengerIds.AddClientForward)]
public async Task AddClientForward(IConnection connection)
{
ForwardAddForwardInfo info = Serializer.Deserialize<ForwardAddForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
ForwardAddForwardInfo info = serializer.Deserialize<ForwardAddForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(info.MachineId, out SignCacheInfo cacheTo) && signCaching.TryGet(connection.Id, out SignCacheInfo cacheFrom) && cacheFrom.GroupId == cacheTo.GroupId)
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
@@ -64,7 +62,7 @@ namespace linker.plugins.forward.messenger
{
Connection = cacheTo.Connection,
MessengerId = (ushort)ForwardMessengerIds.AddClient,
Payload = Serializer.Serialize(info.Data)
Payload = serializer.Serialize(info.Data)
});
}
}
@@ -75,7 +73,7 @@ namespace linker.plugins.forward.messenger
[MessengerId((ushort)ForwardMessengerIds.RemoveClientForward)]
public async Task RemoveClientForward(IConnection connection)
{
ForwardRemoveForwardInfo info = Serializer.Deserialize<ForwardRemoveForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
ForwardRemoveForwardInfo info = serializer.Deserialize<ForwardRemoveForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(info.MachineId, out SignCacheInfo cacheTo) && signCaching.TryGet(connection.Id, out SignCacheInfo cacheFrom) && cacheFrom.GroupId == cacheTo.GroupId)
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
@@ -83,7 +81,7 @@ namespace linker.plugins.forward.messenger
{
Connection = cacheTo.Connection,
MessengerId = (ushort)ForwardMessengerIds.RemoveClient,
Payload = Serializer.Serialize(info.Id)
Payload = serializer.Serialize(info.Id)
});
}
}
@@ -94,17 +92,18 @@ namespace linker.plugins.forward.messenger
{
private readonly ForwardTransfer forwardTransfer;
private readonly IMessengerSender sender;
public ForwardClientMessenger(ForwardTransfer forwardTransfer, IMessengerSender sender)
private readonly ISerializer serializer;
public ForwardClientMessenger(ForwardTransfer forwardTransfer, IMessengerSender sender, ISerializer serializer)
{
this.forwardTransfer = forwardTransfer;
this.sender = sender;
this.serializer = serializer;
}
[MessengerId((ushort)ForwardMessengerIds.Get)]
public void Get(IConnection connection)
{
connection.Write(Serializer.Serialize(forwardTransfer.Get()));
connection.Write(serializer.Serialize(forwardTransfer.Get()));
}
/// <summary>
/// 添加
@@ -113,7 +112,7 @@ namespace linker.plugins.forward.messenger
[MessengerId((ushort)ForwardMessengerIds.AddClient)]
public void AddClient(IConnection connection)
{
ForwardInfo info = Serializer.Deserialize<ForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
ForwardInfo info = serializer.Deserialize<ForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
forwardTransfer.Add(info);
}
// <summary>
@@ -123,21 +122,10 @@ namespace linker.plugins.forward.messenger
[MessengerId((ushort)ForwardMessengerIds.RemoveClient)]
public void RemoveClient(IConnection connection)
{
uint id = Serializer.Deserialize<uint>(connection.ReceiveRequestWrap.Payload.Span);
uint id = serializer.Deserialize<uint>(connection.ReceiveRequestWrap.Payload.Span);
forwardTransfer.Remove(id);
}
}
[MemoryPackable]
public sealed partial class ForwardAddForwardInfo
{
public string MachineId { get; set; }
public ForwardInfo Data { get; set; }
}
[MemoryPackable]
public sealed partial class ForwardRemoveForwardInfo
{
public string MachineId { get; set; }
public uint Id { get; set; }
}
}

2
linker/plugins/forward/messenger/ForwardMessengerIds.cs → linker.messenger.forward/ForwardMessengerIds.cs
View File

@@ -1,4 +1,4 @@
namespace linker.plugins.forward.messenger
namespace linker.messenger.forward
{
public enum ForwardMessengerIds : ushort
{

77
linker/plugins/forward/ForwardTransfer.cs → linker.messenger.forward/ForwardTransfer.cs
View File

@@ -1,20 +1,17 @@
using linker.client.config;
using linker.libs;
using linker.messenger;
using linker.libs;
using linker.libs.extends;
using linker.messenger.forward.proxy;
using linker.messenger.signin;
using linker.plugins.client;
using linker.plugins.forward.proxy;
using MemoryPack;
namespace linker.plugins.forward
namespace linker.messenger.forward
{
public sealed class ForwardTransfer
{
public int Count => running.Data.Forwards.Count(c => c.GroupId == signInClientStore.Group.Id);
public int Count => forwardClientStore.Get().Count(c => c.GroupId == signInClientStore.Group.Id);
public Action OnChanged { get; set; } = () => { };
public Action OnReset{ get; set; } = () => { };
public Action OnReset { get; set; } = () => { };
private readonly RunningConfig running;
private readonly IForwardClientStore forwardClientStore;
private readonly ForwardProxy forwardProxy;
private readonly SignInClientState signInClientState;
private readonly IMessengerSender messengerSender;
@@ -22,9 +19,9 @@ namespace linker.plugins.forward
private readonly NumberSpaceUInt32 ns = new NumberSpaceUInt32();
public ForwardTransfer( RunningConfig running, ForwardProxy forwardProxy, SignInClientState signInClientState, IMessengerSender messengerSender, ISignInClientStore signInClientStore)
public ForwardTransfer(IForwardClientStore forwardClientStore, ForwardProxy forwardProxy, SignInClientState signInClientState, IMessengerSender messengerSender, ISignInClientStore signInClientStore)
{
this.running = running;
this.forwardClientStore = forwardClientStore;
this.forwardProxy = forwardProxy;
this.signInClientState = signInClientState;
this.messengerSender = messengerSender;
@@ -38,15 +35,6 @@ namespace linker.plugins.forward
{
TimerHelper.Async(async () =>
{
if (running.Data.Forwards.All(c => string.IsNullOrWhiteSpace(c.GroupId)))
{
foreach (var item in running.Data.Forwards)
{
item.GroupId = signInClientStore.Group.Id;
}
running.Data.Update();
}
if (groupid != signInClientStore.Group.Id)
{
OnReset();
@@ -58,15 +46,15 @@ namespace linker.plugins.forward
Start(false);
});
}
private void Start(bool errorStop = true)
{
lock (this)
{
uint maxid = running.Data.Forwards.Count > 0 ? running.Data.Forwards.Max(c => c.Id) : 1;
uint maxid = forwardClientStore.Count() > 0 ? forwardClientStore.Get().Max(c => c.Id) : 1;
ns.Reset(maxid);
foreach (var item in running.Data.Forwards.Where(c => c.GroupId == signInClientStore.Group.Id))
foreach (var item in forwardClientStore.Get(signInClientStore.Group.Id))
{
if (item.Started)
{
@@ -76,7 +64,9 @@ namespace linker.plugins.forward
{
Stop(item);
}
forwardClientStore.Update(item);
}
forwardClientStore.Confirm();
OnChanged();
}
}
@@ -124,7 +114,7 @@ namespace linker.plugins.forward
{
lock (this)
{
foreach (var item in running.Data.Forwards)
foreach (var item in forwardClientStore.Get())
{
Stop(item);
}
@@ -136,7 +126,8 @@ namespace linker.plugins.forward
{
if (forwardInfo.Proxy)
{
LoggerHelper.Instance.Debug($"stop forward {forwardInfo.Port}->{forwardInfo.MachineId}->{forwardInfo.TargetEP}");
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Debug($"stop forward {forwardInfo.ToJson()}");
forwardProxy.StopPort(forwardInfo.Port);
forwardInfo.Proxy = false;
}
@@ -150,19 +141,22 @@ namespace linker.plugins.forward
public List<ForwardInfo> Get()
{
return running.Data.Forwards.Where(c => c.GroupId == signInClientStore.Group.Id).ToList();
return forwardClientStore.Get(signInClientStore.Group.Id);
}
public bool Add(ForwardInfo forwardInfo)
{
//同名或者同端口，但是ID不一样
ForwardInfo old = running.Data.Forwards.FirstOrDefault(c => (c.Port == forwardInfo.Port && c.Port != 0) && c.MachineId == forwardInfo.MachineId);
ForwardInfo old = forwardClientStore.Get().FirstOrDefault(c => (c.Port == forwardInfo.Port && c.Port != 0) && c.MachineId == forwardInfo.MachineId);
if (old != null && old.Id != forwardInfo.Id) return false;
if (forwardInfo.Id != 0)
{
old = running.Data.Forwards.FirstOrDefault(c => c.Id == forwardInfo.Id);
old = forwardClientStore.Get(forwardInfo.Id);
if (old == null) return false;
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Debug($"update forward {old.ToJson()}->{forwardInfo.ToJson()}");
old.BindIPAddress = forwardInfo.BindIPAddress;
old.Port = forwardInfo.Port;
old.Name = forwardInfo.Name;
@@ -177,9 +171,13 @@ namespace linker.plugins.forward
{
forwardInfo.Id = ns.Increment();
forwardInfo.GroupId = signInClientStore.Group.Id;
running.Data.Forwards.Add(forwardInfo);
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Debug($"add forward {forwardInfo.ToJson()}");
forwardClientStore.Add(forwardInfo);
}
running.Data.Update();
forwardClientStore.Confirm();
Start();
@@ -188,24 +186,19 @@ namespace linker.plugins.forward
public bool Remove(uint id)
{
//同名或者同端口，但是ID不一样
ForwardInfo old = running.Data.Forwards.FirstOrDefault(c => c.Id == id);
ForwardInfo old = forwardClientStore.Get(id);
if (old == null) return false;
old.Started = false;
running.Data.Forwards.Remove(old);
running.Data.Update();
forwardClientStore.Remove(old.Id);
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Debug($"remove forward {old.ToJson()}");
Start();
forwardClientStore.Confirm();
return true;
}
}
[MemoryPackable]
public sealed partial class CountInfo
{
public string MachineId { get; set; }
public int Count { get; set; }
}
}

16
linker.messenger.forward/IForwardClientStore.cs Normal file
View File

@@ -0,0 +1,16 @@
namespace linker.messenger.forward
{
public interface IForwardClientStore
{
public int Count();
public List<ForwardInfo> Get();
public ForwardInfo Get(uint id);
public List<ForwardInfo> Get(string groupId);
public bool Add(ForwardInfo info);
public bool Update(ForwardInfo info);
public bool Remove(uint id);
public bool Confirm();
}
}

41
linker.messenger.forward/linker.messenger.forward.csproj Normal file
View File

@@ -0,0 +1,41 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net8.0</TargetFrameworks>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>disable</Nullable>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<PublishAot>false</PublishAot>
<JsonSerializerIsReflectionEnabledByDefault>true</JsonSerializerIsReflectionEnabledByDefault>
<EnablePreviewFeatures>True</EnablePreviewFeatures>
<Title>linker messenger forward</Title>
<Authors>snltty</Authors>
<Company>snltty</Company>
<Description>linker messenger forward</Description>
<Copyright>snltty</Copyright>
<PackageProjectUrl>https://github.com/snltty/linker</PackageProjectUrl>
<RepositoryUrl>https://github.com/snltty/linker</RepositoryUrl>
<PackageReleaseNotes>linker messenger forward</PackageReleaseNotes>
<Version>1.6.4</Version>
<AssemblyVersion>1.6.4</AssemblyVersion>
<FileVersion>1.6.4</FileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>full</DebugType>
<DebugSymbols>true</DebugSymbols>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>none</DebugType>
<DebugSymbols>false</DebugSymbols>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\linker.libs\linker.libs.csproj" />
<ProjectReference Include="..\linker.messenger.channel\linker.messenger.channel.csproj" />
<ProjectReference Include="..\linker.messenger.decenter\linker.messenger.decenter.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
</ItemGroup>
</Project>

2
linker/plugins/forward/proxy/ForwardProxy.cs → linker.messenger.forward/proxy/ForwardProxy.cs
View File

@@ -5,7 +5,7 @@ using System.Buffers;
using System.Net;
using System.Net.Sockets;
namespace linker.plugins.forward.proxy
namespace linker.messenger.forward.proxy
{
public partial class ForwardProxy

2
linker/plugins/forward/proxy/ForwardProxyTcp.cs → linker.messenger.forward/proxy/ForwardProxyTcp.cs
View File

@@ -6,7 +6,7 @@ using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
namespace linker.plugins.forward.proxy
namespace linker.messenger.forward.proxy
{
public partial class ForwardProxy
{

14
linker/plugins/forward/proxy/ForwardProxyTunnel.cs → linker.messenger.forward/proxy/ForwardProxyTunnel.cs
View File

@@ -2,16 +2,14 @@
using linker.tunnel.connection;
using System.Collections.Concurrent;
using System.Net;
using linker.plugins.client;
using linker.plugins.tunnel;
using linker.plugins.relay.client;
using linker.plugins.pcp;
using linker.messenger.relay.client;
using linker.messenger.signin;
using linker.messenger.channel;
using linker.messenger.pcp;
namespace linker.plugins.forward.proxy
namespace linker.messenger.forward.proxy
{
public sealed partial class ForwardProxy : TunnelBase, ITunnelConnectionReceiveCallback
public sealed partial class ForwardProxy : Channel, ITunnelConnectionReceiveCallback
{
private readonly ConcurrentDictionary<int, ForwardProxyCacheInfo> caches = new ConcurrentDictionary<int, ForwardProxyCacheInfo>();
private readonly ConcurrentDictionary<string, SemaphoreSlim> locks = new ConcurrentDictionary<string, SemaphoreSlim>();
@@ -19,8 +17,8 @@ namespace linker.plugins.forward.proxy
protected override string TransactionId => "forward";
public ForwardProxy(ISignInClientStore signInClientStore, TunnelTransfer tunnelTransfer, RelayClientTransfer relayTransfer, PcpTransfer pcpTransfer, SignInClientTransfer signInClientTransfer, RelayClientConfigTransfer relayClientConfigTransfer)
: base(tunnelTransfer, relayTransfer, pcpTransfer, signInClientTransfer, signInClientStore, relayClientConfigTransfer)
public ForwardProxy(ISignInClientStore signInClientStore, TunnelTransfer tunnelTransfer, RelayClientTransfer relayTransfer, PcpTransfer pcpTransfer, SignInClientTransfer signInClientTransfer, IRelayClientStore relayClientStore)
: base(tunnelTransfer, relayTransfer, pcpTransfer, signInClientTransfer, signInClientStore, relayClientStore)
{
TaskUdp();
}

2
linker/plugins/forward/proxy/ForwardProxyUdp.cs → linker.messenger.forward/proxy/ForwardProxyUdp.cs
View File

@@ -5,7 +5,7 @@ using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
namespace linker.plugins.forward.proxy
namespace linker.messenger.forward.proxy
{
public partial class ForwardProxy
{

3
linker.messenger.listen/Entry.cs
View File

@@ -1,6 +1,5 @@
using linker.libs;
using Microsoft.Extensions.DependencyInjection;
using System.Security.Cryptography.X509Certificates;
namespace linker.messenger.listen
{
public static class Entry
@@ -10,7 +9,7 @@ namespace linker.messenger.listen
serviceCollection.AddSingleton<TcpServer>();
return serviceCollection;
}
public static ServiceProvider UseListen(this ServiceProvider serviceProvider, X509Certificate2 certificate)
public static ServiceProvider UseListen(this ServiceProvider serviceProvider)
{
TcpServer tcpServer = serviceProvider.GetService<TcpServer>();
IListenStore listenStore = serviceProvider.GetService<IListenStore>();

90
linker.messenger.logger/Entry.cs Normal file
View File

@@ -0,0 +1,90 @@
using linker.libs;
using linker.messenger.api;
using Microsoft.Extensions.DependencyInjection;
namespace linker.messenger.logger
{
public static class Entry
{
public static ServiceCollection AddLoggerClient(this ServiceCollection serviceCollection)
{
LoggerConsole();
serviceCollection.AddSingleton<LoggerApiController>();
return serviceCollection;
}
public static ServiceProvider UseLoggerClient(this ServiceProvider serviceProvider)
{
IApiServer apiServer = serviceProvider.GetService<IApiServer>();
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<LoggerApiController>() });
IAccessStore accessStore= serviceProvider.GetService<IAccessStore>();
ILoggerStore loggerStore= serviceProvider.GetService<ILoggerStore>();
if (accessStore.HasAccess(AccessValue.LoggerLevel) == false)
{
loggerStore.SetLevel( libs.LoggerTypes.WARNING);
loggerStore.Confirm();
}
return serviceProvider;
}
private static void LoggerConsole()
{
if (Directory.Exists("logs") == false)
{
Directory.CreateDirectory("logs");
}
LoggerHelper.Instance.OnLogger += (model) =>
{
ConsoleColor currentForeColor = Console.ForegroundColor;
switch (model.Type)
{
case LoggerTypes.DEBUG:
Console.ForegroundColor = ConsoleColor.Blue;
break;
case LoggerTypes.INFO:
Console.ForegroundColor = ConsoleColor.White;
break;
case LoggerTypes.WARNING:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LoggerTypes.ERROR:
Console.ForegroundColor = ConsoleColor.Red;
break;
default:
break;
}
string line = $"[{model.Type,-7}][{model.Time:yyyy-MM-dd HH:mm:ss}]:{model.Content}";
Console.WriteLine(line);
Console.ForegroundColor = currentForeColor;
try
{
using StreamWriter sw = File.AppendText(Path.Combine("logs", $"{DateTime.Now:yyyy-MM-dd}.log"));
sw.WriteLine(line);
sw.Flush();
sw.Close();
sw.Dispose();
}
catch (Exception)
{
}
};
TimerHelper.SetInterval(() =>
{
string[] files = Directory.GetFiles("logs").OrderBy(c => c).ToArray();
for (int i = 0; i < files.Length - 180; i++)
{
try
{
File.Delete(files[i]);
}
catch (Exception)
{
}
}
return true;
}, 60 * 1000);
}
}
}

15
linker.messenger.logger/ILoggerStore.cs Normal file
View File

@@ -0,0 +1,15 @@
using linker.libs;
namespace linker.messenger.logger
{
public interface ILoggerStore
{
public LoggerTypes LoggerType { get; }
public int LoggerSize { get; }
public bool SetLevel(LoggerTypes level);
public bool SetSize(int size);
public bool Confirm();
}
}

30
linker/plugins/logger/LoggerController.cs → linker.messenger.logger/LoggerController.cs
View File

@@ -1,30 +1,28 @@
using linker.libs.extends;
using linker.libs.api;
using linker.libs;
using linker.config;
using linker.plugins.capi;
using linker.messenger.api;
namespace linker.plugins.logger
namespace linker.messenger.logger
{
public sealed class LoggerClientApiController : IApiClientController
public sealed class LoggerApiController : IApiController
{
private readonly List<LoggerModel> loggers = new List<LoggerModel>();
private readonly FileConfig config;
public LoggerClientApiController(FileConfig config)
private readonly ILoggerStore loggerStore;
public LoggerApiController(ILoggerStore loggerStore)
{
this.config = config;
this.loggerStore = loggerStore;
LoggerHelper.Instance.OnLogger += (LoggerModel logger) =>
{
loggers.Add(logger);
if (loggers.Count > config.Data.Common.LoggerSize)
if (loggers.Count > loggerStore.LoggerSize)
{
loggers.RemoveAt(0);
}
};
}
[ClientApiAccessAttribute(ClientApiAccess.LoggerShow)]
[Access(AccessValue.LoggerShow)]
public LoggerPageInfo Get(ApiControllerParamsInfo param)
{
LoggerPageParamInfo info = param.Content.DeJson<LoggerPageParamInfo>();
@@ -55,18 +53,18 @@ namespace linker.plugins.logger
{
return new LoggerSetParamInfo
{
LoggerType = config.Data.Common.LoggerType,
Size = config.Data.Common.LoggerSize
LoggerType = loggerStore.LoggerType,
Size = loggerStore.LoggerSize
};
}
[ClientApiAccessAttribute(ClientApiAccess.LoggerLevel)]
[Access(AccessValue.LoggerLevel)]
public bool SetConfig(ApiControllerParamsInfo param)
{
LoggerSetParamInfo info = param.Content.DeJson<LoggerSetParamInfo>();
config.Data.Common.LoggerSize = info.Size;
config.Data.Common.LoggerType = info.LoggerType;
config.Data.Update();
loggerStore.SetLevel(info.LoggerType);
loggerStore.SetSize(info.Size);
loggerStore.Confirm();
return true;
}

38
linker.messenger.logger/linker.messenger.logger.csproj Normal file
View File

@@ -0,0 +1,38 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net8.0</TargetFrameworks>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>disable</Nullable>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<PublishAot>false</PublishAot>
<JsonSerializerIsReflectionEnabledByDefault>true</JsonSerializerIsReflectionEnabledByDefault>
<EnablePreviewFeatures>True</EnablePreviewFeatures>
<Title>linker messenger logger</Title>
<Authors>snltty</Authors>
<Company>snltty</Company>
<Description>linker messenger logger</Description>
<Copyright>snltty</Copyright>
<PackageProjectUrl>https://github.com/snltty/linker</PackageProjectUrl>
<RepositoryUrl>https://github.com/snltty/linker</RepositoryUrl>
<PackageReleaseNotes>linker messenger logger</PackageReleaseNotes>
<Version>1.6.4</Version>
<AssemblyVersion>1.6.4</AssemblyVersion>
<FileVersion>1.6.4</FileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>full</DebugType>
<DebugSymbols>true</DebugSymbols>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>none</DebugType>
<DebugSymbols>false</DebugSymbols>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\linker.libs\linker.libs.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
</ItemGroup>
</Project>

8
linker.messenger.pcp/Entry.cs
View File

@@ -3,13 +3,13 @@ namespace linker.messenger.pcp
{
public static class Entry
{
public static ServiceCollection AddRelayClient(this ServiceCollection serviceCollection)
public static ServiceCollection AddPcpClient(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<PcpTransfer>();
serviceCollection.AddSingleton<PcpClientMessenger>();
return serviceCollection;
}
public static ServiceProvider UseRelayClient(this ServiceProvider serviceProvider)
public static ServiceProvider UsePcpClient(this ServiceProvider serviceProvider)
{
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<PcpClientMessenger>() });
@@ -17,12 +17,12 @@ namespace linker.messenger.pcp
}
public static ServiceCollection AddRelayServer(this ServiceCollection serviceCollection)
public static ServiceCollection AddPcpServer(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<PcpServerMessenger>();
return serviceCollection;
}
public static ServiceProvider UseRelayServer(this ServiceProvider serviceProvider)
public static ServiceProvider UsePcpServer(this ServiceProvider serviceProvider)
{
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<PcpServerMessenger>() });

6
linker.messenger.relay/Entry.cs
View File

@@ -6,12 +6,10 @@ using linker.messenger.relay.server.caching;
using linker.messenger.relay.server.validator;
using linker.messenger.sync;
using Microsoft.Extensions.DependencyInjection;
using System.Security.Cryptography.X509Certificates;
namespace linker.messenger.relay
{
public static class Entry
{
public static X509Certificate2 certificate;
public static ServiceCollection AddRelayClient(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<RelayClientTransfer>();
@@ -25,10 +23,8 @@ namespace linker.messenger.relay
return serviceCollection;
}
public static ServiceProvider UseRelayClient(this ServiceProvider serviceProvider, X509Certificate2 certificate)
public static ServiceProvider UseRelayClient(this ServiceProvider serviceProvider)
{
Entry.certificate = certificate;
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<RelayClientMessenger>() });

2
linker.messenger.relay/client/RelayApiController.cs
View File

@@ -1,5 +1,6 @@
using linker.libs.api;
using linker.libs.extends;
using linker.messenger.api;
using linker.messenger.relay.client;
using linker.messenger.relay.client.transport;
using linker.messenger.relay.server;
@@ -27,6 +28,7 @@ namespace linker.messenger.relay
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
[Access(AccessValue.Config)]
public bool SetServers(ApiControllerParamsInfo param)
{
RelayServerInfo info = param.Content.DeJson<RelayServerInfo>();

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

@@ -18,11 +18,11 @@ 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(IMessengerSender messengerSender,ISerializer serializer,IRelayClientStore relayClientStore,SignInClientState signInClientState)
public RelayClientTransfer(IMessengerSender messengerSender,ISerializer serializer,IRelayClientStore relayClientStore,SignInClientState signInClientState,IMessengerStore messengerStore)
{
this.relayClientStore = relayClientStore;
Transports = new List<IRelayClientTransport> {
new RelayClientTransportSelfHost(messengerSender,serializer,relayClientStore,signInClientState),
new RelayClientTransportSelfHost(messengerSender,serializer,relayClientStore,signInClientState,messengerStore),
};
LoggerHelper.Instance.Info($"load relay transport:{string.Join(",", Transports.Select(c => c.GetType().Name))}");
}

6
linker.messenger.relay/client/transport/RelayClientTransportSelfHost.cs
View File

@@ -27,12 +27,14 @@ namespace linker.messenger.relay.client.transport
private readonly ISerializer serializer;
private readonly IRelayClientStore relayClientStore;
private readonly SignInClientState signInClientState;
public RelayClientTransportSelfHost(IMessengerSender messengerSender, ISerializer serializer, IRelayClientStore relayClientStore, SignInClientState signInClientState)
private readonly IMessengerStore messengerStore;
public RelayClientTransportSelfHost(IMessengerSender messengerSender, ISerializer serializer, IRelayClientStore relayClientStore, SignInClientState signInClientState, IMessengerStore messengerStore)
{
this.messengerSender = messengerSender;
this.serializer = serializer;
this.relayClientStore = relayClientStore;
this.signInClientState = signInClientState;
this.messengerStore = messengerStore;
}
public async Task<ITunnelConnection> RelayAsync(RelayInfo relayInfo)
@@ -272,7 +274,7 @@ namespace linker.messenger.relay.client.transport
if (relayInfo.SSL)
{
sslStream = new SslStream(new NetworkStream(socket, false), false);
await sslStream.AuthenticateAsServerAsync(Entry.certificate, false, SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12 | SslProtocols.Tls13, false).ConfigureAwait(false);
await sslStream.AuthenticateAsServerAsync(messengerStore.Certificate, false, SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12 | SslProtocols.Tls13, false).ConfigureAwait(false);
}
return new TunnelConnectionTcp
{

4
linker.messenger.relay/server/IRelayServerNodeStore.cs
View File

@@ -48,12 +48,12 @@ namespace linker.messenger.relay.server
}
}
private string name = Dns.GetHostName().SubStr(0, 12);
private string name = Dns.GetHostName().SubStr(0, 32);
public string Name
{
get => name; set
{
name = value.SubStr(0, 12);
name = value.SubStr(0, 32);
}
}
public string Host { get; set; } = string.Empty;

1
linker.messenger.serializer.memorypack/AccessSerializer.cs
View File

@@ -1,5 +1,6 @@
using MemoryPack;
using linker.messenger.access;
using linker.messenger.api;
namespace linker.messenger.serializer.memorypack
{

33
linker.messenger.serializer.memorypack/Entry.cs
View File

@@ -59,6 +59,39 @@ namespace linker.messenger.serializer.memorypack
MemoryPackFormatterProvider.Register(new Socks5LanInfoFormatter());
MemoryPackFormatterProvider.Register(new Socks5InfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardAddInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardAddResultInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardAddForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardRemoveForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardProxyInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardCountInfoFormatter());
MemoryPackFormatterProvider.Register(new ForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new ForwardAddForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new ForwardRemoveForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new ForwardCountInfoFormatter());
MemoryPackFormatterProvider.Register(new FlowItemInfoFormatter());
MemoryPackFormatterProvider.Register(new FlowInfoFormatter());
MemoryPackFormatterProvider.Register(new RelayFlowItemInfoFormatter());
MemoryPackFormatterProvider.Register(new RelayFlowRequestInfoFormatter());
MemoryPackFormatterProvider.Register(new RelayFlowResponseInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardFlowItemInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardFlowRequestInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardFlowResponseInfoFormatter());
MemoryPackFormatterProvider.Register(new TuntapVeaLanIPAddressFormatter());
MemoryPackFormatterProvider.Register(new TuntapVeaLanIPAddressListFormatter());
MemoryPackFormatterProvider.Register(new TuntapInfoFormatter());
MemoryPackFormatterProvider.Register(new TuntapForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new TuntapForwardTestWrapInfoFormatter());
MemoryPackFormatterProvider.Register(new TuntapForwardTestInfoFormatter());
MemoryPackFormatterProvider.Register(new TuntapLanInfoFormatter());
MemoryPackFormatterProvider.Register(new LeaseInfoFormatter());
return serviceCollection;
}
public static ServiceProvider UseSerializerMemoryPack(this ServiceProvider serviceProvider)

533
linker.messenger.serializer.memorypack/FlowSerializer.cs Normal file
View File

@@ -0,0 +1,533 @@
using MemoryPack;
using linker.messenger.flow;
namespace linker.messenger.serializer.memorypack
{
[MemoryPackable]
public readonly partial struct SerializableFlowItemInfo
{
[MemoryPackIgnore]
public readonly FlowItemInfo info;
[MemoryPackInclude]
ulong ReceiveBytes => info.ReceiveBytes;
[MemoryPackInclude]
ulong SendtBytes => info.SendtBytes;
[MemoryPackConstructor]
SerializableFlowItemInfo(ulong receiveBytes, ulong sendtBytes)
{
var info = new FlowItemInfo { ReceiveBytes = receiveBytes, SendtBytes = sendtBytes };
this.info = info;
}
public SerializableFlowItemInfo(FlowItemInfo info)
{
this.info = info;
}
}
public class FlowItemInfoFormatter : MemoryPackFormatter<FlowItemInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref FlowItemInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableFlowItemInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref FlowItemInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableFlowItemInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableFlowInfo
{
[MemoryPackIgnore]
public readonly FlowInfo info;
[MemoryPackInclude]
Dictionary<string, FlowItemInfo> Items => info.Items;
[MemoryPackInclude]
DateTime Start => info.Start;
[MemoryPackInclude]
DateTime Now => info.Now;
[MemoryPackConstructor]
SerializableFlowInfo(Dictionary<string, FlowItemInfo> items, DateTime start, DateTime now)
{
var info = new FlowInfo { Items = items, Now = now, Start = start };
this.info = info;
}
public SerializableFlowInfo(FlowInfo info)
{
this.info = info;
}
}
public class FlowInfoFormatter : MemoryPackFormatter<FlowInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref FlowInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableFlowInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref FlowInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableFlowInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableRelayFlowItemInfo
{
[MemoryPackIgnore]
public readonly RelayFlowItemInfo info;
[MemoryPackInclude]
ulong ReceiveBytes => info.ReceiveBytes;
[MemoryPackInclude]
ulong SendtBytes => info.SendtBytes;
[MemoryPackInclude]
ulong DiffReceiveBytes => info.DiffReceiveBytes;
[MemoryPackInclude]
ulong DiffSendtBytes => info.DiffSendtBytes;
[MemoryPackInclude]
string FromName => info.FromName;
[MemoryPackInclude]
string ToName => info.ToName;
[MemoryPackConstructor]
SerializableRelayFlowItemInfo(ulong receiveBytes, ulong sendtBytes, ulong diffReceiveBytes, ulong diffSendtBytes, string fromName, string toName)
{
var info = new RelayFlowItemInfo
{
ReceiveBytes = receiveBytes,
SendtBytes = sendtBytes,
DiffReceiveBytes = diffReceiveBytes,
DiffSendtBytes = diffSendtBytes,
FromName = fromName,
ToName = toName
};
this.info = info;
}
public SerializableRelayFlowItemInfo(RelayFlowItemInfo info)
{
this.info = info;
}
}
public class RelayFlowItemInfoFormatter : MemoryPackFormatter<RelayFlowItemInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref RelayFlowItemInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableRelayFlowItemInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref RelayFlowItemInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableRelayFlowItemInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableRelayFlowRequestInfo
{
[MemoryPackIgnore]
public readonly RelayFlowRequestInfo info;
[MemoryPackInclude]
string Key => info.Key;
[MemoryPackInclude]
string SecretKey => info.SecretKey;
[MemoryPackInclude]
int Page => info.Page;
[MemoryPackInclude]
int PageSize => info.PageSize;
[MemoryPackInclude]
RelayFlowOrder Order => info.Order;
[MemoryPackInclude]
RelayFlowOrderType OrderType => info.OrderType;
[MemoryPackConstructor]
SerializableRelayFlowRequestInfo(string key, string secretKey, int page, int pageSize, RelayFlowOrder order, RelayFlowOrderType orderType)
{
var info = new RelayFlowRequestInfo
{
Key = key,
Order = order,
OrderType = orderType,
Page = page,
PageSize = pageSize,
SecretKey = secretKey
};
this.info = info;
}
public SerializableRelayFlowRequestInfo(RelayFlowRequestInfo info)
{
this.info = info;
}
}
public class RelayFlowRequestInfoFormatter : MemoryPackFormatter<RelayFlowRequestInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref RelayFlowRequestInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableRelayFlowRequestInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref RelayFlowRequestInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableRelayFlowRequestInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableRelayFlowResponseInfo
{
[MemoryPackIgnore]
public readonly RelayFlowResponseInfo info;
[MemoryPackInclude]
int Page => info.Page;
[MemoryPackInclude]
int PageSize => info.PageSize;
[MemoryPackInclude]
int Count => info.Count;
[MemoryPackInclude]
List<RelayFlowItemInfo> Data => info.Data;
[MemoryPackConstructor]
SerializableRelayFlowResponseInfo(int page, int pageSize, int count, List<RelayFlowItemInfo> data)
{
var info = new RelayFlowResponseInfo
{
Page = page,
PageSize = pageSize,
Count = count,
Data = data
};
this.info = info;
}
public SerializableRelayFlowResponseInfo(RelayFlowResponseInfo info)
{
this.info = info;
}
}
public class RelayFlowResponseInfoFormatter : MemoryPackFormatter<RelayFlowResponseInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref RelayFlowResponseInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableRelayFlowResponseInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref RelayFlowResponseInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableRelayFlowResponseInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardFlowItemInfo
{
[MemoryPackIgnore]
public readonly SForwardFlowItemInfo info;
[MemoryPackInclude]
ulong ReceiveBytes => info.ReceiveBytes;
[MemoryPackInclude]
ulong SendtBytes => info.SendtBytes;
[MemoryPackInclude]
ulong DiffReceiveBytes => info.DiffReceiveBytes;
[MemoryPackInclude]
ulong DiffSendtBytes => info.DiffSendtBytes;
[MemoryPackInclude]
string Key => info.Key;
[MemoryPackConstructor]
SerializableSForwardFlowItemInfo(ulong receiveBytes, ulong sendtBytes, ulong diffReceiveBytes, ulong diffSendtBytes, string key)
{
var info = new SForwardFlowItemInfo
{
ReceiveBytes = receiveBytes,
SendtBytes = sendtBytes,
DiffReceiveBytes = diffReceiveBytes,
DiffSendtBytes = diffSendtBytes,
Key = key
};
this.info = info;
}
public SerializableSForwardFlowItemInfo(SForwardFlowItemInfo info)
{
this.info = info;
}
}
public class SForwardFlowItemInfoFormatter : MemoryPackFormatter<SForwardFlowItemInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardFlowItemInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardFlowItemInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardFlowItemInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardFlowItemInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardFlowRequestInfo
{
[MemoryPackIgnore]
public readonly SForwardFlowRequestInfo info;
[MemoryPackInclude]
string Key => info.Key;
[MemoryPackInclude]
string SecretKey => info.SecretKey;
[MemoryPackInclude]
int Page => info.Page;
[MemoryPackInclude]
int PageSize => info.PageSize;
[MemoryPackInclude]
SForwardFlowOrder Order => info.Order;
[MemoryPackInclude]
SForwardFlowOrderType OrderType => info.OrderType;
[MemoryPackConstructor]
SerializableSForwardFlowRequestInfo(string key, string secretKey, int page, int pageSize, SForwardFlowOrder order, SForwardFlowOrderType orderType)
{
var info = new SForwardFlowRequestInfo
{
Key = key,
Order = order,
OrderType = orderType,
Page = page,
PageSize = pageSize,
SecretKey = secretKey
};
this.info = info;
}
public SerializableSForwardFlowRequestInfo(SForwardFlowRequestInfo info)
{
this.info = info;
}
}
public class SForwardFlowRequestInfoFormatter : MemoryPackFormatter<SForwardFlowRequestInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardFlowRequestInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardFlowRequestInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardFlowRequestInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardFlowRequestInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardFlowResponseInfo
{
[MemoryPackIgnore]
public readonly SForwardFlowResponseInfo info;
[MemoryPackInclude]
int Page => info.Page;
[MemoryPackInclude]
int PageSize => info.PageSize;
[MemoryPackInclude]
int Count => info.Count;
[MemoryPackInclude]
List<SForwardFlowItemInfo> Data => info.Data;
[MemoryPackConstructor]
SerializableSForwardFlowResponseInfo(int page, int pageSize, int count, List<SForwardFlowItemInfo> data)
{
var info = new SForwardFlowResponseInfo
{
Page = page,
PageSize = pageSize,
Count = count,
Data = data
};
this.info = info;
}
public SerializableSForwardFlowResponseInfo(SForwardFlowResponseInfo info)
{
this.info = info;
}
}
public class SForwardFlowResponseInfoFormatter : MemoryPackFormatter<SForwardFlowResponseInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardFlowResponseInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardFlowResponseInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardFlowResponseInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardFlowResponseInfo>();
value = wrapped.info;
}
}
}

269
linker.messenger.serializer.memorypack/ForwardSerializer.cs Normal file
View File

@@ -0,0 +1,269 @@
using MemoryPack;
using System.Net;
using linker.messenger.forward;
namespace linker.messenger.serializer.memorypack
{
[MemoryPackable]
public readonly partial struct SerializableForwardInfo
{
[MemoryPackIgnore]
public readonly ForwardInfo info;
[MemoryPackInclude]
uint Id => info.Id;
[MemoryPackInclude]
string Name => info.Name;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude]
string GroupId => info.GroupId;
[MemoryPackInclude]
string MachineName => info.MachineName;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress BindIPAddress => info.BindIPAddress;
[MemoryPackInclude]
int Port => info.Port;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPEndPoint TargetEP => info.TargetEP;
[MemoryPackInclude]
bool Started => info.Started;
[MemoryPackInclude]
byte BufferSize => info.BufferSize;
[MemoryPackInclude]
string Msg => info.Msg;
[MemoryPackInclude]
string TargetMsg => info.TargetMsg;
[MemoryPackConstructor]
SerializableForwardInfo(uint id, string name, string machineId, string groupId, string machineName, IPAddress bindIPAddress, int port, IPEndPoint targetEP, bool started, byte bufferSize, string msg, string targetMsg)
{
this.info = new ForwardInfo
{
Name = name,
BufferSize = bufferSize,
Id = id,
Started = started,
BindIPAddress = bindIPAddress,
GroupId = groupId,
MachineId = machineId,
MachineName = machineName,
Msg = msg,
Port = port,
TargetEP = targetEP,
TargetMsg = targetMsg
};
}
public SerializableForwardInfo(ForwardInfo info)
{
this.info = info;
}
}
public class ForwardInfoFormatter : MemoryPackFormatter<ForwardInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref ForwardInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableForwardInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref ForwardInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableForwardInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableForwardAddForwardInfo
{
[MemoryPackIgnore]
public readonly ForwardAddForwardInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude, MemoryPackAllowSerialize]
ForwardInfo Data => info.Data;
[MemoryPackConstructor]
SerializableForwardAddForwardInfo(string machineId, ForwardInfo data)
{
this.info = new ForwardAddForwardInfo
{
MachineId = machineId,
Data = data
};
}
public SerializableForwardAddForwardInfo(ForwardAddForwardInfo info)
{
this.info = info;
}
}
public class ForwardAddForwardInfoFormatter : MemoryPackFormatter<ForwardAddForwardInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref ForwardAddForwardInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableForwardAddForwardInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref ForwardAddForwardInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableForwardAddForwardInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableForwardRemoveForwardInfo
{
[MemoryPackIgnore]
public readonly ForwardRemoveForwardInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude, MemoryPackAllowSerialize]
uint Id => info.Id;
[MemoryPackConstructor]
SerializableForwardRemoveForwardInfo(string machineId, uint id)
{
this.info = new ForwardRemoveForwardInfo
{
MachineId = machineId,
Id = id
};
}
public SerializableForwardRemoveForwardInfo(ForwardRemoveForwardInfo info)
{
this.info = info;
}
}
public class ForwardRemoveForwardInfoFormatter : MemoryPackFormatter<ForwardRemoveForwardInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref ForwardRemoveForwardInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableForwardRemoveForwardInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref ForwardRemoveForwardInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableForwardRemoveForwardInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableForwardCountInfo
{
[MemoryPackIgnore]
public readonly ForwardCountInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude]
int Count => info.Count;
[MemoryPackConstructor]
SerializableForwardCountInfo(string machineId, int count)
{
this.info = new ForwardCountInfo
{
MachineId = machineId,
Count = count
};
}
public SerializableForwardCountInfo(ForwardCountInfo info)
{
this.info = info;
}
}
public class ForwardCountInfoFormatter : MemoryPackFormatter<ForwardCountInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref ForwardCountInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableForwardCountInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref ForwardCountInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableForwardCountInfo>();
value = wrapped.info;
}
}
}

444
linker.messenger.serializer.memorypack/SForwardSerializer.cs Normal file
View File

@@ -0,0 +1,444 @@
using MemoryPack;
using linker.messenger.sforward;
using System.Net;
namespace linker.messenger.serializer.memorypack
{
[MemoryPackable]
public readonly partial struct SerializableSForwardInfo
{
[MemoryPackIgnore]
public readonly SForwardInfo info;
[MemoryPackInclude]
uint Id => info.Id;
[MemoryPackInclude]
string Name => info.Name;
[MemoryPackInclude]
string Domain => info.Domain;
[MemoryPackInclude]
int RemotePort => info.RemotePort;
[MemoryPackInclude]
byte BufferSize => info.BufferSize;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPEndPoint LocalEP => info.LocalEP;
[MemoryPackInclude]
bool Started => info.Started;
[MemoryPackInclude]
string Msg => info.Msg;
[MemoryPackInclude]
string LocalMsg => info.LocalMsg;
[MemoryPackInclude]
int RemotePortMin => info.RemotePortMin;
[MemoryPackInclude]
int RemotePortMax => info.RemotePortMax;
[MemoryPackConstructor]
SerializableSForwardInfo(uint id, string name, string domain, int remotePort, byte bufferSize, IPEndPoint localEP, bool started, string msg, string localMsg, int remotePortMin, int remotePortMax)
{
this.info = new SForwardInfo
{
LocalEP = localEP,
RemotePort = remotePort,
RemotePortMax = remotePortMax,
Name = name,
BufferSize = bufferSize,
Domain = domain,
Id = id,
LocalMsg = localMsg,
Msg = localMsg,
RemotePortMin = remotePortMin,
Started = started,
};
}
public SerializableSForwardInfo(SForwardInfo info)
{
this.info = info;
}
}
public class SForwardInfoFormatter : MemoryPackFormatter<SForwardInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardAddInfo
{
[MemoryPackIgnore]
public readonly SForwardAddInfo info;
[MemoryPackInclude]
string Domain => info.Domain;
[MemoryPackInclude]
int RemotePort => info.RemotePort;
[MemoryPackInclude]
string SecretKey => info.SecretKey;
[MemoryPackConstructor]
SerializableSForwardAddInfo(string domain, int remotePort, string secretKey)
{
this.info = new SForwardAddInfo
{
RemotePort = remotePort,
Domain = domain,
SecretKey = secretKey
};
}
public SerializableSForwardAddInfo(SForwardAddInfo info)
{
this.info = info;
}
}
public class SForwardAddInfoFormatter : MemoryPackFormatter<SForwardAddInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardAddInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardAddInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardAddInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardAddInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardAddResultInfo
{
[MemoryPackIgnore]
public readonly SForwardAddResultInfo info;
[MemoryPackInclude]
bool Success => info.Success;
[MemoryPackInclude]
string Message => info.Message;
[MemoryPackInclude]
byte BufferSize => info.BufferSize;
[MemoryPackConstructor]
SerializableSForwardAddResultInfo(bool success, string message, byte bufferSize)
{
this.info = new SForwardAddResultInfo
{
BufferSize = bufferSize,
Message = message,
Success = success
};
}
public SerializableSForwardAddResultInfo(SForwardAddResultInfo info)
{
this.info = info;
}
}
public class SForwardAddResultInfoFormatter : MemoryPackFormatter<SForwardAddResultInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardAddResultInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardAddResultInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardAddResultInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardAddResultInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardAddForwardInfo
{
[MemoryPackIgnore]
public readonly SForwardAddForwardInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude, MemoryPackAllowSerialize]
SForwardInfo Data => info.Data;
[MemoryPackConstructor]
SerializableSForwardAddForwardInfo(string machineId, SForwardInfo data)
{
this.info = new SForwardAddForwardInfo
{
MachineId = machineId,
Data = data
};
}
public SerializableSForwardAddForwardInfo(SForwardAddForwardInfo info)
{
this.info = info;
}
}
public class SForwardAddForwardInfoFormatter : MemoryPackFormatter<SForwardAddForwardInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardAddForwardInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardAddForwardInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardAddForwardInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardAddForwardInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardRemoveForwardInfo
{
[MemoryPackIgnore]
public readonly SForwardRemoveForwardInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude, MemoryPackAllowSerialize]
uint Id => info.Id;
[MemoryPackConstructor]
SerializableSForwardRemoveForwardInfo(string machineId, uint id)
{
this.info = new SForwardRemoveForwardInfo
{
MachineId = machineId,
Id = id
};
}
public SerializableSForwardRemoveForwardInfo(SForwardRemoveForwardInfo info)
{
this.info = info;
}
}
public class SForwardRemoveForwardInfoFormatter : MemoryPackFormatter<SForwardRemoveForwardInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardRemoveForwardInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardRemoveForwardInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardRemoveForwardInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardRemoveForwardInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardProxyInfo
{
[MemoryPackIgnore]
public readonly SForwardProxyInfo info;
[MemoryPackInclude]
ulong Id => info.Id;
[MemoryPackInclude]
string Domain => info.Domain;
[MemoryPackInclude]
int RemotePort => info.RemotePort;
[MemoryPackInclude]
byte BufferSize => info.BufferSize;
[MemoryPackConstructor]
SerializableSForwardProxyInfo(ulong id, string domain, int remotePort, byte bufferSize)
{
this.info = new SForwardProxyInfo
{
Id = id,
BufferSize = bufferSize,
Domain = domain,
RemotePort = remotePort
};
}
public SerializableSForwardProxyInfo(SForwardProxyInfo info)
{
this.info = info;
}
}
public class SForwardProxyInfoFormatter : MemoryPackFormatter<SForwardProxyInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardProxyInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardProxyInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardProxyInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardProxyInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardCountInfo
{
[MemoryPackIgnore]
public readonly SForwardCountInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude]
int Count => info.Count;
[MemoryPackConstructor]
SerializableSForwardCountInfo(string machineId, int count)
{
this.info = new SForwardCountInfo
{
MachineId = machineId,
Count = count
};
}
public SerializableSForwardCountInfo(SForwardCountInfo info)
{
this.info = info;
}
}
public class SForwardCountInfoFormatter : MemoryPackFormatter<SForwardCountInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardCountInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardCountInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardCountInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardCountInfo>();
value = wrapped.info;
}
}
}

535
linker.messenger.serializer.memorypack/TuntapSerializer.cs Normal file
View File

@@ -0,0 +1,535 @@
using MemoryPack;
using linker.messenger.tuntap;
using System.Net;
using linker.messenger.tuntap.lease;
namespace linker.messenger.serializer.memorypack
{
[MemoryPackable]
public readonly partial struct SerializableTuntapVeaLanIPAddress
{
[MemoryPackIgnore]
public readonly TuntapVeaLanIPAddress info;
[MemoryPackInclude]
uint IPAddress => info.IPAddress;
[MemoryPackInclude]
byte PrefixLength => info.PrefixLength;
[MemoryPackInclude]
uint MaskValue => info.MaskValue;
[MemoryPackInclude]
uint NetWork => info.NetWork;
[MemoryPackInclude]
uint Broadcast => info.Broadcast;
[MemoryPackConstructor]
SerializableTuntapVeaLanIPAddress(uint ipAddress, byte prefixLength, uint maskValue, uint netWork, uint broadcast)
{
var info = new TuntapVeaLanIPAddress
{
Broadcast = broadcast,
IPAddress = ipAddress,
PrefixLength = prefixLength,
MaskValue = maskValue,
NetWork = netWork,
};
this.info = info;
}
public SerializableTuntapVeaLanIPAddress(TuntapVeaLanIPAddress info)
{
this.info = info;
}
}
public class TuntapVeaLanIPAddressFormatter : MemoryPackFormatter<TuntapVeaLanIPAddress>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TuntapVeaLanIPAddress value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableTuntapVeaLanIPAddress(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TuntapVeaLanIPAddress value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableTuntapVeaLanIPAddress>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableTuntapVeaLanIPAddressList
{
[MemoryPackIgnore]
public readonly TuntapVeaLanIPAddressList info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude]
List<TuntapVeaLanIPAddress> IPS => info.IPS;
[MemoryPackConstructor]
SerializableTuntapVeaLanIPAddressList(string machineId, List<TuntapVeaLanIPAddress> ips)
{
var info = new TuntapVeaLanIPAddressList
{
IPS = ips,
MachineId = machineId
};
this.info = info;
}
public SerializableTuntapVeaLanIPAddressList(TuntapVeaLanIPAddressList info)
{
this.info = info;
}
}
public class TuntapVeaLanIPAddressListFormatter : MemoryPackFormatter<TuntapVeaLanIPAddressList>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TuntapVeaLanIPAddressList value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableTuntapVeaLanIPAddressList(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TuntapVeaLanIPAddressList value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableTuntapVeaLanIPAddressList>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableTuntapInfo
{
[MemoryPackIgnore]
public readonly TuntapInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude]
TuntapStatus Status => info.Status;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress IP => info.IP;
[MemoryPackInclude]
byte PrefixLength => info.PrefixLength;
[MemoryPackInclude]
List<TuntapLanInfo> Lans => info.Lans;
[MemoryPackInclude]
string SetupError => info.SetupError;
[MemoryPackInclude]
string NatError => info.NatError;
[MemoryPackInclude]
string SystemInfo => info.SystemInfo;
[MemoryPackInclude]
List<TuntapForwardInfo> Forwards => info.Forwards;
[MemoryPackInclude]
TuntapSwitch Switch => info.Switch;
[MemoryPackConstructor]
SerializableTuntapInfo(string machineId, TuntapStatus status, IPAddress ip, byte prefixLength,
List<TuntapLanInfo> lans, string setupError, string natError, string systemInfo, List<TuntapForwardInfo> forwards, TuntapSwitch Switch)
{
var info = new TuntapInfo
{
MachineId = machineId,
Lans = lans,
Forwards = forwards,
IP = ip,
NatError = natError,
SystemInfo = systemInfo,
SetupError = setupError,
PrefixLength = prefixLength,
Status = status,
Switch = Switch,
};
this.info = info;
}
public SerializableTuntapInfo(TuntapInfo info)
{
this.info = info;
}
}
public class TuntapInfoFormatter : MemoryPackFormatter<TuntapInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TuntapInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableTuntapInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TuntapInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableTuntapInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableTuntapForwardInfo
{
[MemoryPackIgnore]
public readonly TuntapForwardInfo info;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress ListenAddr => info.ListenAddr;
[MemoryPackInclude]
int ListenPort => info.ListenPort;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress ConnectAddr => info.ConnectAddr;
[MemoryPackInclude]
int ConnectPort => info.ConnectPort;
[MemoryPackInclude]
string Remark => info.Remark;
[MemoryPackConstructor]
SerializableTuntapForwardInfo(IPAddress listenAddr, int listenPort, IPAddress connectAddr, int connectPort, string remark)
{
var info = new TuntapForwardInfo
{
ConnectAddr = connectAddr,
ConnectPort = connectPort,
ListenAddr = listenAddr,
ListenPort = listenPort,
Remark = remark
};
this.info = info;
}
public SerializableTuntapForwardInfo(TuntapForwardInfo info)
{
this.info = info;
}
}
public class TuntapForwardInfoFormatter : MemoryPackFormatter<TuntapForwardInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TuntapForwardInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableTuntapForwardInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TuntapForwardInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableTuntapForwardInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableTuntapForwardTestWrapInfo
{
[MemoryPackIgnore]
public readonly TuntapForwardTestWrapInfo info;
[MemoryPackInclude, MemoryPackAllowSerialize]
string MachineId => info.MachineId;
[MemoryPackInclude]
List<TuntapForwardTestInfo> List => info.List;
[MemoryPackConstructor]
SerializableTuntapForwardTestWrapInfo(string machineId, List<TuntapForwardTestInfo> list)
{
var info = new TuntapForwardTestWrapInfo
{
MachineId = machineId,
List = list
};
this.info = info;
}
public SerializableTuntapForwardTestWrapInfo(TuntapForwardTestWrapInfo info)
{
this.info = info;
}
}
public class TuntapForwardTestWrapInfoFormatter : MemoryPackFormatter<TuntapForwardTestWrapInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TuntapForwardTestWrapInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableTuntapForwardTestWrapInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TuntapForwardTestWrapInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableTuntapForwardTestWrapInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableTuntapForwardTestInfo
{
[MemoryPackIgnore]
public readonly TuntapForwardTestInfo info;
[MemoryPackInclude]
int ListenPort => info.ListenPort;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress ConnectAddr => info.ConnectAddr;
[MemoryPackInclude]
int ConnectPort => info.ConnectPort;
[MemoryPackInclude]
string Error => info.Error;
[MemoryPackConstructor]
SerializableTuntapForwardTestInfo(int listenPort, IPAddress connectAddr, int connectPort, string error)
{
var info = new TuntapForwardTestInfo
{
ConnectAddr = connectAddr,
ConnectPort = connectPort,
ListenPort = listenPort,
Error = error
};
this.info = info;
}
public SerializableTuntapForwardTestInfo(TuntapForwardTestInfo info)
{
this.info = info;
}
}
public class TuntapForwardTestInfoFormatter : MemoryPackFormatter<TuntapForwardTestInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TuntapForwardTestInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableTuntapForwardTestInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TuntapForwardTestInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableTuntapForwardTestInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableTuntapLanInfo
{
[MemoryPackIgnore]
public readonly TuntapLanInfo info;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress IP => info.IP;
[MemoryPackInclude, MemoryPackAllowSerialize]
byte PrefixLength => info.PrefixLength;
[MemoryPackInclude]
bool Disabled => info.Disabled;
[MemoryPackInclude]
bool Exists => info.Exists;
[MemoryPackInclude]
string Error => info.Error;
[MemoryPackConstructor]
SerializableTuntapLanInfo(IPAddress ip, byte prefixLength, bool disabled, bool exists, string error)
{
var info = new TuntapLanInfo
{
Disabled = disabled,
Exists = exists,
IP = ip,
PrefixLength = prefixLength,
Error = error
};
this.info = info;
}
public SerializableTuntapLanInfo(TuntapLanInfo info)
{
this.info = info;
}
}
public class TuntapLanInfoFormatter : MemoryPackFormatter<TuntapLanInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref TuntapLanInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableTuntapLanInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref TuntapLanInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableTuntapLanInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableLeaseInfo
{
[MemoryPackIgnore]
public readonly LeaseInfo info;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPAddress IP => info.IP;
[MemoryPackInclude, MemoryPackAllowSerialize]
byte PrefixLength => info.PrefixLength;
[MemoryPackConstructor]
SerializableLeaseInfo(IPAddress ip, byte prefixLength)
{
var info = new LeaseInfo
{
IP = ip,
PrefixLength = prefixLength
};
this.info = info;
}
public SerializableLeaseInfo(LeaseInfo info)
{
this.info = info;
}
}
public class LeaseInfoFormatter : MemoryPackFormatter<LeaseInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref LeaseInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableLeaseInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref LeaseInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableLeaseInfo>();
value = wrapped.info;
}
}
}

5
linker.messenger.serializer.memorypack/linker.messenger.serializer.memorypack.csproj
View File

@@ -37,14 +37,17 @@
<ProjectReference Include="..\linker.libs\linker.libs.csproj" />
<ProjectReference Include="..\linker.messenger.access\linker.messenger.access.csproj" />
<ProjectReference Include="..\linker.messenger.decenter\linker.messenger.decenter.csproj" />
<ProjectReference Include="..\linker.messenger.flow\linker.messenger.flow.csproj" />
<ProjectReference Include="..\linker.messenger.forward\linker.messenger.forward.csproj" />
<ProjectReference Include="..\linker.messenger.relay\linker.messenger.relay.csproj" />
<ProjectReference Include="..\linker.messenger.sforward\linker.messenger.sforward.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger.socks5\linker.messenger.socks5.csproj" />
<ProjectReference Include="..\linker.messenger.sync\linker.messenger.sync.csproj" />
<ProjectReference Include="..\linker.messenger.tunnel\linker.messenger.tunnel.csproj" />
<ProjectReference Include="..\linker.messenger.tuntap\linker.messenger.tuntap.csproj" />
<ProjectReference Include="..\linker.messenger.updater\linker.messenger.updater.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
<ProjectReference Include="..\linker.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.tunnel\linker.tunnel.csproj" />
</ItemGroup>
</Project>

68
linker/plugins/sforward/config/Config.cs → linker.messenger.sforward/Config.cs
View File

@@ -1,21 +1,9 @@
using linker.libs;
using LiteDB;
using MemoryPack;
using System.Net;
using System.Text.Json.Serialization;
namespace linker.client.config
namespace linker.messenger.sforward
{
public sealed partial class RunningConfigInfo
{
/// <summary>
/// 服务器穿透列表
/// </summary>
public List<SForwardInfo> SForwards { get; set; } = new List<SForwardInfo>();
}
[MemoryPackable]
public sealed partial class SForwardInfo
{
public SForwardInfo() { }
@@ -42,7 +30,6 @@ namespace linker.client.config
/// <summary>
/// 本地服务
/// </summary>
[MemoryPackAllowSerialize]
public IPEndPoint LocalEP { get; set; }
/// <summary>
/// 已启动
@@ -57,7 +44,6 @@ namespace linker.client.config
/// </summary>
public string LocalMsg { get; set; }
[JsonIgnore, BsonIgnore, MemoryPackIgnore]
public bool Proxy { get; set; }
/// <summary>
@@ -69,28 +55,6 @@ namespace linker.client.config
/// </summary>
public int RemotePortMax { get; set; }
}
}
namespace linker.config
{
public sealed partial class ConfigClientInfo
{
public SForwardConfigInfo SForward { get; set; } = new SForwardConfigInfo();
}
public sealed class SForwardConfigInfo
{
public string SecretKey { get; set; } = Helper.GlobalString;
}
public partial class ConfigServerInfo
{
/// <summary>
/// 服务器穿透配置
/// </summary>
public SForwardConfigServerInfo SForward { get; set; } = new SForwardConfigServerInfo();
}
public sealed class SForwardConfigServerInfo
{
/// <summary>
@@ -116,14 +80,9 @@ namespace linker.config
}
}
namespace linker.plugins.sforward.config
{
/// <summary>
/// 往服务器添加穿透
/// </summary>
[MemoryPackable]
public sealed partial class SForwardAddInfo
{
/// <summary>
@@ -139,11 +98,9 @@ namespace linker.plugins.sforward.config
/// </summary>
public string SecretKey { get; set; }
}
/// <summary>
/// 添加穿透结果
/// </summary>
[MemoryPackable]
public sealed partial class SForwardAddResultInfo
{
/// <summary>
@@ -160,10 +117,20 @@ namespace linker.plugins.sforward.config
public byte BufferSize { get; set; }
}
public sealed partial class SForwardAddForwardInfo
{
public string MachineId { get; set; }
public SForwardInfo Data { get; set; }
}
public sealed partial class SForwardRemoveForwardInfo
{
public string MachineId { get; set; }
public uint Id { get; set; }
}
/// <summary>
/// 服务器穿透代理信息
/// </summary>
[MemoryPackable]
public sealed partial class SForwardProxyInfo
{
/// <summary>
@@ -183,4 +150,15 @@ namespace linker.plugins.sforward.config
/// </summary>
public byte BufferSize { get; set; } = 3;
}
public sealed class SForwardConfigClientInfo
{
public string SecretKey { get; set; } = Helper.GlobalString;
}
public sealed partial class SForwardCountInfo
{
public string MachineId { get; set; }
public int Count { get; set; }
}
}

75
linker.messenger.sforward/Entry.cs Normal file
View File

@@ -0,0 +1,75 @@
using linker.messenger.api;
using linker.messenger.decenter;
using linker.messenger.sforward.client;
using linker.messenger.sforward.server;
using linker.messenger.sforward.server.validator;
using linker.messenger.sync;
using linker.plugins.sforward.messenger;
using linker.plugins.sforward.proxy;
using Microsoft.Extensions.DependencyInjection;
namespace linker.messenger.sforward
{
public static class Entry
{
public static ServiceCollection AddSForwardClient(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<SForwardApiController>();
serviceCollection.AddSingleton<SForwardClientTransfer>();
serviceCollection.AddSingleton<SForwardClientMessenger>();
serviceCollection.AddSingleton<SForwardSyncSecretKey>();
serviceCollection.AddSingleton<SForwardDecenter>();
serviceCollection.AddSingleton<SForwardProxy>();
return serviceCollection;
}
public static ServiceProvider UseSForwardClient(this ServiceProvider serviceProvider)
{
IApiServer apiServer = serviceProvider.GetService<IApiServer>();
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<SForwardApiController>() });
SForwardClientTransfer sForwardClientTransfer = serviceProvider.GetService<SForwardClientTransfer>();
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<SForwardClientMessenger>() });
SyncTreansfer syncTransfer = serviceProvider.GetService<SyncTreansfer>();
syncTransfer.AddSyncs(new List<ISync> { serviceProvider.GetService<SForwardSyncSecretKey>() });
DecenterClientTransfer decenterClientTransfer = serviceProvider.GetService<DecenterClientTransfer>();
decenterClientTransfer.AddDecenters(new List<IDecenter> { serviceProvider.GetService<SForwardDecenter>() });
return serviceProvider;
}
public static ServiceCollection AddSForwardServer(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<SForwardServerMessenger>();
serviceCollection.AddSingleton<ISForwardServerCahing, SForwardServerCahing>();
serviceCollection.AddSingleton<SForwardValidatorTransfer>();
serviceCollection.AddSingleton<SForwardValidator>();
serviceCollection.AddSingleton<SForwardProxy>();
return serviceCollection;
}
public static ServiceProvider UseSForwardServer(this ServiceProvider serviceProvider)
{
IMessengerResolver messengerResolver = serviceProvider.GetService<IMessengerResolver>();
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<SForwardServerMessenger>() });
SForwardValidatorTransfer sForwardValidatorTransfer = serviceProvider.GetService<SForwardValidatorTransfer>();
sForwardValidatorTransfer.AddValidators(new List<ISForwardValidator> { serviceProvider.GetService<SForwardValidator>() });
return serviceProvider;
}
}
}

21
linker.messenger.sforward/client/ISForwardClientStore.cs Normal file
View File

@@ -0,0 +1,21 @@
namespace linker.messenger.sforward.client
{
public interface ISForwardClientStore
{
public string SecretKey { get; }
public bool SetSecretKey(string key);
public int Count();
public List<SForwardInfo> Get();
public SForwardInfo Get(uint id);
public SForwardInfo Get(string domain);
public SForwardInfo Get(int port);
public bool Add(SForwardInfo info);
public bool Update(SForwardInfo info);
public bool Remove(uint id);
public bool Confirm();
}
}

57
linker/plugins/sforward/SForwardApiController.cs → linker.messenger.sforward/client/SForwardApiController.cs
View File

@@ -1,35 +1,34 @@
using linker.libs.api;
using linker.libs.extends;
using linker.client.config;
using linker.serializer;
using linker.plugins.sforward.messenger;
using linker.plugins.client;
using linker.plugins.capi;
using linker.config;
using System.Collections.Concurrent;
using linker.plugins.access;
using linker.messenger;
using linker.messenger.signin;
using linker.libs;
using linker.messenger.api;
namespace linker.plugins.sforward
namespace linker.messenger.sforward.client
{
public sealed class SForwardClientApiController : IApiClientController
public sealed class SForwardApiController : IApiController
{
private readonly SForwardTransfer forwardTransfer;
private readonly SForwardClientTransfer forwardTransfer;
private readonly IMessengerSender messengerSender;
private readonly SignInClientState signInClientState;
private readonly AccessTransfer accessTransfer;
private readonly ISignInClientStore signInClientStore;
private readonly SForwardDecenter sForwardDecenter;
private readonly ISForwardClientStore sForwardClientStore;
private readonly ISerializer serializer;
private readonly IAccessStore accessStore;
public SForwardClientApiController(SForwardTransfer forwardTransfer, IMessengerSender messengerSender, SignInClientState signInClientState, AccessTransfer accessTransfer, ISignInClientStore signInClientStore, SForwardDecenter sForwardDecenter)
public SForwardApiController(SForwardClientTransfer forwardTransfer, IMessengerSender messengerSender, SignInClientState signInClientState, ISignInClientStore signInClientStore, SForwardDecenter sForwardDecenter, ISForwardClientStore sForwardClientStore, ISerializer serializer, IAccessStore accessStore)
{
this.forwardTransfer = forwardTransfer;
this.messengerSender = messengerSender;
this.signInClientState = signInClientState;
this.accessTransfer = accessTransfer;
this.signInClientStore = signInClientStore;
this.sForwardDecenter = sForwardDecenter;
this.sForwardClientStore = sForwardClientStore;
this.serializer = serializer;
this.accessStore = accessStore;
}
/// <summary>
@@ -39,16 +38,16 @@ namespace linker.plugins.sforward
/// <returns></returns>
public string GetSecretKey(ApiControllerParamsInfo param)
{
return forwardTransfer.SecretKey;
return sForwardClientStore.SecretKey;
}
/// <summary>
/// 设置密钥
/// </summary>
/// <param name="param"></param>
[ClientApiAccessAttribute(ClientApiAccess.Config)]
[Access(AccessValue.Config)]
public void SetSecretKey(ApiControllerParamsInfo param)
{
forwardTransfer.SetSecretKey(param.Content);
sForwardClientStore.SetSecretKey(param.Content);
}
@@ -84,20 +83,20 @@ namespace linker.plugins.sforward
{
if (param.Content == signInClientStore.Id)
{
if (accessTransfer.HasAccess(ClientApiAccess.ForwardShowSelf) == false) return new List<SForwardInfo>();
return forwardTransfer.Get();
if (accessStore.HasAccess(AccessValue.ForwardShowSelf) == false) return new List<SForwardInfo>();
return sForwardClientStore.Get();
}
if (accessTransfer.HasAccess(ClientApiAccess.ForwardShowOther) == false) return new List<SForwardInfo>();
if (accessStore.HasAccess(AccessValue.ForwardShowOther) == false) return new List<SForwardInfo>();
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.GetForward,
Payload = Serializer.Serialize(param.Content)
Payload = serializer.Serialize(param.Content)
});
if (resp.Code == MessageResponeCodes.OK)
{
return Serializer.Deserialize<List<SForwardInfo>>(resp.Data.Span);
return serializer.Deserialize<List<SForwardInfo>>(resp.Data.Span);
}
return new List<SForwardInfo>();
}
@@ -112,16 +111,15 @@ namespace linker.plugins.sforward
SForwardAddForwardInfo info = param.Content.DeJson<SForwardAddForwardInfo>();
if (info.MachineId == signInClientStore.Id)
{
if (accessTransfer.HasAccess(ClientApiAccess.ForwardSelf) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardSelf) == false) return false;
return forwardTransfer.Add(info.Data);
}
if (accessTransfer.HasAccess(ClientApiAccess.ForwardOther) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardOther) == false) return false;
return await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.AddClientForward,
Payload = Serializer.Serialize(info)
Payload = serializer.Serialize(info)
});
}
@@ -135,16 +133,15 @@ namespace linker.plugins.sforward
SForwardRemoveForwardInfo info = param.Content.DeJson<SForwardRemoveForwardInfo>();
if (info.MachineId == signInClientStore.Id)
{
if (accessTransfer.HasAccess(ClientApiAccess.ForwardSelf) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardSelf) == false) return false;
return forwardTransfer.Remove(info.Id);
}
if (accessTransfer.HasAccess(ClientApiAccess.ForwardOther) == false) return false;
if (accessStore.HasAccess(AccessValue.ForwardOther) == false) return false;
return await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.RemoveClientForward,
Payload = Serializer.Serialize(info)
Payload = serializer.Serialize(info)
});
}
@@ -164,7 +161,7 @@ namespace linker.plugins.sforward
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.TestClientForward,
Payload = Serializer.Serialize(param.Content)
Payload = serializer.Serialize(param.Content)
});
return true;
}

88
linker/plugins/sforward/SForwardTransfer.cs → linker.messenger.sforward/client/SForwardClientTransfer.cs
View File

@@ -1,59 +1,44 @@
using linker.client.config;
using linker.libs;
using linker.libs;
using linker.plugins.sforward.messenger;
using linker.serializer;
using linker.plugins.sforward.config;
using System.Net.Sockets;
using System.Net;
using linker.libs.extends;
using linker.plugins.client;
using linker.plugins.messenger;
using linker.config;
using linker.messenger;
using linker.messenger.signin;
using System.Collections.Generic;
namespace linker.plugins.sforward
namespace linker.messenger.sforward.client
{
public sealed class SForwardTransfer
public sealed class SForwardClientTransfer
{
public string SecretKey => fileConfig.Data.Client.SForward.SecretKey;
public int Count => running.Data.SForwards.Count;
public Action OnChanged { get; set; } = () => { };
private readonly FileConfig fileConfig;
private readonly RunningConfig running;
private readonly SignInClientState signInClientState;
private readonly IMessengerSender messengerSender;
private readonly ISignInClientStore signInClientStore;
private readonly ISForwardClientStore sForwardClientStore;
private readonly ISerializer serializer;
private readonly NumberSpaceUInt32 ns = new NumberSpaceUInt32();
private readonly OperatingManager operatingManager = new OperatingManager();
public SForwardTransfer(FileConfig fileConfig, RunningConfig running, SignInClientState signInClientState, IMessengerSender messengerSender, ISignInClientStore signInClientStore)
public SForwardClientTransfer(SignInClientState signInClientState, IMessengerSender messengerSender, ISignInClientStore signInClientStore, ISForwardClientStore sForwardClientStore, ISerializer serializer)
{
this.fileConfig = fileConfig;
this.running = running;
this.signInClientState = signInClientState;
this.messengerSender = messengerSender;
this.signInClientStore = signInClientStore;
this.sForwardClientStore = sForwardClientStore;
signInClientState.NetworkFirstEnabledHandle += () => Start();
}
public void SetSecretKey(string key)
{
fileConfig.Data.Client.SForward.SecretKey = key;
fileConfig.Data.Update();
this.serializer = serializer;
}
private void Start()
{
uint maxid = running.Data.SForwards.Count > 0 ? running.Data.SForwards.Max(c => c.Id) : 1;
var list = sForwardClientStore.Get();
uint maxid = list.Count > 0 ? list.Max(c => c.Id) : 1;
ns.Reset(maxid);
foreach (var item in running.Data.SForwards)
foreach (var item in list)
{
if (item.Started)
{
@@ -63,7 +48,8 @@ namespace linker.plugins.sforward
{
Stop(item);
}
sForwardClientStore.Update(item);
sForwardClientStore.Confirm();
}
OnChanged();
}
@@ -79,16 +65,18 @@ namespace linker.plugins.sforward
try
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Info($"start sforward {forwardInfo.ToJson()}");
messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.Add,
Payload = Serializer.Serialize(new SForwardAddInfo { Domain = forwardInfo.Domain, RemotePort = forwardInfo.RemotePort, SecretKey = fileConfig.Data.Client.SForward.SecretKey })
Payload = serializer.Serialize(new SForwardAddInfo { Domain = forwardInfo.Domain, RemotePort = forwardInfo.RemotePort, SecretKey = sForwardClientStore.SecretKey })
}).ContinueWith((result) =>
{
if (result.Result.Code == MessageResponeCodes.OK)
{
SForwardAddResultInfo sForwardAddResultInfo = Serializer.Deserialize<SForwardAddResultInfo>(result.Result.Data.Span);
SForwardAddResultInfo sForwardAddResultInfo = serializer.Deserialize<SForwardAddResultInfo>(result.Result.Data.Span);
forwardInfo.BufferSize = sForwardAddResultInfo.BufferSize;
if (sForwardAddResultInfo.Success)
{
@@ -110,7 +98,6 @@ namespace linker.plugins.sforward
forwardInfo.Started = false;
LoggerHelper.Instance.Error(ex);
}
OnChanged();
}
private void Stop(SForwardInfo forwardInfo)
@@ -119,16 +106,18 @@ namespace linker.plugins.sforward
{
if (forwardInfo.Proxy)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Info($"stop sforward {forwardInfo.ToJson()}");
messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.Remove,
Payload = Serializer.Serialize(new SForwardAddInfo { Domain = forwardInfo.Domain, RemotePort = forwardInfo.RemotePort, SecretKey = fileConfig.Data.Client.SForward.SecretKey })
Payload = serializer.Serialize(new SForwardAddInfo { Domain = forwardInfo.Domain, RemotePort = forwardInfo.RemotePort, SecretKey = sForwardClientStore.SecretKey })
}).ContinueWith((result) =>
{
if (result.Result.Code == MessageResponeCodes.OK)
{
SForwardAddResultInfo sForwardAddResultInfo = Serializer.Deserialize<SForwardAddResultInfo>(result.Result.Data.Span);
SForwardAddResultInfo sForwardAddResultInfo = serializer.Deserialize<SForwardAddResultInfo>(result.Result.Data.Span);
if (sForwardAddResultInfo.Success)
{
forwardInfo.Proxy = false;
@@ -151,21 +140,20 @@ namespace linker.plugins.sforward
OnChanged();
}
public List<SForwardInfo> Get()
{
return running.Data.SForwards;
}
public bool Add(SForwardInfo forwardInfo)
{
//同名或者同端口，但是ID不一样
SForwardInfo old = running.Data.SForwards.FirstOrDefault(c => (forwardInfo.RemotePort > 0 && c.RemotePort == forwardInfo.RemotePort) || (string.IsNullOrWhiteSpace(forwardInfo.Domain) == false && c.Domain == forwardInfo.Domain));
SForwardInfo old = sForwardClientStore.Get().FirstOrDefault(c => forwardInfo.RemotePort > 0 && c.RemotePort == forwardInfo.RemotePort || string.IsNullOrWhiteSpace(forwardInfo.Domain) == false && c.Domain == forwardInfo.Domain);
if (old != null && old.Id != forwardInfo.Id) return false;
if (forwardInfo.Id != 0)
{
old = running.Data.SForwards.FirstOrDefault(c => c.Id == forwardInfo.Id);
old = sForwardClientStore.Get(forwardInfo.Id);
if (old == null) return false;
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Info($"update sforward {old.ToJson()}->{forwardInfo.ToJson()}");
old.RemotePort = forwardInfo.RemotePort;
old.Name = forwardInfo.Name;
old.LocalEP = forwardInfo.LocalEP;
@@ -177,6 +165,7 @@ namespace linker.plugins.sforward
old.RemotePortMin = min;
old.RemotePortMax = max;
}
sForwardClientStore.Update(old);
}
else
{
@@ -186,10 +175,12 @@ namespace linker.plugins.sforward
forwardInfo.RemotePortMin = min;
forwardInfo.RemotePortMax = max;
}
running.Data.SForwards.Add(forwardInfo);
sForwardClientStore.Add(forwardInfo);
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Info($"add sforward {forwardInfo.ToJson()}");
}
running.Data.Update();
sForwardClientStore.Confirm();
Start();
return true;
@@ -197,7 +188,7 @@ namespace linker.plugins.sforward
public bool Remove(uint id)
{
//同名或者同端口，但是ID不一样
SForwardInfo old = running.Data.SForwards.FirstOrDefault(c => c.Id == id);
SForwardInfo old = sForwardClientStore.Get(id);
if (old == null)
{
return false;
@@ -206,8 +197,11 @@ namespace linker.plugins.sforward
old.Started = false;
Start();
running.Data.SForwards.Remove(old);
running.Data.Update();
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Info($"remove sforward {old.ToJson()}");
sForwardClientStore.Remove(id);
sForwardClientStore.Confirm();
return true;
}
private bool PortRange(string str, out int min, out int max)
@@ -219,7 +213,7 @@ namespace linker.plugins.sforward
string[] arr = str.Split('/');
return arr.Length == 2 && int.TryParse(arr[0], out min) && int.TryParse(arr[1], out max);
}
/// <summary>
/// 测试本机服务
/// </summary>
@@ -231,12 +225,12 @@ namespace linker.plugins.sforward
{
try
{
var results = running.Data.SForwards.Select(c => c.LocalEP).Select(ConnectAsync);
var results = sForwardClientStore.Get().Select(c => c.LocalEP).Select(ConnectAsync);
await Task.Delay(200).ConfigureAwait(false);
foreach (var item in results.Select(c => c.Result))
{
var forward = running.Data.SForwards.FirstOrDefault(c => c.LocalEP.Equals(item.Item1));
var forward = sForwardClientStore.Get().FirstOrDefault(c => c.LocalEP.Equals(item.Item1));
if (forward != null)
{
forward.LocalMsg = item.Item2;

28
linker/plugins/sforward/SForwardDecenter.cs → linker.messenger.sforward/client/SForwardDecenter.cs
View File

@@ -1,12 +1,9 @@
using linker.libs;
using linker.plugins.client;
using linker.serializer;
using System.Collections.Concurrent;
using MemoryPack;
using linker.messenger.decenter;
using linker.messenger.signin;
namespace linker.plugins.sforward
namespace linker.messenger.sforward.client
{
public sealed class SForwardDecenter : IDecenter
{
@@ -16,11 +13,13 @@ namespace linker.plugins.sforward
public ConcurrentDictionary<string, int> CountDic { get; } = new ConcurrentDictionary<string, int>();
private readonly ISignInClientStore signInClientStore;
private readonly SForwardTransfer sForwardTransfer;
public SForwardDecenter(ISignInClientStore signInClientStore, SForwardTransfer sForwardTransfer)
private readonly ISForwardClientStore sForwardClientStore;
private readonly ISerializer serializer;
public SForwardDecenter(ISignInClientStore signInClientStore, ISForwardClientStore sForwardClientStore, ISerializer serializer)
{
this.signInClientStore = signInClientStore;
this.sForwardTransfer = sForwardTransfer;
this.sForwardClientStore = sForwardClientStore;
this.serializer = serializer;
}
public void Refresh()
@@ -30,20 +29,20 @@ namespace linker.plugins.sforward
public Memory<byte> GetData()
{
CountInfo info = new CountInfo { MachineId = signInClientStore.Id, Count = sForwardTransfer.Count };
SForwardCountInfo info = new SForwardCountInfo { MachineId = signInClientStore.Id, Count = sForwardClientStore.Count() };
CountDic.AddOrUpdate(info.MachineId, info.Count, (a, b) => info.Count);
DataVersion.Add();
return Serializer.Serialize(info);
return serializer.Serialize(info);
}
public void SetData(Memory<byte> data)
{
CountInfo info = Serializer.Deserialize<CountInfo>(data.Span);
SForwardCountInfo info = serializer.Deserialize<SForwardCountInfo>(data.Span);
CountDic.AddOrUpdate(info.MachineId, info.Count, (a, b) => info.Count);
DataVersion.Add();
}
public void SetData(List<ReadOnlyMemory<byte>> data)
{
List<CountInfo> list = data.Select(c => Serializer.Deserialize<CountInfo>(c.Span)).ToList();
List<SForwardCountInfo> list = data.Select(c => serializer.Deserialize<SForwardCountInfo>(c.Span)).ToList();
foreach (var info in list)
{
CountDic.AddOrUpdate(info.MachineId, info.Count, (a, b) => info.Count);
@@ -52,10 +51,5 @@ namespace linker.plugins.sforward
}
}
[MemoryPackable]
public sealed partial class CountInfo
{
public string MachineId { get; set; }
public int Count { get; set; }
}
}

27
linker.messenger.sforward/client/SForwardSync.cs Normal file
View File

@@ -0,0 +1,27 @@
using linker.libs;
using linker.messenger.sync;
namespace linker.messenger.sforward.client
{
public sealed class SForwardSyncSecretKey : ISync
{
public string Name => "SForwardSecretKey";
private readonly ISForwardClientStore sForwardClientStore;
private readonly ISerializer serializer;
public SForwardSyncSecretKey(ISForwardClientStore sForwardClientStore, ISerializer serializer)
{
this.sForwardClientStore = sForwardClientStore;
this.serializer = serializer;
}
public Memory<byte> GetData()
{
return serializer.Serialize(sForwardClientStore.SecretKey);
}
public void SetData(Memory<byte> data)
{
sForwardClientStore.SetSecretKey(serializer.Deserialize<string>(data.Span));
}
}
}

40
linker.messenger.sforward/linker.messenger.sforward.csproj Normal file
View File

@@ -0,0 +1,40 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net8.0</TargetFrameworks>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>disable</Nullable>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<PublishAot>false</PublishAot>
<JsonSerializerIsReflectionEnabledByDefault>true</JsonSerializerIsReflectionEnabledByDefault>
<EnablePreviewFeatures>True</EnablePreviewFeatures>
<Title>linker messenger sforward</Title>
<Authors>snltty</Authors>
<Company>snltty</Company>
<Description>linker messenger sforward</Description>
<Copyright>snltty</Copyright>
<PackageProjectUrl>https://github.com/snltty/linker</PackageProjectUrl>
<RepositoryUrl>https://github.com/snltty/linker</RepositoryUrl>
<PackageReleaseNotes>linker messenger sforward</PackageReleaseNotes>
<Version>1.6.4</Version>
<AssemblyVersion>1.6.4</AssemblyVersion>
<FileVersion>1.6.4</FileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>full</DebugType>
<DebugSymbols>true</DebugSymbols>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>none</DebugType>
<DebugSymbols>false</DebugSymbols>
<Optimize>True</Optimize>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\linker.libs\linker.libs.csproj" />
<ProjectReference Include="..\linker.messenger.decenter\linker.messenger.decenter.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger.sync\linker.messenger.sync.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
</ItemGroup>
</Project>

98
linker/plugins/sforward/messenger/SForwardMessenger.cs → linker.messenger.sforward/messenger/SForwardMessenger.cs
View File

@@ -1,15 +1,12 @@
using linker.client.config;
using linker.plugins.sforward.config;
using linker.plugins.sforward.validator;
using linker.serializer;
using linker.plugins.sforward.proxy;
using linker.config;
using LiteDB;
using linker.plugins.sforward.proxy;
using System.Net;
using linker.libs;
using linker.messenger;
using linker.messenger.signin;
using MemoryPack;
using linker.messenger.sforward;
using linker.messenger.sforward.server.validator;
using linker.messenger.sforward.server;
using linker.messenger.sforward.client;
namespace linker.plugins.sforward.messenger
{
@@ -23,11 +20,11 @@ namespace linker.plugins.sforward.messenger
private readonly ISForwardServerCahing sForwardServerCahing;
private readonly IMessengerSender sender;
private readonly SignInServerCaching signCaching;
private readonly FileConfig configWrap;
private readonly ISForwardValidator validator;
private readonly SForwardServerConfigTransfer sForwardServerConfigTransfer;
private readonly SForwardValidatorTransfer validator;
private readonly ISForwardServerStore sForwardServerStore;
private readonly ISerializer serializer;
public SForwardServerMessenger(SForwardProxy proxy, ISForwardServerCahing sForwardServerCahing, IMessengerSender sender, SignInServerCaching signCaching, FileConfig configWrap, ISForwardValidator validator, SForwardServerConfigTransfer sForwardServerConfigTransfer)
public SForwardServerMessenger(SForwardProxy proxy, ISForwardServerCahing sForwardServerCahing, IMessengerSender sender, SignInServerCaching signCaching, SForwardValidatorTransfer validator, ISForwardServerStore sForwardServerStore, ISerializer serializer)
{
this.proxy = proxy;
proxy.WebConnect = WebConnect;
@@ -36,9 +33,9 @@ namespace linker.plugins.sforward.messenger
this.sForwardServerCahing = sForwardServerCahing;
this.sender = sender;
this.signCaching = signCaching;
this.configWrap = configWrap;
this.validator = validator;
this.sForwardServerConfigTransfer = sForwardServerConfigTransfer;
this.sForwardServerStore = sForwardServerStore;
this.serializer = serializer;
}
/// <summary>
@@ -48,8 +45,8 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.Add)]
public async Task Add(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = Serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true, BufferSize = sForwardServerConfigTransfer.BufferSize };
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true, BufferSize = sForwardServerStore.BufferSize };
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) == false)
{
@@ -79,7 +76,7 @@ namespace linker.plugins.sforward.messenger
if (sForwardServerCahing.TryAdd(port, connection.Id))
{
proxy.Stop(port);
result.Message = proxy.Start(port, false, sForwardServerConfigTransfer.BufferSize, cache.GroupId);
result.Message = proxy.Start(port, false, sForwardServerStore.BufferSize, cache.GroupId);
if (string.IsNullOrWhiteSpace(result.Message) == false)
{
LoggerHelper.Instance.Error(result.Message);
@@ -116,7 +113,7 @@ namespace linker.plugins.sforward.messenger
else
{
proxy.Stop(sForwardAddInfo.RemotePort);
string msg = proxy.Start(sForwardAddInfo.RemotePort, false, sForwardServerConfigTransfer.BufferSize, cache.GroupId);
string msg = proxy.Start(sForwardAddInfo.RemotePort, false, sForwardServerStore.BufferSize, cache.GroupId);
if (string.IsNullOrWhiteSpace(msg) == false)
{
result.Success = false;
@@ -140,7 +137,7 @@ namespace linker.plugins.sforward.messenger
}
finally
{
connection.Write(Serializer.Serialize(result));
connection.Write(serializer.Serialize(result));
}
}
@@ -152,7 +149,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.Remove)]
public async Task Remove(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = Serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true };
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) == false)
@@ -207,7 +204,7 @@ namespace linker.plugins.sforward.messenger
}
finally
{
connection.Write(Serializer.Serialize(result));
connection.Write(serializer.Serialize(result));
}
}
@@ -219,7 +216,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.GetForward)]
public void GetForward(IConnection connection)
{
string machineId = Serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
string machineId = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(machineId, out SignCacheInfo cacheTo) && signCaching.TryGet(connection.Id, out SignCacheInfo cacheFrom) && cacheFrom.GroupId == cacheTo.GroupId)
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
@@ -250,7 +247,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.AddClientForward)]
public async Task AddClientForward(IConnection connection)
{
SForwardAddForwardInfo info = Serializer.Deserialize<SForwardAddForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddForwardInfo info = serializer.Deserialize<SForwardAddForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(info.MachineId, out SignCacheInfo cacheTo) && signCaching.TryGet(connection.Id, out SignCacheInfo cacheFrom) && cacheFrom.GroupId == cacheTo.GroupId)
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
@@ -258,7 +255,7 @@ namespace linker.plugins.sforward.messenger
{
Connection = cacheTo.Connection,
MessengerId = (ushort)SForwardMessengerIds.AddClient,
Payload = Serializer.Serialize(info.Data)
Payload = serializer.Serialize(info.Data)
});
}
}
@@ -269,7 +266,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.RemoveClientForward)]
public async Task RemoveClientForward(IConnection connection)
{
SForwardRemoveForwardInfo info = Serializer.Deserialize<SForwardRemoveForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardRemoveForwardInfo info = serializer.Deserialize<SForwardRemoveForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(info.MachineId, out SignCacheInfo cacheTo) && signCaching.TryGet(connection.Id, out SignCacheInfo cacheFrom) && cacheFrom.GroupId == cacheTo.GroupId)
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
@@ -277,7 +274,7 @@ namespace linker.plugins.sforward.messenger
{
Connection = cacheTo.Connection,
MessengerId = (ushort)SForwardMessengerIds.RemoveClient,
Payload = Serializer.Serialize(info.Id)
Payload = serializer.Serialize(info.Id)
});
}
}
@@ -289,7 +286,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.TestClientForward)]
public async Task TestClientForward(IConnection connection)
{
string machineid = Serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
string machineid = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(machineid, out SignCacheInfo cacheTo) && signCaching.TryGet(connection.Id, out SignCacheInfo cacheFrom) && cacheFrom.GroupId == cacheTo.GroupId)
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
@@ -317,7 +314,7 @@ namespace linker.plugins.sforward.messenger
{
Connection = sign.Connection,
MessengerId = (ushort)SForwardMessengerIds.Proxy,
Payload = Serializer.Serialize(new SForwardProxyInfo { Domain = host, RemotePort = port, Id = id, BufferSize = sForwardServerConfigTransfer.BufferSize })
Payload = serializer.Serialize(new SForwardProxyInfo { Domain = host, RemotePort = port, Id = id, BufferSize = sForwardServerStore.BufferSize })
}).ConfigureAwait(false);
}
return false;
@@ -337,7 +334,7 @@ namespace linker.plugins.sforward.messenger
{
Connection = sign.Connection,
MessengerId = (ushort)SForwardMessengerIds.Proxy,
Payload = Serializer.Serialize(new SForwardProxyInfo { RemotePort = port, Id = id, BufferSize = sForwardServerConfigTransfer.BufferSize })
Payload = serializer.Serialize(new SForwardProxyInfo { RemotePort = port, Id = id, BufferSize = sForwardServerStore.BufferSize })
}).ConfigureAwait(false);
}
return false;
@@ -357,7 +354,7 @@ namespace linker.plugins.sforward.messenger
{
Connection = sign.Connection,
MessengerId = (ushort)SForwardMessengerIds.ProxyUdp,
Payload = Serializer.Serialize(new SForwardProxyInfo { RemotePort = port, Id = id, BufferSize = sForwardServerConfigTransfer.BufferSize })
Payload = serializer.Serialize(new SForwardProxyInfo { RemotePort = port, Id = id, BufferSize = sForwardServerStore.BufferSize })
}).ConfigureAwait(false);
}
return false;
@@ -377,14 +374,15 @@ namespace linker.plugins.sforward.messenger
public sealed class SForwardClientMessenger : IMessenger
{
private readonly SForwardProxy proxy;
private readonly RunningConfig runningConfig;
private readonly SForwardTransfer sForwardTransfer;
public SForwardClientMessenger(SForwardProxy proxy, RunningConfig runningConfig, SForwardTransfer sForwardTransfer)
private readonly SForwardClientTransfer sForwardTransfer;
private readonly ISForwardClientStore sForwardClientStore;
private readonly ISerializer serializer;
public SForwardClientMessenger(SForwardProxy proxy, SForwardClientTransfer sForwardTransfer, ISForwardClientStore sForwardClientStore, ISerializer serializer)
{
this.proxy = proxy;
this.runningConfig = runningConfig;
this.sForwardTransfer = sForwardTransfer;
this.sForwardClientStore = sForwardClientStore;
this.serializer = serializer;
}
/// <summary>
@@ -394,8 +392,8 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.Get)]
public void Get(IConnection connection)
{
List<SForwardInfo> result = sForwardTransfer.Get();
connection.Write(Serializer.Serialize(result));
List<SForwardInfo> result = sForwardClientStore.Get();
connection.Write(serializer.Serialize(result));
}
/// <summary>
/// 添加
@@ -404,7 +402,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.AddClient)]
public void AddClient(IConnection connection)
{
SForwardInfo sForwardInfo = Serializer.Deserialize<SForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardInfo sForwardInfo = serializer.Deserialize<SForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
sForwardTransfer.Add(sForwardInfo);
}
// <summary>
@@ -414,7 +412,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.RemoveClient)]
public void RemoveClient(IConnection connection)
{
uint id = Serializer.Deserialize<uint>(connection.ReceiveRequestWrap.Payload.Span);
uint id = serializer.Deserialize<uint>(connection.ReceiveRequestWrap.Payload.Span);
sForwardTransfer.Remove(id);
}
// <summary>
@@ -435,12 +433,12 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.Proxy)]
public void Proxy(IConnection connection)
{
SForwardProxyInfo sForwardProxyInfo = Serializer.Deserialize<SForwardProxyInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardProxyInfo sForwardProxyInfo = serializer.Deserialize<SForwardProxyInfo>(connection.ReceiveRequestWrap.Payload.Span);
//是http
if (string.IsNullOrWhiteSpace(sForwardProxyInfo.Domain) == false)
{
SForwardInfo sForwardInfo = runningConfig.Data.SForwards.FirstOrDefault(c => c.Domain == sForwardProxyInfo.Domain);
SForwardInfo sForwardInfo = sForwardClientStore.Get(sForwardProxyInfo.Domain);
if (sForwardInfo != null)
{
_ = proxy.OnConnectTcp(sForwardProxyInfo.BufferSize, sForwardProxyInfo.Id, new System.Net.IPEndPoint(connection.Address.Address, sForwardProxyInfo.RemotePort), sForwardInfo.LocalEP);
@@ -465,7 +463,7 @@ namespace linker.plugins.sforward.messenger
[MessengerId((ushort)SForwardMessengerIds.ProxyUdp)]
public void ProxyUdp(IConnection connection)
{
SForwardProxyInfo sForwardProxyInfo = Serializer.Deserialize<SForwardProxyInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardProxyInfo sForwardProxyInfo = serializer.Deserialize<SForwardProxyInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (sForwardProxyInfo.RemotePort > 0)
{
IPEndPoint localEP = GetLocalEP(sForwardProxyInfo);
@@ -484,7 +482,7 @@ namespace linker.plugins.sforward.messenger
/// <returns></returns>
private IPEndPoint GetLocalEP(SForwardProxyInfo sForwardProxyInfo)
{
SForwardInfo sForwardInfo = runningConfig.Data.SForwards.FirstOrDefault(c => c.RemotePort == sForwardProxyInfo.RemotePort || (c.RemotePortMin <= sForwardProxyInfo.RemotePort && c.RemotePortMax >= sForwardProxyInfo.RemotePort));
SForwardInfo sForwardInfo = sForwardClientStore.Get().FirstOrDefault(c => c.RemotePort == sForwardProxyInfo.RemotePort || (c.RemotePortMin <= sForwardProxyInfo.RemotePort && c.RemotePortMax >= sForwardProxyInfo.RemotePort));
if (sForwardInfo != null)
{
IPEndPoint localEP = IPEndPoint.Parse(sForwardInfo.LocalEP.ToString());
@@ -500,18 +498,4 @@ namespace linker.plugins.sforward.messenger
}
}
[MemoryPackable]
public sealed partial class SForwardAddForwardInfo
{
public string MachineId { get; set; }
public SForwardInfo Data { get; set; }
}
[MemoryPackable]
public sealed partial class SForwardRemoveForwardInfo
{
public string MachineId { get; set; }
public uint Id { get; set; }
}
}

0
linker/plugins/sforward/messenger/SForwardMessengerIds.cs → linker.messenger.sforward/messenger/SForwardMessengerIds.cs
View File

0
linker/plugins/sforward/proxy/SForwardProxy.cs → linker.messenger.sforward/proxy/SForwardProxy.cs
View File

0
linker/plugins/sforward/proxy/SForwardProxyTcp.cs → linker.messenger.sforward/proxy/SForwardProxyTcp.cs
View File

0
linker/plugins/sforward/proxy/SForwardProxyUdp.cs → linker.messenger.sforward/proxy/SForwardProxyUdp.cs
View File

2
linker/plugins/sforward/config/ISForwardServerCahing.cs → linker.messenger.sforward/server/ISForwardServerCahing.cs
View File

@@ -1,4 +1,4 @@
namespace linker.plugins.sforward.config
namespace linker.messenger.sforward.server
{
public interface ISForwardServerCahing
{

10
linker.messenger.sforward/server/ISForwardServerStore.cs Normal file
View File

@@ -0,0 +1,10 @@
namespace linker.messenger.sforward.server
{
public interface ISForwardServerStore
{
public string SecretKey { get; }
public byte BufferSize { get; }
public int WebPort { get; }
public int[] TunnelPortRange { get; }
}
}

2
linker/plugins/sforward/config/SForwardServerCahing.cs → linker.messenger.sforward/server/SForwardServerCahing.cs
View File

@@ -1,7 +1,7 @@
using linker.messenger.signin;
using System.Collections.Concurrent;
namespace linker.plugins.sforward.config
namespace linker.messenger.sforward.server
{
/// <summary>
/// 服务器穿透缓存，用于识别不同的客户端

3
linker/plugins/sforward/validator/IValidator.cs → linker.messenger.sforward/server/validator/ISForwardValidator.cs
View File

@@ -1,7 +1,6 @@
using linker.messenger.signin;
using linker.plugins.sforward.config;
namespace linker.plugins.sforward.validator
namespace linker.messenger.sforward.server.validator
{
public interface ISForwardValidator
{

34
linker.messenger.sforward/server/validator/SForwardValidator.cs Normal file
View File

@@ -0,0 +1,34 @@
using linker.messenger.signin;
namespace linker.messenger.sforward.server.validator
{
/// <summary>
/// 服务端穿透验证
/// </summary>
public sealed class SForwardValidator : ISForwardValidator
{
private readonly ISForwardServerStore sForwardServerStore;
public SForwardValidator(ISForwardServerStore sForwardServerStore)
{
this.sForwardServerStore = sForwardServerStore;
}
public async Task<string> Validate(SignCacheInfo signCacheInfo, SForwardAddInfo sForwardAddInfo)
{
if (sForwardServerStore.SecretKey != sForwardAddInfo.SecretKey)
{
return $"sforward secretKey 【{sForwardAddInfo.SecretKey}】 valid fail";
}
if (sForwardAddInfo.RemotePort > 0)
{
if (sForwardAddInfo.RemotePort < sForwardServerStore.TunnelPortRange[0] || sForwardAddInfo.RemotePort > sForwardServerStore.TunnelPortRange[1])
{
return $"sforward tunnel port range {string.Join("-", sForwardServerStore.TunnelPortRange)}";
}
}
await Task.CompletedTask;
return string.Empty;
}
}
}

48
linker.messenger.sforward/server/validator/SForwardValidatorTransfer.cs Normal file
View File

@@ -0,0 +1,48 @@
using linker.messenger.signin;
using linker.libs;
namespace linker.messenger.sforward.server.validator
{
/// <summary>
/// 验证
/// </summary>
public sealed partial class SForwardValidatorTransfer
{
private List<ISForwardValidator> validators = new List<ISForwardValidator>();
public SForwardValidatorTransfer()
{
}
/// <summary>
/// 加载验证实现类
/// </summary>
/// <param name="list"></param>
public void AddValidators(List<ISForwardValidator> list)
{
if (list == null) return;
validators = validators.Concat(list).Distinct().ToList();
LoggerHelper.Instance.Info($"load sforward server validator :{string.Join(",", list.Select(c => c.GetType().Name))}");
}
/// <summary>
/// 验证
/// </summary>
/// <param name="signCacheInfo"></param>
/// <param name="sForwardAddInfo"></param>
/// <returns></returns>
public async Task<string> Validate(SignCacheInfo signCacheInfo, SForwardAddInfo sForwardAddInfo)
{
foreach (var item in validators)
{
string result = await item.Validate(signCacheInfo, sForwardAddInfo);
if (string.IsNullOrWhiteSpace(result) == false)
{
return result;
}
}
return string.Empty;
}
}
}

2
linker.messenger.signin/ISignInClientStore.cs
View File

@@ -8,7 +8,7 @@
public string Name { get; }
public void SetName(string newName);
public void SetGroup(SignInClientGroupInfo groups);
public void SetGroups(SignInClientGroupInfo[] groups);
public void SetGroupPassword(string password);
public void SetServer(SignInClientServerInfo servers);
public void SetSecretKey(string secretKey);

23
linker.messenger.signin/SignInApiController.cs
View File

@@ -1,6 +1,7 @@
using linker.libs;
using linker.libs.api;
using linker.libs.extends;
using linker.messenger.api;
namespace linker.messenger.signin
{
@@ -11,21 +12,30 @@ namespace linker.messenger.signin
private readonly IMessengerSender messengerSender;
private readonly SignInClientTransfer signInClientTransfer;
private readonly ISerializer serializer;
private readonly IAccessStore accessStore;
public SignInApiController( SignInClientState signInClientState, ISignInClientStore signInClientStore, IMessengerSender messengerSender,SignInClientTransfer signInClientTransfer, ISerializer serializer)
public SignInApiController( SignInClientState signInClientState, ISignInClientStore signInClientStore, IMessengerSender messengerSender,SignInClientTransfer signInClientTransfer, ISerializer serializer, IAccessStore accessStore)
{
this.signInClientState = signInClientState;
this.signInClientStore = signInClientStore;
this.messengerSender = messengerSender;
this.signInClientTransfer = signInClientTransfer;
this.serializer = serializer;
this.accessStore = accessStore;
}
public void Set(ApiControllerParamsInfo param)
{
ConfigSetInfo info = param.Content.DeJson<ConfigSetInfo>();
signInClientStore.SetName(info.Name);
signInClientStore.SetGroup(info.Groups[0]);
if (accessStore.HasAccess(AccessValue.RenameSelf))
{
signInClientStore.SetName(info.Name);
}
if (accessStore.HasAccess(AccessValue.RenameSelf))
{
signInClientStore.SetGroups(info.Groups);
}
signInClientTransfer.ReSignIn();
}
@@ -35,11 +45,13 @@ namespace linker.messenger.signin
if (info.Id == signInClientStore.Id)
{
if (accessStore.HasAccess(AccessValue.RenameSelf) == false) return false;
signInClientStore.SetName(info.NewName);
signInClientTransfer.ReSignIn();
}
else
{
if (accessStore.HasAccess(AccessValue.RenameSelf) == false) return false;
await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = signInClientState.Connection,
@@ -49,13 +61,15 @@ namespace linker.messenger.signin
}
return true;
}
[Access(AccessValue.Group)]
public void SetGroups(ApiControllerParamsInfo param)
{
SignInClientGroupInfo[] info = param.Content.DeJson<SignInClientGroupInfo[]>();
signInClientStore.SetGroup(info[0]);
signInClientStore.SetGroups(info);
//signInClientTransfer.ReSignIn();
}
[Access(AccessValue.Config)]
public bool SetServers(ApiControllerParamsInfo param)
{
SignInClientServerInfo servers = param.Content.DeJson<SignInClientServerInfo>();
@@ -69,6 +83,7 @@ namespace linker.messenger.signin
return signInClientState;
}
[Access(AccessValue.Config)]
public async Task Del(ApiControllerParamsInfo param)
{
await messengerSender.SendOnly(new MessageRequestWrap

4
linker.messenger.socks5/Entry.cs
View File

@@ -8,7 +8,7 @@ namespace linker.messenger.socks5
{
public static ServiceCollection AddSocks5Client(this ServiceCollection serviceCollection)
{
serviceCollection.AddSingleton<Socks5ClientApiController>();
serviceCollection.AddSingleton<Socks5ApiController>();
serviceCollection.AddSingleton<TunnelProxy>();
serviceCollection.AddSingleton<Socks5ClientMessenger>();
@@ -29,7 +29,7 @@ namespace linker.messenger.socks5
messengerResolver.AddMessenger(new List<IMessenger> { serviceProvider.GetService<Socks5ClientMessenger>() });
IApiServer apiServer = serviceProvider.GetService<IApiServer>();
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<Socks5ClientApiController>() });
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<Socks5ApiController>() });
DecenterClientTransfer decenterClientTransfer = serviceProvider.GetService<DecenterClientTransfer>();
decenterClientTransfer.AddDecenters(new List<IDecenter> { serviceProvider.GetService<Socks5Decenter>() });

14
linker.messenger.socks5/Socks5ApiController.cs
View File

@@ -4,10 +4,11 @@ using System.Collections.Concurrent;
using linker.tunnel.connection;
using linker.messenger.signin;
using linker.libs;
using linker.messenger.api;
namespace linker.messenger.socks5
{
public sealed class Socks5ClientApiController : IApiController
public sealed class Socks5ApiController : IApiController
{
private readonly IMessengerSender messengerSender;
private readonly Socks5Transfer socks5Transfer;
@@ -16,7 +17,8 @@ namespace linker.messenger.socks5
private readonly ISignInClientStore signInClientStore;
private readonly Socks5Decenter socks5Decenter;
private readonly ISerializer serializer;
public Socks5ClientApiController(IMessengerSender messengerSender, SignInClientState signInClientState, TunnelProxy tunnelProxy, Socks5Transfer socks5Transfer, ISignInClientStore signInClientStore, Socks5Decenter socks5Decenter, ISerializer serializer)
private readonly IAccessStore accessStore;
public Socks5ApiController(IMessengerSender messengerSender, SignInClientState signInClientState, TunnelProxy tunnelProxy, Socks5Transfer socks5Transfer, ISignInClientStore signInClientStore, Socks5Decenter socks5Decenter, ISerializer serializer, IAccessStore accessStore)
{
this.messengerSender = messengerSender;
this.socks5Transfer = socks5Transfer;
@@ -25,6 +27,7 @@ namespace linker.messenger.socks5
this.signInClientStore = signInClientStore;
this.socks5Decenter = socks5Decenter;
this.serializer = serializer;
this.accessStore = accessStore;
}
public ConnectionListInfo Connections(ApiControllerParamsInfo param)
@@ -41,6 +44,7 @@ namespace linker.messenger.socks5
return new ConnectionListInfo { HashCode = version };
}
[Access(AccessValue.TunnelRemove)]
public void RemoveConnection(ApiControllerParamsInfo param)
{
tunnelProxy.RemoveConnection(param.Content);
@@ -83,10 +87,12 @@ namespace linker.messenger.socks5
//运行自己的
if (param.Content == signInClientStore.Id)
{
if (accessStore.HasAccess(AccessValue.Socks5StatusSelf) == false) return false;
socks5Transfer.Retstart();
}
else
{
if (accessStore.HasAccess(AccessValue.Socks5StatusOther) == false) return false;
//运行别人的
await messengerSender.SendOnly(new MessageRequestWrap
{
@@ -107,10 +113,12 @@ namespace linker.messenger.socks5
//停止自己的
if (param.Content == signInClientStore.Id)
{
if (accessStore.HasAccess(AccessValue.Socks5StatusSelf) == false) return false;
socks5Transfer.Stop();
}
else
{
if (accessStore.HasAccess(AccessValue.Socks5StatusOther) == false) return false;
//停止别人的
await messengerSender.SendOnly(new MessageRequestWrap
{
@@ -134,10 +142,12 @@ namespace linker.messenger.socks5
//更新自己的
if (info.MachineId == signInClientStore.Id)
{
if (accessStore.HasAccess(AccessValue.Socks5ChangeSelf) == false) return false;
socks5Transfer.UpdateConfig(info);
}
else
{
if (accessStore.HasAccess(AccessValue.Socks5ChangeOther) == false) return false;
//更新别人的
await messengerSender.SendOnly(new MessageRequestWrap
{

5
linker.messenger.store.file/ConfigApiController.cs
View File

@@ -3,6 +3,7 @@ using linker.libs.extends;
using System.IO.Compression;
using linker.libs;
using linker.messenger.signin;
using linker.messenger.api;
namespace linker.messenger.store.file
{
public sealed class ConfigApiController : IApiController
@@ -76,6 +77,7 @@ namespace linker.messenger.store.file
return true;
}
[Access(AccessValue.Export)]
public async Task<bool> Export(ApiControllerParamsInfo param)
{
try
@@ -114,9 +116,10 @@ namespace linker.messenger.store.file
client.CApi.ApiPassword = configExportInfo.ApiPassword;
}
client.Access = accessTransfer.AssignAccess((ClientApiAccess)configExportInfo.Access);
client.Access = config.Data.Client.Access & (AccessValue)configExportInfo.Access;
client.OnlyNode = true;
client.Action.Args.Clear();
client.Action.Arg = string.Empty;
client.Groups = [config.Data.Client.Groups[0]];
File.WriteAllText(Path.Combine(configPath, $"client.json"), client.Serialize(client));

36
linker.messenger.store.file/Entry.cs
View File

@@ -1,23 +1,34 @@
using linker.messenger.access;
using linker.libs;
using linker.messenger.action;
using linker.messenger.api;
using linker.messenger.forward;
using linker.messenger.listen;
using linker.messenger.logger;
using linker.messenger.pcp;
using linker.messenger.relay.client;
using linker.messenger.relay.server;
using linker.messenger.sforward.client;
using linker.messenger.sforward.server;
using linker.messenger.signin;
using linker.messenger.socks5;
using linker.messenger.store.file.action;
using linker.messenger.store.file.api;
using linker.messenger.store.file.common;
using linker.messenger.store.file.forward;
using linker.messenger.store.file.logger;
using linker.messenger.store.file.messenger;
using linker.messenger.store.file.pcp;
using linker.messenger.store.file.relay;
using linker.messenger.store.file.server;
using linker.messenger.store.file.sforward;
using linker.messenger.store.file.signIn;
using linker.messenger.store.file.socks5;
using linker.messenger.store.file.tunnel;
using linker.messenger.store.file.tuntap;
using linker.messenger.store.file.updater;
using linker.messenger.sync;
using linker.messenger.tuntap;
using linker.messenger.tuntap.lease;
using linker.messenger.updater;
using linker.plugins.tunnel;
using Microsoft.Extensions.DependencyInjection;
@@ -27,8 +38,16 @@ namespace linker.messenger.store.file
{
public static ServiceCollection AddStoreFile(this ServiceCollection serviceCollection)
{
LoggerHelper.Instance.Info("add store file");
serviceCollection.AddSingleton<Storefactory>();
serviceCollection.AddSingleton<FileConfig>();
serviceCollection.AddSingleton<RunningConfig>();
serviceCollection.AddSingleton<ConfigApiController>();
serviceCollection.AddSingleton<ICommonStore, CommonStore>();
serviceCollection.AddSingleton<IApiStore, ApiStore>();
serviceCollection.AddSingleton<IAccessStore, AccessStore>();
@@ -60,10 +79,25 @@ namespace linker.messenger.store.file
serviceCollection.AddSingleton<ISocks5Store, Socks5Store>();
serviceCollection.AddSingleton<ISForwardClientStore, SForwardClientStore>();
serviceCollection.AddSingleton<ISForwardServerStore, SForwardServerStore>();
serviceCollection.AddSingleton<ILoggerStore, LoggerStore>();
serviceCollection.AddSingleton<IForwardClientStore, ForwardClientStore>();
serviceCollection.AddSingleton<ITuntapClientStore, TuntapClientStore>();
serviceCollection.AddSingleton<ILeaseServerStore, LeaseServerStore>();
return serviceCollection;
}
public static ServiceProvider UseStoreFile(this ServiceProvider serviceProvider)
{
LoggerHelper.Instance.Info("use store file");
FileConfig fileConfig = serviceProvider.GetService<FileConfig>();
RunningConfig runningConfig = serviceProvider.GetService<RunningConfig>();
IApiServer apiServer = serviceProvider.GetService<IApiServer>();
apiServer.AddPlugins(new List<libs.api.IApiController> { serviceProvider.GetService<ConfigApiController>() });

25
linker.messenger.store.file/FileConfig.cs
View File

@@ -213,37 +213,12 @@ namespace linker.messenger.store.file
public sealed partial class ConfigCommonInfo : IConfig
{
public ConfigCommonInfo() { }
public string[] Modes { get; set; } = new string[] { "client", "server" };
#if DEBUG
private LoggerTypes loggerType { get; set; } = LoggerTypes.DEBUG;
public bool Install { get; set; } = false;
#else
private LoggerTypes loggerType { get; set; } = LoggerTypes.WARNING;
public bool Install { get; set; } = false;
#endif
[JsonIgnore]
public string[] Plugins { get; set; } = Array.Empty<string>();
public LoggerTypes LoggerType
{
get => loggerType; set
{
loggerType = value;
LoggerHelper.Instance.LoggerLevel = value;
}
}
public int LoggerSize { get; set; } = 100;
[JsonIgnore]
public string[] IncludePlugins { get; set; } = Array.Empty<string>();
[JsonIgnore]
public string[] ExcludePlugins { get; set; } = Array.Empty<string>();
public ConfigCommonInfo Load(string text)
{
return text.DeJson<ConfigCommonInfo>();

5
linker.messenger.store.file/api/AccessStore.cs
View File

@@ -1,6 +1,5 @@
using linker.config;
using linker.libs;
using linker.messenger.access;
using linker.libs;
using linker.messenger.api;
namespace linker.messenger.store.file.api
{

4
linker.messenger.store.file/api/ApiStore.cs
View File

@@ -1,6 +1,4 @@
using linker.config;
using linker.libs;
using linker.messenger.api;
using linker.messenger.api;
namespace linker.messenger.store.file.api
{

2
linker.messenger.store.file/api/Config.cs
View File

@@ -3,7 +3,7 @@ using linker.messenger.access;
using linker.messenger.api;
using System.Reflection;
namespace linker.config
namespace linker.messenger.store.file
{
public partial class ConfigClientInfo
{

28
linker.messenger.store.file/common/CommonStore.cs Normal file
View File

@@ -0,0 +1,28 @@
namespace linker.messenger.store.file.common
{
public sealed class CommonStore : ICommonStore
{
public CommonModes Modes
{
get
{
CommonModes modes = 0;
if (fileConfig.Data.Common.Modes.Contains("client"))
{
modes |= CommonModes.Client;
}
if (fileConfig.Data.Common.Modes.Contains("server"))
{
modes |= CommonModes.Server;
}
return modes;
}
}
private readonly FileConfig fileConfig;
public CommonStore(FileConfig fileConfig)
{
this.fileConfig = fileConfig;
}
}
}

9
linker.messenger.store.file/common/Config.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace linker.messenger.store.file
{
public sealed partial class ConfigCommonInfo
{
public string[] Modes { get; set; } = new string[] { "client", "server" };
}
}

13
linker.messenger.store.file/forward/Config.cs Normal file
View File

@@ -0,0 +1,13 @@

using linker.messenger.forward;
namespace linker.messenger.store.file
{
public sealed partial class RunningConfigInfo
{
/// <summary>
/// 端口转发配置
/// </summary>
public List<ForwardInfo> Forwards { get; set; } = new List<ForwardInfo>();
}
}

59
linker.messenger.store.file/forward/ForwardClientStore.cs Normal file
View File

@@ -0,0 +1,59 @@
using linker.messenger.forward;
namespace linker.messenger.store.file.forward
{
public sealed class ForwardClientStore : IForwardClientStore
{
private readonly RunningConfig runningConfig;
public ForwardClientStore(RunningConfig runningConfig)
{
this.runningConfig = runningConfig;
foreach (var item in runningConfig.Data.Forwards)
{
item.Proxy = false;
}
}
public int Count()
{
return runningConfig.Data.SForwards.Count();
}
public List<ForwardInfo> Get()
{
return runningConfig.Data.Forwards;
}
public ForwardInfo Get(uint id)
{
return runningConfig.Data.Forwards.FirstOrDefault(x => x.Id == id);
}
public List<ForwardInfo> Get(string groupid)
{
return runningConfig.Data.Forwards.Where(x => x.GroupId == groupid).ToList();
}
public bool Add(ForwardInfo info)
{
runningConfig.Data.Forwards.Add(info);
return true;
}
public bool Update(ForwardInfo info)
{
return true;
}
public bool Remove(uint id)
{
runningConfig.Data.Forwards.Remove(Get(id));
return true;
}
public bool Confirm()
{
runningConfig.Data.Update();
return true;
}
}
}

4
linker.messenger.store.file/linker.messenger.store.file.csproj
View File

@@ -38,12 +38,16 @@
<ProjectReference Include="..\linker.messenger.access\linker.messenger.access.csproj" />
<ProjectReference Include="..\linker.messenger.action\linker.messenger.action.csproj" />
<ProjectReference Include="..\linker.messenger.api\linker.messenger.api.csproj" />
<ProjectReference Include="..\linker.messenger.forward\linker.messenger.forward.csproj" />
<ProjectReference Include="..\linker.messenger.listen\linker.messenger.listen.csproj" />
<ProjectReference Include="..\linker.messenger.logger\linker.messenger.logger.csproj" />
<ProjectReference Include="..\linker.messenger.pcp\linker.messenger.pcp.csproj" />
<ProjectReference Include="..\linker.messenger.relay\linker.messenger.relay.csproj" />
<ProjectReference Include="..\linker.messenger.sforward\linker.messenger.sforward.csproj" />
<ProjectReference Include="..\linker.messenger.signin\linker.messenger.signin.csproj" />
<ProjectReference Include="..\linker.messenger.socks5\linker.messenger.socks5.csproj" />
<ProjectReference Include="..\linker.messenger.tunnel\linker.messenger.tunnel.csproj" />
<ProjectReference Include="..\linker.messenger.tuntap\linker.messenger.tuntap.csproj" />
<ProjectReference Include="..\linker.messenger.updater\linker.messenger.updater.csproj" />
<ProjectReference Include="..\linker.messenger\linker.messenger.csproj" />
<ProjectReference Include="..\linker.tunnel\linker.tunnel.csproj" />

Some files were not shown because too many files have changed in this diff Show More