sync

.github/workflows/nuget.yml

@@ -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.access -c release
-        dotnet build ./linker.messenger.signin -c release
+        dotnet build ./linker.messenger.action -c release
-        dotnet build ./linker.messenger.tunnel -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.access -c release
-        dotnet pack ./linker.messenger.signin -c release
+        dotnet pack ./linker.messenger.action -c release
-        dotnet pack ./linker.messenger.tunnel -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.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.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.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.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.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

linker.messenger.access/AccessApiController.cs

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

linker.messenger.access/AccessDecenter.cs

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

linker.messenger.access/AccessMessenger.cs

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

linker.messenger.access/Entry.cs

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

linker.messenger.access/linker.messenger.access.csproj

@@ -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>

linker.messenger.action/ActionApiController.cs

@@ -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>>());

linker.messenger.action/Entry.cs

@@ -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;
         }
     }

linker.messenger.action/IActionStore.cs

@@ -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

linker.messenger.action/SignInArgsAction.cs

@@ -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;

linker.messenger.action/linker.messenger.action.csproj

@@ -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>

linker.messenger.api/ApiServer.cs

@@ -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 accessStore.HasAccess((AccessValue)access);
-            //return accessTransfer.HasAccess((ClientApiAccess)access);
         }
     }
 }

linker.messenger.api/Config.cs

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

linker.messenger.api/Entry.cs

@@ -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}");

linker.messenger.api/IAccessStore.cs

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

linker.messenger.decenter/DecenterClientTransfer.cs

@@ -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();
         }
 

linker.messenger.decenter/linker.messenger.decenter.csproj

@@ -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>

linker.messenger.entry/LinkerMessengerEntry.cs

@@ -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>();
+        }
+
+    }
+}

linker.messenger.entry/linker.messenger.entry.csproj

@@ -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>

linker.messenger.example/Program.cs

@@ -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;
-        }
-    }
-
-
-}

linker.messenger.example/linker.messenger.example.csproj

@@ -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>

linker.messenger.exroute/ExRouteTransfer.cs

@@ -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();
            
         }

linker.messenger.flow/Entry.cs

@@ -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;
+        }
+    }
+}

linker.messenger.flow/ExternalFlow.cs

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

linker.messenger.flow/FlowApiController.cs

@@ -1,35 +1,28 @@
-using linker.libs.api;
+using linker.libs;
-using linker.config;
+using linker.libs.api;
-using linker.serializer;
-using linker.client.config;
-using linker.plugins.client;
-using linker.plugins.capi;
-using linker.plugins.flow.messenger;
 using linker.libs.extends;
-using linker.plugins.relay.client;
+using linker.messenger.api;
-using linker.plugins.sforward;
+using linker.messenger.flow.messenger;
-using linker.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 IRelayClientStore relayClientStore;
-        private readonly RunningConfig runningConfig;
+        private readonly ISForwardClientStore sForwardClientStore;
-        private readonly RelayClientConfigTransfer relayClientConfigTransfer;
+        private readonly ISerializer serializer;
-        private readonly SForwardTransfer sForwardTransfer;
+        public FlowApiController(IMessengerSender messengerSender, SignInClientState signInClientState, IRelayClientStore relayClientStore, ISForwardClientStore sForwardClientStore, ISerializer serializer)
-
-        public FlowClientApiController(IMessengerSender messengerSender, SignInClientState signInClientState, FileConfig config, RunningConfig runningConfig, RelayClientConfigTransfer relayClientConfigTransfer, SForwardTransfer sForwardTransfer)
         {
             this.messengerSender = messengerSender;
             this.signInClientState = signInClientState;
-            this.config = config;
+            this.relayClientStore = relayClientStore;
-            this.runningConfig = runningConfig;
+            this.sForwardClientStore = sForwardClientStore;
-            this.relayClientConfigTransfer = relayClientConfigTransfer;
+            this.serializer = serializer;
-            this.sForwardTransfer = sForwardTransfer;
         }
 
         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();
         }

linker.messenger.flow/FlowResolver.cs

@@ -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
     {

linker.messenger.flow/FlowTransfer.cs

@@ -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()

linker.messenger.flow/IFlow.cs

@@ -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; }

linker.messenger.flow/MessengerFlow.cs

@@ -1,12 +1,10 @@
-using linker.messenger;
+namespace linker.messenger.flow
-
-namespace linker.plugins.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;
         }

linker.messenger.flow/RelayFlow.cs

@@ -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; }

linker.messenger.flow/SForwardFlow.cs

@@ -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; }

linker.messenger.flow/linker.messenger.flow.csproj

@@ -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>

linker.messenger.flow/messenger/FlowMessenger.cs

