public void HandlerMsg(FastTunnelServer server, Socket client, Message <JObject> msg)
{
var SwapMsg = msg.Content.ToObject <SwapMassage>();
NewRequest request;
if (!string.IsNullOrEmpty(SwapMsg.msgId) && server.newRequest.TryGetValue(SwapMsg.msgId, out request))
{
server.newRequest.TryRemove(SwapMsg.msgId, out _);
// Join
new AsyncSocketSwap(request.CustomerClient, client)
.BeforeSwap(() => { if (request.Buffer != null)
{
client.Send(request.Buffer);
}
})
.StartSwapAsync();
}
else
{
// 未找到，关闭连接
_logger.LogError($"未找到请求:{SwapMsg.msgId}");
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Debug, $"未找到请求:{SwapMsg.msgId}")
});
}
}
public SuiDaoServer(ILogger <SuiDaoServer> logger, IConfiguration configuration)
{
_logger = logger;
_configuration = configuration;
_fastTunnelServer = new FastTunnelServer(_logger, _configuration.Get <Appsettings>().ServerSettings);
FastTunnelGlobal.AddCustomHandler <IConfigHandler, SuiDaoConfigHandler>(new SuiDaoConfigHandler());
}
public void HandlerMsg(FastTunnelServer server, Socket client, Message <JObject> msg)
{
lock (_locker)
{
HandleLogin(server, client, GetConfig(msg.Content));
}
}
public void HandlerMsg(FastTunnelServer server, Socket client, Message <JObject> msg)
{
client.SendCmd(new Message <HeartMassage>()
{
MessageType = MessageType.Heart, Content = null
});
}
public bool Authentication(FastTunnelServer server, LogInMassage requet)
{
if (string.IsNullOrEmpty(server.ServerSettings.Token))
{
return(true);
}
return(server.ServerSettings.Token.Equals(requet.Token));
}
public override async Task <bool> HandlerMsg(FastTunnelServer server, WebSocket client, string content)
{
var version = typeof(LoginHandler).Assembly.GetName().Version;
var versionLow = $"当前客户端版本低于服务端版本{version}，请下载最新的客户端：https://github.com/FastTunnel/SuiDao/releases";
var logMsg = System.Text.Json.JsonSerializer.Deserialize <LogInByKeyMassage>(content);
if (string.IsNullOrEmpty(logMsg.client_version) || Version.Parse(logMsg.client_version).Major < version.Major)
{
throw new Exception(versionLow);
}
var res = HttpHelper.PostAsJsonAsync(SuiDaoApi.GetTunnelListByKeyAndServerId, logMsg.ToJson()).Result;
var jobj = System.Text.Json.JsonSerializer.Deserialize <ApiResponse <Tunnel[]> >(res);
if (jobj.success)
{
var tunnels = jobj.data;
var Webs = new List <WebConfig>();
var SSH = new List <ForwardConfig>();
foreach (var tunnel in tunnels)
{
if (tunnel.app_type == 1) // web
{
Webs.Add(new WebConfig
{
LocalIp = tunnel.local_ip,
LocalPort = tunnel.local_port,
SubDomain = tunnel.sub_domain,
WWW = string.IsNullOrEmpty(tunnel.custom_domain) ? null : new string[] { tunnel.custom_domain }
});
}
else if (tunnel.app_type == 2)
{
SSH.Add(new ForwardConfig
{
LocalIp = tunnel.local_ip,
LocalPort = tunnel.local_port,
RemotePort = tunnel.remote_port,
});
}
}
await HandleLoginAsync(server, client, new LogInMassage
{
Forwards = SSH,
Webs = Webs,
});
return(NeedRecive);
}
else
{
throw new APIErrorException(jobj.errorMsg);
}
}
public ClientDispatcher(FastTunnelServer fastTunnelServer, ILogger logger, IServerConfig serverSettings)
{
_logger = logger;
_serverSettings = serverSettings;
_fastTunnelServer = fastTunnelServer;
_loginHandler = new LoginMessageHandler(logger);
_heartHandler = new HeartMessageHandler();
_swapMsgHandler = new SwapMessageHandler(logger);
}
public ServiceFastTunnelServer(
ILogger <ServiceFastTunnelServer> logger,
FastTunnelServer fastTunnelServer,
IAuthenticationFilter authenticationFilter)
{
_logger = logger;
_authenticationFilter = authenticationFilter;
_server = fastTunnelServer;
//AppDomain.CurrentDomain.FirstChanceException += CurrentDomain_FirstChanceException;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
}
private static void Run(Appsettings settings)
{
var logger = new ConsoleLogger();
var server = new FastTunnelServer(settings.ServerSettings, logger);
server.Run();
while (true)
{
Thread.Sleep(10000 * 60);
}
}
public ClientConnection(FastTunnelServer fastTunnelServer, Socket accept, ILogger logerr)
{
Socket = accept;
_logger = logerr;
_fastTunnelServer = fastTunnelServer;
_loginHandler = new LoginHandler(_logger);
_heartHandler = new HeartMessageHandler();
_swapMsgHandler = new SwapMessageHandler(_logger);
reader = new DataReciver(Socket);
}
public ClientListenerV2(FastTunnelServer fastTunnelServer, string ip, int port, ILogger logerr)
{
_fastTunnelServer = fastTunnelServer;
_logger = logerr;
this.ListenIp = ip;
this.ListenPort = port;
_loginHandler = new LoginHandler(_logger);
_heartHandler = new HeartMessageHandler();
_swapMsgHandler = new SwapMessageHandler(_logger);
server = new Server.Server(2000, 100, false, _logger);
}
public ClientListener(FastTunnelServer fastTunnelServer, string ip, int port, ILogger logerr)
{
_fastTunnelServer = fastTunnelServer;
_logerr = logerr;
this.ListenIp = ip;
this.ListenPort = port;
IPAddress ipa = IPAddress.Parse(ListenIp);
IPEndPoint localEndPoint = new IPEndPoint(ipa, ListenPort);
listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(localEndPoint);
}
public void HandlerMsg(FastTunnelServer server, Socket client, Message <JObject> msg)
{
var SwapMsg = msg.Content.ToObject <SwapMassage>();
NewRequest request;
if (SwapMsg.msgId.Contains("_"))
{
var interval = long.Parse(DateTime.Now.GetChinaTicks()) - long.Parse(SwapMsg.msgId.Split('_')[0]);
_logger.LogDebug($"[开始转发HTTP]：{SwapMsg.msgId} 客户端耗时：{interval}ms");
}
if (!string.IsNullOrEmpty(SwapMsg.msgId) && server.RequestTemp.TryGetValue(SwapMsg.msgId, out request))
{
server.RequestTemp.TryRemove(SwapMsg.msgId, out _);
_logger.LogDebug($"SwapMassage：{SwapMsg.msgId}");
new SocketSwap(request.CustomerClient, client, _logger, SwapMsg.msgId)
.BeforeSwap(() =>
{
if (request.Buffer != null)
{
client.Send(request.Buffer);
}
})
.StartSwap();
}
else
{
// 未找到，关闭连接
_logger.LogError($"未找到请求:{SwapMsg.msgId}");
client.SendCmd(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Debug, $"未找到请求:{SwapMsg.msgId}")
});
try
{
client.Shutdown(SocketShutdown.Both);
}
catch (Exception)
{
}
client.Close();
}
}
public Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("===== FastTunnel Server Starting =====");
_fastTunnelServer = new FastTunnelServer(_logger, _configuration.Get <AppSettings>().ServerSettings);
FastTunnelGlobal.AddFilter(_authenticationFilter);
try
{
_fastTunnelServer.Run();
_logger.LogDebug("Server Run Success");
}
catch (Exception ex)
{
// NLog: catch any exception and log it.
_logger.LogError(ex, "Server Error");
Console.WriteLine(ex);
}
return(Task.CompletedTask);
}
public void HandleLogin(FastTunnelServer server, Socket client, LogInMassage requet)
{
if (requet.Webs != null && requet.Webs.Count() > 0)
{
foreach (var item in requet.Webs)
{
var hostName = $"{item.SubDomain}.{server._serverSettings.Domain}".Trim();
if (server.WebList.ContainsKey(hostName))
{
_logger.LogDebug($"renew domain '{hostName}'");
server.WebList.Remove(hostName);
server.WebList.Add(hostName, new WebInfo {
Socket = client, WebConfig = item
});
}
else
{
_logger.LogDebug($"new domain '{hostName}'");
server.WebList.Add(hostName, new WebInfo {
Socket = client, WebConfig = item
});
}
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, $"TunnelForWeb is OK: you can visit {item.LocalIp}:{item.LocalPort} from http://{hostName}:{server._serverSettings.ProxyPort_HTTP}")
});
}
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, "web隧道已建立完毕")
});
}
if (requet.SSH != null && requet.SSH.Count() > 0)
{
foreach (var item in requet.SSH)
{
try
{
if (item.RemotePort.Equals(server._serverSettings.BindPort))
{
_logger.LogError($"RemotePort can not be same with BindPort: {item.RemotePort}");
continue;
}
if (item.RemotePort.Equals(server._serverSettings.ProxyPort_HTTP))
{
_logger.LogError($"RemotePort can not be same with ProxyPort_HTTP: {item.RemotePort}");
continue;
}
SSHInfo <SSHHandlerArg> old;
if (server.SSHList.TryGetValue(item.RemotePort, out old))
{
_logger.LogDebug($"Remove Listener {old.Listener.IP}:{old.Listener.Port}");
old.Listener.ShutdownAndClose();
server.SSHList.Remove(item.RemotePort);
}
var ls = new Listener <SSHHandlerArg>("0.0.0.0", item.RemotePort, _logger,
(client, local) =>
{
var msgid = Guid.NewGuid().ToString();
local.LocalClient.Send(new Message <NewSSHRequest> {
MessageType = MessageType.S_NewSSH, Content = new NewSSHRequest {
MsgId = msgid, SSHConfig = local.SSHConfig
}
});
server.newRequest.Add(msgid, new NewRequest
{
CustomerClient = client,
});
}
, new SSHHandlerArg {
LocalClient = client, SSHConfig = item
});
ls.Listen();
// listen success
server.SSHList.Add(item.RemotePort, new SSHInfo <SSHHandlerArg> {
Listener = ls, Socket = client, SSHConfig = item
});
_logger.LogDebug($"SSH proxy success: {item.RemotePort} -> {item.LocalIp}:{item.LocalPort}");
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, $"TunnelForSSH is OK: [ServerAddr]:{item.RemotePort}->{item.LocalIp}:{item.LocalPort}")
});
}
catch (Exception ex)
{
_logger.LogError($"SSH proxy error: {item.RemotePort} -> {item.LocalIp}:{item.LocalPort}");
_logger.LogError(ex.Message);
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, ex.Message)
});
continue;
}
}
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, "远程桌面隧道已建立完毕")
});
}
}
public void HandleLogin(FastTunnelServer server, Socket client, LogInMassage requet)
{
bool hasTunnel = false;
var filters = FastTunnelGlobal.GetFilters(typeof(IFastTunnelAuthenticationFilter));
if (filters.Count() > 0)
{
foreach (IFastTunnelAuthenticationFilter item in filters)
{
var result = item.Authentication(server, requet);
if (!result)
{
client.Send(new Message <LogMassage>
{
MessageType = MessageType.Log,
Content = new LogMassage(LogMsgType.Error, "认证失败")
});
return;
}
}
}
var sb = new StringBuilder($"{Environment.NewLine}=====隧道已建立成功，可通过以下方式访问内网服务====={Environment.NewLine}");
if (requet.Webs != null && requet.Webs.Count() > 0)
{
hasTunnel = true;
foreach (var item in requet.Webs)
{
var hostName = $"{item.SubDomain}.{server.ServerSettings.WebDomain}".Trim();
var info = new WebInfo {
Socket = client, WebConfig = item
};
_logger.LogDebug($"new domain '{hostName}'");
server.WebList.AddOrUpdate(hostName, info, (key, oldInfo) => { return(info); });
sb.Append($"{Environment.NewLine} http://{hostName}{(server.ServerSettings.WebHasNginxProxy ? string.Empty : ":" + server.ServerSettings.WebProxyPort)} => {item.LocalIp}:{item.LocalPort}");
if (item.WWW != null)
{
foreach (var www in item.WWW)
{
if (!www.EndsWith(server.ServerSettings.WebDomain))
{
server.WebList.AddOrUpdate(www, info, (key, oldInfo) => { return(info); });
sb.Append($"{Environment.NewLine} http://{www}{(server.ServerSettings.WebHasNginxProxy ? string.Empty : ":" + server.ServerSettings.WebProxyPort)} => {item.LocalIp}:{item.LocalPort}");
}
else
{
// can`t use WebDomain
_logger.LogError($"Invalid WebDomain IN WWW {www}");
}
}
}
}
}
if (requet.SSH != null && requet.SSH.Count() > 0)
{
hasTunnel = true;
foreach (var item in requet.SSH)
{
try
{
if (item.RemotePort.Equals(server.ServerSettings.BindPort))
{
_logger.LogError($"RemotePort can not be same with BindPort: {item.RemotePort}");
continue;
}
if (item.RemotePort.Equals(server.ServerSettings.WebProxyPort))
{
_logger.LogError($"RemotePort can not be same with ProxyPort_HTTP: {item.RemotePort}");
continue;
}
SSHInfo <SSHHandlerArg> old;
if (server.SSHList.TryGetValue(item.RemotePort, out old))
{
_logger.LogDebug($"Remove Listener {old.Listener.ListenIp}:{old.Listener.ListenPort}");
old.Listener.Stop();
server.SSHList.TryRemove(item.RemotePort, out SSHInfo <SSHHandlerArg> _);
}
var ls = new PortProxyListener("0.0.0.0", item.RemotePort, _logger);
ls.Start(new SSHDispatcher(server, client, item));
// listen success
server.SSHList.TryAdd(item.RemotePort, new SSHInfo <SSHHandlerArg> {
Listener = ls, Socket = client, SSHConfig = item
});
_logger.LogDebug($"SSH proxy success: {item.RemotePort} => {item.LocalIp}:{item.LocalPort}");
sb.Append($"{Environment.NewLine} {server.ServerSettings.WebDomain}:{item.RemotePort} => {item.LocalIp}:{item.LocalPort}");
}
catch (Exception ex)
{
_logger.LogError($"SSH proxy error: {item.RemotePort} => {item.LocalIp}:{item.LocalPort}");
_logger.LogError(ex.Message);
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, ex.Message)
});
continue;
}
}
}
if (!hasTunnel)
{
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, TunnelResource.NoTunnel)
});
}
else
{
sb.Append($"{Environment.NewLine}{Environment.NewLine}====================================================");
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, sb.ToString())
});
}
}
public ServiceFastTunnelServer(ILogger <ServiceFastTunnelServer> logger, IConfiguration configuration)
{
_logger = logger;
_fastTunnelServer = new FastTunnelServer(_logger, configuration.Get <Appsettings>().ServerSettings);
}
public SuiDaoServer(ILogger <SuiDaoServer> logger, IConfiguration configuration, FastTunnelServer fastTunnelServer)
{
_logger = logger;
_configuration = configuration;
_fastTunnelServer = fastTunnelServer;
}
public void HandleLogin(FastTunnelServer server, Socket client, LogInMassage requet)
{
bool hasTunnel = false;
var sb = new StringBuilder($"{Environment.NewLine}=====隧道已建立成功，可通过以下方式访问内网服务====={Environment.NewLine}");
if (requet.Webs != null && requet.Webs.Count() > 0)
{
hasTunnel = true;
foreach (var item in requet.Webs)
{
var hostName = $"{item.SubDomain}.{server._serverSettings.Domain}".Trim();
if (server.WebList.ContainsKey(hostName))
{
_logger.LogDebug($"renew domain '{hostName}'");
server.WebList.Remove(hostName);
server.WebList.Add(hostName, new WebInfo {
Socket = client, WebConfig = item
});
}
else
{
_logger.LogDebug($"new domain '{hostName}'");
server.WebList.Add(hostName, new WebInfo {
Socket = client, WebConfig = item
});
}
sb.Append($"{Environment.NewLine} http://{hostName}{(server._serverSettings.HasNginxProxy ? string.Empty : ":" + server._serverSettings.ProxyPort_HTTP)} => {item.LocalIp}:{item.LocalPort}");
}
}
if (requet.SSH != null && requet.SSH.Count() > 0)
{
hasTunnel = true;
foreach (var item in requet.SSH)
{
try
{
if (item.RemotePort.Equals(server._serverSettings.BindPort))
{
_logger.LogError($"RemotePort can not be same with BindPort: {item.RemotePort}");
continue;
}
if (item.RemotePort.Equals(server._serverSettings.ProxyPort_HTTP))
{
_logger.LogError($"RemotePort can not be same with ProxyPort_HTTP: {item.RemotePort}");
continue;
}
SSHInfo <SSHHandlerArg> old;
if (server.SSHList.TryGetValue(item.RemotePort, out old))
{
_logger.LogDebug($"Remove Listener {old.Listener.IP}:{old.Listener.Port}");
old.Listener.ShutdownAndClose();
server.SSHList.Remove(item.RemotePort);
}
var ls = new Listener <SSHHandlerArg>("0.0.0.0", item.RemotePort, _logger,
(client, local) =>
{
var msgid = Guid.NewGuid().ToString();
local.LocalClient.Send(new Message <NewSSHRequest> {
MessageType = MessageType.S_NewSSH, Content = new NewSSHRequest {
MsgId = msgid, SSHConfig = local.SSHConfig
}
});
server.newRequest.Add(msgid, new NewRequest
{
CustomerClient = client,
});
}
, new SSHHandlerArg {
LocalClient = client, SSHConfig = item
});
ls.Listen();
// listen success
server.SSHList.Add(item.RemotePort, new SSHInfo <SSHHandlerArg> {
Listener = ls, Socket = client, SSHConfig = item
});
_logger.LogDebug($"SSH proxy success: {item.RemotePort} => {item.LocalIp}:{item.LocalPort}");
sb.Append($"{Environment.NewLine} {server._serverSettings.Domain}:{item.RemotePort} => {item.LocalIp}:{item.LocalPort}");
}
catch (Exception ex)
{
_logger.LogError($"SSH proxy error: {item.RemotePort} => {item.LocalIp}:{item.LocalPort}");
_logger.LogError(ex.Message);
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, ex.Message)
});
continue;
}
}
}
if (!hasTunnel)
{
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, TunnelResource.NoTunnel)
});
}
else
{
sb.Append($"{Environment.NewLine}{Environment.NewLine}====================================================");
client.Send(new Message <LogMassage> {
MessageType = MessageType.Log, Content = new LogMassage(LogMsgType.Info, sb.ToString())
});
}
}
public TunnelController(FastTunnelServer fastTunnelServer)
{
_fastTunnelServer = fastTunnelServer;
}
public SSHDispatcher(FastTunnelServer server, Socket client, SSHConfig config)
{
_server = server;
_client = client;
_config = config;
}
public virtual bool Authentication(FastTunnelServer server, LogInMassage requet)
{
return(true);
}
public bool Authentication(FastTunnelServer server, LogInMassage requet)
{
return(!string.IsNullOrEmpty(requet.AuthInfo) && requet.AuthInfo.Equals("ODadoNDONODHSoDMFMsdpapdoNDSHDoadpwPDNoWAHDoNfa"));
}
public HttpDispatcherV2(FastTunnelServer fastTunnelServer, ILogger logger, IServerConfig serverSettings)
{
_logger = logger;
_serverSettings = serverSettings;
_fastTunnelServer = fastTunnelServer;
}
