udp中继

src/linker.doc.web/docs/3、打洞和中继/3.2、中继.md

@@ -51,7 +51,12 @@ sidebar_position: 2
         //主服务器地址
         "MasterHost": "linker.snltty.com:1802",
         //主服务器的密钥，主服务里的，Master里的SecretKey
-        "MasterSecretKey": ""
+        "MasterSecretKey": "",
+        //随便什么url，在客户端看节点列表的时候可以点击跳转
+        "Url": "",
+        //是否允许TCP，UDP
+        "AllowTcp":true,
+        "AllowUdp":false,
     },
     //我是主服务器，接收其它中继节点服务器的信息
     "Master": {

src/linker.libs/Crypto.cs

@@ -20,9 +20,13 @@ namespace linker.libs
     public interface ICrypto
     {
         public byte[] Encode(byte[] buffer);
-        public byte[] Encode(byte[] buffer, int offset, int length);
+        public byte[] Encode(byte[] buffer, int offset, int lengtht);
+        public int Encode(byte[] buffer, byte[] outputBuffer, int outputOffset);
+        public int Encode(byte[] buffer, int offset, int length, byte[] outputBuffer, int outputOffset);
         public Memory<byte> Decode(byte[] buffer);
         public Memory<byte> Decode(byte[] buffer, int offset, int length);
+        public int Decode(byte[] buffer, byte[] outputBuffer, int outputOffset);
+        public int Decode(byte[] buffer, int offset, int length, byte[] outputBuffer, int outputOffset);
 
         public void Dispose();
     }
@@ -56,6 +60,26 @@ namespace linker.libs
         {
             return encryptoTransform.TransformFinalBlock(buffer, offset, length);
         }
+        public int Encode(byte[] buffer, byte[] outputBuffer, int outputOffset)
+        {
+            return Encode(buffer, 0, buffer.Length, outputBuffer, outputOffset);
+        }
+        public int Encode(byte[] buffer, int offset, int length, byte[] outputBuffer, int outputOffset)
+        {
+            int blockSize = encryptoTransform.InputBlockSize;
+            int blocks = length / blockSize;
+            int remainingBytes = length % blockSize;
+
+            int written = encryptoTransform.TransformBlock(buffer, offset, blockSize * blocks, outputBuffer, outputOffset);
+            if (remainingBytes > 0)
+            {
+                byte[] finalBlock = encryptoTransform.TransformFinalBlock(buffer, offset + blocks * blockSize, remainingBytes);
+                finalBlock.CopyTo(outputBuffer, outputOffset + written);
+                written += finalBlock.Length;
+            }
+            return written;
+        }
+
         public Memory<byte> Decode(byte[] buffer)
         {
             return Decode(buffer, 0, buffer.Length);
@@ -64,12 +88,32 @@ namespace linker.libs
         {
             return decryptoTransform.TransformFinalBlock(buffer, offset, length);
         }
+        public int Decode(byte[] buffer, byte[] outputBuffer, int outputOffset)
+        {
+            return Decode(buffer, 0, buffer.Length, outputBuffer, outputOffset);
+        }
+        public int Decode(byte[] buffer, int offset, int length, byte[] outputBuffer, int outputOffset)
+        {
+            int blockSize = decryptoTransform.InputBlockSize;
+            int blocks = length / blockSize;
+            int remainingBytes = length % blockSize;
+
+            int written = decryptoTransform.TransformBlock(buffer, offset, blockSize * blocks, outputBuffer, outputOffset);
+            if (remainingBytes > 0)
+            {
+                byte[] finalBlock = decryptoTransform.TransformFinalBlock(buffer, offset + blocks * blockSize, remainingBytes);
+                finalBlock.CopyTo(outputBuffer, outputOffset + written);
+                written += finalBlock.Length;
+            }
+            return written;
+        }
+
+
         public void Dispose()
         {
             encryptoTransform.Dispose();
             decryptoTransform.Dispose();
         }
-
         private (byte[] Key, byte[] IV) GenerateKeyAndIV(string password)
         {
             byte[] key = new byte[16];

src/linker.libs/NetworkHelper.cs

@@ -88,7 +88,7 @@ namespace linker.libs
                 {
                     return ip;
                 }
-                return (await Dns.GetHostEntryAsync(domain, AddressFamily.InterNetwork)).AddressList.FirstOrDefault();
+                return (await Dns.GetHostEntryAsync(domain, AddressFamily.InterNetwork).ConfigureAwait(false)).AddressList.FirstOrDefault();
             }
             catch (Exception)
             {
@@ -123,7 +123,7 @@ namespace linker.libs
                 {
                     port = int.Parse(hostArr[1]);
                 }
-                IPAddress ip = await GetDomainIpAsync(hostArr[0]);
+                IPAddress ip = await GetDomainIpAsync(hostArr[0]).ConfigureAwait(false);
                 return new IPEndPoint(ip, port);
             }
             catch (Exception)
@@ -227,7 +227,12 @@ namespace linker.libs
             return GetIP()
                  .Where(c => c.AddressFamily == AddressFamily.InterNetworkV6)
                  .Where(c => c.GetAddressBytes().AsSpan(0, 8).SequenceEqual(ipv6LocalBytes) == false)
-                 .Where(c=>c.Equals(IPAddress.IPv6Loopback) == false)
+                 .Where(c => c.Equals(IPAddress.IPv6Loopback) == false)
+                 .Where(c =>
+                 {
+                     byte[] addressBytes = c.GetAddressBytes();
+                     return (addressBytes[0] == 0xFD || (addressBytes[0] == 0xFE && (addressBytes[1] & 0xC0) == 0x80)) == false;
+                 })
                  .Distinct().ToArray();
         }
         public static IPAddress[] GetIPV4()

src/linker.libs/TimerHelper.cs

@@ -9,86 +9,46 @@ namespace linker.libs
         {
             Task.Run(async () =>
             {
-                await Task.Delay(delayMs);
+                await Task.Delay(delayMs).ConfigureAwait(false);
                 action();
             });
         }
 
-        public static void SetInterval(Func<bool> action, int delayMs)
-        {
-            Task.Run(async () =>
-            {
-                while (action())
-                {
-                    await Task.Delay(delayMs).ConfigureAwait(false);
-                }
-            });
-        }
         public static void SetIntervalLong(Func<bool> action, int delayMs)
         {
-            Task.Factory.StartNew(async () =>
+            Task.Factory.StartNew(() =>
             {
                 while (action())
                 {
-                    await Task.Delay(delayMs).ConfigureAwait(false);
+                    Task.Delay(delayMs).Wait();
                 }
             }, TaskCreationOptions.LongRunning);
         }
-        public static void SetInterval(Func<Task<bool>> action, int delayMs)
-        {
-            Task.Run(async () =>
-            {
-                while (await action())
-                {
-                    await Task.Delay(delayMs).ConfigureAwait(false);
-                }
-            });
-        }
         public static void SetIntervalLong(Func<Task<bool>> action, int delay)
         {
             Task.Factory.StartNew(async () =>
             {
-                while (await action())
+                while (await action().ConfigureAwait(false))
                 {
                     await Task.Delay(delay).ConfigureAwait(false);
                 }
             }, TaskCreationOptions.LongRunning);
         }
-        public static void SetInterval(Func<bool> action, Func<int> delay)
-        {
-            Task.Run(async () =>
-            {
-                while (action())
-                {
-                    await Task.Delay(delay()).ConfigureAwait(false);
-                }
-            });
-        }
         public static void SetIntervalLong(Func<bool> action, Func<int> delay)
         {
-            Task.Factory.StartNew(async () =>
+            Task.Factory.StartNew(() =>
             {
                 while (action())
                 {
-                    await Task.Delay(delay()).ConfigureAwait(false);
+                    Task.Delay(delay()).Wait();
                 }
             }, TaskCreationOptions.LongRunning);
         }
-        public static void SetInterval(Func<Task<bool>> action, Func<int> delay)
-        {
-            Task.Run(async () =>
-            {
-                while (await action())
-                {
-                    await Task.Delay(delay()).ConfigureAwait(false);
-                }
-            });
-        }
         public static void SetIntervalLong(Func<Task<bool>> action, Func<int> delay)
         {
             Task.Factory.StartNew(async () =>
             {
-                while (await action())
+                while (await action().ConfigureAwait(false))
                 {
                     await Task.Delay(delay()).ConfigureAwait(false);
                 }
@@ -103,10 +63,7 @@ namespace linker.libs
         {
             Task.Run(action);
         }
-        public static void AsyncLong(Func<Task> action)
-        {
-            Task.Factory.StartNew(action,TaskCreationOptions.LongRunning);
-        }
+
 
     }
 }

src/linker.messenger.access/AccessApiController.cs

@@ -63,7 +63,7 @@ namespace linker.messenger.access
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)AccessMessengerIds.AccessUpdateForward,
                 Payload = serializer.Serialize(configUpdateAccessInfo)
-            });
+            }).ConfigureAwait(false);
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
 
@@ -84,7 +84,7 @@ namespace linker.messenger.access
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)AccessMessengerIds.SetApiPasswordForward,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
 

src/linker.messenger.action/ActionTransfer.cs

@@ -11,10 +11,10 @@ namespace linker.messenger.action
             {
                 using HttpClient client = new HttpClient();
                 JsonContent json = JsonContent.Create(JsonObject.Parse(actionJson));
-                HttpResponseMessage resp = await client.PostAsync(url, json);
+                HttpResponseMessage resp = await client.PostAsync(url, json).ConfigureAwait(false);
                 if (resp.IsSuccessStatusCode)
                 {
-                    string result = await resp.Content.ReadAsStringAsync();
+                    string result = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
                     if (result.Equals("ok", StringComparison.CurrentCultureIgnoreCase) == false)
                     {
                         return $"post {url} fail->{result}";

src/linker.messenger.action/SignInArgsAction.cs

@@ -141,7 +141,7 @@ namespace linker.messenger.action
                         IPAddress = signInfo.Connection.Address.Address
                     }
                 };
-                return await actionTransfer.ExcuteActions(Replace(replace, str), actionServerStore.SignInActionUrl);
+                return await actionTransfer.ExcuteActions(Replace(replace, str), actionServerStore.SignInActionUrl).ConfigureAwait(false);
             }
 
             return string.Empty;
@@ -192,7 +192,7 @@ namespace linker.messenger.action
                         IPAddress = fromMachine.Connection.Address.Address,
                     }
                 };
-                return await actionTransfer.ExcuteActions(Replace(replace, str), actionServerStore.RelayActionUrl);
+                return await actionTransfer.ExcuteActions(Replace(replace, str), actionServerStore.RelayActionUrl).ConfigureAwait(false);
             }
             return string.Empty;
         }
@@ -234,7 +234,7 @@ namespace linker.messenger.action
                         IPAddress = cache.Connection.Address.Address
                     }
                 };
-                return await actionTransfer.ExcuteActions(Replace(replace, str), actionServerStore.SForwardActionUrl);
+                return await actionTransfer.ExcuteActions(Replace(replace, str), actionServerStore.SForwardActionUrl).ConfigureAwait(false);
             }
             return string.Empty;
         }

src/linker.messenger.channel/Channel.cs

@@ -85,7 +85,7 @@ namespace linker.messenger.channel
             try
             {
                 //锁
-                if (await WaitAsync(machineId) == false)
+                if (await WaitAsync(machineId).ConfigureAwait(false) == false)
                 {
                     return null;
                 }
@@ -96,12 +96,12 @@ namespace linker.messenger.channel
                     return connection;
                 }
                 //不在线就不必连了
-                if (await signInClientTransfer.GetOnline(machineId) == false)
+                if (await signInClientTransfer.GetOnline(machineId).ConfigureAwait(false) == false)
                 {
                     return null;
                 }
 
-                connection = await RelayAndP2P(machineId, denyProtocols);
+                connection = await RelayAndP2P(machineId, denyProtocols).ConfigureAwait(false);
 
                 if (connection != null)
                 {
@@ -123,7 +123,7 @@ namespace linker.messenger.channel
         {
             //中继
             if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG) LoggerHelper.Instance.Debug($"{TransactionId} relay to {machineId}");
-            ITunnelConnection connection = await relayTransfer.ConnectAsync(signInClientStore.Id, machineId, TransactionId, relayClientStore.DefaultNodeId).ConfigureAwait(false);
+            ITunnelConnection connection = await relayTransfer.ConnectAsync(signInClientStore.Id, machineId, TransactionId, denyProtocols, relayClientStore.DefaultNodeId).ConfigureAwait(false);
             if (connection != null)
             {
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG) LoggerHelper.Instance.Debug($"{TransactionId} relay success,{connection.ToString()}");

src/linker.messenger.decenter/DecenterClientTransfer.cs

@@ -74,7 +74,7 @@ namespace linker.messenger.decenter
                     }).ToList();
                     if (tasks.Count > 0)
                     {
-                        await Task.WhenAll(tasks.Select(c => c.Task));
+                        await Task.WhenAll(tasks.Select(c => c.Task)).ConfigureAwait(false);
                         foreach (var task in tasks)
                         {
                             if (task.Task.Result.Code == MessageResponeCodes.OK)

src/linker.messenger.flow/FlowApiController.cs

@@ -31,7 +31,7 @@ namespace linker.messenger.flow
             {
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)FlowMessengerIds.List,
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
             {
                 return serializer.Deserialize<FlowInfo>(resp.Data.Span);
@@ -44,7 +44,7 @@ namespace linker.messenger.flow
             {
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)FlowMessengerIds.Citys,
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
             {
                 return serializer.Deserialize<List<FlowReportNetInfo>>(resp.Data.Span);
@@ -58,7 +58,7 @@ namespace linker.messenger.flow
             {
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)FlowMessengerIds.Messenger,
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
             {
                 return serializer.Deserialize<Dictionary<ushort, FlowItemInfo>>(resp.Data.Span);
@@ -77,7 +77,7 @@ namespace linker.messenger.flow
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)FlowMessengerIds.SForward,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
             {
                 return serializer.Deserialize<SForwardFlowResponseInfo>(resp.Data.Span);
@@ -96,7 +96,7 @@ namespace linker.messenger.flow
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)FlowMessengerIds.Relay,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
             {
                 return serializer.Deserialize<RelayFlowResponseInfo>(resp.Data.Span);

src/linker.messenger.flow/FlowResolver.cs

@@ -37,7 +37,7 @@ namespace linker.messenger.flow
 
         public async Task Resolve(Socket socket, Memory<byte> memory)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
         public async Task Resolve(Socket socket, IPEndPoint ep, Memory<byte> memory)
         {
@@ -63,7 +63,7 @@ namespace linker.messenger.flow
             {
             }
 
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
 
 

src/linker.messenger.forward/ForwardApiController.cs

@@ -95,7 +95,7 @@ namespace linker.messenger.forward
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)ForwardMessengerIds.GetForward,
                 Payload = serializer.Serialize(param.Content)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 return serializer.Deserialize<List<ForwardInfo>>(resp.Data.Span);
@@ -123,7 +123,7 @@ namespace linker.messenger.forward
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)ForwardMessengerIds.AddForward,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -146,7 +146,7 @@ namespace linker.messenger.forward
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)ForwardMessengerIds.RemoveForward,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -166,7 +166,7 @@ namespace linker.messenger.forward
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)ForwardMessengerIds.SubTestForward,
                 Payload = serializer.Serialize(param.Content)
-            });
+            }).ConfigureAwait(false);
             return true;
         }
     }

src/linker.messenger.forward/ForwardMessenger.cs

@@ -63,7 +63,7 @@ namespace linker.messenger.forward
                     Connection = cacheTo.Connection,
                     MessengerId = (ushort)ForwardMessengerIds.Add,
                     Payload = serializer.Serialize(info.Data)
-                });
+                }).ConfigureAwait(false);
             }
         }
         /// <summary>
@@ -82,7 +82,7 @@ namespace linker.messenger.forward
                     Connection = cacheTo.Connection,
                     MessengerId = (ushort)ForwardMessengerIds.Remove,
                     Payload = serializer.Serialize(info.Id)
-                });
+                }).ConfigureAwait(false);
             }
         }
 
@@ -97,7 +97,7 @@ namespace linker.messenger.forward
                 {
                     Connection = cacheTo.Connection,
                     MessengerId = (ushort)ForwardMessengerIds.SubTest
-                });
+                }).ConfigureAwait(false);
             }
         }
 

src/linker.messenger.forward/ForwardTransfer.cs

@@ -164,7 +164,7 @@ namespace linker.messenger.forward
                 return false;
             }
 
-            await Task.WhenAll(list.Select(Connect));
+            await Task.WhenAll(list.Select(Connect)).ConfigureAwait(false);
             testing.StopOperation();
             return true;
 
@@ -173,7 +173,7 @@ namespace linker.messenger.forward
                 Socket socket = new Socket(info.Target.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                 try
                 {
-                    await socket.ConnectAsync(info.Target).WaitAsync(TimeSpan.FromMilliseconds(100));
+                    await socket.ConnectAsync(info.Target).WaitAsync(TimeSpan.FromMilliseconds(100)).ConfigureAwait(false);
                     info.Msg = string.Empty;
                 }
                 catch (Exception ex)

src/linker.messenger.forward/proxy/ForwardProxyTunnel.cs

@@ -79,7 +79,7 @@ namespace linker.messenger.forward.proxy
         public async Task Closed(ITunnelConnection connection, object userToken)
         {
             Version.Add();
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
 
         /// <summary>

src/linker.messenger.pcp/PcpTransfer.cs

@@ -65,7 +65,7 @@ namespace linker.messenger.pcp
         {
             //TunnelTagInfo tag = new TunnelTagInfo { FromMachineId = signInClientStore.Id, ToMachineId = remoteMachineId, TransactionId = transactionId, NodeId = string.Empty, NodeIds = pcpStore.PcpHistory.History };
 
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return null;
         }
 

src/linker.messenger.relay/client/RelayApiController.cs

@@ -7,6 +7,7 @@ using linker.messenger.relay.client.transport;
 using linker.messenger.relay.messenger;
 using linker.messenger.relay.server;
 using linker.messenger.signin;
+using linker.tunnel.connection;
 
 namespace linker.messenger.relay
 {
@@ -52,7 +53,13 @@ namespace linker.messenger.relay
         public bool Connect(ApiControllerParamsInfo param)
         {
             RelayConnectInfo relayConnectInfo = param.Content.DeJson<RelayConnectInfo>();
-            _ = relayTransfer.ConnectAsync(relayConnectInfo.FromMachineId, relayConnectInfo.ToMachineId, relayConnectInfo.TransactionId, relayConnectInfo.NodeId);
+            if(relayConnectInfo.Protocol == TunnelProtocolType.None)
+            {
+                relayConnectInfo.Protocol = TunnelProtocolType.Tcp;
+            }
+            relayConnectInfo.ToMachineId = "67d67cb942b4da0c16b5f5ec";
+            relayConnectInfo.TransactionId = "tuntap";
+            _ = relayTransfer.ConnectAsync(relayConnectInfo.FromMachineId, relayConnectInfo.ToMachineId, relayConnectInfo.TransactionId, relayConnectInfo.NodeId, relayConnectInfo.Protocol);
             relayClientStore.SetDefaultNodeId(relayConnectInfo.NodeId);
             return true;
         }
@@ -65,7 +72,7 @@ namespace linker.messenger.relay
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)RelayMessengerIds.AccessCdkey,
                 Payload = serializer.Serialize(relayClientStore.Server.SecretKey)
-            });
+            }).ConfigureAwait(false);
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
 
@@ -82,7 +89,7 @@ namespace linker.messenger.relay
                     Data = info,
                     SecretKey = relayClientStore.Server.SecretKey
                 })
-            });
+            }).ConfigureAwait(false);
 
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
@@ -100,7 +107,7 @@ namespace linker.messenger.relay
                     UserId = signInClientStore.Server.UserId,
                     SecretKey = relayClientStore.Server.SecretKey
                 })
-            });
+            }).ConfigureAwait(false);
 
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
@@ -115,7 +122,7 @@ namespace linker.messenger.relay
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)RelayMessengerIds.PageCdkey,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 return serializer.Deserialize<RelayServerCdkeyPageResultInfo>(resp.Data.Span);
@@ -134,7 +141,7 @@ namespace linker.messenger.relay
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)RelayMessengerIds.PageCdkey,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 return serializer.Deserialize<RelayServerCdkeyPageResultInfo>(resp.Data.Span);
@@ -153,7 +160,7 @@ namespace linker.messenger.relay
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)RelayMessengerIds.TestCdkey,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 return serializer.Deserialize<RelayServerCdkeyTestResultInfo>(resp.Data.Span);
@@ -172,7 +179,7 @@ namespace linker.messenger.relay
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)RelayMessengerIds.ImportCdkey,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 return serializer.Deserialize<string>(resp.Data.Span);
@@ -191,7 +198,7 @@ namespace linker.messenger.relay
                     Info = info,
                     SecretKey = relayClientStore.Server.SecretKey
                 })
-            });
+            }).ConfigureAwait(false);
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
     }
@@ -202,6 +209,9 @@ namespace linker.messenger.relay
         public string ToMachineId { get; set; }
         public string TransactionId { get; set; }
         public string NodeId { get; set; }
+        public TunnelProtocolType Protocol { get; set; }
+
+
     }
 
 }

src/linker.messenger.relay/client/RelayClientTestTransfer.cs

@@ -48,7 +48,7 @@ namespace linker.messenger.relay
                         MachineId = signInClientStore.Id,
                         SecretKey = relayClientStore.Server.SecretKey,
                         UserId = signInClientStore.Server.UserId