@@ -1,11 +1,9 @@
-using linker.config;
+using linker.libs;
-using linker.messenger;
+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 IRelayServerStore relayServerStore;
-        private readonly RelayServerConfigTransfer relayServerConfigTransfer;
+        private readonly ISForwardServerStore sForwardServerStore;
-        private readonly SForwardServerConfigTransfer sForwardServerConfigTransfer;
+        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.relayServerStore = relayServerStore;
-            this.relayServerConfigTransfer = relayServerConfigTransfer;
+            this.sForwardServerStore = sForwardServerStore;
-            this.sForwardServerConfigTransfer = sForwardServerConfigTransfer;
+            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);
+            RelayFlowRequestInfo info = serializer.Deserialize<RelayFlowRequestInfo>(connection.ReceiveRequestWrap.Payload.Span);
-            if (relayServerConfigTransfer.SecretKey == info.SecretKey)
+            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)));
         }
     }
 

linker.messenger.flow/messenger/FlowMessengerIds.cs

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

linker.messenger.forward/Config.cs

@@ -1,22 +1,9 @@
-using LiteDB;
+using System.Net;
-using MemoryPack;
+namespace linker.messenger.forward
-using System.Net;
-using System.Text.Json.Serialization;
-
-namespace linker.client.config
 {
-    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; }
+    }
 }

linker.messenger.forward/Entry.cs

@@ -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;
+        }
+    }
+}

linker.messenger.forward/ForwardApiController.cs

@@ -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)
             });
         }
     }

linker.messenger.forward/ForwardDecenter.cs

@@ -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);

linker.messenger.forward/ForwardMessenger.cs

@@ -1,21 +1,19 @@
-using linker.client.config;
+using linker.libs;
-using linker.messenger;
 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;
-
+        private readonly ISerializer serializer;
-        public ForwardServerMessenger(IMessengerSender sender, SignInServerCaching signCaching)
+        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;
-
+        private readonly ISerializer serializer;
-        public ForwardClientMessenger(ForwardTransfer forwardTransfer, IMessengerSender sender)
+        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; }
-    }
 }

linker.messenger.forward/ForwardMessengerIds.cs

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

linker.messenger.forward/ForwardTransfer.cs

@@ -1,20 +1,17 @@
-using linker.client.config;
+using linker.libs;
-using linker.libs;
+using linker.libs.extends;
-using linker.messenger;
+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);
+            forwardClientStore.Remove(old.Id);
-            running.Data.Update();
+
+            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; }
-    }
 }

linker.messenger.forward/IForwardClientStore.cs

@@ -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();
+    }
+}

linker.messenger.forward/linker.messenger.forward.csproj

@@ -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>

linker.messenger.forward/proxy/ForwardProxy.cs

@@ -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

linker.messenger.forward/proxy/ForwardProxyTcp.cs

@@ -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
     {

linker.messenger.forward/proxy/ForwardProxyTunnel.cs

@@ -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)
+        public ForwardProxy(ISignInClientStore signInClientStore, TunnelTransfer tunnelTransfer, RelayClientTransfer relayTransfer, PcpTransfer pcpTransfer, SignInClientTransfer signInClientTransfer, IRelayClientStore relayClientStore)
-            : base(tunnelTransfer, relayTransfer, pcpTransfer, signInClientTransfer, signInClientStore, relayClientConfigTransfer)
+            : base(tunnelTransfer, relayTransfer, pcpTransfer, signInClientTransfer, signInClientStore, relayClientStore)
         {
             TaskUdp();
         }

linker.messenger.forward/proxy/ForwardProxyUdp.cs

@@ -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
     {

linker.messenger.listen/Entry.cs

@@ -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>();

linker.messenger.logger/Entry.cs

@@ -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);
+        }
+
+    }
+}

linker.messenger.logger/ILoggerStore.cs

@@ -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();
+    }
+}

linker.messenger.logger/LoggerController.cs

@@ -1,30 +1,28 @@
 using linker.libs.extends;
 using linker.libs.api;
 using linker.libs;
-using linker.config;
+using linker.messenger.api;
-using linker.plugins.capi;
 
-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 ILoggerStore loggerStore;
-        private readonly FileConfig config;
+        public LoggerApiController(ILoggerStore loggerStore)
-        public LoggerClientApiController(FileConfig config)
         {
-            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,
+                LoggerType = loggerStore.LoggerType,
-                Size = config.Data.Common.LoggerSize
+                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;
+            loggerStore.SetLevel(info.LoggerType);
-            config.Data.Common.LoggerType = info.LoggerType;
+            loggerStore.SetSize(info.Size);
-            config.Data.Update();
+            loggerStore.Confirm();
             return true;
         }
 

linker.messenger.logger/linker.messenger.logger.csproj

@@ -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>

linker.messenger.pcp/Entry.cs

@@ -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>() });

linker.messenger.relay/Entry.cs

@@ -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>() });
 

linker.messenger.relay/client/RelayApiController.cs

@@ -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>();

linker.messenger.relay/client/RelayClientTransfer.cs

@@ -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))}");
         }

linker.messenger.relay/client/transport/RelayClientTransportSelfHost.cs

@@ -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
                 {

linker.messenger.relay/server/IRelayServerNodeStore.cs

@@ -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;

linker.messenger.serializer.memorypack/AccessSerializer.cs

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

linker.messenger.serializer.memorypack/Entry.cs

@@ -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)

linker.messenger.serializer.memorypack/FlowSerializer.cs

@@ -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;
+        }
+    }
+}

