diff --git a/FastTunnel.Client/appsettings.json b/FastTunnel.Client/appsettings.json
index 46bd569..8850014 100644
--- a/FastTunnel.Client/appsettings.json
+++ b/FastTunnel.Client/appsettings.json
@@ -1,12 +1,12 @@
 {
-  "Logging": {
-    "LogLevel": {
-      // Trace Debug Information Warning Error
-      "Default": "Information",
-      "Microsoft": "Warning",
-      "Microsoft.Hosting.Lifetime": "Information"
-    }
-  },
+  //"Logging": {
+  //  "LogLevel": {
+  //    // Trace Debug Information Warning Error
+  //    "Default": "Information",
+  //    "Microsoft": "Warning",
+  //    "Microsoft.Hosting.Lifetime": "Information"
+  //  }
+  //},
   "EnableFileLog": false,
   "ClientSettings": {
     "Server": {
diff --git a/FastTunnel.Core/Client/FastTunnelClient.cs b/FastTunnel.Core/Client/FastTunnelClient.cs
index 3667dfc..d93843a 100644
--- a/FastTunnel.Core/Client/FastTunnelClient.cs
+++ b/FastTunnel.Core/Client/FastTunnelClient.cs
@@ -34,13 +34,14 @@ namespace FastTunnel.Core.Client
         public FastTunnelClient(
             ILogger<FastTunnelClient> logger,
             SwapHandler newCustomerHandler,
-             LogHandler logHandler,
+            LogHandler logHandler,
             IOptionsMonitor<DefaultClientConfig> configuration)
         {
             _logger = logger;
             _newCustomerHandler = newCustomerHandler;
             _logHandler = logHandler;
             ClientConfig = configuration.CurrentValue;
+            Server = ClientConfig.Server;
         }
 
         /// <summary>
@@ -69,41 +70,46 @@ namespace FastTunnel.Core.Client
             _logger.LogInformation("===== FastTunnel Client End =====");
         }
 
-        protected virtual async Task loginAsync(CancellationToken cancellationToken)
+        private async Task loginAsync(CancellationToken cancellationToken)
         {
-            Server = ClientConfig.Server;
-            _logger.LogInformation($"正在连接服务端 {Server.ServerAddr}:{Server.ServerPort}");
-
             try
             {
+                var logMsg = GetLoginMsg();
+
                 // 连接到的目标IP
                 socket = new ClientWebSocket();
                 socket.Options.RemoteCertificateValidationCallback = delegate { return true; };
                 socket.Options.SetRequestHeader(FastTunnelConst.FASTTUNNEL_FLAG, "2.0.0");
                 socket.Options.SetRequestHeader(FastTunnelConst.FASTTUNNEL_TYPE, FastTunnelConst.TYPE_CLIENT);
 
+                _logger.LogInformation($"正在连接服务端 {Server.ServerAddr}:{Server.ServerPort}");
                 await socket.ConnectAsync(
-                    new Uri($"ws://{ClientConfig.Server.ServerAddr}:{ClientConfig.Server.ServerPort}"), cancellationToken);
+                    new Uri($"ws://{Server.ServerAddr}:{Server.ServerPort}"), cancellationToken);
 
                 _logger.LogDebug("连接服务端成功");
+
+                // 登录
+                await socket.SendCmdAsync(MessageType.LogIn, logMsg, cancellationToken);
             }
             catch (Exception)
             {
                 throw;
             }
+        }
 
-            // 登录
-            await socket.SendCmdAsync(MessageType.LogIn, new LogInMassage
+        public virtual string GetLoginMsg()
+        {
+            Server = ClientConfig.Server;
+            return new LogInMassage
             {
                 Webs = ClientConfig.Webs,
                 Forwards = ClientConfig.Forwards,
-            }.ToJson(), cancellationToken);
+            }.ToJson();
         }
 
         private async Task ReceiveServerAsync(CancellationToken cancellationToken)
         {
-            byte[] buffer = new byte[128];
-
+            byte[] buffer = new byte[FastTunnelConst.CMD_MAX_LENGTH];
             while (!cancellationToken.IsCancellationRequested)
             {
                 var res = await socket.ReceiveAsync(buffer, cancellationToken);
@@ -115,14 +121,14 @@ namespace FastTunnel.Core.Client
 
         private async void HandleServerRequestAsync(byte cmd, string ctx, CancellationToken cancellationToken)
         {
+            await Task.Yield();
+
             try
             {
                 IClientHandler handler;
                 switch ((MessageType)cmd)
                 {
                     case MessageType.SwapMsg:
-                        handler = _newCustomerHandler;
-                        break;
                     case MessageType.Forward:
                         handler = _newCustomerHandler;
                         break;
@@ -144,10 +150,13 @@ namespace FastTunnel.Core.Client
         public void Stop(CancellationToken cancellationToken)
         {
             _logger.LogInformation("===== FastTunnel Client Stoping =====");
+            if (socket == null)
+                return;
+
             if (socket.State == WebSocketState.Connecting)
                 return;
 
-            socket.CloseAsync(WebSocketCloseStatus.Empty, "客户端主动关闭", cancellationToken);
+            socket.CloseAsync(WebSocketCloseStatus.Empty, string.Empty, cancellationToken);
         }
     }
 }
diff --git a/FastTunnel.Core/Config/DefaultServerConfig.cs b/FastTunnel.Core/Config/DefaultServerConfig.cs
index 44eecf7..babba9a 100644
--- a/FastTunnel.Core/Config/DefaultServerConfig.cs
+++ b/FastTunnel.Core/Config/DefaultServerConfig.cs
@@ -9,8 +9,6 @@ namespace FastTunnel.Core.Config
     {
         public string WebDomain { get; set; }
 
-        public int WebProxyPort { get; set; } = 1270;
-
         public string[] WebAllowAccessIps { get; set; }
 
         public bool EnableForward { get; set; } = false;
diff --git a/FastTunnel.Core/Config/IServerConfig.cs b/FastTunnel.Core/Config/IServerConfig.cs
index f9f7eaa..8476a42 100644
--- a/FastTunnel.Core/Config/IServerConfig.cs
+++ b/FastTunnel.Core/Config/IServerConfig.cs
@@ -6,16 +6,10 @@ namespace FastTunnel.Core.Config
 {
     public interface IServerConfig
     {
-        #region Web相关配置
-
-        int WebProxyPort { get; set; }
-
         string WebDomain { get; set; }
 
         string[] WebAllowAccessIps { get; set; }
 
-        #endregion
-
         bool EnableForward { get; set; }
     }
 }
diff --git a/FastTunnel.Core/Extensions/ServicesExtensions.cs b/FastTunnel.Core/Extensions/ServicesExtensions.cs
index 38cb697..c8b51ee 100644
--- a/FastTunnel.Core/Extensions/ServicesExtensions.cs
+++ b/FastTunnel.Core/Extensions/ServicesExtensions.cs
@@ -13,6 +13,7 @@ using Microsoft.AspNetCore.Builder;
 using FastTunnel.Core.Filters;
 using Microsoft.AspNetCore.Mvc.Filters;
 using FastTunnel.Core.Models;
+using FastTunnel.Core.Handlers.Server;
 
 namespace FastTunnel.Core
 {
@@ -25,10 +26,16 @@ namespace FastTunnel.Core
         public static void AddFastTunnelClient(this IServiceCollection services, IConfigurationSection configurationSection)
         {
             services.Configure<DefaultClientConfig>(configurationSection);
+            services.AddFastTunnelClient();
+        }
 
+        public static void AddFastTunnelClient(this IServiceCollection services)
+        {
             services.AddTransient<IFastTunnelClient, FastTunnelClient>()
                 .AddSingleton<IExceptionFilter, FastTunnelExceptionFilter>()
+                .AddSingleton<ILoginHandler, LoginHandler>()
                 .AddSingleton<LogHandler>()
+                .AddTransient<TunnelClient>()
                 .AddSingleton<SwapHandler>();
 
             services.AddHostedService<ServiceFastTunnelClient>();
@@ -45,9 +52,10 @@ namespace FastTunnel.Core
 
             services.Configure<DefaultServerConfig>(configurationSection)
                 .AddSingleton<IExceptionFilter, FastTunnelExceptionFilter>()
-                .AddSingleton<FastTunnelClientHandler, FastTunnelClientHandler>()
-                .AddSingleton<FastTunnelSwapHandler, FastTunnelSwapHandler>()
-                .AddSingleton<FastTunnelServer, FastTunnelServer>();
+                .AddTransient<TunnelClient>()
+                .AddSingleton<FastTunnelClientHandler>()
+                .AddSingleton<FastTunnelSwapHandler>()
+                .AddSingleton<FastTunnelServer>();
         }
 
         /// <summary>
diff --git a/FastTunnel.Core/Extensions/WebSocketExtensions.cs b/FastTunnel.Core/Extensions/WebSocketExtensions.cs
index 21bce7c..8524e00 100644
--- a/FastTunnel.Core/Extensions/WebSocketExtensions.cs
+++ b/FastTunnel.Core/Extensions/WebSocketExtensions.cs
@@ -15,7 +15,7 @@ namespace FastTunnel.Core.Extensions
         public static async Task SendCmdAsync(this WebSocket socket, MessageType type, string content, CancellationToken cancellationToken)
         {
             var buffer = Encoding.UTF8.GetBytes($"{(char)type}{content}\n");
-            if (type != MessageType.LogIn && buffer.Length > 128)
+            if (type != MessageType.LogIn && buffer.Length > FastTunnelConst.CMD_MAX_LENGTH)
                 throw new ArgumentOutOfRangeException(nameof(content));
 
             await socket.SendAsync(buffer, WebSocketMessageType.Binary, false, cancellationToken);
diff --git a/FastTunnel.Core/FastTunnelConst.cs b/FastTunnel.Core/FastTunnelConst.cs
index d7676a0..d1c62ac 100644
--- a/FastTunnel.Core/FastTunnelConst.cs
+++ b/FastTunnel.Core/FastTunnelConst.cs
@@ -15,5 +15,7 @@ namespace FastTunnel.Core
         public const string TYPE_CLIENT = "CLIENT";
 
         public const string TYPE_SWAP = "SWAP";
+
+        public const int CMD_MAX_LENGTH = 100;
     }
 }
diff --git a/FastTunnel.Core/Forwarder/MiddleWare/FastTunnelClientHandler.cs b/FastTunnel.Core/Forwarder/MiddleWare/FastTunnelClientHandler.cs
index 84a5d5a..b98d53d 100644
--- a/FastTunnel.Core/Forwarder/MiddleWare/FastTunnelClientHandler.cs
+++ b/FastTunnel.Core/Forwarder/MiddleWare/FastTunnelClientHandler.cs
@@ -46,8 +46,7 @@ namespace FastTunnel.Core.MiddleWares
         private async Task handleClient(HttpContext context, Func<Task> next)
         {
             using var webSocket = await context.WebSockets.AcceptWebSocketAsync();
-
-            var tunnelClient = new TunnelClient(logger, fastTunnelServer).SetSocket(webSocket);
+            var tunnelClient = context.RequestServices.GetRequiredService<TunnelClient>().SetSocket(webSocket);
 
             try
             {
diff --git a/FastTunnel.Core/Handlers/Client/SwapHandler.cs b/FastTunnel.Core/Handlers/Client/SwapHandler.cs
index 398711d..28b1ad3 100644
--- a/FastTunnel.Core/Handlers/Client/SwapHandler.cs
+++ b/FastTunnel.Core/Handlers/Client/SwapHandler.cs
@@ -34,8 +34,6 @@ namespace FastTunnel.Core.Handlers.Client
             var requestId = msgs[0];
             var address = msgs[1];
 
-            await Task.Yield();
-
             try
             {
                 using Stream serverStream = await createRemote(requestId, cleint, cancellationToken);
@@ -66,7 +64,7 @@ namespace FastTunnel.Core.Handlers.Client
             await connecter.ConnectAsync();
 
             Stream serverConn = new NetworkStream(connecter.Socket, true);
-            var reverse = $"PROXY /{requestId} HTTP/1.1\r\nHost: {cleint.Server.ServerAddr}:{cleint.Server.ServerPort}\r\nConnection: keep-alive\r\n\r\n";
+            var reverse = $"PROXY /{requestId} HTTP/1.1\r\nHost: {cleint.Server.ServerAddr}:{cleint.Server.ServerPort}\r\n\r\n";
 
             var requestMsg = Encoding.ASCII.GetBytes(reverse);
             await serverConn.WriteAsync(requestMsg, cancellationToken);
diff --git a/FastTunnel.Core/Handlers/Server/IClientMessageHandler.cs b/FastTunnel.Core/Handlers/Server/IClientMessageHandler.cs
index 9a8d1b2..2abe45a 100644
--- a/FastTunnel.Core/Handlers/Server/IClientMessageHandler.cs
+++ b/FastTunnel.Core/Handlers/Server/IClientMessageHandler.cs
@@ -13,6 +13,6 @@ namespace FastTunnel.Core.Handlers
     {
         bool NeedRecive { get; }
 
-        Task<bool> HandlerMsg<T>(FastTunnelServer server, WebSocket client, T msg) where T : TunnelMassage;
+        Task<bool> HandlerMsg(FastTunnelServer server, WebSocket client, string msg);
     }
 }
\ No newline at end of file
diff --git a/FastTunnel.Core/Handlers/Server/ILoginHandler.cs b/FastTunnel.Core/Handlers/Server/ILoginHandler.cs
new file mode 100644
index 0000000..29dbddb
--- /dev/null
+++ b/FastTunnel.Core/Handlers/Server/ILoginHandler.cs
@@ -0,0 +1,15 @@
+using FastTunnel.Core.Client;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FastTunnel.Core.Handlers.Server
+{
+    public interface ILoginHandler
+    {
+        Task<bool> HandlerMsg(FastTunnelServer fastTunnelServer, WebSocket webSocket, string lineCmd);
+    }
+}
diff --git a/FastTunnel.Core/Handlers/Server/LoginHandler.cs b/FastTunnel.Core/Handlers/Server/LoginHandler.cs
index 13fa8cd..22c87a6 100644
--- a/FastTunnel.Core/Handlers/Server/LoginHandler.cs
+++ b/FastTunnel.Core/Handlers/Server/LoginHandler.cs
@@ -10,28 +10,27 @@ using System.Linq;
 using System.Net.Sockets;
 using System.Net.WebSockets;
 using System.Text;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Yarp.ReverseProxy.Configuration;
 using Yarp.Sample;
 
-namespace FastTunnel.Core.Handlers
+namespace FastTunnel.Core.Handlers.Server
 {
-    public class LoginHandler : IClientMessageHandler
+    public class LoginHandler : ILoginHandler
     {
         ILogger _logger;
-
-        public bool NeedRecive => true;
-
         IProxyConfigProvider proxyConfig;
+        public const bool NeedRecive = true;
 
-        public LoginHandler(ILogger logger, IProxyConfigProvider proxyConfig)
+        public LoginHandler(ILogger<LoginHandler> logger, IProxyConfigProvider proxyConfig)
         {
             this.proxyConfig = proxyConfig;
             this._logger = logger;
         }
 
-        private async Task HandleLoginAsync(FastTunnelServer server, WebSocket client, LogInMassage requet)
+        protected async Task HandleLoginAsync(FastTunnelServer server, WebSocket client, LogInMassage requet)
         {
             bool hasTunnel = false;
 
@@ -48,7 +47,7 @@ namespace FastTunnel.Core.Handlers
                     server.WebList.AddOrUpdate(hostName, info, (key, oldInfo) => { return info; });
                     (proxyConfig as InMemoryConfigProvider).AddWeb(hostName);
 
-                    await client.SendCmdAsync(MessageType.Log, $"  HTTP   | http://{hostName}:{server.serverOption.CurrentValue.WebProxyPort} => {item.LocalIp}:{item.LocalPort}", CancellationToken.None);
+                    await client.SendCmdAsync(MessageType.Log, $"  HTTP   | http://{hostName} => {item.LocalIp}:{item.LocalPort}", CancellationToken.None);
 
                     if (item.WWW != null)
                     {
@@ -60,7 +59,7 @@ namespace FastTunnel.Core.Handlers
                             server.WebList.AddOrUpdate(www, info, (key, oldInfo) => { return info; });
                             (proxyConfig as InMemoryConfigProvider).AddWeb(hostName);
 
-                            await client.SendCmdAsync(MessageType.Log, $"  HTTP   | http://{www}:{server.serverOption.CurrentValue.WebProxyPort} => {item.LocalIp}:{item.LocalPort}", CancellationToken.None);
+                            await client.SendCmdAsync(MessageType.Log, $"  HTTP   | http://{www} => {item.LocalIp}:{item.LocalPort}", CancellationToken.None);
 
                         }
                     }
@@ -77,12 +76,6 @@ namespace FastTunnel.Core.Handlers
                     {
                         try
                         {
-                            if (item.RemotePort.Equals(server.serverOption.CurrentValue.WebProxyPort))
-                            {
-                                _logger.LogError($"RemotePort can not be same with ProxyPort_HTTP: {item.RemotePort}");
-                                continue;
-                            }
-
                             ForwardInfo<ForwardHandlerArg> old;
                             if (server.ForwardList.TryGetValue(item.RemotePort, out old))
                             {
@@ -120,10 +113,10 @@ namespace FastTunnel.Core.Handlers
                 await client.SendCmdAsync(MessageType.Log, TunnelResource.NoTunnel, CancellationToken.None);
         }
 
-        public async Task<bool> HandlerMsg<T>(FastTunnelServer server, WebSocket client, T msg)
-            where T : TunnelMassage
+        public virtual async Task<bool> HandlerMsg(FastTunnelServer server, WebSocket client, string content)
         {
-            await HandleLoginAsync(server, client, msg as LogInMassage);
+            var msg = JsonSerializer.Deserialize<LogInMassage>(content);
+            await HandleLoginAsync(server, client, msg);
             return NeedRecive;
         }
     }
diff --git a/FastTunnel.Core/Models/TunnelClient.cs b/FastTunnel.Core/Models/TunnelClient.cs
index c16c138..805acb2 100644
--- a/FastTunnel.Core/Models/TunnelClient.cs
+++ b/FastTunnel.Core/Models/TunnelClient.cs
@@ -1,6 +1,7 @@
 using FastTunnel.Core.Client;
 using FastTunnel.Core.Extensions;
 using FastTunnel.Core.Handlers;
+using FastTunnel.Core.Handlers.Server;
 using FastTunnel.Core.Protocol;
 using Microsoft.Extensions.Logging;
 using System;
@@ -18,16 +19,16 @@ namespace FastTunnel.Core.Models
 {
     public class TunnelClient
     {
-        readonly LoginHandler _loginHandler;
+        readonly ILoginHandler _loginHandler;
         FastTunnelServer fastTunnelServer;
         ILogger logger;
         WebSocket webSocket;
 
-        public TunnelClient(ILogger logger, FastTunnelServer fastTunnelServer)
+        public TunnelClient(ILogger<TunnelClient> logger, FastTunnelServer fastTunnelServer, ILoginHandler loginHandler)
         {
             this.logger = logger;
             this.fastTunnelServer = fastTunnelServer;
-            this._loginHandler = new LoginHandler(logger, fastTunnelServer.proxyConfig);
+            this._loginHandler = loginHandler;
         }
 
         public TunnelClient SetSocket(WebSocket webSocket)
@@ -38,7 +39,7 @@ namespace FastTunnel.Core.Models
 
         public async Task ReviceAsync(CancellationToken cancellationToken)
         {
-            var buffer = new byte[128];
+            var buffer = new byte[FastTunnelConst.CMD_MAX_LENGTH];
             var tunnelProtocol = new TunnelProtocol();
 
             while (true)
@@ -62,9 +63,7 @@ namespace FastTunnel.Core.Models
             try
             {
                 logger.LogDebug($"client：{lineCmd}");
-
-                var msg = JsonSerializer.Deserialize<LogInMassage>(lineCmd.Substring(1));
-                return await _loginHandler.HandlerMsg(fastTunnelServer, webSocket, msg);
+                return await _loginHandler.HandlerMsg(fastTunnelServer, webSocket, lineCmd.Substring(1));
             }
             catch (Exception ex)
             {
diff --git a/FastTunnel.Server/Program.cs b/FastTunnel.Server/Program.cs
index 52c9a10..27b1e7c 100644
--- a/FastTunnel.Server/Program.cs
+++ b/FastTunnel.Server/Program.cs
@@ -1,10 +1,12 @@
 using FastTunnel.Core.Extensions;
 using FastTunnel.Core.Services;
+using log4net.Repository.Hierarchy;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using Serilog;
 using System;
 
 namespace FastTunnel.Server
diff --git a/addhost.bat b/addhost.bat
index b8a76c8..fbeecbd 100644
--- a/addhost.bat
+++ b/addhost.bat
@@ -5,5 +5,7 @@ echo 127.0.0.1 test1.test.cc >>C:\Windows\System32\drivers\etc\hosts
 echo 127.0.0.1 test2.test.cc >>C:\Windows\System32\drivers\etc\hosts
 echo 127.0.0.1 test3.test.cc >>C:\Windows\System32\drivers\etc\hosts
 echo 127.0.0.1 www.abc.com >>C:\Windows\System32\drivers\etc\hosts
+echo 127.0.0.1 sd.test.cc >>C:\Windows\System32\drivers\etc\hosts
+echo 127.0.0.1 test9527.sd.test.cc >>C:\Windows\System32\drivers\etc\hosts
 
 pause
\ No newline at end of file