-                    });
+                    }).ConfigureAwait(false);
                     var tasks = Nodes.Select(async (c) =>
                     {
                         IPEndPoint ep = c.EndPoint == null || c.EndPoint.Address.Equals(IPAddress.Any) ? signInClientState.Connection.Address : c.EndPoint;
@@ -57,7 +57,7 @@ namespace linker.messenger.relay
                         var resp = await ping.SendPingAsync(ep.Address, 1000);
                         c.Delay = resp.Status == IPStatus.Success ? (int)resp.RoundtripTime : -1;
                     });
-                    await Task.WhenAll(tasks);
+                    await Task.WhenAll(tasks).ConfigureAwait(false);
                 }
             }
             catch (Exception)
@@ -70,7 +70,7 @@ namespace linker.messenger.relay
             {
                 if (lastTicksManager.DiffLessEqual(3000))
                 {
-                    await TaskRelay();
+                    await TaskRelay().ConfigureAwait(false);
                 }
                 return true;
             }, 3000);

src/linker.messenger.relay/client/RelayClientTransfer.cs

@@ -14,7 +14,8 @@ namespace linker.messenger.relay.client
     {
         public List<IRelayClientTransport> Transports { get; private set; }
 
-        private ConcurrentDictionary<string, bool> connectingDic = new ConcurrentDictionary<string, bool>();
+        private OperatingMultipleManager operating = new OperatingMultipleManager();
+
         private Dictionary<string, List<Action<ITunnelConnection>>> OnConnected { get; } = new Dictionary<string, List<Action<ITunnelConnection>>>();
 
         private readonly IRelayClientStore relayClientStore;
@@ -25,6 +26,7 @@ namespace linker.messenger.relay.client
             this.signInClientStore = signInClientStore;
             Transports = new List<IRelayClientTransport> {
                 new RelayClientTransportSelfHost(messengerSender,serializer,relayClientStore,signInClientState,messengerStore),
+                new RelayClientTransportSelfHostUdp(messengerSender,serializer,relayClientStore,signInClientState,messengerStore),
             };
             LoggerHelper.Instance.Info($"load relay transport:{string.Join(",", Transports.Select(c => c.GetType().Name))}");
         }
@@ -55,6 +57,11 @@ namespace linker.messenger.relay.client
                 callbacks.Remove(callback);
             }
         }
+
+        public async Task<ITunnelConnection> ConnectAsync(string fromMachineId, string remoteMachineId, string transactionId, string nodeId, TunnelProtocolType protocol)
+        {
+            return await ConnectAsync(fromMachineId, remoteMachineId, transactionId, TunnelProtocolType.All & (~protocol), nodeId).ConfigureAwait(false);
+        }
         /// <summary>
         /// 中继连接对方
         /// </summary>
@@ -62,22 +69,26 @@ namespace linker.messenger.relay.client
         /// <param name="remoteMachineId">对方id</param>
         /// <param name="transactionId">事务</param>
         /// <returns></returns>
-        public async Task<ITunnelConnection> ConnectAsync(string fromMachineId, string remoteMachineId, string transactionId, string nodeId = "")
+        public async Task<ITunnelConnection> ConnectAsync(string fromMachineId, string remoteMachineId, string transactionId, TunnelProtocolType denyProtocols, string nodeId = "")
         {
-            if (connectingDic.TryAdd(remoteMachineId, true) == false)
+           
+            if (operating.StartOperation(remoteMachineId) == false)
             {
                 return null;
             }
-            try
+            if (relayClientStore.Server.Disabled)
             {
-                IRelayClientTransport transport = Transports.FirstOrDefault(c => c.Type == relayClientStore.Server.RelayType && relayClientStore.Server.Disabled == false);
-                if (transport == null)
-                {
-                    if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                        LoggerHelper.Instance.Error($"relay to {remoteMachineId} fail,transport not found {relayClientStore.Server.RelayType},{relayClientStore.Server.Disabled}");
                 return null;
             }
 
+            foreach (IRelayClientTransport transport in Transports.Where(c => denyProtocols.HasFlag(c.ProtocolType) == false))
+            {
+                if (transport == null)
+                {
+                    continue;
+                }
+                try
+                {
                     transport.RelayInfo170 relayInfo = new transport.RelayInfo170
                     {
                         FlowingId = 0,
@@ -95,19 +106,19 @@ namespace linker.messenger.relay.client
                     };
 
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                    LoggerHelper.Instance.Info($"relay to {relayInfo.RemoteMachineId}->{relayInfo.RemoteMachineName} {relayInfo.ToJson()}");
+                        LoggerHelper.Instance.Info($"relay {transport.Name} to {relayInfo.RemoteMachineId}->{relayInfo.RemoteMachineName} {relayInfo.ToJson()}");
                     ITunnelConnection connection = await transport.RelayAsync(relayInfo).ConfigureAwait(false);
                     if (connection != null)
                     {
                         if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                        LoggerHelper.Instance.Debug($"relay to {relayInfo.RemoteMachineId}->{relayInfo.RemoteMachineName} success,{relayInfo.ToJson()}");
+                            LoggerHelper.Instance.Debug($"relay {transport.Name} to {relayInfo.RemoteMachineId}->{relayInfo.RemoteMachineName} success,{relayInfo.ToJson()}");
                         ConnectedCallback(relayInfo, connection);
                         return connection;
                     }
                     else
                     {
                         if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                        LoggerHelper.Instance.Error($"relay to {relayInfo.RemoteMachineId}->{relayInfo.RemoteMachineName} fail,{relayInfo.ToJson()}");
+                            LoggerHelper.Instance.Error($"relay {transport.Name} to {relayInfo.RemoteMachineId}->{relayInfo.RemoteMachineName} fail,{relayInfo.ToJson()}");
                     }
 
                 }
@@ -117,9 +128,9 @@ namespace linker.messenger.relay.client
                 }
                 finally
                 {
-                connectingDic.TryRemove(remoteMachineId, out _);
+                    operating.StopOperation(remoteMachineId);
+                }
             }
-
             return null;
         }
         /// <summary>
@@ -129,7 +140,7 @@ namespace linker.messenger.relay.client
         /// <returns></returns>
         public async Task<bool> OnBeginAsync(transport.RelayInfo170 relayInfo)
         {
-            if (connectingDic.TryAdd(relayInfo.FromMachineId, true) == false)
+            if (operating.StartOperation(relayInfo.FromMachineId) == false)
             {
                 return false;
             }
@@ -164,7 +175,7 @@ namespace linker.messenger.relay.client
             }
             finally
             {
-                connectingDic.TryRemove(relayInfo.FromMachineId, out _);
+                operating.StopOperation(relayInfo.FromMachineId);
             }
             return false;
         }

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

@@ -11,6 +11,8 @@ using System.Security.Cryptography.X509Certificates;
 using System.Buffers;
 using linker.messenger.relay.server;
 using linker.messenger.signin;
+using System.Text;
+using System;
 
 namespace linker.messenger.relay.client.transport
 {
@@ -44,7 +46,7 @@ namespace linker.messenger.relay.client.transport
             try
             {
                 //问一下能不能中继
-                RelayAskResultInfo170 relayAskResultInfo = await RelayAsk(relayInfo);
+                RelayAskResultInfo170 relayAskResultInfo = await RelayAsk(relayInfo).ConfigureAwait(false);
                 relayInfo.FlowingId = relayAskResultInfo.FlowingId;
                 if (relayInfo.FlowingId == 0 || relayAskResultInfo.Nodes.Count == 0)
                 {
@@ -60,7 +62,7 @@ namespace linker.messenger.relay.client.transport
                 }
 
                 //连接中继节点服务器
-                Socket socket = await ConnectNodeServer(relayInfo, relayAskResultInfo.Nodes);
+                Socket socket = await ConnectNodeServer(relayInfo, relayAskResultInfo.Nodes).ConfigureAwait(false);
                 if (socket == null)
                 {
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
@@ -69,7 +71,7 @@ namespace linker.messenger.relay.client.transport
                 }
 
                 //让对方确认中继
-                if (await RelayConfirm(relayInfo) == false)
+                if (await RelayConfirm(relayInfo).ConfigureAwait(false) == false)
                 {
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                         LoggerHelper.Instance.Error($"relay confirm fail,flowid:{relayInfo.FlowingId},nodes:{relayAskResultInfo.Nodes.Count}");
@@ -171,13 +173,13 @@ namespace linker.messenger.relay.client.transport
                             ToId = relayInfo.RemoteMachineId,
                             NodeId = node.Id,
                         };
-                        await socket.SendAsync(new byte[] { (byte)ResolverType.Relay });
-                        await socket.SendAsync(serializer.Serialize(relayMessage));
+                        await socket.SendAsync(new byte[] { (byte)ResolverType.Relay }).ConfigureAwait(false);
+                        await socket.SendAsync(serializer.Serialize(relayMessage)).ConfigureAwait(false);
 
                         if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG) LoggerHelper.Instance.Debug($"relay  connected {ep}");
 
                         //是否允许连接
-                        int length = await socket.ReceiveAsync(buffer.AsMemory(0, 1));
+                        int length = await socket.ReceiveAsync(buffer.AsMemory(0, 1)).ConfigureAwait(false);
 
                         if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                             LoggerHelper.Instance.Debug($"relay  connected {ep}->{buffer[0]}");
@@ -219,7 +221,7 @@ namespace linker.messenger.relay.client.transport
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)RelayMessengerIds.RelayForward170,
                 Payload = serializer.Serialize(relayInfo),
-            });
+            }).ConfigureAwait(false);
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
 
@@ -246,8 +248,8 @@ namespace linker.messenger.relay.client.transport
                     ToId = relayInfo.RemoteMachineId,
                     NodeId = relayInfo.NodeId,
                 };
-                await socket.SendAsync(new byte[] { (byte)ResolverType.Relay });
-                await socket.SendAsync(serializer.Serialize(relayMessage));
+                await socket.SendAsync(new byte[] { (byte)ResolverType.Relay }).ConfigureAwait(false);
+                await socket.SendAsync(serializer.Serialize(relayMessage)).ConfigureAwait(false);
 
                 _ = WaitSSL(socket, relayInfo).ContinueWith((result) =>
                 {
@@ -337,6 +339,8 @@ namespace linker.messenger.relay.client.transport
         public RelayClientType Type => RelayClientType.Linker;
         public TunnelProtocolType ProtocolType => TunnelProtocolType.Udp;
 
+        private byte[] relayFlag = Encoding.UTF8.GetBytes($"{Helper.GlobalString}.relay.flag");
+
         private readonly IMessengerSender messengerSender;
         private readonly ISerializer serializer;
         private readonly IRelayClientStore relayClientStore;
@@ -358,7 +362,7 @@ namespace linker.messenger.relay.client.transport
             try
             {
                 //问一下能不能中继
-                RelayAskResultInfo170 relayAskResultInfo = await RelayAsk(relayInfo);
+                RelayAskResultInfo170 relayAskResultInfo = await RelayAsk(relayInfo).ConfigureAwait(false);
                 relayInfo.FlowingId = relayAskResultInfo.FlowingId;
                 if (relayInfo.FlowingId == 0 || relayAskResultInfo.Nodes.Count == 0)
                 {
@@ -374,7 +378,7 @@ namespace linker.messenger.relay.client.transport
                 }
 
                 //连接中继节点服务器
-                Socket socket = await ConnectNodeServer(relayInfo, relayAskResultInfo.Nodes);
+                var (socket, ep) = await ConnectNodeServer(relayInfo, relayAskResultInfo.Nodes).ConfigureAwait(false);
                 if (socket == null)
                 {
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
@@ -383,40 +387,29 @@ namespace linker.messenger.relay.client.transport
                 }
 
                 //让对方确认中继
-                if (await RelayConfirm(relayInfo) == false)
+                if (await RelayConfirm(relayInfo).ConfigureAwait(false) == false)
                 {
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                         LoggerHelper.Instance.Error($"relay confirm fail,flowid:{relayInfo.FlowingId},nodes:{relayAskResultInfo.Nodes.Count}");
                     return null;
                 }
 
-                //成功建立连接，
-                SslStream sslStream = null;
-                if (relayInfo.SSL)
+                return new TunnelConnectionUdp
                 {
-                    sslStream = new SslStream(new NetworkStream(socket, false), false, new RemoteCertificateValidationCallback(ValidateServerCertificate), null);
-                    await sslStream.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
-                    {
-                        EnabledSslProtocols = SslProtocols.Tls13 | SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls
-                    }).ConfigureAwait(false);
-                }
-
-                return new TunnelConnectionTcp
-                {
-                    Direction = TunnelDirection.Forward,
-                    ProtocolType = TunnelProtocolType.Tcp,
+                    UdpClient = socket,
+                    IPEndPoint = NetworkHelper.TransEndpointFamily(ep),
+                    TransactionId = relayInfo.TransactionId,
                     RemoteMachineId = relayInfo.RemoteMachineId,
                     RemoteMachineName = relayInfo.RemoteMachineName,
-                    Stream = sslStream,
-                    Socket = socket,
-                    Mode = TunnelMode.Client,
-                    IPEndPoint = NetworkHelper.TransEndpointFamily(socket.RemoteEndPoint as IPEndPoint),
-                    TransactionId = relayInfo.TransactionId,
                     TransportName = Name,
+                    Direction = TunnelDirection.Forward,
+                    ProtocolType = ProtocolType,
                     Type = TunnelType.Relay,
-                    NodeId = relayInfo.NodeId,
+                    Mode = TunnelMode.Client,
+                    Label = string.Empty,
+                    Receive = true,
                     SSL = relayInfo.SSL,
-                    BufferSize = 3
+                    Crypto = CryptoFactory.CreateSymmetric(relayInfo.RemoteMachineId)
                 };
             }
             catch (Exception ex)
@@ -452,9 +445,9 @@ namespace linker.messenger.relay.client.transport
             return result;
 
         }
-        private async Task<Socket> ConnectNodeServer(RelayInfo170 relayInfo, List<RelayServerNodeReportInfo170> nodes)
+        private async Task<(Socket, IPEndPoint)> ConnectNodeServer(RelayInfo170 relayInfo, List<RelayServerNodeReportInfo170> nodes)
         {
-            byte[] buffer = ArrayPool<byte>.Shared.Rent(1 * 1024);
+            byte[] buffer = ArrayPool<byte>.Shared.Rent(4 * 1024);
 
             try
             {
@@ -472,9 +465,8 @@ namespace linker.messenger.relay.client.transport
                             LoggerHelper.Instance.Debug($"connect relay server {ep}");
 
                         //连接中继服务器
-                        Socket socket = new Socket(ep.AddressFamily, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
-                        socket.KeepAlive();
-                        await socket.ConnectAsync(ep).WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
+                        Socket socket = new Socket(ep.AddressFamily, SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp);
+                        socket.WindowsUdpBug();
 
                         //建立关联
                         RelayMessageInfo relayMessage = new RelayMessageInfo
@@ -485,21 +477,18 @@ namespace linker.messenger.relay.client.transport
                             ToId = relayInfo.RemoteMachineId,
                             NodeId = node.Id,
                         };
-                        await socket.SendAsync(new byte[] { (byte)ResolverType.Relay });
-                        await socket.SendAsync(serializer.Serialize(relayMessage));
-
-                        if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG) LoggerHelper.Instance.Debug($"relay  connected {ep}");
+                        await socket.SendToAsync(BuildPacket(buffer, relayMessage), ep).ConfigureAwait(false);
                         
                         //是否允许连接
-                        int length = await socket.ReceiveAsync(buffer.AsMemory(0, 1));
-
+                        IPEndPoint temp = new IPEndPoint(IPAddress.Any, 0);
+                        SocketReceiveFromResult result = await socket.ReceiveFromAsync(buffer, temp).ConfigureAwait(false);
                         if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                             LoggerHelper.Instance.Debug($"relay  connected {ep}->{buffer[0]}");
                         if (buffer[0] == 0)
                         {
                             relayInfo.Server = node.EndPoint;
                             relayInfo.NodeId = node.Id;
-                            return socket;
+                            return (socket, ep);
                         }
                         socket.SafeClose();
                     }
@@ -523,8 +512,26 @@ namespace linker.messenger.relay.client.transport
             {
                 ArrayPool<byte>.Shared.Return(buffer);
             }
-            return null;
+            return (null, null);
         }
+        private Memory<byte> BuildPacket(byte[] buffer,RelayMessageInfo relayMessage)
+        {
+            int index = 0;
+            buffer[0] = (byte)ResolverType.Relay;
+            buffer[1] = (byte)RelayUdpStep.Connect;
+            buffer[2] = (byte)relayFlag.Length;
+            index += 3;
+
+            relayFlag.AsMemory().CopyTo(buffer.AsMemory(index));
+            index += relayFlag.Length;
+
+            byte[] bytes = serializer.Serialize(relayMessage);
+            bytes.AsMemory().CopyTo(buffer.AsMemory(index));
+            index += bytes.Length;
+
+            return buffer.AsMemory(0, index);
+        }
+
         private async Task<bool> RelayConfirm(RelayInfo170 relayInfo)
         {
             //通知对方去确认中继
@@ -533,24 +540,18 @@ namespace linker.messenger.relay.client.transport
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)RelayMessengerIds.RelayForward170,
                 Payload = serializer.Serialize(relayInfo),
-            });
+            }).ConfigureAwait(false);
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
 
-
-        private bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
-        {
-            return true;
-        }
         public async Task<bool> OnBeginAsync(RelayInfo170 relayInfo, Action<ITunnelConnection> callback)
         {
+            byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
             try
             {
                 IPEndPoint ep = relayInfo.Server == null || relayInfo.Server.Address.Equals(IPAddress.Any) ? signInClientState.Connection.Address : relayInfo.Server;
-
-                Socket socket = new Socket(ep.AddressFamily, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
-                socket.KeepAlive();
-                await socket.ConnectAsync(ep).WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
+                Socket socket = new Socket(ep.AddressFamily, SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp);
+                socket.WindowsUdpBug();
 
                 RelayMessageInfo relayMessage = new RelayMessageInfo
                 {
@@ -560,14 +561,25 @@ namespace linker.messenger.relay.client.transport
                     ToId = relayInfo.RemoteMachineId,
                     NodeId = relayInfo.NodeId,
                 };
-                await socket.SendAsync(new byte[] { (byte)ResolverType.Relay });
-                await socket.SendAsync(serializer.Serialize(relayMessage));
+                await socket.SendToAsync(BuildPacket(buffer, relayMessage), ep).ConfigureAwait(false);
 
-                _ = WaitSSL(socket, relayInfo).ContinueWith((result) =>
+                callback(new TunnelConnectionUdp
                 {
-                    callback(result.Result);
+                    UdpClient = socket,
+                    IPEndPoint = NetworkHelper.TransEndpointFamily(ep),
+                    TransactionId = relayInfo.TransactionId,
+                    RemoteMachineId = relayInfo.RemoteMachineId,
+                    RemoteMachineName = relayInfo.RemoteMachineName,
+                    TransportName = Name,
+                    Direction = TunnelDirection.Forward,
+                    ProtocolType = ProtocolType,
+                    Type = TunnelType.Relay,
+                    Mode = TunnelMode.Server,
+                    Label = string.Empty,
+                    Receive = true,
+                    SSL = relayInfo.SSL,
+                    Crypto = CryptoFactory.CreateSymmetric(relayInfo.RemoteMachineId)
                 });
-
                 return true;
             }
             catch (Exception ex)
@@ -578,48 +590,13 @@ namespace linker.messenger.relay.client.transport
                 }
                 callback(null);
             }
+            finally
+            {
+                ArrayPool<byte>.Shared.Return(buffer);
+            }
             return false;
         }
 
-        private async Task<TunnelConnectionTcp> WaitSSL(Socket socket, RelayInfo170 relayInfo)
-        {
-            try
-            {
-                SslStream sslStream = null;
-                if (relayInfo.SSL)
-                {
-                    sslStream = new SslStream(new NetworkStream(socket, false), false);
-                    await sslStream.AuthenticateAsServerAsync(messengerStore.Certificate, false, SslProtocols.Tls13 | SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls, false).ConfigureAwait(false);
-                }
-                return new TunnelConnectionTcp
-                {
-                    Direction = TunnelDirection.Reverse,
-                    ProtocolType = TunnelProtocolType.Tcp,
-                    RemoteMachineId = relayInfo.RemoteMachineId,
-                    RemoteMachineName = relayInfo.RemoteMachineName,
-                    Stream = sslStream,
-                    Socket = socket,
-                    Mode = TunnelMode.Server,
-                    IPEndPoint = NetworkHelper.TransEndpointFamily(socket.RemoteEndPoint as IPEndPoint),
-                    TransactionId = relayInfo.TransactionId,
-                    TransportName = Name,
-                    Type = TunnelType.Relay,
-                    NodeId = relayInfo.NodeId,
-                    SSL = relayInfo.SSL,
-                    BufferSize = 3,
-                };
-            }
-            catch (Exception ex)
-            {
-                if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                {
-                    LoggerHelper.Instance.Error(ex);
-                }
-                socket.SafeClose();
-            }
-            return null;
-        }
-
         public async Task<List<RelayServerNodeReportInfo170>> RelayTestAsync(RelayTestInfo170 relayTestInfo)
         {
             try

src/linker.messenger.relay/messenger/RelayMessenger.cs

@@ -5,8 +5,6 @@ using linker.messenger.relay.client;
 using linker.messenger.relay.server;
 using linker.messenger.signin;
 using linker.messenger.relay.server.validator;
-using linker.libs.extends;
-using System.Collections.Generic;
 
 namespace linker.messenger.relay.messenger
 {
@@ -76,7 +74,7 @@ namespace linker.messenger.relay.messenger
                 List<RelayServerNodeReportInfo> list = relayServerTransfer.GetNodes(validated).Select(c => (RelayServerNodeReportInfo)c).ToList();
 
                 return serializer.Serialize(list);
-            });
+            }).ConfigureAwait(false);
         }
         [MessengerId((ushort)RelayMessengerIds.RelayTest170)]
         public async Task RelayTest170(IConnection connection)