linker.messenger.serializer.memorypack/ForwardSerializer.cs

@@ -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;
+        }
+    }
+}

linker.messenger.serializer.memorypack/SForwardSerializer.cs

@@ -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;
+        }
+    }
+}

linker.messenger.serializer.memorypack/TuntapSerializer.cs

@@ -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;
+        }
+    }
+}

linker.messenger.serializer.memorypack/linker.messenger.serializer.memorypack.csproj

@@ -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>

linker.messenger.sforward/Config.cs

@@ -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; }
+    }
 }

linker.messenger.sforward/Entry.cs

@@ -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;
+        }
+    }
+}

linker.messenger.sforward/client/ISForwardClientStore.cs

@@ -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();
+    }
+}

linker.messenger.sforward/client/SForwardApiController.cs

@@ -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>();
+                if (accessStore.HasAccess(AccessValue.ForwardShowSelf) == false) return new List<SForwardInfo>();
-                return forwardTransfer.Get();
+                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 (accessStore.HasAccess(AccessValue.ForwardOther) == false) return false;
-            if (accessTransfer.HasAccess(ClientApiAccess.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;
         }

linker.messenger.sforward/client/SForwardClientTransfer.cs

@@ -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();
-            
+            this.serializer = serializer;
-        }
-      
-        public void SetSecretKey(string key)
-        {
-            fileConfig.Data.Client.SForward.SecretKey = key;
-            fileConfig.Data.Update();
         }
 
         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);
+            if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-            running.Data.Update();
+                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;

linker.messenger.sforward/client/SForwardDecenter.cs

@@ -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;
+        private readonly ISForwardClientStore sForwardClientStore;
-        public SForwardDecenter(ISignInClientStore signInClientStore, SForwardTransfer sForwardTransfer)
+        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; }
-    }
 }

linker.messenger.sforward/client/SForwardSync.cs

@@ -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));
+        }
+    }
+}

linker.messenger.sforward/linker.messenger.sforward.csproj

@@ -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>

linker.messenger.sforward/messenger/SForwardMessenger.cs

@@ -1,15 +1,12 @@
-using linker.client.config;
+using linker.plugins.sforward.proxy;
-using linker.plugins.sforward.config;
-using linker.plugins.sforward.validator;
-using linker.serializer;
-using linker.plugins.sforward.proxy;
-using linker.config;
-using LiteDB;
 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 SForwardValidatorTransfer validator;
-        private readonly ISForwardValidator validator;
+        private readonly ISForwardServerStore sForwardServerStore;
-        private readonly SForwardServerConfigTransfer sForwardServerConfigTransfer;
+        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);
+            SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
-            SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true, BufferSize = sForwardServerConfigTransfer.BufferSize };
+            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 SForwardClientTransfer sForwardTransfer;
-        private readonly SForwardTransfer sForwardTransfer;
+        private readonly ISForwardClientStore sForwardClientStore;
-
+        private readonly ISerializer serializer;
-        public SForwardClientMessenger(SForwardProxy proxy, RunningConfig runningConfig, SForwardTransfer sForwardTransfer)
+        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();
+            List<SForwardInfo> result = sForwardClientStore.Get();
-            connection.Write(Serializer.Serialize(result));
+            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; }
-    }
 }

linker.messenger.sforward/server/ISForwardServerCahing.cs

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

linker.messenger.sforward/server/ISForwardServerStore.cs

@@ -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; }
+    }
+}

linker.messenger.sforward/server/SForwardServerCahing.cs

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

linker.messenger.sforward/server/validator/ISForwardValidator.cs

@@ -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
     {

linker.messenger.sforward/server/validator/SForwardValidator.cs

@@ -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;
+        }
+    }
+}

linker.messenger.sforward/server/validator/SForwardValidatorTransfer.cs

@@ -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;
+        }
+
+    }
+}

linker.messenger.signin/ISignInClientStore.cs

@@ -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);

linker.messenger.signin/SignInApiController.cs

@@ -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);
+            if (accessStore.HasAccess(AccessValue.RenameSelf))
-            signInClientStore.SetGroup(info.Groups[0]);
+            {
+                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

linker.messenger.socks5/Entry.cs

@@ -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>() });

linker.messenger.socks5/Socks5ApiController.cs

@@ -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
                 {

linker.messenger.store.file/ConfigApiController.cs

@@ -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));

linker.messenger.store.file/Entry.cs

@@ -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>() });
 

linker.messenger.store.file/FileConfig.cs

@@ -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>();

linker.messenger.store.file/api/AccessStore.cs

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

linker.messenger.store.file/api/ApiStore.cs

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

linker.messenger.store.file/api/Config.cs

@@ -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
     {

linker.messenger.store.file/common/CommonStore.cs

@@ -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;
+        }
+    }
+}

linker.messenger.store.file/common/Config.cs

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

linker.messenger.store.file/forward/Config.cs

@@ -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>();
+    }
+}

linker.messenger.store.file/forward/ForwardClientStore.cs

@@ -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;
+        }
+
+
+    }
+}

linker.messenger.store.file/linker.messenger.store.file.csproj

@@ -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" />