579 lines
18 KiB
C++
579 lines
18 KiB
C++
// websocket
|
|
#include <boost/beast/core.hpp>
|
|
#include <boost/beast/ssl.hpp>
|
|
#include <boost/beast/websocket.hpp>
|
|
#include <boost/beast/websocket/ssl.hpp>
|
|
#include <boost/asio/ip/tcp.hpp>
|
|
#include <boost/asio/ssl/stream.hpp>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <functional>
|
|
|
|
// json
|
|
#include <nlohmann/json.hpp>
|
|
|
|
// windows child process
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <tchar.h>
|
|
|
|
// windows terminate process
|
|
#include <tlhelp32.h>
|
|
|
|
//hash
|
|
#include <boost/functional/hash.hpp>
|
|
|
|
// time
|
|
#include <chrono>
|
|
#include <ctime>
|
|
|
|
// fixed int
|
|
#include <cstdint>
|
|
|
|
// user
|
|
#include "user.h"
|
|
#include <vector>
|
|
|
|
// session
|
|
#include "sessionManager.h"
|
|
|
|
// current directory
|
|
#include <filesystem>
|
|
|
|
// file read/write
|
|
#include <fstream>
|
|
|
|
// openssl
|
|
#define BOOST_NETWORK_ENABLE_HTTPS
|
|
|
|
// using SSL
|
|
#define USE_SSL
|
|
|
|
namespace beast = boost::beast;
|
|
namespace http = beast::http;
|
|
namespace websocket = beast::websocket;
|
|
namespace net = boost::asio;
|
|
namespace ssl = boost::asio::ssl;
|
|
using tcp = boost::asio::ip::tcp;
|
|
|
|
// end process by process id
|
|
void EndProc(DWORD procId)
|
|
{
|
|
PROCESSENTRY32 pe;
|
|
|
|
memset(&pe, 0, sizeof(PROCESSENTRY32));
|
|
pe.dwSize = sizeof(PROCESSENTRY32);
|
|
|
|
HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
|
|
|
if (::Process32First(hSnap, &pe))
|
|
{
|
|
BOOL bContinue = TRUE;
|
|
|
|
// kill child processes
|
|
while (bContinue)
|
|
{
|
|
// only kill child processes
|
|
if (pe.th32ParentProcessID == procId)
|
|
{
|
|
HANDLE hChildProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);
|
|
|
|
if (hChildProc)
|
|
{
|
|
::TerminateProcess(hChildProc, 1);
|
|
::CloseHandle(hChildProc);
|
|
}
|
|
}
|
|
|
|
bContinue = ::Process32Next(hSnap, &pe);
|
|
}
|
|
|
|
// kill the main process
|
|
HANDLE hProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, procId);
|
|
|
|
if (hProc)
|
|
{
|
|
::TerminateProcess(hProc, 1);
|
|
::CloseHandle(hProc);
|
|
}
|
|
}
|
|
}
|
|
|
|
// create process
|
|
bool CreateProc(
|
|
std::string path,
|
|
std::string args,
|
|
PROCESS_INFORMATION* processInfo
|
|
)
|
|
{
|
|
std::wstring path_ws = std::wstring(path.begin(), path.end());
|
|
const wchar_t* path_cw = path_ws.c_str();
|
|
|
|
std::wstring cmd_ws = std::wstring(args.begin(), args.end());
|
|
wchar_t* cmd_w = const_cast<wchar_t*>(cmd_ws.c_str());
|
|
|
|
// creating process
|
|
STARTUPINFO startupInfo = { sizeof(startupInfo) };
|
|
if (!CreateProcess(path_cw, cmd_w, NULL, NULL, TRUE, 0, NULL, NULL, &startupInfo, processInfo))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
template <typename T>
|
|
uint32_t hash6(T arg)
|
|
{
|
|
boost::hash<T> h;
|
|
return h(arg) % 1000000;
|
|
}
|
|
|
|
LRESULT CALLBACK GLWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (msg == WM_DESTROY) PostQuitMessage(0);
|
|
return DefWindowProc(hWnd, msg, wParam, lParam);
|
|
}
|
|
|
|
// log
|
|
HANDLE hConsoleOutputColor;
|
|
std::ofstream logFile;
|
|
void LOG(std::stringstream&& s, WORD color)
|
|
{
|
|
SetConsoleTextAttribute(hConsoleOutputColor, color);
|
|
std::cout << s.str() << std::endl;
|
|
if (logFile.is_open())
|
|
{
|
|
logFile << s.str() << std::endl;
|
|
}
|
|
}
|
|
|
|
#ifdef USE_SSL
|
|
void do_session(tcp::socket sock, ssl::context& ctx, sessionManager& sessManager, std::string ip, uint64_t& user_n, std::string appPath, std::string appArgs, uint16_t portStream, uint16_t portHttp);
|
|
#endif
|
|
#ifndef USE_SSL
|
|
void do_session(tcp::socket sock, /*ssl::context& ctx,*/ sessionManager& sessManager, std::string ip, uint64_t& user_n, std::string appPath, std::string appArgs, uint16_t portStream, uint16_t portHttp);
|
|
#endif
|
|
|
|
|
|
// creating listen socket and validate client messages
|
|
int main(int argc, char* argv[])
|
|
{
|
|
// disable console input
|
|
HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
|
|
DWORD prev_mode;
|
|
GetConsoleMode(hInput, &prev_mode);
|
|
SetConsoleMode(hInput, ENABLE_EXTENDED_FLAGS |
|
|
(prev_mode & ~ENABLE_QUICK_EDIT_MODE));
|
|
|
|
// configure logs function
|
|
{
|
|
// get output handle for log function
|
|
hConsoleOutputColor = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
// open log file
|
|
std::string logsFolder = std::filesystem::current_path().string() + "\\ServerLogs";
|
|
std::string logFileName = std::to_string(std::chrono::system_clock::now().time_since_epoch().count()) + ".log";
|
|
std::wstring logsFolder_LPCWSTR = std::wstring(logsFolder.begin(), logsFolder.end());
|
|
logFile.open(logsFolder + "\\" + logFileName, std::ios::out);
|
|
if (!logFile)
|
|
{
|
|
if (CreateDirectory(logsFolder_LPCWSTR.c_str(), NULL) || ERROR_ALREADY_EXISTS == GetLastError())
|
|
{
|
|
logFile.open(logsFolder + "\\" + logFileName, std::ios::out);
|
|
}
|
|
else
|
|
{
|
|
std::cout << "create direcotry failed: " << logsFolder << std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
// args
|
|
// 1 - copies amount
|
|
// 2 - server ip
|
|
// 3 - server port
|
|
// 4 - path_to_node.js
|
|
// 5 - start_http_port
|
|
// 6 - start_streamer_port
|
|
|
|
// 7 - path to crt
|
|
// 8 - path to key
|
|
// 9 - path to pem
|
|
|
|
// 10 - path_to_application
|
|
// 11 - application_args (without -pixelStreamingPort cos its argv[3])
|
|
|
|
// sessions
|
|
uint16_t sessionLimit = std::atoi(argv[1]);
|
|
sessionManager sessManager;
|
|
sessManager.setlimit(sessionLimit);
|
|
|
|
// user count
|
|
uint64_t user_n = 0;
|
|
|
|
// merging app arguments
|
|
std::string appPath = argv[10];
|
|
std::string appArgs;
|
|
for (int i = 11; i < argc; ++i)
|
|
appArgs += argv[i] + std::string(" ");
|
|
|
|
appArgs += "-PixelStreamingPort=";
|
|
|
|
// first app ports
|
|
uint16_t portHttp = std::atoi(argv[5]);
|
|
uint16_t portStream = std::atoi(argv[6]);
|
|
|
|
// starting node js servers
|
|
for (uint16_t i = 0; i < sessionLimit; ++i)
|
|
{
|
|
system((std::string("start node ") + argv[4] + " " + std::to_string(portHttp + i) + " " + std::to_string(portStream + i)).c_str());
|
|
}
|
|
|
|
// ip and socket init
|
|
std::string ip(argv[2]);
|
|
LOG((std::stringstream() << "ip: " << ip), 7);
|
|
auto const address = net::ip::make_address(ip);
|
|
auto const port = static_cast<uint16_t>(std::atoi(argv[3]));
|
|
LOG((std::stringstream() << "port: " << port), 7);
|
|
|
|
try
|
|
{
|
|
// the io_context is required for all I/O
|
|
net::io_context ioc{ 1 };
|
|
|
|
#ifdef USE_SSL
|
|
// the SSL context is required, and holds certificates
|
|
ssl::context ctx{ ssl::context::tlsv12 };
|
|
|
|
//// loading certificate, key, pem
|
|
ctx.use_certificate_chain_file(argv[7]);
|
|
ctx.use_private_key_file(argv[8], boost::asio::ssl::context::file_format::pem);
|
|
ctx.use_tmp_dh_file(argv[9]);
|
|
#endif
|
|
|
|
// the acceptor receives incoming connections
|
|
tcp::acceptor acceptor{ ioc, {address, port} };
|
|
|
|
while (true)
|
|
{
|
|
// This will receive the new connection
|
|
tcp::socket socket(ioc);
|
|
// Block until we get a connection
|
|
acceptor.accept(socket);
|
|
|
|
// Launch the session, transferring ownership of the socket
|
|
std::thread
|
|
{
|
|
&do_session,
|
|
std::move(socket),
|
|
#ifdef USE_SSL
|
|
std::ref(ctx),
|
|
#endif
|
|
std::ref(sessManager),
|
|
ip,
|
|
std::ref(user_n),
|
|
appPath,
|
|
appArgs,
|
|
portStream,
|
|
portHttp
|
|
}.detach();
|
|
}
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
LOG(std::stringstream() << "Error: " << e.what(), 12);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
logFile.close();
|
|
return 0;
|
|
}
|
|
|
|
#ifdef USE_SSL
|
|
void do_session(tcp::socket sock, ssl::context& ctx, sessionManager& sessManager, std::string ip, uint64_t& user_n, std::string appPath, std::string appArgs, uint16_t portStream, uint16_t portHttp)
|
|
#endif
|
|
#ifndef USE_SSL
|
|
void do_session(tcp::socket sock, /*ssl::context& ctx,*/ sessionManager& sessManager, std::string ip, uint64_t& user_n, std::string appPath, std::string appArgs, uint16_t portStream, uint16_t portHttp)
|
|
#endif
|
|
{
|
|
std::string user_ip = sock.remote_endpoint().address().to_string();
|
|
uint64_t user_id = std::chrono::system_clock::now().time_since_epoch().count();
|
|
user_id = hash6(user_ip + std::to_string(user_id));
|
|
uint64_t thisUserNum = ++user_n;
|
|
LOG((std::stringstream() << "user(" << thisUserNum << ") connected (ip: " << user_ip << "), (id: " << user_id << ")"), 7);
|
|
|
|
#ifdef USE_SSL
|
|
// Construct the websocket stream around the socket
|
|
websocket::stream<beast::ssl_stream<tcp::socket&>> ws(sock, ctx);
|
|
#endif
|
|
#ifndef USE_SSL
|
|
websocket::stream<tcp::socket> ws{ std::move(sock) };
|
|
#endif
|
|
|
|
|
|
|
|
try
|
|
{
|
|
#ifdef USE_SSL
|
|
// Perform the SSL handshake
|
|
ws.next_layer().handshake(ssl::stream_base::server);
|
|
#endif
|
|
// Set a decorator to change the Server of the handshake
|
|
ws.set_option(websocket::stream_base::decorator(
|
|
[](websocket::response_type& res)
|
|
{
|
|
res.set(http::field::server,
|
|
std::string(BOOST_BEAST_VERSION_STRING) +
|
|
" websocket-server-sync-ssl");
|
|
}));
|
|
|
|
ws.accept();
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
LOG(std::stringstream() << "Error: " << e.what(), 12);
|
|
return;
|
|
}
|
|
catch (beast::system_error const& se)
|
|
{
|
|
LOG(std::stringstream() << "Error: " << se.what(), 12);
|
|
return;
|
|
}
|
|
|
|
nlohmann::json jsonData;
|
|
std::string message;
|
|
std::string content;
|
|
|
|
//session sessTmp;
|
|
session* sessCur = nullptr;
|
|
uint32_t sessId = 0;
|
|
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
// This buffer will hold the incoming message
|
|
// buffer types https://www.boost.org/doc/libs/1_75_0/libs/beast/doc/html/beast/using_io/buffer_types.html
|
|
// check for the best one
|
|
// beast::multi_buffer buffer;
|
|
beast::flat_buffer buffer;
|
|
|
|
// Read a message
|
|
ws.read(buffer);
|
|
|
|
// cout buffer to string
|
|
//std::cout << beast::buffers_to_string(buffer.data()) << std::endl;
|
|
|
|
// validate json errors
|
|
try
|
|
{
|
|
jsonData = nlohmann::json::parse(beast::buffers_to_string(buffer.data()));
|
|
message = jsonData.at("message");
|
|
}
|
|
catch (nlohmann::json::parse_error& e)
|
|
{
|
|
std::cout << "Parse error:" << e.what() << std::endl;
|
|
}
|
|
catch (nlohmann::json::out_of_range& e)
|
|
{
|
|
std::cout << "Out of range:" << e.what() << std::endl;
|
|
}
|
|
catch (nlohmann::json::exception& e)
|
|
{
|
|
std::cout << "JSON exception: " << e.what() << std::endl;
|
|
}
|
|
catch (std::exception& e)
|
|
{
|
|
std::cout << "Unknown exception" << e.what() << std::endl;
|
|
}
|
|
|
|
|
|
|
|
|
|
// validate client message
|
|
if (message == "NEW_USER")
|
|
{
|
|
buffer.clear();
|
|
boost::beast::ostream(buffer) << "connected";
|
|
ws.write(buffer.data());
|
|
|
|
}
|
|
else if (message == "NEW_SESS")
|
|
{
|
|
buffer.clear();
|
|
|
|
if (sessManager.isLimitReached())
|
|
{
|
|
boost::beast::ostream(buffer)
|
|
<< std::string("{\"message\" : \"SESS_LIMIT\"}").c_str();
|
|
ws.write(buffer.data());
|
|
continue;
|
|
}
|
|
if (sessManager.existsOwnerId(user_id))
|
|
{
|
|
boost::beast::ostream(buffer)
|
|
<< std::string("{\"message\" : \"PERSON_LIMIT\"}").c_str();
|
|
ws.write(buffer.data());
|
|
continue;
|
|
}
|
|
|
|
|
|
// get session port
|
|
//uint16_t sessMinPort = sessManager.getMinPort(portHttp);
|
|
uint16_t sessHttpPort = sessManager.getMinPort(portHttp);//(sessMinPort == 0) ? portHttp : sessMinPort + 1;
|
|
uint16_t sessStreamPort = portStream + (sessHttpPort - portHttp);
|
|
|
|
|
|
// creating process
|
|
PROCESS_INFORMATION appProcInfo;
|
|
|
|
if (!CreateProc(appPath, appPath + " " + appArgs + std::to_string(sessStreamPort), &appProcInfo))
|
|
{
|
|
LOG((std::stringstream() << "CreateProcess failed (" << GetLastError() << ")."), 12);
|
|
continue;
|
|
}
|
|
|
|
boost::beast::ostream(buffer)
|
|
<< std::string("{\"message\" : \"CREATING_SESSION\", \"content\" : \"true\"}").c_str();
|
|
ws.write(buffer.data());
|
|
|
|
|
|
|
|
// bind app process close listen
|
|
std::thread([appProcInfo]()
|
|
{
|
|
WaitForSingleObject(appProcInfo.hProcess, INFINITE);
|
|
CloseHandle(appProcInfo.hProcess);
|
|
CloseHandle(appProcInfo.hThread);
|
|
}).detach();
|
|
|
|
sessId = hash6(user_id);
|
|
|
|
// create session
|
|
sessManager.add(
|
|
session(
|
|
sessId,
|
|
ip + std::to_string(sessHttpPort),
|
|
user_ip,
|
|
sessHttpPort
|
|
));
|
|
|
|
if (sessManager.getById(sessId, &sessCur))
|
|
{
|
|
// add user
|
|
sessCur->addUser(user(user_id));
|
|
|
|
// add process ids
|
|
sessCur->addProcId(GetProcessId(appProcInfo.hProcess));
|
|
//sessCur->addProcId(GetProcessId(nodeProcInfo.hProcess));
|
|
}
|
|
|
|
LOG((std::stringstream() << "session ["
|
|
<< sessId << "] created, (httpPort: " << sessHttpPort << "), (streamPort: " << std::to_string(sessStreamPort) + ")"), 10);
|
|
|
|
// send respond
|
|
buffer.clear();
|
|
boost::beast::ostream(buffer)
|
|
<< (std::string("{\"message\" : \"SESS_CREATION\", \"id\" : \"")
|
|
+ std::to_string(sessId) + "\", \"port\" : \"" + std::to_string(sessHttpPort) + "\"}");
|
|
ws.write(buffer.data());
|
|
}
|
|
else if (message == "SESS_CONNECT")
|
|
{
|
|
// read session id
|
|
try
|
|
{
|
|
jsonData = nlohmann::json::parse(beast::buffers_to_string(buffer.data()));
|
|
content = jsonData.at("content");
|
|
}
|
|
catch (nlohmann::json::parse_error& e)
|
|
{
|
|
std::cout << "Parse error:" << e.what() << std::endl;
|
|
}
|
|
catch (nlohmann::json::out_of_range& e)
|
|
{
|
|
std::cout << "Out of range:" << e.what() << std::endl;
|
|
}
|
|
catch (nlohmann::json::exception& e)
|
|
{
|
|
std::cout << "JSON exception: " << e.what() << std::endl;
|
|
}
|
|
catch (std::exception& e)
|
|
{
|
|
std::cout << "Unknown exception" << e.what() << std::endl;
|
|
}
|
|
|
|
sessId = atoi(content.c_str());
|
|
// connect to session
|
|
if (sessManager.getById(sessId, &sessCur))
|
|
{
|
|
if (sessCur->existsUserId(user_id))
|
|
{
|
|
LOG((std::stringstream() << "user exists: " << user_id), 7);
|
|
continue;
|
|
}
|
|
sessCur->addUser(user(user_id));
|
|
LOG((std::stringstream() << "user(" << thisUserNum << ") connected to session (id: " << sessCur->getId()
|
|
<< "), (users: " << sessCur->getUsersCount() << ")"), 14);
|
|
|
|
buffer.clear();
|
|
boost::beast::ostream(buffer)
|
|
<< (std::string("{\"message\" : \"SESS_CONNECT\", \"content\" : \"") + std::to_string(sessCur->getPort()) + "\"}");
|
|
ws.write(buffer.data());
|
|
}
|
|
else
|
|
{
|
|
LOG((std::stringstream() << "no session (id: " << content << ")"), 14);
|
|
buffer.clear();
|
|
boost::beast::ostream(buffer)
|
|
<< (std::string("{\"message\" : \"SESS_NOT_EXISTS\"}"));
|
|
ws.write(buffer.data());
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Echo the message back
|
|
// ws.text(ws.got_text());
|
|
// boost::beast::ostream(buffer) << "something";
|
|
// ws.write(buffer.data());
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
LOG((std::stringstream() << "Error: " << e.what()), 14);
|
|
if (sessId)
|
|
{
|
|
sessManager.getById(sessId, &sessCur);
|
|
if (sessCur == nullptr)
|
|
{
|
|
std::cout << "nullptr session" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
sessCur->removeUserById(user_id);
|
|
|
|
if (!sessCur->getUsersCount())
|
|
{
|
|
LOG((std::stringstream() << "session [" << sessCur->getId() << "] destroyed"), 12);
|
|
std::vector<DWORD> procIds(sessCur->getProcIds());
|
|
for (auto& id : procIds)
|
|
EndProc(id);
|
|
sessManager.remove(sessId);
|
|
}
|
|
}
|
|
}
|
|
LOG((std::stringstream() << "user(" << thisUserNum << ") disconnected"), 7);
|
|
break;
|
|
}
|
|
catch (beast::system_error const& se)
|
|
{
|
|
LOG((std::stringstream() << "user(" << thisUserNum << ") fdisconnected"), 7);
|
|
break;
|
|
|
|
/* if (se.code() != websocket::error::closed)
|
|
{
|
|
std::cerr << "Error: " << se.code().message() << std::endl;
|
|
break;
|
|
}*/
|
|
}
|
|
}
|
|
} |