@@ -85,7 +83,7 @@ namespace linker.messenger.relay.messenger
             await RelayTest(connection, info, (validated) =>
             {
                 return serializer.Serialize(relayServerTransfer.GetNodes(validated));
-            });
+            }).ConfigureAwait(false);
         }
         private async Task RelayTest(IConnection connection, RelayTestInfo info, Func<bool, byte[]> data)
         {
@@ -101,7 +99,7 @@ namespace linker.messenger.relay.messenger
                 FromMachineName = cache.MachineName,
                 TransactionId = "test",
                 TransportName = "test",
-            }, cache, null);
+            }, cache, null).ConfigureAwait(false);
 
             connection.Write(data(string.IsNullOrWhiteSpace(result)));
         }
@@ -126,7 +124,7 @@ namespace linker.messenger.relay.messenger
             info.FromMachineName = cacheFrom.MachineName;
 
             RelayAskResultInfo result = new RelayAskResultInfo();
-            string error = await relayValidatorTransfer.Validate(info, cacheFrom, cacheTo);
+            string error = await relayValidatorTransfer.Validate(info, cacheFrom, cacheTo).ConfigureAwait(false);
             bool validated = string.IsNullOrWhiteSpace(error);
             result.Nodes = relayServerTransfer.GetNodes(validated).Select(c => (RelayServerNodeReportInfo)c).ToList();
 
@@ -153,14 +151,14 @@ namespace linker.messenger.relay.messenger
             info.FromMachineName = cacheFrom.MachineName;
 
             RelayAskResultInfo170 result = new RelayAskResultInfo170();
-            string error = await relayValidatorTransfer.Validate(info, cacheFrom, cacheTo);
+            string error = await relayValidatorTransfer.Validate(info, cacheFrom, cacheTo).ConfigureAwait(false);
             bool validated = string.IsNullOrWhiteSpace(error);
             result.Nodes = relayServerTransfer.GetNodes(validated);
 
             if (result.Nodes.Count > 0)
             {
                 List<RelayServerCdkeyInfo> cdkeys = info.UseCdkey
-                    ? (await relayServerCdkeyStore.GetAvailable(info.UserId)).Select(c => new RelayServerCdkeyInfo { Bandwidth = c.Bandwidth, Id = c.Id, LastBytes = c.LastBytes }).ToList()
+                    ? (await relayServerCdkeyStore.GetAvailable(info.UserId).ConfigureAwait(false)).Select(c => new RelayServerCdkeyInfo { Bandwidth = c.Bandwidth, Id = c.Id, LastBytes = c.LastBytes }).ToList()
                     : new List<RelayServerCdkeyInfo>();
 
                 result.FlowingId = relayServerTransfer.AddRelay(cacheFrom.MachineId, cacheFrom.MachineName, cacheTo.MachineId, cacheTo.MachineName, cacheFrom.GroupId, validated, cdkeys);
@@ -181,7 +179,7 @@ namespace linker.messenger.relay.messenger
             await RelayForward(connection, info, () =>
             {
                 return serializer.Serialize(info);
-            });
+            }).ConfigureAwait(false);
         }
         [MessengerId((ushort)RelayMessengerIds.RelayForward170)]
         public async Task RelayForward170(IConnection connection)
@@ -190,7 +188,7 @@ namespace linker.messenger.relay.messenger
             await RelayForward(connection, info, () =>
             {
                 return serializer.Serialize(info);
-            });
+            }).ConfigureAwait(false);
         }
         public async Task RelayForward(IConnection connection, RelayInfo info, Func<byte[]> data)
         {
@@ -207,7 +205,7 @@ namespace linker.messenger.relay.messenger
                 info.FromMachineId = cacheFrom.MachineId;
                 info.RemoteMachineName = cacheTo.MachineName;
                 info.FromMachineName = cacheFrom.MachineName;
-                string result = await relayValidatorTransfer.Validate(info, cacheFrom, cacheTo);
+                string result = await relayValidatorTransfer.Validate(info, cacheFrom, cacheTo).ConfigureAwait(false);
                 if (string.IsNullOrWhiteSpace(result) == false)
                 {
                     connection.Write(Helper.FalseArray);
@@ -292,7 +290,7 @@ namespace linker.messenger.relay.messenger
             RelayServerNodeUpdateWrapInfo info = serializer.Deserialize<RelayServerNodeUpdateWrapInfo>(connection.ReceiveRequestWrap.Payload.Span);
             if (info.SecretKey == relayServerStore.SecretKey)
             {
-                await relayServerTransfer.UpdateNodeReport(info.Info);
+                await relayServerTransfer.UpdateNodeReport(info.Info).ConfigureAwait(false);
                 connection.Write(Helper.TrueArray);
             }
             else
@@ -356,7 +354,7 @@ namespace linker.messenger.relay.messenger
                 return;
             }
 
-            await relayServerCdkeyStore.Add(info.Data);
+            await relayServerCdkeyStore.Add(info.Data).ConfigureAwait(false);
             connection.Write(Helper.TrueArray);
         }
 
@@ -376,11 +374,11 @@ namespace linker.messenger.relay.messenger
             }
             if (relayServerStore.SecretKey == info.SecretKey)
             {
-                await relayServerCdkeyStore.Del(info.Id);
+                await relayServerCdkeyStore.Del(info.Id).ConfigureAwait(false);
             }
             else
             {
-                await relayServerCdkeyStore.Del(info.Id, info.UserId);
+                await relayServerCdkeyStore.Del(info.Id, info.UserId).ConfigureAwait(false);
             }
             connection.Write(Helper.TrueArray);
         }
@@ -405,7 +403,7 @@ namespace linker.messenger.relay.messenger
                 return;
             }
 
-            var page = await relayServerCdkeyStore.Page(info);
+            var page = await relayServerCdkeyStore.Page(info).ConfigureAwait(false);
 
             connection.Write(serializer.Serialize(page));
         }
@@ -430,7 +428,7 @@ namespace linker.messenger.relay.messenger
                 connection.Write(serializer.Serialize(new RelayServerCdkeyTestResultInfo { }));
                 return;
             }
-            RelayServerCdkeyTestResultInfo test = await relayServerCdkeyStore.Test(info);
+            RelayServerCdkeyTestResultInfo test = await relayServerCdkeyStore.Test(info).ConfigureAwait(false);
             connection.Write(serializer.Serialize(test));
         }
 
@@ -448,7 +446,7 @@ namespace linker.messenger.relay.messenger
                 connection.Write(Helper.FalseArray);
                 return;
             }
-            string result = await relayServerCdkeyStore.Import(info);
+            string result = await relayServerCdkeyStore.Import(info).ConfigureAwait(false);
             connection.Write(serializer.Serialize(result));
         }
     }

src/linker.messenger.relay/server/IRelayServerNodeStore.cs

@@ -2,6 +2,7 @@
 using System.Net;
 using linker.libs.extends;
 using System.Text.Json.Serialization;
+using linker.tunnel.connection;
 
 namespace linker.messenger.relay.server
 {
@@ -80,6 +81,9 @@ namespace linker.messenger.relay.server
         public string MasterSecretKey { get; set; } = string.Empty;
 #endif
         public string Url { get; set; } = "https://linker-doc.snltty.com";
+
+        public bool AllowTcp { get; set; } = true;
+        public bool AllowUdp { get; set; } = false;
     }
 
     public sealed partial class RelayServerNodeUpdateWrapInfo
@@ -100,6 +104,9 @@ namespace linker.messenger.relay.server
         public bool Public { get; set; }
 
         public string Url { get; set; } = "https://linker-doc.snltty.com";
+
+        public bool AllowTcp { get; set; } = true;
+        public bool AllowUdp { get; set; } = false;
     }
     public partial class RelayServerNodeReportInfo
     {
@@ -123,9 +130,10 @@ namespace linker.messenger.relay.server
 
         public long LastTicks { get; set; }
     }
-    public sealed partial class RelayServerNodeReportInfo170: RelayServerNodeReportInfo
+    public sealed partial class RelayServerNodeReportInfo170 : RelayServerNodeReportInfo
     {
         public string Url { get; set; } = "https://linker-doc.snltty.com";
+        public TunnelProtocolType AllowProtocol { get; set; } = TunnelProtocolType.Tcp;
 
         [JsonIgnore]
         public IConnection Connection { get; set; }

src/linker.messenger.relay/server/RelayServerMasterTransfer.cs

@@ -109,7 +109,7 @@ namespace linker.messenger.relay.server
                     Connection = cache.Connection,
                     MessengerId = (ushort)RelayMessengerIds.UpdateNode,
                     Payload = serializer.Serialize(info)
-                });
+                }).ConfigureAwait(false);
             }
         }
 
@@ -198,7 +198,7 @@ namespace linker.messenger.relay.server
                             Connection = c.Connection,
                             MessengerId = (ushort)RelayMessengerIds.SendLastBytes,
                             Payload = bytes,
-                        })).ToList());
+                        })).ToList()).ConfigureAwait(false);
                     }
                     catch (Exception ex)
                     {

src/linker.messenger.relay/server/RelayServerNodeTransfer.cs

@@ -1,6 +1,7 @@
 using linker.libs;
 using linker.libs.extends;
 using linker.messenger.relay.messenger;
+using linker.tunnel.connection;
 using System.Buffers;
 using System.Collections.Concurrent;
 using System.Net;
@@ -16,7 +17,7 @@ namespace linker.messenger.relay.server
         /// <summary>
         /// 配置了就用配置的，每配置就用一个默认的
         /// </summary>
-        public RelayServerNodeInfo node = null;
+        public RelayServerNodeInfo node => relayServerNodeStore.Node;
 
         private uint connectionNum = 0;
         private IConnection connection;
@@ -40,21 +41,14 @@ namespace linker.messenger.relay.server
             this.messengerResolver = messengerResolver;
             this.messengerSender = messengerSender;
 
-            node = string.IsNullOrWhiteSpace(relayServerNodeStore.Node.MasterHost) ? new RelayServerNodeInfo
+            if (string.IsNullOrWhiteSpace(relayServerNodeStore.Node.MasterHost))
             {
-                Id = "824777CF-2804-83FE-DE71-69B7B7D3BBA7",
-                Host = new IPEndPoint(IPAddress.Any, relayServerNodeStore.ServicePort).ToString(),
-                MasterHost = new IPEndPoint(IPAddress.Loopback, relayServerNodeStore.ServicePort).ToString(),
-                MasterSecretKey = relayServerMasterStore.Master.SecretKey,
-                MaxBandwidth = 0,
-                MaxConnection = 0,
-                MaxBandwidthTotal = 0,
-                MaxGbTotal = 0,
-                MaxGbTotalLastBytes = 0,
-                MaxGbTotalMonth = 0,
-                Name = "default",
-                Public = false,
-            } : relayServerNodeStore.Node;
+                relayServerNodeStore.Node.Host = new IPEndPoint(IPAddress.Any, relayServerNodeStore.ServicePort).ToString();
+                relayServerNodeStore.Node.MasterHost = new IPEndPoint(IPAddress.Loopback, relayServerNodeStore.ServicePort).ToString();
+                relayServerNodeStore.Node.MasterSecretKey = relayServerMasterStore.Master.SecretKey;
+                relayServerNodeStore.Node.Name = "default";
+                relayServerNodeStore.Node.Public = false;
+            }
 
             limitTotal.SetLimit((uint)Math.Ceiling((node.MaxBandwidthTotal * 1024 * 1024) / 8.0));
 
@@ -64,6 +58,8 @@ namespace linker.messenger.relay.server
 
         }
 
+
+
         public async ValueTask<RelayCacheInfo> TryGetRelayCache(string key)
         {
             try
@@ -73,7 +69,7 @@ namespace linker.messenger.relay.server
                     Connection = connection,
                     MessengerId = (ushort)RelayMessengerIds.NodeGetCache,
                     Payload = serializer.Serialize(key)
-                });
+                }).ConfigureAwait(false);
                 if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
                 {
                     return serializer.Deserialize<RelayCacheInfo>(resp.Data.Span);
@@ -90,9 +86,20 @@ namespace linker.messenger.relay.server
         public void UpdateNode(RelayServerNodeUpdateInfo info)
         {
             if (info.Id == node.Id)
+            {
                 relayServerNodeStore.UpdateInfo(info);
+                relayServerNodeStore.Confirm();
+            }
         }
 
+
+        public bool Validate(TunnelProtocolType tunnelProtocolType)
+        {
+            if (tunnelProtocolType == TunnelProtocolType.Udp && node.AllowUdp == false) return false;
+            if (tunnelProtocolType == TunnelProtocolType.Tcp && node.AllowTcp == false) return false;
+
+            return true;
+        }
         /// <summary>
         /// 无效请求
         /// </summary>
@@ -296,7 +303,7 @@ namespace linker.messenger.relay.server
                     SecretKey = node.MasterSecretKey
                 }),
                 Timeout = 4000
-            });
+            }).ConfigureAwait(false);
 
             if (result)
             {
@@ -320,7 +327,7 @@ namespace linker.messenger.relay.server
                 try
                 {
                     ResetNodeBytes();
-                    await UploadBytes();
+                    await UploadBytes().ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -339,7 +346,7 @@ namespace linker.messenger.relay.server
 
                 try
                 {
-                    IPEndPoint endPoint = await NetworkHelper.GetEndPointAsync(node.Host, relayServerNodeStore.ServicePort) ?? new IPEndPoint(IPAddress.Any, relayServerNodeStore.ServicePort);
+                    IPEndPoint endPoint = await NetworkHelper.GetEndPointAsync(node.Host, relayServerNodeStore.ServicePort).ConfigureAwait(false) ?? new IPEndPoint(IPAddress.Any, relayServerNodeStore.ServicePort);
                     RelayServerNodeReportInfo170 relayNodeReportInfo = new RelayServerNodeReportInfo170
                     {
                         Id = node.Id,
@@ -353,14 +360,16 @@ namespace linker.messenger.relay.server
                         MaxConnection = node.MaxConnection,
                         ConnectionRatio = connectionNum,
                         EndPoint = endPoint,
-                        Url = node.Url
+                        Url = node.Url,
+                        AllowProtocol = (node.AllowTcp ? TunnelProtocolType.Tcp :TunnelProtocolType.None)
+                         | (node.AllowUdp ? TunnelProtocolType.Udp : TunnelProtocolType.None)
                     };
                     await messengerSender.SendOnly(new MessageRequestWrap
                     {
                         Connection = connection,
                         MessengerId = (ushort)RelayMessengerIds.NodeReport,
                         Payload = serializer.Serialize(relayNodeReportInfo)
-                    });
+                    }).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -395,7 +404,7 @@ namespace linker.messenger.relay.server
                 secretKeyBytes.AsSpan().CopyTo(bytes.AsSpan(1));
 
 
-                IPEndPoint remote = await NetworkHelper.GetEndPointAsync(host, 1802);
+                IPEndPoint remote = await NetworkHelper.GetEndPointAsync(host, 1802).ConfigureAwait(false);
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                 {
                     LoggerHelper.Instance.Warning($"relay node sign in to {remote}");

src/linker.messenger.relay/server/RelayServerReportResolver.cs

@@ -48,7 +48,7 @@ namespace linker.messenger.relay.server
 
                 if (relayServerMasterStore.Master.SecretKey.Md5() == key)
                 {
-                    await messengerResolver.BeginReceiveServer(socket, Helper.EmptyArray);
+                    await messengerResolver.BeginReceiveServer(socket, Helper.EmptyArray).ConfigureAwait(false);
                 }
                 else
                 {
@@ -71,7 +71,7 @@ namespace linker.messenger.relay.server
 
         public async Task Resolve(Socket socket, IPEndPoint ep, Memory<byte> memory)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
     }
 }

src/linker.messenger.relay/server/RelayServerResolver.cs

@@ -5,6 +5,7 @@ using System.Collections.Concurrent;
 using System.Net;
 using linker.libs;
 using System;
+using System.Text;
 
 namespace linker.messenger.relay.server
 {
@@ -17,6 +18,9 @@ namespace linker.messenger.relay.server
 
         private readonly RelayServerNodeTransfer relayServerNodeTransfer;
         private readonly ISerializer serializer;
+
+        private string relayFlag = $"{Helper.GlobalString}.relay.flag";
+
         public RelayServerResolver(RelayServerNodeTransfer relayServerNodeTransfer, ISerializer serializer)
         {
             this.relayServerNodeTransfer = relayServerNodeTransfer;
@@ -44,6 +48,11 @@ namespace linker.messenger.relay.server
 
         public async Task Resolve(Socket socket, IPEndPoint ep, Memory<byte> memory)
         {
+            if (relayServerNodeTransfer.Validate(tunnel.connection.TunnelProtocolType.Udp) == false)
+            {
+                return;
+            }
+
             RelayUdpStep step = (RelayUdpStep)memory.Span[0];
             memory = memory.Slice(1);
 
@@ -52,22 +61,30 @@ namespace linker.messenger.relay.server
                 if (udpNat.TryGetValue(ep, out RelayUdpNatInfo natTarget) && natTarget.Target != null)
                 {
                     natTarget.LastTicks = Environment.TickCount64;
-                    await CopyToAsync(natTarget, socket,ep,memory);
+                    await CopyToAsync(natTarget, socket, ep, memory).ConfigureAwait(false);
                 }
                 return;
             }
 
+            byte flagLength = memory.Span[0];
+            if(Encoding.UTF8.GetString(memory.Slice(1, flagLength).Span) != relayFlag)
+            {
+                await socket.SendToAsync(new byte[] { 1 }, ep).ConfigureAwait(false);
+                return;
+            }
+            memory = memory.Slice(1 + flagLength);
+
             RelayMessageInfo relayMessage = serializer.Deserialize<RelayMessageInfo>(memory.Span);
 
             //ask 是发起端来的，那key就是 发起端->目标端， answer的，目标和来源会交换，所以转换一下
             string key = relayMessage.Type == RelayMessengerType.Ask ? $"{relayMessage.FromId}->{relayMessage.ToId}->{relayMessage.FlowId}" : $"{relayMessage.ToId}->{relayMessage.FromId}->{relayMessage.FlowId}";
             //获取缓存
-            RelayCacheInfo relayCache = await relayServerNodeTransfer.TryGetRelayCache(key);
+            RelayCacheInfo relayCache = await relayServerNodeTransfer.TryGetRelayCache(key).ConfigureAwait(false);
             if (relayCache == null)
             {
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                     LoggerHelper.Instance.Error($"relay {relayMessage.Type} get cache fail,flowid:{relayMessage.FlowId}");
-                await socket.SendToAsync(new byte[] { 1 }, ep);
+                await socket.SendToAsync(new byte[] { 1 }, ep).ConfigureAwait(false);
                 return;
             }
 
@@ -75,13 +92,12 @@ namespace linker.messenger.relay.server
             {
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                     LoggerHelper.Instance.Error($"relay {relayMessage.Type} Validate false,flowid:{relayMessage.FlowId}");
-                await socket.SendToAsync(new byte[] { 1 }, ep);
+                await socket.SendToAsync(new byte[] { 1 }, ep).ConfigureAwait(false);
                 return;
             }
 
             //流量统计
             AddReceive(relayCache.FromId, relayCache.FromName, relayCache.ToName, relayCache.GroupId, memory.Length);
-
             //回应
             if (relayMessage.Type == RelayMessengerType.Answer)
             {
@@ -104,6 +120,8 @@ namespace linker.messenger.relay.server
             relayServerNodeTransfer.AddTrafficCache(trafficCacheInfo);
             relayServerNodeTransfer.IncrementConnectionNum();
 
+            await socket.SendToAsync(new byte[] { 0 }, ep).ConfigureAwait(false);
+
         }
         private async Task CopyToAsync(RelayUdpNatInfo nat, Socket socket, IPEndPoint ep, Memory<byte> memory)
         {
@@ -133,6 +151,12 @@ namespace linker.messenger.relay.server
 
         public async Task Resolve(Socket socket, Memory<byte> memory)
         {
+            if (relayServerNodeTransfer.Validate(tunnel.connection.TunnelProtocolType.Tcp) == false)
+            {
+                socket.SafeClose();
+                return;
+            }
+
             byte[] buffer1 = new byte[8 * 1024];
             try
             {
@@ -142,12 +166,12 @@ namespace linker.messenger.relay.server
                 //ask 是发起端来的，那key就是 发起端->目标端， answer的，目标和来源会交换，所以转换一下
                 string key = relayMessage.Type == RelayMessengerType.Ask ? $"{relayMessage.FromId}->{relayMessage.ToId}->{relayMessage.FlowId}" : $"{relayMessage.ToId}->{relayMessage.FromId}->{relayMessage.FlowId}";
                 //获取缓存
-                RelayCacheInfo relayCache = await relayServerNodeTransfer.TryGetRelayCache(key);
+                RelayCacheInfo relayCache = await relayServerNodeTransfer.TryGetRelayCache(key).ConfigureAwait(false);
                 if (relayCache == null)
                 {
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                         LoggerHelper.Instance.Error($"relay {relayMessage.Type} get cache fail,flowid:{relayMessage.FlowId}");
-                    await socket.SendAsync(new byte[] { 1 });
+                    await socket.SendAsync(new byte[] { 1 }).ConfigureAwait(false);
                     socket.SafeClose();
                     return;
                 }
@@ -156,7 +180,7 @@ namespace linker.messenger.relay.server
                 {
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                         LoggerHelper.Instance.Error($"relay {relayMessage.Type} validate false,flowid:{relayMessage.FlowId}");
-                    await socket.SendAsync(new byte[] { 1 });
+                    await socket.SendAsync(new byte[] { 1 }).ConfigureAwait(false);
                     socket.SafeClose();
                     return;
                 }
@@ -179,11 +203,11 @@ namespace linker.messenger.relay.server
 
                 try
                 {
-                    await socket.SendAsync(new byte[] { 0 });
+                    await socket.SendAsync(new byte[] { 0 }).ConfigureAwait(false);
 
                     TaskCompletionSource<Socket> tcs = new TaskCompletionSource<Socket>();
                     relayDic.TryAdd(relayCache.FlowId, tcs);
-                    Socket answerSocket = await tcs.Task.WaitAsync(TimeSpan.FromMilliseconds(15000));
+                    Socket answerSocket = await tcs.Task.WaitAsync(TimeSpan.FromMilliseconds(15000)).ConfigureAwait(false);
 
                     byte[] buffer2 = new byte[8 * 1024];
                     RelayTrafficCacheInfo trafficCacheInfo = new RelayTrafficCacheInfo { Cache = relayCache, Sendt = 0, Limit = new RelaySpeedLimit() };

src/linker.messenger.relay/server/validator/RelayServerValidatorSecretKey.cs

@@ -20,7 +20,7 @@ namespace linker.messenger.relay.server.validator
                 return $"SecretKey validate fail";
             }
 
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
     }

src/linker.messenger.relay/server/validator/RelayServerValidatorTransfer.cs

@@ -51,7 +51,7 @@ namespace linker.messenger.relay.server.validator
         {
             foreach (var item in validators)
             {
-                string result = await item.Validate(relayInfo, cache, cache1);
+                string result = await item.Validate(relayInfo, cache, cache1).ConfigureAwait(false);
                 if (string.IsNullOrWhiteSpace(result) == false)
                 {
                     return result;

src/linker.messenger.serializer.memorypack/RelaySerializer.cs

@@ -1,5 +1,6 @@
 using linker.messenger.relay.client.transport;
 using linker.messenger.relay.server;
+using linker.tunnel.connection;
 using MemoryPack;
 using System.Net;
 using System.Xml.Linq;
@@ -321,12 +322,17 @@ namespace linker.messenger.serializer.memorypack
         [MemoryPackInclude]
         string Url => info.Url;
 
+        [MemoryPackInclude]
+        bool AllowTcp => info.AllowTcp;
+        [MemoryPackInclude]
+        bool AllowUdp => info.AllowUdp;
+
         [MemoryPackConstructor]
         SerializableRelayServerNodeUpdateInfo(
             string id, string name,
             int maxConnection, double maxBandwidth, double maxBandwidthTotal,
             double maxGbTotal, long maxGbTotalLastBytes,
-            bool Public, string url)
+            bool Public, string url, bool allowTcp, bool allowUdp)
         {
             var info = new RelayServerNodeUpdateInfo
             {
@@ -338,7 +344,9 @@ namespace linker.messenger.serializer.memorypack
                 MaxGbTotalLastBytes = maxGbTotalLastBytes,
                 Name = name,
                 Public = Public,
-                Url = url
+                Url = url,
+                AllowTcp = allowTcp,
+                AllowUdp = allowUdp,
             };
             this.info = info;
         }
@@ -558,6 +566,9 @@ namespace linker.messenger.serializer.memorypack
         [MemoryPackInclude]
         string Url => info.Url;
 
+        [MemoryPackInclude]
+        TunnelProtocolType AllowProtocol => info.AllowProtocol;
+
 
         [MemoryPackConstructor]
         SerializableRelayServerNodeReportInfo170(
@@ -566,7 +577,7 @@ namespace linker.messenger.serializer.memorypack
             double maxGbTotal, long maxGbTotalLastBytes,
             double connectionRatio, double bandwidthRatio,
             bool Public, int delay,
-            IPEndPoint endPoint, long lastTicks, string url)
+            IPEndPoint endPoint, long lastTicks, string url, TunnelProtocolType allowProtocol)
         {
             var info = new RelayServerNodeReportInfo170
             {
@@ -583,7 +594,8 @@ namespace linker.messenger.serializer.memorypack
                 MaxGbTotalLastBytes = maxGbTotalLastBytes,
                 Name = name,
                 Public = Public,
-                Url = url
+                Url = url,
+                AllowProtocol = allowProtocol
             };
             this.info = info;
         }

src/linker.messenger.sforward/client/SForwardApiController.cs

@@ -93,7 +93,7 @@ namespace linker.messenger.sforward.client
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)SForwardMessengerIds.GetForward,
                 Payload = serializer.Serialize(param.Content)
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 return serializer.Deserialize<List<SForwardInfo>>(resp.Data.Span);
@@ -120,7 +120,7 @@ namespace linker.messenger.sforward.client
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)SForwardMessengerIds.AddClientForward,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -142,7 +142,7 @@ namespace linker.messenger.sforward.client
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)SForwardMessengerIds.RemoveClientForward,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -162,7 +162,7 @@ namespace linker.messenger.sforward.client
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)SForwardMessengerIds.TestClientForward,
                 Payload = serializer.Serialize(param.Content)
-            });
+            }).ConfigureAwait(false);
             return true;
         }
 

