King_Tech/FastTunnel
King_Tech/FastTunnel
2
0
Fork 0
mirror of https://github.com/FastTunnel/FastTunnel.git synced 2024-09-20 23:48:30 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

=。=

Browse Source
This commit is contained in:
SpringHgui 2021-08-08 20:36:42 +08:00
parent 6e0d00bed5
commit 1e127f5e6e
15 changed files with 84 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
FastTunnel.Client/appsettings.json
View File

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

35
FastTunnel.Core/Client/FastTunnelClient.cs
View File

@ -41,6 +41,7 @@ namespace FastTunnel.Core.Client
_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);
}
}
}

2
FastTunnel.Core/Config/DefaultServerConfig.cs
View File

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

6
FastTunnel.Core/Config/IServerConfig.cs
View File

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

14
FastTunnel.Core/Extensions/ServicesExtensions.cs
View File

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

2
FastTunnel.Core/Extensions/WebSocketExtensions.cs
View File

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

2
FastTunnel.Core/FastTunnelConst.cs
View File

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

3
FastTunnel.Core/Forwarder/MiddleWare/FastTunnelClientHandler.cs
View File

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

4
FastTunnel.Core/Handlers/Client/SwapHandler.cs
View File

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

2
FastTunnel.Core/Handlers/Server/IClientMessageHandler.cs
View File

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

15
FastTunnel.Core/Handlers/Server/ILoginHandler.cs Normal file
View File

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

29
FastTunnel.Core/Handlers/Server/LoginHandler.cs
View File

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

13
FastTunnel.Core/Models/TunnelClient.cs
View File

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

2
FastTunnel.Server/Program.cs
View File

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

2
addhost.bat
View File

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