static void ChangeMap(Map map)
{
if (MapList == null)
{
MapList = new List <Map>();
}
switch (map.ChangeType)
{
case (int)ChangeMapType.新增:
MapList.Add(map);
break;
case (int)ChangeMapType.修改:
var item = MapList.Find(c => c.id == map.id);
if (item != null)
{
item = map;
}
else
{
MapList.Add(map);
}
break;
case (int)ChangeMapType.除:
MapList.RemoveAll(c => c.id == map.id);
break;
}
HandleLog.WriteLine($"映射{Enum.GetName(typeof(ChangeMapType), map.ChangeType)}成功：{JsonHelper.Instance.Serialize(map)}", false);
HandleLog.WriteLine($"【{map.name}】映射{Enum.GetName(typeof(ChangeMapType), map.ChangeType)}成功：{map.local} --> {map.remote}");
}
public void Init()
{
TcpClient = new EasyClient <ClientPackageInfo>()
{
NoDelay = true
//Security = new SecurityOption()
//{
// EnabledSslProtocols = System.Security.Authentication.SslProtocols.Tls12,
// AllowNameMismatchCertificate = true,
// AllowCertificateChainErrors = true,
// AllowUnstrustedCertificate = true
//}
};
TcpClient.Initialize(new ClientReceiveFilter());
TcpClient.Connected += OnClientConnected;
TcpClient.NewPackageReceived += OnPackageReceived;
TcpClient.Error += OnClientError;
TcpClient.Closed += OnClientClosed;
var arr = PackJson.Local.Split(":");
var ip = arr[0];
int.TryParse(arr[1], out int port);
mark:
var res = TcpClient.ConnectAsync(new IPEndPoint(IPAddress.Parse(ip), port)).Result;
while (!res)
{
HandleLog.WriteLine($"{PackJson.UserId}连接{PackJson.Local}失败,1s后重新连接...");
Thread.Sleep(1000);
goto mark;
}
LocalEndPoint = TcpClient.LocalEndPoint?.ToString();
}
private void OnPackageReceived(Socket socket, NatPackageInfo packageInfo)
{
Task.Run(() =>
{
var tcpModel = packageInfo.Raw;
//先gzip压缩 再转为16进制字符串
var body = DataHelper.Compress(packageInfo.Raw);
var pack = PackHelper.CreatePack(new JsonData()
{
Type = (int)JsonType.TCP,
Action = (int)TcpAction.TransferData,
Data = new TcpModel()
{
ServerId = RemoteSession.ServerId,
Host = RemoteSession.Host,
Local = RemoteSession.Local,
SessionId = RemoteSession.SessionId,
Content = body
}.ToJson()
});
//转发给服务器
NatClient.Send(pack);
HandleLog.WriteLine($"<---- {RemoteSession.SessionId} 收到报文{packageInfo.Raw.Length}字节");
});
}
private static void StartNATServer(int port)
{
Task.Run(async() =>
{
try
{
NATServer = new NatServer(new ServerOption()
{
Ip = "Any",
Port = port,
ProtocolType = ProtocolType.Tcp,
BackLog = 100,
NoDelay = true,
Security = SslProtocols.Tls12,
SslServerAuthenticationOptions = new SslServerAuthenticationOptions
{
EnabledSslProtocols = SslProtocols.Tls12,
ClientCertificateRequired = false,
ServerCertificate = new X509Certificate2(GlobalConfig.CertFile, GlobalConfig.CertPassword)
}
});
NATServer.OnConnected += Connected;
NATServer.OnReceived += Received;
NATServer.OnClosed += Closed;
await NATServer.StartAsync();
HandleLog.WriteLine($"NAT服务启动成功，监听端口：{port}");
}
catch (Exception ex)
{
HandleLog.WriteLine($"NAT服务启动失败，端口：{port}，{ex}");
}
});
}
public static void ChangeMap(int type, Map map)
{
try
{
map.ChangeType = type;
ChangeMapList(map);
var natClient = NATServer.GetSingle(c => c.Client?.id == map.client_id);
if (natClient == null)
{
return;
}
ChangeMap(map, natClient);
var pack = PackHelper.CreatePack(new JsonData()
{
Type = (int)JsonType.NAT,
Action = (int)NatAction.MapChange,
Data = map.ToJson()
});
natClient.Send(pack);
}
catch (Exception ex)
{
HandleLog.WriteLine($"映射更新异常：{ex}，参数为：{JsonHelper.Instance.Serialize(map)}");
}
}
/// <summary>
/// 异步接收数据
/// </summary>
/// <param name="session"></param>
private async void ProcessReadAsync(TSession session)
{
try
{
while (true)
{
ReadResult result = await session.Reader.ReadAsync();
ReadOnlySequence <byte> buffer = result.Buffer;
SequencePosition consumed = buffer.Start;
SequencePosition examined = buffer.End;
try
{
if (result.IsCanceled)
{
break;
}
var completed = result.IsCompleted;
if (buffer.Length > 0)
{
if (!ReaderBuffer(session, ref buffer, out consumed, out examined))
{
completed = true;
break;
}
}
if (completed)
{
break;
}
}
catch (Exception e)
{
HandleLog.WriteLine($"ProcessReadAsync error,{e.Message}");
break;
}
finally
{
session.Reader.AdvanceTo(consumed, examined);
}
}
// Mark the PipeReader as complete.
await session.Reader.CompleteAsync();
}
catch (Exception ex)
{
HandleLog.WriteLine($"ProcessReadAsync error,{ex.Message}");
}
finally
{
// close the connection if get a protocol error
Close(session);
}
}
static void ChangeMapList(Map map)
{
try
{
switch (map.ChangeType)
{
case (int)ChangeMapType.新增:
MapList.Add(map);
break;
case (int)ChangeMapType.修改:
MapList.RemoveAll(c => c.id == map.id);
MapList.Add(map);
break;
case (int)ChangeMapType.除:
MapList.RemoveAll(c => c.id == map.id);
break;
}
HandleLog.WriteLine($"服务映射缓存{Enum.GetName(typeof(ChangeMapType), map.ChangeType)}成功：{JsonHelper.Instance.Serialize(map)}", false);
HandleLog.WriteLine($"【{map.name}】服务映射缓存{Enum.GetName(typeof(ChangeMapType), map.ChangeType)}成功：{map.local_endpoint} --> {map.remote_endpoint}");
}
catch (Exception ex)
{
throw ex;
}
}
public virtual bool Start()
{
try
{
IPEndPoint localEndPoint = new IPEndPoint(ServerOption.Ip == "Any" ? IPAddress.Any : IPAddress.Parse(ServerOption.Ip), ServerOption.Port);
listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ServerOption.ProtocolType);
listenSocket.Bind(localEndPoint);
listenSocket.Listen(ServerOption.BackLog);
listenSocket.NoDelay = ServerOption.NoDelay;
//循环接收连接的任务
Task.Run(async() =>
{
while (true)
{
var socket = await listenSocket.AcceptAsync();
ProcessSocketAsync(socket);
}
});
return(true);
}
catch (Exception ex)
{
HandleLog.WriteLine($"【{ServerOption.Port}】端口启动监听异常：{ex}");
return(false);
}
}
public void OnPackageReceived(object sender, PackageEventArgs <ClientPackageInfo> e)
{
Task.Run(() =>
{
//先gzip压缩 再转为16进制字符串
var body = DataHelper.Compress(e.Package.Data);
var pack = new PackJson()
{
Host = PackJson.Host,
UserId = PackJson.UserId,
Content = body
};
var json = JsonHelper.Instance.Serialize(pack);
var jsonBytes = Encoding.UTF8.GetBytes(json);
//03 02 数据长度(4) 正文数据(n) ---tcp响应包
var sendBytes = new List <byte>()
{
0x3, 0x2
};
sendBytes.AddRange(BitConverter.GetBytes(jsonBytes.Length).Reverse());
sendBytes.AddRange(jsonBytes);
//转发给服务器
NatClient.Send(sendBytes.ToArray());
HandleLog.WriteLine($"<---- {PackJson.UserId} 收到报文{e.Package.Data.Length}字节");
});
}
private static void StartHttpsServer(ServerConfig serverConfig)
{
try
{
foreach (var port in serverConfig.port_list)
{
var server = new HttpsServer(new ServerOption()
{
Ip = "Any",
Port = port,
ProtocolType = ProtocolType.Tcp,
BackLog = 100,
NoDelay = true,
Security = serverConfig.is_ssl ? SslProtocols.Tls12 : SslProtocols.None,
SslServerAuthenticationOptions = serverConfig.is_ssl ? new SslServerAuthenticationOptions
{
EnabledSslProtocols = SslProtocols.Tls12,
ServerCertificate = new X509Certificate2(string.IsNullOrEmpty(serverConfig.certfile) ? GlobalConfig.CertFile : serverConfig.certfile, string.IsNullOrEmpty(serverConfig.certpwd) ? GlobalConfig.CertPassword : serverConfig.certpwd)
} : null
})
{
NATServer = NATServer
};
_ = server.StartAsync();
HttpsServerList.Add(server);
}
HandleLog.WriteLine($"{serverConfig.protocol}服务启动成功，监听端口：{serverConfig.port}");
}
catch (Exception ex)
{
HandleLog.WriteLine($"{serverConfig.protocol}服务初始化失败，端口：{serverConfig.port}，{ex}");
}
}
private void Received(TcpSession session, NatRequestInfo requestInfo)
{
Task.Run(() =>
{
try
{
while (session.NatSession == null)
{
Thread.Sleep(50);
}
//先gzip压缩 再转为16进制字符串
var body = DataHelper.Compress(requestInfo.Raw);
//转发数据
var pack = new JsonData()
{
Type = (int)JsonType.TCP,
Action = (int)TcpAction.TransferData,
Data = new TcpModel()
{
ServerId = ServerId,
Host = session.Map?.remote_endpoint,
Local = session.Map?.local_endpoint,
SessionId = session.SessionId,
Content = body
}.ToJson()
};
session.NatSession.Send(PackHelper.CreatePack(pack));
HandleLog.WriteLine($"<---- {session.SessionId} 收到报文{body.Length}字节");
}
catch (Exception ex)
{
HandleLog.WriteLine($"【{session.Local}】请求参数：{requestInfo.Raw.ToHexWithSpace()}，处理发生异常：{ex}");
}
});
}
public void StartAllServer()
{
try
{
var bll = new ServerConfigBll();
var serverList = bll.GetList("").Data ?? new List <ServerConfig>();
if (serverList.Any())
{
foreach (var item in serverList)
{
switch (item.protocol)
{
case "http":
//StartHttpServer(item);
//break;
case "https":
StartHttpsServer(item);
break;
case "tcp":
case "udp":
StartTcpServer(item);
break;
}
}
}
}
catch (Exception ex)
{
HandleLog.WriteLine($"启动服务失败：{ex}");
}
}
private static void StartWebServer(Common.Models.ServerConfig serverConfig)
{
if (serverConfig.port_list.Any())
{
var server = new HttpAppServer()
{
ServerConfig = serverConfig
};
bool setup = server.Setup(new RootConfig()
{
DisablePerformanceDataCollector = true
}, new CSuperSocket.SocketBase.Config.ServerConfig()
{
Listeners = from s in serverConfig.port_list
select new ListenerConfig
{
Ip = "Any",
Port = s
}, //批量监听
TextEncoding = "ASCII",
MaxRequestLength = 102400,
MaxConnectionNumber = 1000,
ReceiveBufferSize = 102400,
SendBufferSize = 102400,
LogBasicSessionActivity = true,
LogAllSocketException = true,
SyncSend = false,
Security = serverConfig.ssl_type == null ? null : Enum.GetName(typeof(ssl_type), serverConfig.ssl_type),
Certificate = serverConfig.ssl_type == null ? null : new CertificateConfig()
{
FilePath = string.IsNullOrEmpty(serverConfig.certfile) ? CertFile : serverConfig.certfile,
Password = string.IsNullOrEmpty(serverConfig.certpwd) ? CertPassword : serverConfig.certpwd,
ClientCertificateRequired = false
},
DisableSessionSnapshot = true,
SessionSnapshotInterval = 1
});
if (setup)
{
var start = server.Start();
if (start)
{
server.NewSessionConnected += WebServer_NewSessionConnected;
server.NewRequestReceived += WebServer_NewRequestReceived;
server.SessionClosed += WebServer_SessionClosed;
HttpServerList.Add(server);
HandleLog.WriteLine($"{serverConfig.protocol}服务启动成功，监听端口：{serverConfig.port}");
}
else
{
HandleLog.WriteLine($"{serverConfig.protocol}服务启动失败，端口：{serverConfig.port}");
}
}
else
{
HandleLog.WriteLine($"{serverConfig.protocol}服务初始化失败，端口：{serverConfig.port}");
}
}
}
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
var ex = e.ExceptionObject as Exception;
var oldColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
HandleLog.WriteLine(ex.Message);
Console.ForegroundColor = oldColor;
}
public HomeController(ILogger <HomeController> logger, AppDbContext appDbContext,
IWebHostEnvironment webHostEnvironment, HandleLog handleLog, HandleLogByLine handleLogParallel)
{
_logger = logger;
this.appDbContext = appDbContext;
hostingEnvironment = webHostEnvironment;
this.handleLog = handleLog;
this.handleLogParallel = handleLogParallel;
}
public static void Init()
{
var builder = new ConfigurationBuilder()
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
.AddJsonFile("appsettings.json", false);
var configuration = builder.Build();
//加载配置到全局
GlobalConfig.ConnetionString = configuration.GetValue <string>("DBConfig:ConnetionString");
GlobalConfig.NatPort = configuration.GetValue <int>("ServerConfig:NatPort");
GlobalConfig.ServerPort = configuration.GetValue <int>("ServerConfig:ServerPort");
GlobalConfig.DefaultUrl = configuration.GetValue <string>("ServerConfig:DefaultUrl");
GlobalConfig.RegRoleId = configuration.GetValue <string>("ServerConfig:RegRoleId");
Repository = LogManager.CreateRepository("NETCoreRepository");
XmlConfigurator.Configure(Repository, new FileInfo("log4net.config"));
Log4netUtil.LogRepository = Repository;//类库中定义的静态变量
HandleLog.WriteLog += (log, isPrint) =>
{
if (isPrint)
{
Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss,ffff} {log}");
}
Log4netUtil.Info(log);
};
Task.Run(() =>
{
while (true)
{
//更新假在线的主机
using var bll = new ClientBll();
var res = bll.UpdateOfflineClient();
HandleLog.WriteLine(res.Message, false);
Thread.Sleep(60000);
}
});
var appSettingSetion = configuration.GetSection("AppSettingConfig");
var appSettingConfig = appSettingSetion.Get <AppSettingConfig>();
IocUnity.AddSingleton <AppSettingConfig>(appSettingConfig);
//var setion = configuration.GetSection("SimpleSocketConfig");
//var simpleConfig = setion.Get<SimpleSocketConfig>();
//IocUnity.AddSingleton<SimpleSocketConfig>(simpleConfig);
var loggerSection = configuration.GetSection("LogConfig");
var logConfig = loggerSection.Get <LogConfig>();
logConfig.LogBaseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, logConfig.LogBaseDir);
IocUnity.AddSingleton <LogConfig>(logConfig);
InitAppSetting();
InitLog();
}
private static void StartWebServer()
{
if (GlobalConfig.WebPortList.Any())
{
HttpServer = new HttpAppServer();
bool setup = HttpServer.Setup(new RootConfig()
{
DisablePerformanceDataCollector = true
}, new ServerConfig()
{
Listeners = from s in GlobalConfig.WebPortList
select new ListenerConfig
{
Ip = "Any",
Port = s
}, //批量监听
TextEncoding = "ASCII",
MaxRequestLength = 102400,
MaxConnectionNumber = 1000,
ReceiveBufferSize = 102400,
SendBufferSize = 102400,
LogBasicSessionActivity = true,
LogAllSocketException = true,
SyncSend = false,
//Security = "tls12",
//Certificate = new CertificateConfig()
//{
// FilePath = CertFile,
// Password = CertPassword,
// ClientCertificateRequired = false
//},
DisableSessionSnapshot = true,
SessionSnapshotInterval = 1
});
if (setup)
{
var start = HttpServer.Start();
if (start)
{
HttpServer.NewSessionConnected += WebServer_NewSessionConnected;
HttpServer.NewRequestReceived += WebServer_NewRequestReceived;
HttpServer.SessionClosed += WebServer_SessionClosed;
HandleLog.WriteLine($"Web服务启动成功，监听端口：{GlobalConfig.WebPort}");
}
else
{
HandleLog.WriteLine($"Web服务启动失败，端口：{GlobalConfig.WebPort}");
}
}
else
{
HandleLog.WriteLine($"Web服务初始化失败，端口：{GlobalConfig.WebPort}");
}
}
}
private void Closed(TcpSession session)
{
try
{
CloseLocalClient(session);
HandleLog.WriteLine($"客户端【{session.SessionId},{session.Remote}】已下线");
}
catch (Exception ex)
{
HandleLog.WriteLine($"关闭连接【{session.Local}】发生异常：{ex}");
}
}
static void OnPackageReceived(Socket socket, NatPackageInfo packageInfo)
{
Task.Run(() =>
{
switch (packageInfo.Body.Type)
{
case (byte)JsonType.NAT:
NatClient.ProcessData(socket, packageInfo);
break;
case (byte)JsonType.HTTP:
HttpClientProxy.ProcessData(NatClient, packageInfo);
break;
case (byte)JsonType.TCP:
{
int waitTimes = 50;
var tcpModel = packageInfo.Body.Data.FromJson <TcpModel>();
TcpClientProxy clientProxy = null;
mark:
clientProxy = TcpClientProxyList.Find(c => c.RemoteSession.SessionId == tcpModel.SessionId);
if (packageInfo.Body.Action == (int)TcpAction.TransferData)
{
if ((clientProxy == null || !clientProxy.IsConnected) && waitTimes >= 0)
{
HandleLog.WriteLine($"----> {tcpModel.SessionId} 未连接 IsConnected={clientProxy?.IsConnected.ToString() ?? "NULL"} ProxyCount={TcpClientProxyList.Count}");
Thread.Sleep(100);
waitTimes--;
goto mark;
}
}
if (clientProxy == null)
{
var arr = tcpModel.Local.Split(":");
var ip = arr[0];
int.TryParse(arr[1], out int port);
clientProxy = new TcpClientProxy(new ClientOptions()
{
Ip = ip,
Port = port,
NoDelay = true,
ProtocolType = ProtocolType.Tcp
})
{
NatClient = NatClient
};
}
clientProxy.ProcessData(NatClient, packageInfo);
break;
}
}
});
}
private static void TcpServer_SessionClosed(TcpAppSession session, CSuperSocket.SocketBase.CloseReason value)
{
try
{
CloseLocalClient(session);
HandleLog.WriteLine($"客户端【{session.PackJson.UserId},{session.RemoteEndPoint}】已下线：{value}");
}
catch (Exception ex)
{
HandleLog.WriteLine($"关闭连接【{session.LocalEndPoint}】发生异常：{ex}");
}
}
public void ProcessData(Socket socket, NatPackageInfo packageInfo)
{
try
{
switch (packageInfo.Body.Action)
{
case (int)NatAction.Connect:
{
//注册包回复
Client = packageInfo.Body.Data.FromJson <Model.Client>();
if (Client.MapList == null)
{
Client.MapList = new List <Map>();
}
HandleLog.WriteLine($"【{Client.user_name},{Client.name}】主机密钥验证成功！");
if (Client.MapList.Any())
{
foreach (var item in Client.MapList)
{
HandleLog.WriteLine($"【{item.name}】映射成功：{item.local_endpoint} --> {item.remote_endpoint}");
}
}
else
{
HandleLog.WriteLine($"端口映射列表为空,请到管理后台创建映射！");
}
}
break;
case (int)NatAction.MapChange:
{
//Map变动
var map = packageInfo.Body.Data.FromJson <Map>();
ChangeMap(map);
}
break;
case (int)NatAction.ServerMessage:
{
//服务端消息
var msg = packageInfo.Body.Data.FromJson <ServerMessage>();
ClientHandler.IsReConnect = msg.ReConnect;
HandleLog.WriteLine(msg.Message);
}
break;
}
}
catch (Exception ex)
{
HandleLog.WriteLine($"客户端处理穿透业务异常，{ex}");
}
}
public void SendServerMessage(NatSession session, ServerMessage serverMessage)
{
HandleLog.WriteLine(serverMessage.Message);
var pack = new JsonData()
{
Type = (int)JsonType.NAT,
Action = (int)NatAction.ServerMessage,
Data = serverMessage.ToJson()
};
//转发给客户端
session?.Send(PackHelper.CreatePack(pack));
}
public void Close()
{
try
{
IsConnected = false;
OnClosed?.Invoke(Socket);
Socket?.Close();
}
catch (Exception ex)
{
HandleLog.WriteLine($"Socket Close Error,{ex}");
}
}
static void ReConnect()
{
while (IsReConnect)
{
Thread.Sleep(3000);
if (!NatClient.IsConnected && !isLock)
{
//重连
HandleLog.WriteLine("尝试重新连接服务器...");
ConnectNatServer();
}
}
}
static void ReConnect()
{
while (!IsStop)
{
Thread.Sleep(5000);
if (!NatClient.IsConnected)
{
//重连
HandleLog.WriteLine("尝试重新连接服务器...");
ConnectNatServer();
}
}
}
public void Close(TSession session)
{
try
{
m_sessionManager.Remove(session);
OnClosed?.Invoke(session);
session.Socket?.Close();
}
catch (Exception ex)
{
HandleLog.WriteLine(ex.Message);
}
}
public bool DeviceDataChanged(object data)
{
var rst = (ResponseResult <object>)data;
//var serviceData = JsonHelper.Instance.Deserialize<Alarm>(rst.service.data.ToString());
HandleLog.WriteLog($"服务Id：{rst.service.serviceId}");
HandleLog.WriteLog($"服务类型：{rst.service.serviceType}");
HandleLog.WriteLog($"服务数据：{Environment.NewLine}{rst.service.data.ToString()}");
//HandleLog.WriteLog($"燃气值：{serviceData.FuelGas}");
//HandleLog.WriteLog($"结束符：{serviceData.EndFlag}");
return(true);
}
private static void NATServer_SessionClosed(NatAppSession session, CSuperSocket.SocketBase.CloseReason value)
{
HandleLog.WriteLine($"内网客户端【{session.RemoteEndPoint}】已下线");
Task.Run(() =>
{
//更新在线状态
using var bll = new ClientBll();
var updateRst = bll.UpdateOnlineStatus(new Client()
{
secret = session.Client.secret, is_online = false
});
HandleLog.WriteLine($"更新主机【{session.Client.name}】离线状态结果：{updateRst.Message}");
});
}
public void Start()
{
//TODO Console.WriteLine放在线程里会阻塞 放在主线程待测试是否阻塞
HandleLog.WriteLog += (log, isPrint) =>
{
if (isPrint)
{
Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss,ffff} {log}");
}
Log4netUtil.Info(log);
};
Task.Run(() =>
{
try
{
Repository = LogManager.CreateRepository("NETCoreRepository");
XmlConfigurator.Configure(Repository, new FileInfo("log4net.config"));
Log4netUtil.LogRepository = Repository;//类库中定义的静态变量
//加载映射列表
var maps = GetMapList(Secret);
while (!maps.Result && maps.Status == -1)
{
maps = GetMapList(Secret);
//请求失败5s后重新请求
HandleLog.WriteLine($"请求获取映射列表失败！5s后重新请求！");
Thread.Sleep(5000);
}
MapList = maps.Data ?? new List <Map>();
//连接服务器
ConnectNatServer();
//开启重连线程
reConnectThread = new Thread(ReConnect)
{
IsBackground = true
};
reConnectThread.Start();
//开启心跳线程
heartThread = new Thread(SendHeart)
{
IsBackground = true
};
heartThread.Start();
}
catch (Exception ex)
{
HandleLog.WriteLine($"{ex}");
}
});
}
public void Send(byte[] data)
{
try
{
lock (Stream)
{
Stream.Write(data);
}
}
catch (Exception ex)
{
Close();
HandleLog.WriteLine($"Send Error,Socket Close,{ex}");
}
}