src/linker.messenger.sforward/client/SForwardClientTransfer.cs

@@ -168,7 +168,7 @@ namespace linker.messenger.sforward.client
                 Socket socket = new Socket(info.LocalEP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                 try
                 {
-                    await socket.ConnectAsync(info.LocalEP).WaitAsync(TimeSpan.FromMilliseconds(500));
+                    await socket.ConnectAsync(info.LocalEP).WaitAsync(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
                     sForwardClientStore.Update(info.Id, string.Empty);
                     return true;
                 }

src/linker.messenger.sforward/messenger/SForwardMessenger.cs

@@ -57,7 +57,7 @@ namespace linker.plugins.sforward.messenger
 
             try
             {
-                string error = await validator.Validate(cache, sForwardAddInfo);
+                string error = await validator.Validate(cache, sForwardAddInfo).ConfigureAwait(false);
                 if (string.IsNullOrWhiteSpace(error) == false)
                 {
                     result.Success = false;
@@ -160,7 +160,7 @@ namespace linker.plugins.sforward.messenger
             }
             try
             {
-                string error = await validator.Validate(cache, sForwardAddInfo);
+                string error = await validator.Validate(cache, sForwardAddInfo).ConfigureAwait(false);
                 if (string.IsNullOrWhiteSpace(error) == false)
                 {
                     result.Success = false;
@@ -256,7 +256,7 @@ namespace linker.plugins.sforward.messenger
                     Connection = cacheTo.Connection,
                     MessengerId = (ushort)SForwardMessengerIds.AddClient,
                     Payload = serializer.Serialize(info.Data)
-                });
+                }).ConfigureAwait(false);
             }
         }
         /// <summary>
@@ -275,7 +275,7 @@ namespace linker.plugins.sforward.messenger
                     Connection = cacheTo.Connection,
                     MessengerId = (ushort)SForwardMessengerIds.RemoveClient,
                     Payload = serializer.Serialize(info.Id)
-                });
+                }).ConfigureAwait(false);
             }
         }
 
@@ -294,7 +294,7 @@ namespace linker.plugins.sforward.messenger
                 {
                     Connection = cacheTo.Connection,
                     MessengerId = (ushort)SForwardMessengerIds.TestClientForward
-                });
+                }).ConfigureAwait(false);
             }
         }
 

src/linker.messenger.sforward/proxy/SForwardProxyTcp.cs

@@ -12,8 +12,8 @@ namespace linker.plugins.sforward.proxy
         private ConcurrentDictionary<int, AsyncUserToken> tcpListens = new ConcurrentDictionary<int, AsyncUserToken>();
         private ConcurrentDictionary<ulong, TaskCompletionSource<Socket>> tcpConnections = new ConcurrentDictionary<ulong, TaskCompletionSource<Socket>>();
 
-        public Func<int, ulong, Task<bool>> TunnelConnect { get; set; } = async (port, id) => { return await Task.FromResult(false); };
-        public Func<string, int, ulong, Task<bool>> WebConnect { get; set; } = async (host, port, id) => { return await Task.FromResult(false); };
+        public Func<int, ulong, Task<bool>> TunnelConnect { get; set; } = async (port, id) => { return await Task.FromResult(false).ConfigureAwait(false); };
+        public Func<string, int, ulong, Task<bool>> WebConnect { get; set; } = async (host, port, id) => { return await Task.FromResult(false).ConfigureAwait(false); };
 
         #region 服务端
 

src/linker.messenger.sforward/proxy/SForwardProxyUdp.cs

@@ -19,7 +19,7 @@ namespace linker.plugins.sforward.proxy
         //本地服务表，其实不必要，只是缓存一下去定时检测过期没有
         private ConcurrentDictionary<ulong, UdpConnectedCache> udpConnecteds = new ConcurrentDictionary<ulong, UdpConnectedCache>();
 
-        public Func<int, ulong, Task<bool>> UdpConnect { get; set; } = async (port, id) => { return await Task.FromResult(false); };
+        public Func<int, ulong, Task<bool>> UdpConnect { get; set; } = async (port, id) => { return await Task.FromResult(false).ConfigureAwait(false); };
 
         #region 服务端
 

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

@@ -29,7 +29,7 @@ namespace linker.messenger.sforward.server.validator
                     return $"sforward tunnel port range {string.Join("-", sForwardServerStore.TunnelPortRange)}";
                 }
             }
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
     }

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

@@ -48,7 +48,7 @@ namespace linker.messenger.sforward.server.validator
         {
             foreach (var item in validators)
             {
-                string result = await item.Validate(signCacheInfo, sForwardAddInfo);
+                string result = await item.Validate(signCacheInfo, sForwardAddInfo).ConfigureAwait(false);
                 if (string.IsNullOrWhiteSpace(result) == false)
                 {
                     return result;

src/linker.messenger.signin/SignInClientTransfer.cs

@@ -76,12 +76,12 @@ namespace linker.messenger.signin
 
             try
             {
-                await clientSignInState.PushSignInBefore();
+                await clientSignInState.PushSignInBefore().ConfigureAwait(false);
 
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                     LoggerHelper.Instance.Info($"connect to signin server:{signInClientStore.Server.Host}");
 
-                IPEndPoint ip = await NetworkHelper.GetEndPointAsync(signInClientStore.Server.Host, 1802);
+                IPEndPoint ip = await NetworkHelper.GetEndPointAsync(signInClientStore.Server.Host, 1802).ConfigureAwait(false);
                 if (ip == null)
                 {
                     if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
@@ -136,7 +136,7 @@ namespace linker.messenger.signin
         private async Task<bool> SignIn2Server()
         {
             Dictionary<string, string> args = [];
-            string argResult = await signInArgsTransfer.Invoke(signInClientStore.Server.Host, args);
+            string argResult = await signInArgsTransfer.Invoke(signInClientStore.Server.Host, args).ConfigureAwait(false);
             if (string.IsNullOrWhiteSpace(argResult) == false)
             {
                 LoggerHelper.Instance.Error(argResult);
@@ -226,7 +226,7 @@ namespace linker.messenger.signin
                 MessengerId = (ushort)SignInMessengerIds.Online,
                 Payload = serializer.Serialize(machineId),
                 Timeout = 3000
-            });
+            }).ConfigureAwait(false);
 
             return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
         }
@@ -241,7 +241,7 @@ namespace linker.messenger.signin
                 Connection = clientSignInState.Connection,
                 MessengerId = (ushort)SignInMessengerIds.NewId,
                 Timeout = 3000
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 return serializer.Deserialize<string>(resp.Data.Span);

src/linker.messenger.signin/SignInMessenger.cs

@@ -63,7 +63,7 @@ namespace linker.messenger.signin
             LoggerHelper.Instance.Info($"sign in from >=v131 {connection.Address}->{info.ToJson()}");
 
             info.Connection = connection;
-            string msg = await signCaching.Sign(info);
+            string msg = await signCaching.Sign(info).ConfigureAwait(false);
 
             SignInResponseInfo resp = new SignInResponseInfo
             {

src/linker.messenger.signin/SignInServerCaching.cs

@@ -47,7 +47,7 @@ namespace linker.messenger.signin
             }
 
             //参数验证失败
-            string verifyResult = await signInArgsTransfer.Validate(signInfo, cache);
+            string verifyResult = await signInArgsTransfer.Validate(signInfo, cache).ConfigureAwait(false);
             if (string.IsNullOrWhiteSpace(verifyResult) == false)
             {
                 cache.Connected = false;

src/linker.messenger.signin/args/SignInArgsGroupPassword.cs

@@ -18,13 +18,13 @@
         public async Task<string> Invoke(string host, Dictionary<string, string> args)
         {
             args.TryAdd("signin-gpwd", signInClientStore.Group.Password);
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 
         public async Task<string> Validate(SignInfo signInfo, SignCacheInfo cache)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
     }
@@ -40,7 +40,7 @@
         }
         public async Task<string> Invoke(string host, Dictionary<string, string> args)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 
@@ -56,7 +56,7 @@
             {
                 signInfo.GroupId = $"{signInfo.GroupId}->{gpwd}";
             }
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 

src/linker.messenger.signin/args/SignInArgsMachineKey.cs

@@ -20,14 +20,14 @@ namespace linker.messenger.signin.args
 
             args.TryAdd("machineKey", machineKey);
 
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
 
             return string.Empty;
         }
 
         public async Task<string> Validate(SignInfo signInfo, SignCacheInfo cache)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
     }
@@ -40,7 +40,7 @@ namespace linker.messenger.signin.args
         public string Name => "machineId";
         public async Task<string> Invoke(string host, Dictionary<string, string> args)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 
@@ -64,7 +64,7 @@ namespace linker.messenger.signin.args
                     return $"your id 【{signInfo.MachineId}】 is already online, online machineName {cache.MachineName}";
                 }
             }
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 

src/linker.messenger.signin/args/SignInArgsSecretKey.cs

@@ -15,13 +15,13 @@
         public async Task<string> Invoke(string host, Dictionary<string, string> args)
         {
             args.TryAdd("signin-secretkey", signInClientStore.Server.SecretKey);
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 
         public async Task<string> Validate(SignInfo signInfo, SignCacheInfo cache)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
     }
@@ -39,7 +39,7 @@
         }
         public async Task<string> Invoke(string host, Dictionary<string, string> args)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 
@@ -58,7 +58,7 @@
                     return $"server secretkey validate fail";
                 }
             }
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 

src/linker.messenger.signin/args/SignInArgsTransfer.cs

@@ -44,7 +44,7 @@
         {
             foreach (var item in startups)
             {
-                string result = await item.Invoke(host, args);
+                string result = await item.Invoke(host, args).ConfigureAwait(false);
                 if (string.IsNullOrWhiteSpace(result) == false)
                 {
                     return result;
@@ -62,7 +62,7 @@
         {
             foreach (var item in startups)
             {
-                string result = await item.Validate(signInfo, cache);
+                string result = await item.Validate(signInfo, cache).ConfigureAwait(false);
                 if (string.IsNullOrWhiteSpace(result) == false)
                 {
                     return result;

src/linker.messenger.signin/args/SignInArgsVersion.cs

@@ -12,14 +12,14 @@ namespace linker.messenger.signin.args
         {
             args.TryAdd("version", VersionHelper.version);
 
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
 
             return string.Empty;
         }
 
         public async Task<string> Validate(SignInfo signInfo, SignCacheInfo cache)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
     }
@@ -38,7 +38,7 @@ namespace linker.messenger.signin.args
         /// <returns></returns>
         public async Task<string> Invoke(string host, Dictionary<string, string> args)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 
@@ -55,7 +55,7 @@ namespace linker.messenger.signin.args
                 return "need v1.5.0+";
             }
 
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
 

src/linker.messenger.socks5/Socks5Decenter.cs

@@ -67,7 +67,7 @@ namespace linker.messenger.socks5
             Socks5Info info = serializer.Deserialize<Socks5Info>(data.Span);
             TimerHelper.Async(async () =>
             {
-                await slim.WaitAsync();
+                await slim.WaitAsync().ConfigureAwait(false);
                 try
                 {
                     socks5Infos.AddOrUpdate(info.MachineId, info, (a, b) => info);
@@ -89,7 +89,7 @@ namespace linker.messenger.socks5
             List<Socks5Info> list = data.Select(c => serializer.Deserialize<Socks5Info>(c.Span)).ToList();
             TimerHelper.Async(async () =>
             {
-                await slim.WaitAsync();
+                await slim.WaitAsync().ConfigureAwait(false);
 
                 try
                 {

src/linker.messenger.socks5/Socks5Proxy.cs

@@ -91,7 +91,7 @@ namespace linker.messenger.socks5
         /// <returns></returns>
         private async ValueTask<bool> ConnectTunnelConnection(AsyncUserToken token)
         {
-            int length = await token.Socket.ReceiveAsync(token.Buffer.AsMemory(), SocketFlags.None);
+            int length = await token.Socket.ReceiveAsync(token.Buffer.AsMemory(), SocketFlags.None).ConfigureAwait(false);
             if (length == 0)
             {
                 return true;
@@ -102,7 +102,7 @@ namespace linker.messenger.socks5
 
             //步骤，request
             token.Proxy.Rsv = (byte)Socks5EnumStep.Request;
-            if (await ReceiveCommandData(token) == false)
+            if (await ReceiveCommandData(token).ConfigureAwait(false) == false)
             {
                 return true;
             }

src/linker.messenger.socks5/TunnelProxy.cs

@@ -54,7 +54,7 @@ namespace linker.messenger.socks5
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                     LoggerHelper.Instance.Error(ex);
             }
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
         /// <summary>
         /// 根据不同的消息类型做不同的事情

src/linker.messenger.store.file/ConfigApiController.cs

@@ -110,7 +110,7 @@ namespace linker.messenger.store.file
                 client.Name = string.Empty;
                 if (configExportInfo.Single || client.OnlyNode)
                 {
-                    client.Id = await signInClientTransfer.GetNewId();
+                    client.Id = await signInClientTransfer.GetNewId().ConfigureAwait(false);
                     client.Name = configExportInfo.Name;
                 }
                 if (client.OnlyNode == false)

src/linker.messenger.store.file/relay/RelayServerCdkeyStore.cs

@@ -40,15 +40,15 @@ namespace linker.messenger.store.file.relay
             {
                 liteCollection.Update(info);
             }
-            return await Task.FromResult(true);
+            return await Task.FromResult(true).ConfigureAwait(false);
         }
         public async Task<bool> Del(int id)
         {
-            return await Task.FromResult(liteCollection.UpdateMany(c => new RelayServerCdkeyStoreInfo { Deleted = true }, c => c.Id == id) > 0);
+            return await Task.FromResult(liteCollection.UpdateMany(c => new RelayServerCdkeyStoreInfo { Deleted = true }, c => c.Id == id) > 0).ConfigureAwait(false);
         }
         public async Task<bool> Del(int id, string userid)
         {
-            return await Task.FromResult(liteCollection.UpdateMany(c => new RelayServerCdkeyStoreInfo { Deleted = true }, c => c.Id == id && c.UserId == userid) > 0);
+            return await Task.FromResult(liteCollection.UpdateMany(c => new RelayServerCdkeyStoreInfo { Deleted = true }, c => c.Id == id && c.UserId == userid) > 0).ConfigureAwait(false);
         }
 
         public async Task<RelayServerCdkeyTestResultInfo> Test(RelayServerCdkeyImportInfo info)
@@ -102,11 +102,11 @@ namespace linker.messenger.store.file.relay
             }
             result.Field = error;
 
-            return await Task.FromResult(result);
+            return await Task.FromResult(result).ConfigureAwait(false);
         }
         public async Task<string> Import(RelayServerCdkeyImportInfo info)
         {
-            RelayServerCdkeyTestResultInfo test = await Test(info);
+            RelayServerCdkeyTestResultInfo test = await Test(info).ConfigureAwait(false);
 
             if (test.Field.Count > 0)
             {
@@ -151,7 +151,7 @@ namespace linker.messenger.store.file.relay
                 UserPrice = order.UserPrice
             };
             liteCollection.Insert(store);
-            return await Task.FromResult(string.Empty);
+            return await Task.FromResult(string.Empty).ConfigureAwait(false);
         }
 
         public async Task<bool> Traffic(Dictionary<int, long> dic)
@@ -165,20 +165,20 @@ namespace linker.messenger.store.file.relay
                     liteCollection.UpdateMany(x => new RelayServerCdkeyStoreInfo { LastBytes = bytes, UseTime = DateTime.Now }, c => c.Id == item.Key);
                 }
             }
-            return await Task.FromResult(true);
+            return await Task.FromResult(true).ConfigureAwait(false);
         }
         public async Task<Dictionary<int, long>> GetLastBytes(List<int> ids)
         {
-            return await Task.FromResult(liteCollection.Find(c => ids.Contains(c.Id)).ToDictionary(c => c.Id, c => c.LastBytes));
+            return await Task.FromResult(liteCollection.Find(c => ids.Contains(c.Id)).ToDictionary(c => c.Id, c => c.LastBytes)).ConfigureAwait(false);
         }
 
         public async Task<List<RelayServerCdkeyStoreInfo>> GetAvailable(string userid)
         {
-            return await Task.FromResult(liteCollection.Find(x => x.UserId == userid && x.LastBytes > 0 && x.StartTime <= DateTime.Now && x.EndTime >= DateTime.Now && x.Deleted == false).ToList());
+            return await Task.FromResult(liteCollection.Find(x => x.UserId == userid && x.LastBytes > 0 && x.StartTime <= DateTime.Now && x.EndTime >= DateTime.Now && x.Deleted == false).ToList()).ConfigureAwait(false);
         }
         public async Task<List<RelayServerCdkeyStoreInfo>> Get(List<int> ids)
         {
-            return await Task.FromResult(liteCollection.Find(x => ids.Contains(x.Id)).ToList());
+            return await Task.FromResult(liteCollection.Find(x => ids.Contains(x.Id)).ToList()).ConfigureAwait(false);
         }
 
         public async Task<RelayServerCdkeyPageResultInfo> Page(RelayServerCdkeyPageRequestInfo info)
@@ -241,7 +241,7 @@ namespace linker.messenger.store.file.relay
                 Size = info.Size,
                 Count = query.Count(),
                 List = query.Skip((info.Page - 1) * info.Size).Limit(info.Size).ToList()
-            });
+            }).ConfigureAwait(false);
         }
 
 

src/linker.messenger.store.file/relay/RelayServerNodeStore.cs

@@ -32,6 +32,8 @@ namespace linker.messenger.store.file.relay
             config.Data.Server.Relay.Distributed.Node.MaxGbTotalLastBytes = update.MaxGbTotalLastBytes;
             config.Data.Server.Relay.Distributed.Node.Public = update.Public;
             config.Data.Server.Relay.Distributed.Node.Url = update.Url;
+            config.Data.Server.Relay.Distributed.Node.AllowTcp = update.AllowTcp;
+            config.Data.Server.Relay.Distributed.Node.AllowUdp = update.AllowUdp;
 
         }
         public void SetMaxGbTotalLastBytes(long value)

src/linker.messenger.store.file/tunnel/TunnelClientStore.cs

@@ -32,12 +32,12 @@ namespace linker.messenger.store.file.tunnel
 
             OnChanged();
 
-            return await Task.FromResult(true);
+            return await Task.FromResult(true).ConfigureAwait(false);
         }
 
         public async Task<List<TunnelTransportItemInfo>> GetTunnelTransports()
         {
-            return await Task.FromResult(config.Data.Client.Tunnel.Transports);
+            return await Task.FromResult(config.Data.Client.Tunnel.Transports).ConfigureAwait(false);
         }
 
         public async Task<bool> SetRouteLevelPlus(int level)
@@ -45,7 +45,7 @@ namespace linker.messenger.store.file.tunnel
             runningConfig.Data.Tunnel.RouteLevelPlus = level;
             runningConfig.Data.Update();
             OnChanged();
-            return await Task.FromResult(true);
+            return await Task.FromResult(true).ConfigureAwait(false);
         }
 
         public async Task<bool> SetPortMap(int privatePort, int publicPort)
@@ -54,7 +54,7 @@ namespace linker.messenger.store.file.tunnel
             runningConfig.Data.Tunnel.PortMapWan = publicPort;
             runningConfig.Data.Update();
             OnChanged();
-            return await Task.FromResult(true);
+            return await Task.FromResult(true).ConfigureAwait(false);
         }
     }
 }

src/linker.messenger.sync/SyncApiController.cs

@@ -23,7 +23,7 @@ namespace linker.messenger.sync
             string[] names = param.Content.DeJson<string[]>();
             if (names.Length == 1)
             {
-                await syncTreansfer.Sync(names[0]);
+                await syncTreansfer.Sync(names[0]).ConfigureAwait(false);
             }
             else
             {

src/linker.messenger.sync/SyncMessenger.cs

@@ -36,7 +36,7 @@ namespace linker.messenger.sync
                     }));
                 }
 
-                await Task.WhenAll(tasks);
+                await Task.WhenAll(tasks).ConfigureAwait(false);
             }
         }
     }

src/linker.messenger.sync/SyncTreansfer.cs

@@ -33,7 +33,7 @@ namespace linker.messenger.sync
         {
             TimerHelper.Async(async () =>
             {
-                await slim.WaitAsync();
+                await slim.WaitAsync().ConfigureAwait(false);
                 try
                 {
                     var tasks = syncs.Where(c => names.Contains(c.Name)).Select(c =>
@@ -46,7 +46,7 @@ namespace linker.messenger.sync
 
                          });
                      }).ToList();
-                    await Task.WhenAll(tasks);
+                    await Task.WhenAll(tasks).ConfigureAwait(false);
                 }
                 catch (Exception)
                 {
@@ -64,7 +64,7 @@ namespace linker.messenger.sync
                     Connection = signInClientState.Connection,
                     MessengerId = (ushort)ConfigMessengerIds.SyncForward,
                     Payload = serializer.Serialize(new SyncInfo { Name = sync.Name, Data = sync.GetData() }),
-                });
+                }).ConfigureAwait(false);
             }
         }
         public void Sync(SyncInfo info)

src/linker.messenger.tunnel/SignInArgsNet.cs

@@ -16,14 +16,14 @@ namespace linker.messenger.tunnel
         {
             args.TryAdd("tunnelNet", new SignInArgsNetInfo { Lat = tunnelNetworkTransfer.Info.Net.Lat, Lon = tunnelNetworkTransfer.Info.Net.Lon, City = tunnelNetworkTransfer.Info.Net.City }.ToJson());
 
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
 
             return string.Empty;
         }
 
         public async Task<string> Validate(SignInfo signInfo, SignCacheInfo cache)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
             return string.Empty;
         }
     }

src/linker.messenger.tunnel/TunnelApiController.cs

@@ -69,8 +69,8 @@ namespace linker.messenger.tunnel
 
             if (tunnelSetRouteLevelInfo.MachineId == signInClientStore.Id)
             {
-                await tunnelClientStore.SetRouteLevelPlus(tunnelSetRouteLevelInfo.RouteLevelPlus);
-                await tunnelClientStore.SetPortMap(tunnelSetRouteLevelInfo.PortMapLan, tunnelSetRouteLevelInfo.PortMapWan);
+                await tunnelClientStore.SetRouteLevelPlus(tunnelSetRouteLevelInfo.RouteLevelPlus).ConfigureAwait(false);
+                await tunnelClientStore.SetPortMap(tunnelSetRouteLevelInfo.PortMapLan, tunnelSetRouteLevelInfo.PortMapWan).ConfigureAwait(false);
             }
             else
             {
@@ -91,7 +91,7 @@ namespace linker.messenger.tunnel
         /// <returns></returns>
         public async Task<List<TunnelTransportItemInfo>> GetTransports(ApiControllerParamsInfo param)
         {
-            return await tunnelClientStore.GetTunnelTransports();
+            return await tunnelClientStore.GetTunnelTransports().ConfigureAwait(false);
         }
         /// <summary>
         /// 设置打洞协议
@@ -102,7 +102,7 @@ namespace linker.messenger.tunnel
         public async Task<bool> SetTransports(ApiControllerParamsInfo param)
         {
             List<TunnelTransportItemInfo> info = param.Content.DeJson<List<TunnelTransportItemInfo>>();
-            await tunnelClientStore.SetTunnelTransports(info);
+            await tunnelClientStore.SetTunnelTransports(info).ConfigureAwait(false);
             return true;
         }
 

src/linker.messenger.tunnel/TunnelClientMessengerAdapter.cs

@@ -94,12 +94,12 @@ namespace linker.plugins.tunnel
 
         public async Task<List<TunnelTransportItemInfo>> GetTunnelTransports()
         {
-            return await tunnelClientStore.GetTunnelTransports();
+            return await tunnelClientStore.GetTunnelTransports().ConfigureAwait(false);
         }
 
         public async Task<bool> SetTunnelTransports(List<TunnelTransportItemInfo> list)
         {
-            return await tunnelClientStore.SetTunnelTransports(list);
+            return await tunnelClientStore.SetTunnelTransports(list).ConfigureAwait(false);
         }
 
         public async Task<TunnelTransportWanPortInfo> GetRemoteWanPort(TunnelWanPortProtocolInfo info)

src/linker.messenger.tunnel/TunnelMessenger.cs

@@ -52,7 +52,7 @@ namespace linker.messenger.tunnel
                         Code = MessageResponeCodes.ERROR,
                         Payload = Helper.EmptyArray,
                         RequestId = requestid
-                    }, (ushort)TunnelMessengerIds.Info);
+                    }, (ushort)TunnelMessengerIds.Info).ConfigureAwait(false);
                 }
                 else
                 {
@@ -62,7 +62,7 @@ namespace linker.messenger.tunnel
                         Code = MessageResponeCodes.OK,
                         Payload = serializer.Serialize(result.Result),
                         RequestId = requestid
-                    }, (ushort)TunnelMessengerIds.Info);
+                    }, (ushort)TunnelMessengerIds.Info).ConfigureAwait(false);
                 }
             });
         }
@@ -94,8 +94,8 @@ namespace linker.messenger.tunnel
         public async Task RouteLevel(IConnection connection)
         {
             TunnelSetRouteLevelInfo tunnelTransportFileConfigInfo = serializer.Deserialize<TunnelSetRouteLevelInfo>(connection.ReceiveRequestWrap.Payload.Span);
-            await tunnelClientStore.SetRouteLevelPlus(tunnelTransportFileConfigInfo.RouteLevelPlus);
-            await tunnelClientStore.SetPortMap(tunnelTransportFileConfigInfo.PortMapLan, tunnelTransportFileConfigInfo.PortMapWan);
+            await tunnelClientStore.SetRouteLevelPlus(tunnelTransportFileConfigInfo.RouteLevelPlus).ConfigureAwait(false);
+            await tunnelClientStore.SetPortMap(tunnelTransportFileConfigInfo.PortMapLan, tunnelTransportFileConfigInfo.PortMapWan).ConfigureAwait(false);
         }
     }
 

src/linker.messenger.tunnel/TunnelNetworkTransfer.cs

@@ -51,7 +51,7 @@ namespace linker.messenger.tunnel
             try
             {
                 using HttpClient httpClient = new HttpClient();
-                string str = await httpClient.GetStringAsync($"http://ip-api.com/json").WaitAsync(TimeSpan.FromMilliseconds(3000));
+                string str = await httpClient.GetStringAsync($"http://ip-api.com/json").WaitAsync(TimeSpan.FromMilliseconds(3000)).ConfigureAwait(false);
 
                 if (string.IsNullOrWhiteSpace(str) == false)
                 {
@@ -75,7 +75,7 @@ namespace linker.messenger.tunnel
             try
             {
                 using HttpClient httpClient = new HttpClient();
-                string str = await httpClient.GetStringAsync($"https://api.myip.la/en?json").WaitAsync(TimeSpan.FromMilliseconds(5000));
+                string str = await httpClient.GetStringAsync($"https://api.myip.la/en?json").WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
 
                 if (string.IsNullOrWhiteSpace(str) == false)
                 {
@@ -94,7 +94,7 @@ namespace linker.messenger.tunnel
         {
             if (string.IsNullOrWhiteSpace(Info.Net.City))
             {
-                await Task.WhenAll(GetIsp(), GetPosition());
+                await Task.WhenAll(GetIsp(), GetPosition()).ConfigureAwait(false);
             }
         }
 

src/linker.messenger.tuntap/TuntapAdapter.cs

@@ -4,7 +4,6 @@ using linker.messenger.exroute;
 using linker.messenger.signin;
 using linker.tun;
 using linker.tunnel.connection;
-using System.Diagnostics;
 
 namespace linker.messenger.tuntap
 {
@@ -12,6 +11,8 @@ namespace linker.messenger.tuntap
     {
         private List<LinkerTunDeviceForwardItem> forwardItems = new List<LinkerTunDeviceForwardItem>();
 
+        private bool skipCheck => tuntapTransfer.Status == TuntapStatus.Operating || tuntapConfigTransfer.Running == false;
+        private bool needRestart => tuntapTransfer.Status != TuntapStatus.Running || tuntapConfigTransfer.Changed;
 
         private readonly TuntapTransfer tuntapTransfer;
         private readonly TuntapConfigTransfer tuntapConfigTransfer;
@@ -76,37 +77,31 @@ namespace linker.messenger.tuntap
         }
 
 
-        private ulong configVersion = 0;
         private OperatingManager checking = new OperatingManager();
         private void CheckDeviceTask()
         {
             TimerHelper.SetIntervalLong(async () =>
             {
-                await CheckDevice();
+                await CheckDevice().ConfigureAwait(false);
                 return true;
-            }, 30000);
+            }, 5000);
         }
         private async Task CheckDevice()
         {
             try
             {
-                bool start = checking.StartOperation();
-
-                //开始操作失败，或者网卡正在操作中，或者不需要运行
-                if (start == false || tuntapTransfer.Status == TuntapStatus.Operating || tuntapConfigTransfer.Running == false)
+                if (checking.StartOperation() == false || skipCheck)
                 {
-                    if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                        LoggerHelper.Instance.Warning($"tuntap check device continue :start:{start},status:{tuntapTransfer.Status},running:{tuntapConfigTransfer.Running}");
                     return;
                 }
-
-                //配置发生变化，或者网卡不可用
-                if (tuntapConfigTransfer.Version.Eq(configVersion, out ulong version) == false || tuntapTransfer.Status != TuntapStatus.Running || await tuntapTransfer.CheckAvailable() == false)
+                if (needRestart)
                 {
-                    if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                        LoggerHelper.Instance.Warning($"tuntap config version changed, restarting device");
-                    configVersion = version;
-                    await RetstartDevice();
+                    await RetstartDevice().ConfigureAwait(false);
+                    return;
+                }
+                if (await tuntapTransfer.CheckAvailable().ConfigureAwait(false) == false)
+                {
+                    tuntapTransfer.Refresh();
                 }
             }
             catch (Exception)
@@ -127,13 +122,13 @@ namespace linker.messenger.tuntap
                     return;
                 }
             }
-            await tuntapProxy.InputPacket(packet);
+            await tuntapProxy.InputPacket(packet).ConfigureAwait(false);
         }
 
         public async ValueTask Close(ITunnelConnection connection)
         {
             tuntapDecenter.Refresh();
-            await ValueTask.CompletedTask;
+            await ValueTask.CompletedTask.ConfigureAwait(false);
         }
         public void Receive(ITunnelConnection connection, ReadOnlyMemory<byte> buffer)
         {
@@ -142,7 +137,7 @@ namespace linker.messenger.tuntap
         public async ValueTask NotFound(uint ip)
         {
             tuntapDecenter.Refresh();
-            await ValueTask.CompletedTask;
+            await ValueTask.CompletedTask.ConfigureAwait(false);
         }
 
         /// <summary>
@@ -154,7 +149,7 @@ namespace linker.messenger.tuntap
             if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                 LoggerHelper.Instance.Warning($"restart, stop device");
             tuntapTransfer.Shutdown();
-            await tuntapConfigTransfer.RefreshIPASync();
+            await tuntapConfigTransfer.RefreshIPASync().ConfigureAwait(false);
             tuntapTransfer.Setup(tuntapConfigTransfer.Name, tuntapConfigTransfer.Info.IP, tuntapConfigTransfer.Info.PrefixLength, tuntapConfigTransfer.Info.DisableNat == false);
         }
         /// <summary>

src/linker.messenger.tuntap/TuntapApiController.cs

@@ -104,7 +104,7 @@ namespace linker.messenger.tuntap
 
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                     LoggerHelper.Instance.Warning($"api restarting device");
-                await tuntapAdapter.RetstartDevice();
+                await tuntapAdapter.RetstartDevice().ConfigureAwait(false);
             }
             else
             {
@@ -209,8 +209,8 @@ namespace linker.messenger.tuntap
         [Access(AccessValue.Lease)]
         public async Task AddNetwork(ApiControllerParamsInfo param)
         {
-            await leaseClientTreansfer.AddNetwork(param.Content.DeJson<LeaseInfo>());
-            await leaseClientTreansfer.LeaseChange();
+            await leaseClientTreansfer.AddNetwork(param.Content.DeJson<LeaseInfo>()).ConfigureAwait(false);
+            await leaseClientTreansfer.LeaseChange().ConfigureAwait(false);
             tuntapConfigTransfer.RefreshIP();
         }
         /// <summary>
@@ -220,7 +220,7 @@ namespace linker.messenger.tuntap
         /// <returns></returns>
         public async Task<LeaseInfo> GetNetwork(ApiControllerParamsInfo param)
         {
-            return await leaseClientTreansfer.GetNetwork();
+            return await leaseClientTreansfer.GetNetwork().ConfigureAwait(false);
         }
 
         /// <summary>
@@ -242,7 +242,7 @@ namespace linker.messenger.tuntap
 
             if (tuntapForwardTestWrapInfo.MachineId == signInClientStore.Id)
             {
-                await pingTransfer.SubscribeForwardTest(tuntapForwardTestWrapInfo.List);
+                await pingTransfer.SubscribeForwardTest(tuntapForwardTestWrapInfo.List).ConfigureAwait(false);
             }
             else
             {

src/linker.messenger.tuntap/TuntapConfigTransfer.cs

@@ -16,6 +16,18 @@ namespace linker.messenger.tuntap
         private string name = string.Empty;
         public string Name => string.IsNullOrWhiteSpace(Info.Name) ? (string.IsNullOrWhiteSpace(name) ? "linker" : name) : Info.Name;
 
+
+        private ulong configVersion = 0;
+        public bool Changed
+        {
+            get
+            {
+                bool result = Version.Eq(configVersion, out ulong version);
+                configVersion = version;
+                return result == false;
+            }
+        }
+
         public VersionManager Version { get; } = new VersionManager();
 
         private readonly ITuntapClientStore tuntapStore;
@@ -65,7 +77,7 @@ namespace linker.messenger.tuntap
                 Info.Forwards = info.Forwards;
                 tuntapStore.Confirm();
 
-                await LeaseIP();
+                await LeaseIP().ConfigureAwait(false);
                 SetGroupIP();
 
                 if (ip.Equals(Info.IP) == false || prefixLength != Info.PrefixLength || string.Equals(name, Info.Name) == false)
@@ -93,7 +105,7 @@ namespace linker.messenger.tuntap
             byte prefixLength = Info.PrefixLength;
 
             LoadGroupIP();
-            await LeaseIP();
+            await LeaseIP().ConfigureAwait(false);
             SetGroupIP();
 
             if ((oldIP.Equals(Info.IP) == false || prefixLength != Info.PrefixLength) && Info.Running)
@@ -105,7 +117,7 @@ namespace linker.messenger.tuntap
         }
         private async Task LeaseIP()
         {
-            LeaseInfo leaseInfo = await leaseClientTreansfer.LeaseIp(Info.IP, Info.PrefixLength);
+            LeaseInfo leaseInfo = await leaseClientTreansfer.LeaseIp(Info.IP, Info.PrefixLength).ConfigureAwait(false);
             Info.IP = leaseInfo.IP;
             Info.PrefixLength = leaseInfo.PrefixLength;
             name = leaseInfo.Name;

src/linker.messenger.tuntap/TuntapDecenter.cs

@@ -12,7 +12,6 @@ namespace linker.messenger.tuntap
     {
         public string Name => "tuntap";
         public VersionManager SyncVersion { get; } = new VersionManager();
-
         public VersionManager DataVersion { get; } = new VersionManager();
         public ConcurrentDictionary<string, TuntapInfo> Infos => tuntapInfos;
         public LinkerTunDeviceRouteItem[] Routes => routeItems;
@@ -95,7 +94,7 @@ namespace linker.messenger.tuntap
 
             TimerHelper.Async(async () =>
             {
-                await slim.WaitAsync();
+                await slim.WaitAsync().ConfigureAwait(false);
                 try
                 {
                     tuntapInfos.AddOrUpdate(info.MachineId, info, (a, b) => info);
@@ -117,7 +116,7 @@ namespace linker.messenger.tuntap
             List<TuntapInfo> list = data.Select(c => serializer.Deserialize<TuntapInfo>(c.Span)).ToList();
             TimerHelper.Async(async () =>
             {
-                await slim.WaitAsync();
+                await slim.WaitAsync().ConfigureAwait(false);
 
                 try
                 {

src/linker.messenger.tuntap/TuntapPingTransfer.cs

@@ -25,7 +25,6 @@ namespace linker.messenger.tuntap
             this.tuntapDecenter = tuntapDecenter;
 
             PingTask();
-           
         }
 
         private readonly LastTicksManager lastTicksManager = new LastTicksManager();
@@ -39,14 +38,14 @@ namespace linker.messenger.tuntap
             {
                 if (tuntapTransfer.Status == TuntapStatus.Running)
                 {
-                    await Ping();
+                    await Ping().ConfigureAwait(false);
                 }
                 return true;
             }, () => tuntapTransfer.Status == TuntapStatus.Running && lastTicksManager.DiffLessEqual(5000) ? 3000 : 30000);
         }
         private async Task Ping()
         {
-            if (tuntapTransfer.Status == TuntapStatus.Running && (tuntapConfigTransfer.Switch & TuntapSwitch.ShowDelay) == TuntapSwitch.ShowDelay)
+            if (tuntapTransfer.Status == TuntapStatus.Running && tuntapConfigTransfer.Switch.HasFlag(TuntapSwitch.ShowDelay))
             {
                 var items = tuntapDecenter.Infos.Values.Where(c => c.IP != null && c.IP.Equals(IPAddress.Any) == false && (c.Status & TuntapStatus.Running) == TuntapStatus.Running);
                 if ((tuntapConfigTransfer.Switch & TuntapSwitch.AutoConnect) != TuntapSwitch.AutoConnect)
@@ -58,10 +57,10 @@ namespace linker.messenger.tuntap
                 await Task.WhenAll(items.Select(async c =>
                 {
                     using Ping ping = new Ping();
-                    PingReply pingReply = await ping.SendPingAsync(c.IP, 500);
+                    PingReply pingReply = await ping.SendPingAsync(c.IP, 500).ConfigureAwait(false);
                     c.Delay = pingReply.Status == IPStatus.Success ? (int)pingReply.RoundtripTime : -1;
                     tuntapDecenter.DataVersion.Add();
-                }));
+                })).ConfigureAwait(false);
             }
         }
 
@@ -72,7 +71,7 @@ namespace linker.messenger.tuntap
                 try
                 {
                     var socket = new Socket(c.ConnectAddr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
-                    await socket.ConnectAsync(new IPEndPoint(c.ConnectAddr, c.ConnectPort)).WaitAsync(TimeSpan.FromMilliseconds(500));
+                    await socket.ConnectAsync(new IPEndPoint(c.ConnectAddr, c.ConnectPort)).WaitAsync(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
                     socket.SafeClose();
                     c.Error = string.Empty;
                 }
@@ -80,7 +79,7 @@ namespace linker.messenger.tuntap
                 {
                     c.Error = ex.Message;
                 }
-            }));
+            })).ConfigureAwait(false);
         }
     }
 }

src/linker.messenger.tuntap/TuntapProxy.cs

@@ -112,7 +112,7 @@ namespace linker.messenger.tuntap
                 }, ip);
                 return;
             }
-            await connection.SendAsync(packet.Packet);
+            await connection.SendAsync(packet.Packet).ConfigureAwait(false);
         }
 
         /// <summary>

src/linker.messenger.tuntap/TuntapTransfer.cs

@@ -35,6 +35,7 @@ namespace linker.messenger.tuntap
             AppDomain.CurrentDomain.ProcessExit += (s, e) => linkerTunDeviceAdapter.Shutdown();
             Console.CancelKeyPress += (s, e) => linkerTunDeviceAdapter.Shutdown();
         }
+
         public bool Write(ReadOnlyMemory<byte> buffer)
         {
             return linkerTunDeviceAdapter.Write(buffer);
@@ -88,6 +89,35 @@ namespace linker.messenger.tuntap
             });
         }
 
+        /// <summary>
+        /// 刷新网卡
+        /// </summary>
+        public void Refresh()
+        {
+            if (operatingManager.StartOperation() == false)
+            {
+                return;
+            }
+            TimerHelper.Async(() =>
+            {
+                try
+                {
+                    linkerTunDeviceAdapter.Refresh();
+                }
+                catch (Exception ex)
+                {
+                    if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
+                    {
+                        LoggerHelper.Instance.Error(ex);
+                    }
+                }
+                finally
+                {
+                    operatingManager.StopOperation();
+                }
+            });
+        }
+
         /// <summary>
         /// 停止网卡
         /// </summary>
@@ -137,7 +167,7 @@ namespace linker.messenger.tuntap
         }
         public async Task<bool> CheckAvailable()
         {
-            return await linkerTunDeviceAdapter.CheckAvailable();
+            return await linkerTunDeviceAdapter.CheckAvailable().ConfigureAwait(false);
         }
     }
 }

src/linker.messenger.tuntap/lease/LeaseClientTreansfer.cs

@@ -25,7 +25,7 @@ namespace linker.messenger.tuntap.lease
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)TuntapMessengerIds.LeaseAddNetwork,
                 Payload = serializer.Serialize(info)
-            });
+            }).ConfigureAwait(false);
         }
         public async Task<LeaseInfo> GetNetwork()
         {
@@ -34,7 +34,7 @@ namespace linker.messenger.tuntap.lease
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)TuntapMessengerIds.LeaseGetNetwork
 
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 LeaseInfo info = serializer.Deserialize<LeaseInfo>(resp.Data.Span);
@@ -48,7 +48,7 @@ namespace linker.messenger.tuntap.lease
             {
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)TuntapMessengerIds.LeaseChangeForward
-            });
+            }).ConfigureAwait(false);
         }
 
         public async Task<LeaseInfo> LeaseIp(IPAddress ip, byte prefixLength)
@@ -59,7 +59,7 @@ namespace linker.messenger.tuntap.lease
                 MessengerId = (ushort)TuntapMessengerIds.LeaseIP,
                 Payload = serializer.Serialize(new LeaseInfo { IP = ip, PrefixLength = prefixLength })
 
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK)
             {
                 LeaseInfo newip = serializer.Deserialize<LeaseInfo>(resp.Data.Span);
@@ -79,7 +79,7 @@ namespace linker.messenger.tuntap.lease
                 {
                     Connection = signInClientState.Connection,
                     MessengerId = (ushort)TuntapMessengerIds.LeaseExp,
-                });
+                }).ConfigureAwait(false);
 
                 return true;
             },  60000);

src/linker.messenger.updater/UpdaterApiController.cs

@@ -47,7 +47,7 @@ namespace linker.messenger.updater
             {
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)UpdaterMessengerIds.UpdateServer,
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
             {
                 return serializer.Deserialize<UpdaterInfo>(resp.Data.Span);
@@ -61,7 +61,7 @@ namespace linker.messenger.updater
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)UpdaterMessengerIds.ConfirmServer,
                 Payload = serializer.Serialize(new UpdaterConfirmServerInfo { SecretKey = updaterClientStore.SecretKey, Version = param.Content })
-            });
+            }).ConfigureAwait(false);
         }
         public async Task ExitServer(ApiControllerParamsInfo param)
         {
@@ -70,7 +70,7 @@ namespace linker.messenger.updater
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)UpdaterMessengerIds.ExitServer,
                 Payload = serializer.Serialize(new UpdaterConfirmServerInfo { SecretKey = updaterClientStore.SecretKey, Version = string.Empty })
-            });
+            }).ConfigureAwait(false);
         }
 
         public UpdaterInfo GetCurrent(ApiControllerParamsInfo param)
@@ -108,7 +108,7 @@ namespace linker.messenger.updater
                     Connection = signInClientState.Connection,
                     MessengerId = (ushort)UpdaterMessengerIds.ConfirmForward,
                     Payload = serializer.Serialize(confirm)
-                });
+                }).ConfigureAwait(false);
                 if (resp.Code != MessageResponeCodes.OK || resp.Data.Span.SequenceEqual(Helper.TrueArray) == false)
                 {
                     return false;
@@ -133,7 +133,7 @@ namespace linker.messenger.updater
                     Connection = signInClientState.Connection,
                     MessengerId = (ushort)UpdaterMessengerIds.ExitForward,
                     Payload = serializer.Serialize(param.Content)
-                });
+                }).ConfigureAwait(false);
             }
             return true;
         }
@@ -144,7 +144,7 @@ namespace linker.messenger.updater
             {
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)UpdaterMessengerIds.SubscribeForward
-            });
+            }).ConfigureAwait(false);
         }
         public async Task Check(ApiControllerParamsInfo param)
         {
@@ -155,7 +155,7 @@ namespace linker.messenger.updater
                     Connection = signInClientState.Connection,
                     MessengerId = (ushort)UpdaterMessengerIds.CheckForward,
                     Payload = string.IsNullOrWhiteSpace(param.Content) ? Helper.EmptyArray : serializer.Serialize(param.Content)
-                });
+                }).ConfigureAwait(false);
             }
             
             if (string.IsNullOrWhiteSpace(param.Content) || param.Content == signInClientStore.Id)

src/linker.messenger.updater/UpdaterClientTransfer.cs

@@ -91,7 +91,7 @@ namespace linker.messenger.updater
         {
             TimerHelper.SetIntervalLong(async () =>
             {
-                await GetUpdateInfo();
+                await GetUpdateInfo().ConfigureAwait(false);
                 if (updateInfo.Updated)
                 {
                     updateInfo.MachineId = signInClientStore.Id;
@@ -113,7 +113,7 @@ namespace linker.messenger.updater
                                     MachineId = updateInfo.MachineId
                                 }
                             }),
-                        });
+                        }).ConfigureAwait(false);
                     }
                     Update(updateInfo);
                 }
@@ -136,7 +136,7 @@ namespace linker.messenger.updater
             {
                 Connection = signInClientState.Connection,
                 MessengerId = (ushort)UpdaterMessengerIds.UpdateServer,
-            });
+            }).ConfigureAwait(false);
             if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
             {
                 UpdaterInfo info = serializer.Deserialize<UpdaterInfo>(resp.Data.Span);

src/linker.messenger.updater/UpdaterHelper.cs

@@ -36,7 +36,7 @@ namespace linker.messenger.updater
                 using HttpClientHandler handler = new HttpClientHandler();
                 handler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => true;
                 using HttpClient httpClient = new HttpClient(handler);
-                string str = await httpClient.GetStringAsync($"{updaterCommonTransfer.UpdateUrl}/version.txt").WaitAsync(TimeSpan.FromSeconds(15));
+                string str = await httpClient.GetStringAsync($"{updaterCommonTransfer.UpdateUrl}/version.txt").WaitAsync(TimeSpan.FromSeconds(15)).ConfigureAwait(false);
 
                 string[] arr = str.Split(Environment.NewLine).Select(c => c.Trim('\r').Trim('\n')).ToArray();
 
@@ -83,18 +83,18 @@ namespace linker.messenger.updater
                 LoggerHelper.Instance.Warning($"updater {url}");
 
                 using HttpClient httpClient = new HttpClient();
-                using HttpResponseMessage response = await httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
+                using HttpResponseMessage response = await httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
                 response.EnsureSuccessStatusCode();
                 updateInfo.Length = response.Content.Headers.ContentLength ?? 0;
-                using Stream contentStream = await response.Content.ReadAsStreamAsync();
+                using Stream contentStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
 
 
                 using FileStream fileStream = new FileStream("updater.zip", FileMode.OpenOrCreate, FileAccess.ReadWrite);
                 byte[] buffer = new byte[4096];
                 int readBytes = 0;
-                while ((readBytes = await contentStream.ReadAsync(buffer)) != 0)
+                while ((readBytes = await contentStream.ReadAsync(buffer).ConfigureAwait(false)) != 0)
                 {
-                    await fileStream.WriteAsync(buffer.AsMemory(0, readBytes));
+                    await fileStream.WriteAsync(buffer.AsMemory(0, readBytes)).ConfigureAwait(false);
                     updateInfo.Current += readBytes;
                 }
 
@@ -169,7 +169,7 @@ namespace linker.messenger.updater
                     using FileStream fileStream = File.Create(entryPath);
                     byte[] buffer = new byte[4096];
                     int bytesRead;
-                    while ((bytesRead = await entryStream.ReadAsync(buffer)) != 0)
+                    while ((bytesRead = await entryStream.ReadAsync(buffer).ConfigureAwait(false)) != 0)
                     {
                         await fileStream.WriteAsync(buffer.AsMemory(0, bytesRead));
                         updateInfo.Current += bytesRead;
@@ -203,8 +203,8 @@ namespace linker.messenger.updater
 
             TimerHelper.Async(async () =>
             {
-                await DownloadUpdate(updateInfo, version);
-                await ExtractUpdate(updateInfo);
+                await DownloadUpdate(updateInfo, version).ConfigureAwait(false);
+                await ExtractUpdate(updateInfo).ConfigureAwait(false);
 
                 if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
                 {

src/linker.messenger.updater/UpdaterMessenger.cs

@@ -235,7 +235,7 @@ namespace linker.messenger.updater
                 {
                     Connection = cache1.Connection,
                     MessengerId = (ushort)UpdaterMessengerIds.Exit
-                });
+                }).ConfigureAwait(false);
             }
         }
 

src/linker.messenger.updater/UpdaterServerTransfer.cs

@@ -28,11 +28,11 @@ namespace linker.messenger.updater
 
         private void CheckTask()
         {
-            TimerHelper.SetInterval(async () =>
+            TimerHelper.SetIntervalLong(async () =>
             {
                 if (updaterCommonTransfer.CheckUpdate)
                 {
-                    await updaterHelper.GetUpdateInfo(updateInfo);
+                    await updaterHelper.GetUpdateInfo(updateInfo).ConfigureAwait(false);
                 }
                 return true;
             }, () => updaterCommonTransfer.UpdateIntervalSeconds * 1000);

src/linker.messenger/IConnection.cs

@@ -447,7 +447,7 @@ namespace linker.messenger
             if (pong == false) return;
             pong = false;
             pingTicks.Update();
-            await SendPingPong(pingBytes);
+            await SendPingPong(pingBytes).ConfigureAwait(false);
         }
         public override async Task<bool> SendAsync(ReadOnlyMemory<byte> data)
         {

src/linker.messenger/MessengerResolver.cs

@@ -32,11 +32,11 @@ namespace linker.messenger
         }
         public async Task Resolve(Socket socket, Memory<byte> memory)
         {
-            await messengerResolver.BeginReceiveServer(socket, memory);
+            await messengerResolver.BeginReceiveServer(socket, memory).ConfigureAwait(false);
         }
         public async Task Resolve(Socket socket, IPEndPoint ep, Memory<byte> memory)
         {
-            await messengerResolver.BeginReceiveServer(socket, ep, memory);
+            await messengerResolver.BeginReceiveServer(socket, ep, memory).ConfigureAwait(false);
         }
     }
 
@@ -94,7 +94,7 @@ namespace linker.messenger
         /// <returns></returns>
         public async Task BeginReceiveServer(Socket socket, IPEndPoint ep, Memory<byte> memory)
         {
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
 
         /// <summary>
@@ -104,7 +104,7 @@ namespace linker.messenger
         /// <returns></returns>
         public async Task<IConnection> BeginReceiveClient(Socket socket)
         {
-            return await BeginReceiveClient(socket, false, 0, Helper.EmptyArray);
+            return await BeginReceiveClient(socket, false, 0, Helper.EmptyArray).ConfigureAwait(false);
         }
         /// <summary>
         /// 以客户端模式接收数据

src/linker.messenger/ResolverTransfer.cs

@@ -49,7 +49,7 @@ namespace linker.messenger
 
                 if (resolvers.TryGetValue(type, out IResolver resolver))
                 {
-                    await resolver.Resolve(socket, buffer.AsMemory(1, length));
+                    await resolver.Resolve(socket, buffer.AsMemory(1, length)).ConfigureAwait(false);
                 }
             }
             catch (Exception ex)
@@ -73,7 +73,7 @@ namespace linker.messenger
         {
             if (resolvers.TryGetValue(memory.Span[0], out IResolver resolver))
             {
-                await resolver.Resolve(socket, ep, memory.Slice(1));
+                await resolver.Resolve(socket, ep, memory.Slice(1)).ConfigureAwait(false);
             }
         }
     }

src/linker.route.win/default.aproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<project ver="10" name="linker.route.win" libEmbed="true" icon="res\favicon.ico" ui="win" output="linker.route.win.exe" CompanyName="snltty" FileDescription="linker.route.win" LegalCopyright="Copyright (C) snltty 2024" ProductName="linker.route.win" InternalName="linker.route.win" FileVersion="0.0.0.18" ProductVersion="0.0.0.18" publishDir="/dist/" dstrip="false">
+<project ver="10" name="linker.route.win" libEmbed="true" icon="res\favicon.ico" ui="win" output="linker.route.win.exe" CompanyName="snltty" FileDescription="linker.route.win" LegalCopyright="Copyright (C) snltty 2024" ProductName="linker.route.win" InternalName="linker.route.win" FileVersion="0.0.0.19" ProductVersion="0.0.0.19" publishDir="/dist/" dstrip="false">
 	<file name="main.aardio" path="main.aardio" comment="main.aardio"/>
 	<folder name="资源文件" path="res" embed="true" local="false" ignored="false">
 		<file name="Program.cs" path="res\Program.cs" comment="res\Program.cs"/>

src/linker.tray.win/default.aproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<project ver="10" name="linker.tray.win" libEmbed="true" icon="..\linker\favicon.ico" ui="win" output="linker.tray.win.exe" CompanyName="snltty" FileDescription="linker.tray.win" LegalCopyright="Copyright (C) snltty 2024" ProductName="linker.tray.win" InternalName="linker.install.win" FileVersion="0.0.0.217" ProductVersion="0.0.0.217" publishDir="/dist/" dstrip="false" local="false" ignored="false">
+<project ver="10" name="linker.tray.win" libEmbed="true" icon="..\linker\favicon.ico" ui="win" output="linker.tray.win.exe" CompanyName="snltty" FileDescription="linker.tray.win" LegalCopyright="Copyright (C) snltty 2024" ProductName="linker.tray.win" InternalName="linker.install.win" FileVersion="0.0.0.219" ProductVersion="0.0.0.219" publishDir="/dist/" dstrip="false" local="false" ignored="false">
 	<file name="main.aardio" path="main.aardio" comment="main.aardio"/>
 	<folder name="资源文件" path="res" embed="true" local="false" ignored="false">
 		<file name="favicon.ico" path="res\favicon.ico" comment="res\favicon.ico"/>

src/linker.tun/Example.cs

@@ -29,7 +29,7 @@ namespace linker.tun
         public async Task Callback(LinkerTunDevicPacket packet)
         {
             TCPUDPRead(packet);
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
         private unsafe void TCPUDPRead(LinkerTunDevicPacket packet)
         {
@@ -60,7 +60,7 @@ namespace linker.tun
         public async Task Callback(LinkerTunDevicPacket packet)
         {
             ICMPAnswer(packet);
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
         private unsafe void ICMPAnswer(LinkerTunDevicPacket packet)
         {

src/linker.tun/ILinkerTunDevice.cs

@@ -35,6 +35,8 @@ namespace linker.tun
         /// </summary>
         public void Shutdown();
 
+        public void Refresh();
+
         /// <summary>
         /// 设置MTU
         /// </summary>

src/linker.tun/LinkerLinuxTunDevice.cs

@@ -1,4 +1,5 @@
-using linker.libs;
+
+using linker.libs;
 using linker.libs.extends;
 using Microsoft.Win32.SafeHandles;
 using System.Net;
@@ -25,7 +26,7 @@ namespace linker.tun
 
         }
 
-        public bool Setup(string name,IPAddress address, IPAddress gateway, byte prefixLength, out string error)
+        public bool Setup(string name, IPAddress address, IPAddress gateway, byte prefixLength, out string error)
         {
             this.name = name;
             error = string.Empty;
@@ -126,6 +127,20 @@ namespace linker.tun
             CommandHelper.Linux(string.Empty, new string[] { $"ip link del {Name}", $"ip tuntap del mode tun dev {Name}" });
         }
 
+        public void Refresh()
+        {
+            if (fs == null) return;
+            try
+            {
+                CommandHelper.Linux(string.Empty, new string[] {
+                    $"ip link set dev {Name} up"
+                });
+            }
+            catch (Exception)
+            {
+            }
+        }
+
         public void SetMtu(int value)
         {
             CommandHelper.Linux(string.Empty, new string[] { $"ip link set dev {Name} mtu {value}" });
@@ -300,6 +315,8 @@ namespace linker.tun
         private object writeLockObj = new object();
         public ReadOnlyMemory<byte> Read()
         {
+            if (fs == null) return Helper.EmptyArray;
+
             int length = fs.Read(buffer.AsSpan(4));
             length.ToBytes(buffer);
             return buffer.AsMemory(0, length + 4);
@@ -326,7 +343,7 @@ namespace linker.tun
         public async Task<bool> CheckAvailable()
         {
             string output = CommandHelper.Linux(string.Empty, new string[] { $"ip link show {Name}" });
-            return await Task.FromResult(output.Contains("state UP"));
+            return await Task.FromResult(output.Contains("state UP")).ConfigureAwait(false);
         }
     }
 

src/linker.tun/LinkerOsxTunDevice.cs

@@ -2,6 +2,7 @@
 using linker.libs.extends;
 using Microsoft.Win32.SafeHandles;
 using System.Net;
+using System.Threading;
 
 namespace linker.tun
 {
@@ -59,6 +60,10 @@ namespace linker.tun
             IPAddress network = NetworkHelper.ToNetworkIP(address, NetworkHelper.ToPrefixValue(this.prefixLength));
             CommandHelper.Osx(string.Empty, new string[] { $"route delete -net {network}/{prefixLength} {address}" });
         }
+        public void Refresh()
+        {
+            
+        }
 
         public void AddRoute(LinkerTunDeviceRouteItem[] ips, IPAddress ip)
         {
@@ -179,7 +184,7 @@ namespace linker.tun
 
         public async Task<bool> CheckAvailable()
         {
-            return await Task.FromResult(true);
+            return await Task.FromResult(true).ConfigureAwait(false);
         }
     }
 }

src/linker.tun/LinkerTunDeviceAdapter.cs

@@ -131,6 +131,15 @@ namespace linker.tun
             return true;
         }
 
+
+        /// <summary>
+        /// 刷新网卡
+        /// </summary>
+        public void Refresh()
+        {
+            linkerTunDevice?.Refresh();
+        }
+
         /// <summary>
         /// 添加NAT转发,这会将来到本网卡且目标IP不是本网卡IP的包转发到其它网卡
         /// </summary>
@@ -193,7 +202,7 @@ namespace linker.tun
 
         private void Read()
         {
-            TimerHelper.AsyncLong(async () =>
+            TimerHelper.Async(async () =>
             {
                 cancellationTokenSource = new CancellationTokenSource();
                 while (cancellationTokenSource.IsCancellationRequested == false)
@@ -203,9 +212,7 @@ namespace linker.tun
                         ReadOnlyMemory<byte> buffer = linkerTunDevice.Read();
                         if (buffer.Length == 0)
                         {
-                            if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
-                                LoggerHelper.Instance.Warning($"read buffer 0, stop device");
-                            Shutdown();
+                            await Task.Delay(1000);
                             break;
                         }
 
@@ -226,8 +233,7 @@ namespace linker.tun
                         if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                             LoggerHelper.Instance.Warning($"read buffer Exception, stop device");
                         setupError = ex.Message;
-                        Shutdown();
-                        break;
+                        await Task.Delay(1000);
                     }
                 }
             });

src/linker.tun/LinkerWinTunDevice.cs

@@ -42,15 +42,18 @@ namespace linker.tun
                 error = ($"Adapter already exists");
                 return false;
             }
-            ClearRegistry();
-            Guid guid = Guid.NewGuid();
+            Guid guid = Guid.Parse("771EF382-8718-5BC5-EBF0-A28B86142278");
             adapter = WinTun.WintunCreateAdapter(name, name, ref guid);
             if (adapter == 0)
+            {
+                adapter = WinTun.WintunOpenAdapter(name);
+                if(adapter == 0)
                 {
                     error = ($"Failed to create adapter {Marshal.GetLastWin32Error()}");
                     Shutdown();
                     return false;
                 }
+            }
             uint version = WinTun.WintunGetRunningDriverVersion();
             session = WinTun.WintunStartSession(adapter, 0x400000);
             if (session == 0)
@@ -87,6 +90,10 @@ namespace linker.tun
 
         private void AddIPV4()
         {
+            try
+            {
+                if (session == 0) return;
+
                 WinTun.WintunGetAdapterLUID(adapter, out ulong luid);
                 {
                     WinTun.MIB_UNICASTIPADDRESS_ROW AddressRow = default;
@@ -100,6 +107,10 @@ namespace linker.tun
                     if (LastError != 0) throw new InvalidOperationException();
                 }
             }
+            catch (Exception)
+            {
+            }
+        }
         private void AddIPV6()
         {
             NetworkInterface networkInterface = NetworkInterface.GetAllNetworkInterfaces().FirstOrDefault(c => c.Name == Name);
@@ -139,6 +150,25 @@ namespace linker.tun
             interfaceNumber = 0;
         }
 
+        public void Refresh()
+        {
+            if (session == 0) return;
+            try
+            {
+                WinTun.SetEvent(waitHandle);
+                WinTun.WintunEndSession(session);
+
+                CommandHelper.Windows(string.Empty, new string[] { $"netsh interface set interface {Name} enable" });
+                session = WinTun.WintunStartSession(adapter, 0x400000);
+                waitHandle = WinTun.WintunGetReadWaitEvent(session);
+                AddIPV4();
+                AddIPV6();
+            }
+            catch (Exception)
+            {
+            }
+        }
+
         public void SetMtu(int value)
         {
             CommandHelper.Windows(string.Empty, new string[] {
@@ -270,6 +300,7 @@ namespace linker.tun
         private byte[] buffer = new byte[8 * 1024];
         public unsafe ReadOnlyMemory<byte> Read()
         {
+            if (session == 0) return Helper.EmptyArray;
             for (; tokenSource.IsCancellationRequested == false;)
             {
                 IntPtr packet = WinTun.WintunReceivePacket(session, out var packetSize);
@@ -356,94 +387,20 @@ namespace linker.tun
             }
         }
        
-        private void ClearRegistry()
-        {
-            string[] delValues = [Name];
-            try
-            {
-                RegistryKey key = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkList\\Profiles");
-                foreach (var item in key.GetSubKeyNames())
-                {
-                    RegistryKey itemKey = key.OpenSubKey(item);
-                    string value = itemKey.GetValue("Description", string.Empty).ToString();
-                    itemKey.Close();
-                    if (delValues.Any(c => value.StartsWith($"{c}") || value == c))
-                    {
-                        try
-                        {
-                            Registry.LocalMachine.DeleteSubKey($"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkList\\Profiles\\{item}");
-                        }
-                        catch (Exception)
-                        {
-                        }
-                    }
-                }
-                key.Close();
-
-                key = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkList\\Signatures\\Unmanaged");
-                foreach (var item in key.GetSubKeyNames())
-                {
-                    RegistryKey itemKey = key.OpenSubKey(item);
-                    string value = itemKey.GetValue("Description", string.Empty).ToString();
-                    itemKey.Close();
-                    if (delValues.Any(c => value.StartsWith($"{c}") || value == c))
-                    {
-                        try
-                        {
-                            Registry.LocalMachine.DeleteSubKey($"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkList\\Signatures\\Unmanaged\\{item}");
-                        }
-                        catch (Exception)
-                        {
-                        }
-                    }
-                }
-                key.Close();
-            }
-            catch (Exception)
-            {
-            }
-        }
-
         public async Task<bool> CheckAvailable()
         {
             InterfaceOrder();
-            NetworkInterface networkInterface = NetworkInterface.GetAllNetworkInterfaces().FirstOrDefault(c => c.Name == Name || c.Description == $"{Name} Tunnel" || c.Name.Contains(Name));
+            NetworkInterface networkInterface = NetworkInterface.GetAllNetworkInterfaces()
+                .FirstOrDefault(c => c.Name == Name || c.Description == $"{Name} Tunnel" || c.Name.Contains(Name));
 
-            if (networkInterface == null)
+            UnicastIPAddressInformation firstIpv4 = networkInterface?.GetIPProperties()
+                .UnicastAddresses.FirstOrDefault(c => c.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
+
+            if (networkInterface == null || firstIpv4 == null || firstIpv4.Address == null || firstIpv4.Address.Equals(address) == false)
             {
                 return false;
             }
-
-            UnicastIPAddressInformation firstIpv4 = networkInterface.GetIPProperties().UnicastAddresses.FirstOrDefault(c => c.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
-            if (firstIpv4 == null || firstIpv4.Address == null || firstIpv4.Address.Equals(address) == false)
-            {
-                return true;
-            }
-
-            return await InterfacePing();
-
-            async Task<bool> InterfacePing()
-            {
-                for (int i = 0; i < 10; i++)
-                {
-                    try
-                    {
-                        using Ping ping = new Ping();
-                        PingReply pingReply = await ping.SendPingAsync(address, 30);
-                        if (pingReply.Status != IPStatus.TimedOut)
-                        {
-                            return pingReply.Status == IPStatus.Success;
-                        }
-                        LoggerHelper.Instance.Error($"ping {address} at {i}->TimedOut");
-                    }
-                    catch (Exception ex)
-                    {
-                        LoggerHelper.Instance.Error($"ping {address} at {i}->{ex}");
-                    }
-                    await Task.Delay(2000);
-                }
-                return false;
-            }
+            return await Task.FromResult(true);
         }
         private void InterfaceOrder()
         {
@@ -478,6 +435,7 @@ namespace linker.tun
                 }
             }
         }
+
     }
 }
 

src/linker.tunnel/TunnelTransfer.cs

@@ -17,7 +17,7 @@ namespace linker.tunnel
         private TunnelWanPortTransfer tunnelWanPortTransfer;
         private TunnelUpnpTransfer tunnelUpnpTransfer;
 
-        private ConcurrentDictionary<string, bool> connectingDic = new ConcurrentDictionary<string, bool>();
+        private OperatingMultipleManager operating = new OperatingMultipleManager();
         private uint flowid = 1;
         private Dictionary<string, List<Action<ITunnelConnection>>> OnConnected { get; } = new Dictionary<string, List<Action<ITunnelConnection>>>();
 
@@ -48,7 +48,7 @@ namespace linker.tunnel
         }
         private async Task RebuildTransports()
         {
-            var transportItems = (await tunnelMessengerAdapter.GetTunnelTransports()).ToList();
+            var transportItems = (await tunnelMessengerAdapter.GetTunnelTransports().ConfigureAwait(false)).ToList();
             //有新的协议
             var newTransportNames = transports.Select(c => c.Name).Except(transportItems.Select(c => c.Name));
             if (newTransportNames.Any())
@@ -99,7 +99,7 @@ namespace linker.tunnel
                 }
             }
 
-            await tunnelMessengerAdapter.SetTunnelTransports(transportItems);
+            await tunnelMessengerAdapter.SetTunnelTransports(transportItems).ConfigureAwait(false);
             LoggerHelper.Instance.Info($"load tunnel transport:{string.Join(",", transports.Select(c => c.GetType().Name))}");
         }
 
@@ -139,8 +139,8 @@ namespace linker.tunnel
                     var socket = new Socket(server.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                     try
                     {
-                        await socket.ConnectAsync(server);
-                        await socket.SendAsync(new byte[] { 255 });
+                        await socket.ConnectAsync(server).ConfigureAwait(false);
+                        await socket.SendAsync(new byte[] { 255 }).ConfigureAwait(false);
                         return (socket.LocalEndPoint as IPEndPoint).Address;
                     }
                     catch (Exception)
@@ -193,7 +193,7 @@ namespace linker.tunnel
         /// <returns></returns>
         public async Task<ITunnelConnection> ConnectAsync(string remoteMachineId, string transactionId, TunnelProtocolType denyProtocols)
         {
-            return await ConnectAsync(remoteMachineId, transactionId, transactionId, denyProtocols);
+            return await ConnectAsync(remoteMachineId, transactionId, transactionId, denyProtocols).ConfigureAwait(false);
         }
         /// <summary>
         /// 开始连接对方
@@ -205,11 +205,11 @@ namespace linker.tunnel
         /// <returns></returns>
         public async Task<ITunnelConnection> ConnectAsync(string remoteMachineId, string transactionId, string transactionTag, TunnelProtocolType denyProtocols)
         {
-            if (connectingDic.TryAdd(remoteMachineId, true) == false) return null;
+            if (operating.StartOperation(remoteMachineId) == false) return null;
 
             try
             {
-                var _transports = await tunnelMessengerAdapter.GetTunnelTransports();
+                var _transports = await tunnelMessengerAdapter.GetTunnelTransports().ConfigureAwait(false);
                 foreach (TunnelTransportItemInfo transportItem in _transports.OrderBy(c => c.Order).Where(c => c.Disabled == false))
                 {
                     ITunnelTransport transport = transports.FirstOrDefault(c => c.Name == transportItem.Name);
@@ -311,7 +311,7 @@ namespace linker.tunnel
             }
             finally
             {
-                connectingDic.TryRemove(remoteMachineId, out _);
+                operating.StopOperation(remoteMachineId);
             }
             return null;
         }
@@ -321,13 +321,13 @@ namespace linker.tunnel
         /// <param name="tunnelTransportInfo"></param>
         public async Task OnBegin(TunnelTransportInfo tunnelTransportInfo)
         {
-            if (connectingDic.TryAdd(tunnelTransportInfo.Remote.MachineId, true) == false)
+            if (operating.StartOperation(tunnelTransportInfo.Remote.MachineId) == false)
             {
                 return;
             }
             try
             {
-                var _transports = await tunnelMessengerAdapter.GetTunnelTransports();
+                var _transports = await tunnelMessengerAdapter.GetTunnelTransports().ConfigureAwait(false);
                 ITunnelTransport transport = transports.FirstOrDefault(c => c.Name == tunnelTransportInfo.TransportName && c.ProtocolType == tunnelTransportInfo.TransportType);
                 TunnelTransportItemInfo item = _transports.FirstOrDefault(c => c.Name == tunnelTransportInfo.TransportName && c.Disabled == false);
                 if (transport != null && item != null)
@@ -337,18 +337,18 @@ namespace linker.tunnel
                     ParseRemoteEndPoint(tunnelTransportInfo);
                     _ = transport.OnBegin(tunnelTransportInfo).ContinueWith((result) =>
                     {
-                        connectingDic.TryRemove(tunnelTransportInfo.Remote.MachineId, out _);
+                        operating.StopOperation(tunnelTransportInfo.Remote.MachineId);
                     });
                 }
                 else
                 {
-                    connectingDic.TryRemove(tunnelTransportInfo.Remote.MachineId, out _);
+                    operating.StopOperation(tunnelTransportInfo.Remote.MachineId);
                     _ = tunnelMessengerAdapter.SendConnectFail(tunnelTransportInfo);
                 }
             }
             catch (Exception ex)
             {
-                connectingDic.TryRemove(tunnelTransportInfo.Remote.MachineId, out _);
+                operating.StopOperation(tunnelTransportInfo.Remote.MachineId);
                 if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
                 {
                     LoggerHelper.Instance.Error(ex);
@@ -534,20 +534,20 @@ namespace linker.tunnel
                 {
                     ITunnelConnection connection = null;
 
-                    await Task.Delay(delay);
+                    await Task.Delay(delay).ConfigureAwait(false);
                     for (int i = 1; i <= times; i++)
                     {
                         if (stopCallback()) break;
 
-                        connection = await ConnectAsync(remoteMachineId, transactionId, denyProtocols);
+                        connection = await ConnectAsync(remoteMachineId, transactionId, denyProtocols).ConfigureAwait(false);
                         if (connection != null)
                         {
                             break;
                         }
-                        await Task.Delay(i * 3000);
+                        await Task.Delay(i * 3000).ConfigureAwait(false);
                     }
 
-                    await resultCallback(connection);
+                    await resultCallback(connection).ConfigureAwait(false);
                 }
                 catch (Exception)
                 {

src/linker.tunnel/TunnelUpnpTransfer.cs

@@ -56,17 +56,17 @@ namespace linker.tunnel
 
             TimerHelper.Async(async () =>
             {
-                await locker.WaitAsync();
+                await locker.WaitAsync().ConfigureAwait(false);
 
                 foreach (var device in natDevices.Values)
                 {
                     try
                     {
-                        if (await HasMap(device, Protocol.Tcp, MapInfo.PublicPort) == false)
+                        if (await HasMap(device, Protocol.Tcp, MapInfo.PublicPort).ConfigureAwait(false) == false)
                         {
                             Mapping mapping = new Mapping(Protocol.Tcp, MapInfo.PrivatePort, MapInfo.PublicPort, 720, $"linker-tcp-{MapInfo.PublicPort}-{MapInfo.PrivatePort}");
-                            await device.CreatePortMapAsync(mapping);
-                            Mapping m = await device.GetSpecificMappingAsync(Protocol.Tcp, mapping.PublicPort);
+                            await device.CreatePortMapAsync(mapping).ConfigureAwait(false);
+                            Mapping m = await device.GetSpecificMappingAsync(Protocol.Tcp, mapping.PublicPort).ConfigureAwait(false);
                         }
                     }
                     catch
@@ -75,11 +75,11 @@ namespace linker.tunnel
 
                     try
                     {
-                        if (await HasMap(device, Protocol.Udp, MapInfo.PublicPort) == false)
+                        if (await HasMap(device, Protocol.Udp, MapInfo.PublicPort).ConfigureAwait(false) == false)
                         {
                             Mapping mapping = new Mapping(Protocol.Udp, MapInfo.PrivatePort, MapInfo.PublicPort, 720, $"linker-udp-{MapInfo.PublicPort}-{MapInfo.PrivatePort}");
-                            await device.CreatePortMapAsync(mapping);
-                            Mapping m = await device.GetSpecificMappingAsync(Protocol.Udp, mapping.PublicPort);
+                            await device.CreatePortMapAsync(mapping).ConfigureAwait(false);
+                            Mapping m = await device.GetSpecificMappingAsync(Protocol.Udp, mapping.PublicPort).ConfigureAwait(false);
                         }
                     }
                     catch
@@ -93,7 +93,7 @@ namespace linker.tunnel
         {
             try
             {
-                Mapping m = await device.GetSpecificMappingAsync(protocol, publicPort);
+                Mapping m = await device.GetSpecificMappingAsync(protocol, publicPort).ConfigureAwait(false);
                 return true;
             }
             catch (Exception)

src/linker.tunnel/connection/ITunnelConnection.cs

@@ -13,6 +13,7 @@ namespace linker.tunnel.connection
         Tcp = 1,
         Udp = 2,
         Quic = 4,
+        All = 255
     }
     /// <summary>
     /// 隧道模式

src/linker.tunnel/connection/TunnelConnectionMsQuic.cs

@@ -167,7 +167,7 @@ namespace linker.tunnel.connection
             {
                 try
                 {
-                    await callback.Receive(this, packet, this.userToken);
+                    await callback.Receive(this, packet, this.userToken).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -233,6 +233,7 @@ namespace linker.tunnel.connection
         public async Task<bool> SendAsync(ReadOnlyMemory<byte> data)
         {
             await semaphoreSlim.WaitAsync().ConfigureAwait(false);
+
             try
             {
                 await Stream.WriteAsync(data, cancellationTokenSource.Token).ConfigureAwait(false);

src/linker.tunnel/connection/TunnelConnectionTcp.cs

@@ -180,7 +180,7 @@ namespace linker.tunnel.connection
             }
             try
             {
-                await callback.Receive(this, packet, this.userToken);
+                await callback.Receive(this, packet, this.userToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -262,7 +262,9 @@ namespace linker.tunnel.connection
             if (callback == null) return false;
 
             if (Stream != null)
+            {
                 await semaphoreSlim.WaitAsync().ConfigureAwait(false);
+            }
             try
             {
                 if (Stream != null)

src/linker.tunnel/connection/TunnelConnectionUdp.cs

@@ -103,7 +103,7 @@ namespace linker.tunnel.connection
                     {
                         break;
                     }
-                    await CallbackPacket(buffer.AsMemory(0, result.ReceivedBytes)).ConfigureAwait(false);
+                    await CallbackPacket(buffer, 0, result.ReceivedBytes).ConfigureAwait(false);
                 }
             }
             catch (Exception ex)
@@ -121,21 +121,21 @@ namespace linker.tunnel.connection
             }
         }
 
-        public async Task<bool> ProcessWrite(Memory<byte> packet)
+        public async Task<bool> ProcessWrite(byte[] buffer, int offset, int length)
         {
             if (callback == null)
             {
                 return false;
             }
-            await CallbackPacket(packet).ConfigureAwait(false);
+            await CallbackPacket(buffer, offset, length).ConfigureAwait(false);
             return true;
         }
-        private async Task CallbackPacket(Memory<byte> packet)
+        private async Task CallbackPacket(byte[] buffer, int offset, int length)
         {
-            ReceiveBytes += packet.Length;
+            ReceiveBytes += length;
             LastTicks.Update();
 
-            Memory<byte> memory = packet.Slice(4);
+            Memory<byte> memory = buffer.AsMemory(offset, length);
             if (memory.Length == pingBytes.Length && memory.Span.Slice(0, pingBytes.Length - 4).SequenceEqual(pingBytes.AsSpan(0, pingBytes.Length - 4)))
             {
                 if (memory.Span.SequenceEqual(pingBytes))
@@ -158,17 +158,16 @@ namespace linker.tunnel.connection
                 {
                     if (SSL)
                     {
-                        packet.CopyTo(decodeBuffer);
-                        packet = Crypto.Decode(decodeBuffer, 0, packet.Length);
+                        int writen = Crypto.Decode(buffer, offset, length, decodeBuffer, 0);
+                        memory = decodeBuffer.AsMemory(0, writen);
                     }
-
-                    await callback.Receive(this, packet.Slice(4), this.userToken);
+                    await callback.Receive(this, memory, this.userToken).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
                     LoggerHelper.Instance.Error(ex);
-                    LoggerHelper.Instance.Error($"udp connection error :{packet.Length}");
-                    LoggerHelper.Instance.Error($"udp connection error :{Encoding.UTF8.GetString(packet.Span)}");
+                    LoggerHelper.Instance.Error($"udp connection error :{length}");
+                    LoggerHelper.Instance.Error($"udp connection error buffer:{Encoding.UTF8.GetString(buffer, offset, length)}");
                 }
             }
         }
@@ -199,12 +198,24 @@ namespace linker.tunnel.connection
         }
         private async Task SendPingPong(byte[] data)
         {
-            int length = 4 + data.Length;
+            int length = 0;
 
-            byte[] heartData = ArrayPool<byte>.Shared.Rent(length);
-            data.Length.ToBytes(heartData);
-            data.AsMemory().CopyTo(heartData.AsMemory(4));
-            SendBytes += data.Length;
+            byte[] heartData = ArrayPool<byte>.Shared.Rent(1024);
+            Memory<byte> memory = heartData.AsMemory();
+
+            //中继包头
+            if (Type == TunnelType.Relay)
+            {
+                length += 2;
+                heartData[0] = 2; //relay
+                heartData[1] = 1; //forward
+                memory = memory.Slice(2);
+            }
+            //真的数据
+            data.AsMemory().CopyTo(memory);
+            length += data.Length;
+
+            SendBytes += length;
             try
             {
                 await UdpClient.SendToAsync(heartData.AsMemory(0, length), IPEndPoint, cancellationTokenSource.Token).ConfigureAwait(false);
@@ -230,17 +241,35 @@ namespace linker.tunnel.connection
         }
 
 
+        private byte[] encodeTempBuffer = new byte[8 * 1014];
         private byte[] encodeBuffer = new byte[8 * 1024];
-        private byte[] decodeBuffer = new byte[8 * 2014];
+        private byte[] decodeBuffer = new byte[8 * 1014];
+
         public async Task<bool> SendAsync(ReadOnlyMemory<byte> data)
         {
             try
             {
+                data = data.Slice(4);
+
+                int skip = 0;
+                if (Type == TunnelType.Relay)
+                {
+                    skip = 2;
+                    encodeBuffer[0] = 2; //relay
+                    encodeBuffer[1] = 1; //forward
+                }
                 if (SSL)
                 {
-                    data.CopyTo(encodeBuffer);
-                    data = Crypto.Encode(encodeBuffer, 0, data.Length);
+                    data.CopyTo(encodeTempBuffer);
+                    int length = Crypto.Encode(encodeTempBuffer, 0, data.Length, encodeBuffer, skip);
+                    data = encodeBuffer.AsMemory(0, length + skip);
                 }
+                else
+                {
+                    data.CopyTo(encodeBuffer.AsMemory(skip));
+                    data = encodeBuffer.AsMemory(0, data.Length + skip);
+                }
+
                 await UdpClient.SendToAsync(data, IPEndPoint, cancellationTokenSource.Token).ConfigureAwait(false);
                 SendBytes += data.Length;
                 return true;

src/linker.tunnel/transport/TransportMsQuic.cs

@@ -87,7 +87,7 @@ namespace linker.tunnel.transport
                 {
                     return null;
                 }
-                await Task.Delay(100);
+                await Task.Delay(100).ConfigureAwait(false);
                 ITunnelConnection connection = await ConnectForward(tunnelTransportInfo).ConfigureAwait(false);
                 if (connection != null)
                 {
@@ -645,7 +645,7 @@ namespace linker.tunnel.transport
                     }
                 }
             }
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
 
         /// <summary>

src/linker.tunnel/transport/TransportTcpPortMap.cs

@@ -57,7 +57,7 @@ namespace linker.tunnel.transport
         SemaphoreSlim slim = new SemaphoreSlim(1);
         public async Task Listen(int localPort)
         {
-            await slim.WaitAsync();
+            await slim.WaitAsync().ConfigureAwait(false);
             try
             {
                 if (localPort == 0) return;
@@ -90,20 +90,20 @@ namespace linker.tunnel.transport
                 {
                     try
                     {
-                        Socket client = await socket.AcceptAsync();
+                        Socket client = await socket.AcceptAsync().ConfigureAwait(false);
 
                         TimerHelper.Async(async () =>
                         {
                             try
                             {
                                 byte[] bytes = new byte[1024];
-                                int length = await client.ReceiveAsync(bytes.AsMemory()).AsTask().WaitAsync(TimeSpan.FromMilliseconds(3000));
+                                int length = await client.ReceiveAsync(bytes.AsMemory()).AsTask().WaitAsync(TimeSpan.FromMilliseconds(3000)).ConfigureAwait(false);
                                 if (length > 0)
                                 {
                                     string key = bytes.AsMemory(0, length).GetString();
                                     if (distDic.TryRemove(key, out TaskCompletionSource<Socket> tcs))
                                     {
-                                        await client.SendAsync(bytes.AsMemory(0, length));
+                                        await client.SendAsync(bytes.AsMemory(0, length)).ConfigureAwait(false);
                                         tcs.SetResult(client);
                                         return;
                                     }
@@ -247,7 +247,7 @@ namespace linker.tunnel.transport
             distDic.TryAdd(key, tcs);
             try
             {
-                Socket socket = await tcs.Task.WaitAsync(TimeSpan.FromMilliseconds(5000));
+                Socket socket = await tcs.Task.WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
 
                 socket.KeepAlive();
                 SslStream sslStream = null;
@@ -323,8 +323,8 @@ namespace linker.tunnel.transport
                     }
                     await targetSocket.ConnectAsync(ep).WaitAsync(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
 
-                    await targetSocket.SendAsync($"{tunnelTransportInfo.Local.MachineId}-{tunnelTransportInfo.FlowId}".ToBytes());
-                    await targetSocket.ReceiveAsync(new byte[1024]).WaitAsync(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false); ;
+                    await targetSocket.SendAsync($"{tunnelTransportInfo.Local.MachineId}-{tunnelTransportInfo.FlowId}".ToBytes()).ConfigureAwait(false);
+                    await targetSocket.ReceiveAsync(new byte[1024]).WaitAsync(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
 
                     //需要ssl
                     SslStream sslStream = null;

src/linker.tunnel/transport/TransportUdp.cs

@@ -225,7 +225,7 @@ namespace linker.tunnel.transport
             {
                 byte[] buffer = new byte[1024];
                 SocketReceiveFromResult result = await socket.ReceiveFromAsync(buffer, new IPEndPoint(IPAddress.IPv6Any, 0)).ConfigureAwait(false);
-                await socket.SendToAsync(endBytes, result.RemoteEndPoint);
+                await socket.SendToAsync(endBytes, result.RemoteEndPoint).ConfigureAwait(false);
                 tcs.SetResult(result.RemoteEndPoint as IPEndPoint);
             });
             return socket;
@@ -287,7 +287,7 @@ namespace linker.tunnel.transport
                     }
                     else
                     {
-                        await token.LocalUdp.SendToAsync(buffer.AsMemory(0, result.ReceivedBytes), result.RemoteEndPoint);
+                        await token.LocalUdp.SendToAsync(buffer.AsMemory(0, result.ReceivedBytes), result.RemoteEndPoint).ConfigureAwait(false);
                     }
                 }
             }
@@ -429,7 +429,7 @@ namespace linker.tunnel.transport
                     }
                 }
             }
-            await Task.CompletedTask;
+            await Task.CompletedTask.ConfigureAwait(false);
         }
 
         sealed class ListenAsyncToken

src/linker.tunnel/transport/TransportUdpPortMap.cs

@@ -91,7 +91,7 @@ namespace linker.tunnel.transport
                 {
                     try
                     {
-                        SocketReceiveFromResult result = await socket.ReceiveFromAsync(bytes.AsMemory(), ep);
+                        SocketReceiveFromResult result = await socket.ReceiveFromAsync(bytes.AsMemory(), ep).ConfigureAwait(false);
                         if (result.ReceivedBytes == 0)
                         {
                             break;
@@ -108,7 +108,7 @@ namespace linker.tunnel.transport
                                 string key = memory.GetString();
                                 if (distDic.TryRemove(key, out TaskCompletionSource<State> tcs))
                                 {
-                                    await socket.SendToAsync(memory, result.RemoteEndPoint);
+                                    await socket.SendToAsync(memory, result.RemoteEndPoint).ConfigureAwait(false);
                                     try
                                     {
                                         State state = new State { Socket = socket, RemoteEndPoint = remoteEP };
@@ -122,7 +122,7 @@ namespace linker.tunnel.transport
                         }
                         else if (cache.Connection != null)
                         {
-                            bool success = await cache.Connection.ProcessWrite(memory);
+                            bool success = await cache.Connection.ProcessWrite(bytes,0, result.ReceivedBytes).ConfigureAwait(false);
                             if (success == false)
                             {
                                 connectionsDic.TryRemove(remoteEP, out _);

src/linker.tunnel/wanport/TunnelWanPortProtocolLinker.cs

@@ -35,7 +35,7 @@ namespace linker.tunnel.wanport
                 {
                     for (byte i = 1; i < 10; i++)
                     {
-                        await Task.Delay(15);
+                        await Task.Delay(15).ConfigureAwait(false);
                         await udpClient.SendAsync(BuildSendData(buffer, i), server).ConfigureAwait(false);
                     }
                 });
@@ -106,7 +106,7 @@ namespace linker.tunnel.wanport
                 socket.ReuseBind(new IPEndPoint(IPAddress.Any, 0));
                 await socket.ConnectAsync(server).ConfigureAwait(false);
 
-                await socket.SendAsync(BuildSendData(buffer, (byte)new Random().Next(0, 255)));
+                await socket.SendAsync(BuildSendData(buffer, (byte)new Random().Next(0, 255))).ConfigureAwait(false);
 
                 int length = await socket.ReceiveAsync(buffer.AsMemory(), SocketFlags.None).ConfigureAwait(false);
                 for (int j = 0; j < length; j++)

src/linker.web/src/lang/en-us.js

@@ -131,6 +131,7 @@ export default {
     'server.relayConnection': 'Conn',
     'server.relayDelay': 'Delay',
     'server.relayPublic': 'Public',
+    'server.relayAllow': 'Allow',
     'server.relayUrl': 'Url',
     'server.relayOper': 'Oper',
     'server.relayUse': 'Use',

src/linker.web/src/lang/zh-cn.js

@@ -134,6 +134,7 @@ export default {
     'server.relayConnection': '连接数',
     'server.relayDelay': '延迟',
     'server.relayPublic': '公开',
+    'server.relayAllow': '支持协议',
     'server.relayUrl': 'Url',
     'server.relayOper': '操作',
     'server.relayUse': '使用',

src/linker.web/src/views/full/devices/ConnectionsEdit.vue

@@ -4,9 +4,9 @@
             <el-table :data="state.data" size="small" border height="500">
                 <el-table-column property="RemoteMachineId" label="目标/服务器">
                     <template #default="scope">
-                        <div :class="{green:scope.row.Connected}">
-                            <p>{{scope.row.IPEndPoint}}</p>
-                            <p>ssl : {{scope.row.SSL}}</p>
+                        <div :class="{ green: scope.row.Connected }">
+                            <p>{{ scope.row.IPEndPoint }}</p>
+                            <p>ssl : {{ scope.row.SSL }}</p>
                         </div>
                     </template>
                 </el-table-column>
@@ -18,38 +18,41 @@
                 <el-table-column property="TransportName" label="协议">
                     <template #default="scope">
                         <div>
-                            <p>{{scope.row.TransportName}}({{ state.protocolTypes[scope.row.ProtocolType] }})</p>
-                            <p>{{ state.types[scope.row.Type] }} - {{1<<scope.row.BufferSize}}KB</p>
+                            <p>{{ scope.row.TransportName }}({{ state.protocolTypes[scope.row.ProtocolType] }})</p>
+                            <p>{{ state.types[scope.row.Type] }} - {{ 1 << scope.row.BufferSize }}KB</p>
                         </div>
                     </template>
                 </el-table-column>
                 <el-table-column property="Delay" label="延迟" width="60">
                     <template #default="scope">
-                        <span>{{scope.row.Delay}}ms</span>
+                        <span>{{ scope.row.Delay }}ms</span>
                     </template>
                 </el-table-column>
                 <el-table-column property="Bytes" label="通信">
                     <template #default="scope">
                         <div>
-                            <p>up : {{scope.row.SendBytesText}}</p>
-                            <p>down : {{scope.row.ReceiveBytesText}}</p>
+                            <p>up : {{ scope.row.SendBytesText }}</p>
+                            <p>down : {{ scope.row.ReceiveBytesText }}</p>
                         </div>
                     </template>
                 </el-table-column>
                 <el-table-column property="relay" label="中继节点">
                     <template #default="scope">
                         <div>
-                            <a href="javascript:;" class="a-line" @click="handleNode(scope.row)">{{ state.nodesDic[scope.row.NodeId] || '选择节点' }}</a>
+                            <a href="javascript:;" class="a-line" @click="handleNode(scope.row)">{{
+                                state.nodesDic[scope.row.NodeId] || '选择节点' }}</a>
                         </div>
                     </template>
                 </el-table-column>
                 <el-table-column label="操作" width="54">
                     <template #default="scope">
                         <div>
-                            <el-popconfirm v-if="hasTunnelRemove" confirm-button-text="确认" cancel-button-text="取消" title="确定关闭此连接?"
-                                @confirm="handleDel(scope.row)">
+                            <el-popconfirm v-if="hasTunnelRemove" confirm-button-text="确认" cancel-button-text="取消"
+                                title="确定关闭此连接?" @confirm="handleDel(scope.row)">
                                 <template #reference>
-                                    <el-button type="danger" size="small"><el-icon><Delete /></el-icon></el-button>
+                                    <el-button type="danger" size="small"><el-icon>
+                                            <Delete />
+                                        </el-icon></el-button>
                                 </template>
                             </el-popconfirm>
                         </div>
@@ -63,14 +66,22 @@
             <el-table :data="state.nodes" size="small" border height="600">
                 <el-table-column property="Name" :label="$t('server.relayName')">
                     <template #default="scope">
+                        <div>
                             <a :href="scope.row.Url" class="a-line blue" target="_blank">{{ scope.row.Name }}</a>
+                            <a href="javascript:;" class="a-line">
+                                <span v-if="(scope.row.AllowProtocol & 1) == 1">,tcp</span>
+                                <span v-if="(scope.row.AllowProtocol & 2) == 2">,udp</span>
+                            </a>
+                        </div>
                     </template>
                 </el-table-column>
-                <el-table-column property="MaxGbTotal" :label="$t('server.relayFlow')" width="160">
+                <el-table-column property="MaxGbTotal" :label="$t('server.relayFlow')" width="140">
                     <template #default="scope">
                         <span v-if="scope.row.MaxGbTotal == 0">--</span>
                         <span v-else>
-                            {{ (scope.row.MaxGbTotalLastBytes/1024/1024/1024).toFixed(2) }}GB / {{ scope.row.MaxGbTotal }}GB
+                            {{ (scope.row.MaxGbTotalLastBytes / 1024 / 1024 / 1024).toFixed(2) }}GB / {{
+                                scope.row.MaxGbTotal
+                            }}GB
                         </span>
                     </template>
                 </el-table-column>
@@ -80,10 +91,11 @@
                         <span v-else>{{ scope.row.MaxBandwidth }}Mbps</span>
                     </template>
                 </el-table-column>
-                <el-table-column property="MaxBandwidthTotal" :label="`${$t('server.relaySpeed2')}/${$t('server.relaySpeed1')}`" width="120">
+                <el-table-column property="MaxBandwidthTotal"
+                    :label="`${$t('server.relaySpeed2')}/${$t('server.relaySpeed1')}`" width="120">
                     <template #default="scope">
                         <span>
-                            <span>{{scope.row.BandwidthRatio}}Mbps</span>
+                            <span>{{ scope.row.BandwidthRatio }}Mbps</span>
                             <span>/</span>
                             <span v-if="scope.row.MaxBandwidthTotal == 0">--</span>
                             <span v-else>{{ scope.row.MaxBandwidthTotal }}Mbps</span>
@@ -92,7 +104,7 @@
                 </el-table-column>
                 <el-table-column property="ConnectionRatio" :label="$t('server.relayConnection')" width="80">
                     <template #default="scope">
-                        <span><strong>{{scope.row.ConnectionRatio}}</strong>/{{scope.row.MaxConnection}}</span>
+                        <span><strong>{{ scope.row.ConnectionRatio }}</strong>/{{ scope.row.MaxConnection }}</span>
                     </template>
                 </el-table-column>
                 <el-table-column property="Delay" :label="$t('server.relayDelay')" width="60">
@@ -102,12 +114,25 @@
                 </el-table-column>
                 <el-table-column property="Public" :label="$t('server.relayPublic')" width="50">
                     <template #default="scope">
-                        <el-switch disabled v-model="scope.row.Public " size="small" />
+                        <el-switch disabled v-model="scope.row.Public" size="small" />
                     </template>
                 </el-table-column>
-                <el-table-column property="Oper" :label="$t('server.relayOper')" width="65">
+                <el-table-column property="Oper" :label="$t('server.relayOper')" width="75">
                     <template #default="scope">
-                        <el-button type="success" size="small" @click="handleConnect(scope.row.Id)">{{$t('server.relayUse')}}</el-button>
+                        <el-dropdown size="small">
+                            <div class="dropdown">
+                                <span>{{ $t('server.relayUse') }}</span>
+                                <el-icon class="el-icon--right">
+                                    <ArrowDown />
+                                </el-icon>
+                            </div>
+                            <template #dropdown>
+                                <el-dropdown-menu>
+                                    <el-dropdown-item v-if="(scope.row.AllowProtocol & 1) == 1" @click="handleConnect(scope.row.Id, 1)">TCP</el-dropdown-item>
+                                    <el-dropdown-item v-if="(scope.row.AllowProtocol & 2) == 2" @click="handleConnect(scope.row.Id, 2)">UDP</el-dropdown-item>
+                                </el-dropdown-menu>
+                            </template>
+                        </el-dropdown>
                     </template>
                 </el-table-column>
             </el-table>
@@ -115,22 +140,22 @@
     </el-dialog>
 </template>
 <script>
-import { reactive, watch,computed,  onMounted, onUnmounted } from 'vue';
+import { reactive, watch, computed, onMounted, onUnmounted } from 'vue';
 import { ElMessage } from 'element-plus';
 import { useConnections, useForwardConnections, useSocks5Connections, useTuntapConnections } from './connections';
-import { Delete } from '@element-plus/icons-vue';
+import { Delete, Select, ArrowDown } from '@element-plus/icons-vue';
 import { injectGlobalData } from '@/provide';
 import { relayConnect, setRelaySubscribe } from '@/apis/relay';
 import { useI18n } from 'vue-i18n';
 export default {
     props: ['modelValue'],
-    emits: ['change','update:modelValue'],
-    components: {Delete},
+    emits: ['change', 'update:modelValue'],
+    components: { Delete, Select, ArrowDown },
     setup(props, { emit }) {
 
-        const {t} = useI18n();
+        const { t } = useI18n();
         const globalData = injectGlobalData();
-        const hasTunnelRemove = computed(()=>globalData.value.hasAccess('TunnelRemove')); 
+        const hasTunnelRemove = computed(() => globalData.value.hasAccess('TunnelRemove'));
 
         const connections = useConnections();
         const forwardConnections = useForwardConnections();
@@ -138,22 +163,22 @@ export default {
         const socks5Connections = useSocks5Connections();
         const state = reactive({
             show: true,
-            protocolTypes:{1:'tcp',2:'udp',4:'msquic'},
-            types:{0:'打洞',1:'中继',2:'节点'},
-            transactions:{'forward':'端口转发','tuntap':'虚拟网卡','socks5':'代理转发'},
-            machineName:connections.value.currentName,
-            currentRow:{},
-            data: computed(()=>{
+            protocolTypes: { 1: 'tcp', 2: 'udp', 4: 'msquic' },
+            types: { 0: '打洞', 1: '中继', 2: '节点' },
+            transactions: { 'forward': '端口转发', 'tuntap': '虚拟网卡', 'socks5': '代理转发' },
+            machineName: connections.value.currentName,
+            currentRow: {},
+            data: computed(() => {
                 return [
                     forwardConnections.value.list[connections.value.current],
                     tuntapConnections.value.list[connections.value.current],
                     socks5Connections.value.list[connections.value.current],
-                ].filter(c=>!!c);
+                ].filter(c => !!c);
             }),
-            showNodes:false,
-            nodes:[],
-            nodesDic:{},
-            timer:0
+            showNodes: true,
+            nodes: [],
+            nodesDic: {},
+            timer: 0
         });
         watch(() => state.show, (val) => {
             if (!val) {
@@ -163,54 +188,55 @@ export default {
                 }, 300);
             }
         });
-        const handleDel = (row)=>{
-            if(!hasTunnelRemove.value) return;
-            row.removeFunc(row.RemoteMachineId).then(()=>{
+        const handleDel = (row) => {
+            if (!hasTunnelRemove.value) return;
+            row.removeFunc(row.RemoteMachineId).then(() => {
                 ElMessage.success(t('common.oper'));
-            }).catch(()=>{});
+            }).catch(() => { });
         }
 
-        const _setRelaySubscribe = ()=>{
-            setRelaySubscribe().then((res)=>{
+        const _setRelaySubscribe = () => {
+            setRelaySubscribe().then((res) => {
                 state.nodes = res;
-                state.nodesDic = res.reduce((a,b)=>{
+                state.nodesDic = res.reduce((a, b) => {
                     a[b.Id] = b.Name;
                     return a;
-                },{});
-                state.timer = setTimeout(_setRelaySubscribe,1000);
-            }).catch(()=>{
-                state.timer = setTimeout(_setRelaySubscribe,1000);
+                }, {});
+                state.timer = setTimeout(_setRelaySubscribe, 1000);
+            }).catch(() => {
+                state.timer = setTimeout(_setRelaySubscribe, 1000);
             });
         }
-        const handleNode = (row)=>{
+        const handleNode = (row) => {
             state.currentRow = row;
             state.showNodes = true;
         }
-        const handleConnect = (id)=>{
+        const handleConnect = (id, protocol) => {
             const json = {
-                FromMachineId:globalData.value.config.Client.Id,
+                FromMachineId: globalData.value.config.Client.Id,
                 TransactionId: state.currentRow.TransactionId,
                 ToMachineId: state.currentRow.RemoteMachineId,
-                NodeId:id,
+                NodeId: id,
+                Protocol: protocol
             };
-            if(json.NodeId == state.currentRow.NodeId){
+            if (json.NodeId == state.currentRow.NodeId) {
                 return;
             }
-            relayConnect(json).then(()=>{}).catch(()=>{});
+            relayConnect(json).then(() => {ElMessage.success(t('common.oper')); }).catch(() => {ElMessage.success(t('common.operFail')); });
             state.showNodes = false;
         }
 
-        onMounted(()=>{
+        onMounted(() => {
             connections.value.updateRealTime(true);
             _setRelaySubscribe();
         });
-        onUnmounted(()=>{
+        onUnmounted(() => {
             connections.value.updateRealTime(false);
             clearTimeout(state.timer);
         })
 
         return {
-            state,handleDel,hasTunnelRemove,handleNode,handleConnect
+            state, handleDel, hasTunnelRemove, handleNode, handleConnect
         }
     }
 }
@@ -221,4 +247,26 @@ export default {
 .blue {
     color: #409EFF;
 }
+.dropdown{
+    border:1px solid #ddd;
+    padding:.4rem;
+    font-size:1.3rem;
+    border-radius:.4rem;
+    position:relative;
+    .el-icon{
+        vertical-align:middle;
+    }
+
+    .badge{
+        position:absolute;
+        right:-1rem;
+        top:-50%;
+        border-radius:10px;
+        background-color:#f1ae05;
+        color:#fff;
+        padding:.2rem .6rem;
+        font-size:1.2rem;
+        
+    }
+}
 </style>

src/linker.web/src/views/full/server/EditNode.vue

@@ -26,6 +26,10 @@
                 <el-form-item :label="$t('server.relayPublic')" prop="Public">
                     <el-switch v-model="state.ruleForm.Public " size="small" />
                 </el-form-item>
+                <el-form-item :label="$t('server.relayAllow')" prop="Allow">
+                    <el-checkbox v-model="state.ruleForm.AllowTcp">TCP</el-checkbox>
+                    <el-checkbox v-model="state.ruleForm.AllowUdp">UDP</el-checkbox>
+                </el-form-item>
                 <el-form-item></el-form-item>
                 <el-form-item label="" prop="Btns">
                     <div class="t-c w-100">
@@ -62,6 +66,8 @@ export default {
                 MaxGbTotalLastBytes:props.data.MaxGbTotalLastBytes,
                 Public:props.data.Public,
                 Url:props.data.Url,
+                AllowTcp:(props.data.AllowProtocol & 1) == 1,
+                AllowUdp:(props.data.AllowProtocol & 2) == 2,
             },
             rules:{
             }
@@ -83,6 +89,8 @@ export default {
                 if (!valid) return;
 
                 const json = JSON.parse(JSON.stringify(state.ruleForm));
+                json.AllowProtocol = (json.AllowTcp ? 1 : 0) | (json.AllowUdp ? 2 : 0);
+
                 relayUpdateNode(json).then((res)=>{
                     if(res){
                         ElMessage.success(t('common.oper'));