293 lines
8.1 KiB
C++
293 lines
8.1 KiB
C++
#include "include/websocket.h"
|
|
|
|
websocket::websocket(std::function<void(const std::string)> toLog)
|
|
: toLog(std::move(toLog))
|
|
{
|
|
#ifdef IBM
|
|
// Required on Windows
|
|
ix::initNetSystem();
|
|
#endif
|
|
|
|
server = new ix::WebSocketServer(8080, "0.0.0.0");
|
|
|
|
server->setOnClientMessageCallback(
|
|
[this](std::shared_ptr<ix::ConnectionState> connectionState,
|
|
ix::WebSocket &ws,
|
|
const ix::WebSocketMessagePtr &msg) {
|
|
this->onClientMessageCallback(connectionState, ws, msg);
|
|
});
|
|
|
|
std::pair<bool, std::string> res = server->listen();
|
|
if (!res.first) {
|
|
// Error handling
|
|
throw std::invalid_argument("Encountered: " + res.second + "\n");
|
|
}
|
|
|
|
// Run the server in the background. Server can be stopped by calling
|
|
server->start();
|
|
}
|
|
|
|
websocket::~websocket()
|
|
{
|
|
server->stop();
|
|
|
|
#ifdef IBM
|
|
// Required on Windows
|
|
ix::uninitNetSystem();
|
|
#endif
|
|
}
|
|
|
|
void websocket::onClientMessageCallback(
|
|
std::shared_ptr<ix::ConnectionState> &connectionState,
|
|
ix::WebSocket &ws,
|
|
const ix::WebSocketMessagePtr &msg)
|
|
{
|
|
if (msg->type == ix::WebSocketMessageType::Open) {
|
|
std::stringstream debug_msg;
|
|
|
|
debug_msg << "New connection" << std::endl;
|
|
debug_msg << "Remote ip: " << connectionState->getRemoteIp()
|
|
<< std::endl;
|
|
debug_msg << "id: " << connectionState->getId() << std::endl;
|
|
debug_msg << "Uri: " << msg->openInfo.uri << std::endl;
|
|
debug_msg << "Headers:" << std::endl;
|
|
for (const auto &it : msg->openInfo.headers) {
|
|
debug_msg << it.first << ": " << it.second << std::endl;
|
|
}
|
|
|
|
toLog(debug_msg.str());
|
|
|
|
const std::lock_guard<std::mutex> guard(wsLock);
|
|
webSocket = &ws;
|
|
} else if (msg->type == ix::WebSocketMessageType::Close) {
|
|
std::stringstream debug_msg;
|
|
|
|
debug_msg << "Connection closed" << std::endl;
|
|
debug_msg << "id: " << connectionState->getId() << std::endl;
|
|
debug_msg << "Code: " << msg->closeInfo.code << std::endl;
|
|
debug_msg << "Reason: " << msg->closeInfo.reason << std::endl;
|
|
debug_msg << "Remote: " << msg->closeInfo.remote << std::endl;
|
|
|
|
toLog(debug_msg.str());
|
|
|
|
const std::lock_guard<std::mutex> guard(wsLock);
|
|
webSocket = nullptr;
|
|
} else if (msg->type == ix::WebSocketMessageType::Error) {
|
|
std::stringstream debug_msg;
|
|
|
|
debug_msg << "Connection error" << std::endl;
|
|
debug_msg << "id: " << connectionState->getId() << std::endl;
|
|
debug_msg << "Decompression: " << msg->errorInfo.decompressionError
|
|
<< std::endl;
|
|
debug_msg << "HTTP status: " << msg->errorInfo.http_status << std::endl;
|
|
debug_msg << "Reason: " << msg->errorInfo.reason << std::endl;
|
|
debug_msg << "Retries: " << msg->errorInfo.retries << std::endl;
|
|
debug_msg << "Wait time: " << msg->errorInfo.wait_time << std::endl;
|
|
|
|
toLog(debug_msg.str());
|
|
|
|
const std::lock_guard<std::mutex> guard(wsLock);
|
|
webSocket = nullptr;
|
|
} else if (msg->type == ix::WebSocketMessageType::Message) {
|
|
if (!msg->str.empty()) {
|
|
ws.send("Echo: " + msg->str, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void websocket::sendData(data d)
|
|
{
|
|
char *hash = (char *)calloc(2 * MD5LEN + 1, sizeof(char));
|
|
if (hash != nullptr) {
|
|
if (strcmp(d.path, lastPath) != 0) {
|
|
strcpy(lastPath, d.path);
|
|
if (generateMD5(d.path)) {
|
|
strcpy(lastHash, "NOT SET");
|
|
}
|
|
}
|
|
|
|
nlohmann::json json = {
|
|
{"altitude", d.alt},
|
|
{"vs", d.vs},
|
|
{"ias", d.ias},
|
|
{"magHdg", d.magHeading},
|
|
{"truHdg", d.truHdg},
|
|
{"totFuel", d.totFuelKg},
|
|
{"fuelFlow", d.ff},
|
|
{"hash", lastHash},
|
|
};
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(wsLock);
|
|
if (webSocket != nullptr) {
|
|
webSocket->send(json.dump(), false);
|
|
}
|
|
free(hash);
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef IBM
|
|
int websocket::generateMD5(const char *filepath)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
HCRYPTPROV hProv = 0;
|
|
HCRYPTHASH hHash = 0;
|
|
HANDLE hFile = nullptr;
|
|
BYTE rgbFile[BUFSIZE] = {0};
|
|
DWORD cbRead = 0;
|
|
BYTE rgbHash[MD5LEN] = {0};
|
|
DWORD cbHash = 0;
|
|
|
|
// Logic to check usage goes here.
|
|
hFile = CreateFile(filepath,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
nullptr,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_SEQUENTIAL_SCAN,
|
|
nullptr);
|
|
|
|
// Get handle to the crypto provider
|
|
if (!CryptAcquireContext(&hProv,
|
|
nullptr,
|
|
nullptr,
|
|
PROV_RSA_FULL,
|
|
CRYPT_VERIFYCONTEXT)) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptAcquireContext returned with error "
|
|
<< GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CloseHandle(hFile);
|
|
return 1;
|
|
}
|
|
|
|
if (!CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash)) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptCreateHash returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CloseHandle(hFile);
|
|
CryptReleaseContext(hProv, 0);
|
|
return 1;
|
|
}
|
|
|
|
while ((bResult = ReadFile(hFile, rgbFile, BUFSIZE, &cbRead, nullptr))) {
|
|
if (0 == cbRead) {
|
|
break;
|
|
}
|
|
|
|
if (!CryptHashData(hHash, rgbFile, cbRead, 0)) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptHashData returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CryptReleaseContext(hProv, 0);
|
|
CryptDestroyHash(hHash);
|
|
CloseHandle(hFile);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (!bResult) {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "ReadFile returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
|
|
CryptReleaseContext(hProv, 0);
|
|
CryptDestroyHash(hHash);
|
|
CloseHandle(hFile);
|
|
return 1;
|
|
}
|
|
|
|
cbHash = MD5LEN;
|
|
if (CryptGetHashParam(hHash, HP_HASHVAL, rgbHash, &cbHash, 0)) {
|
|
to_hex((char *)rgbHash, lastHash);
|
|
} else {
|
|
std::stringstream debug_msg;
|
|
debug_msg << "CryptGetHashParam returned with error " << GetLastError();
|
|
toLog(debug_msg.str());
|
|
}
|
|
|
|
CryptDestroyHash(hHash);
|
|
CryptReleaseContext(hProv, 0);
|
|
CloseHandle(hFile);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
#ifdef APL
|
|
int websocket::generateMD5(const char *filepath)
|
|
{
|
|
int file_descript;
|
|
unsigned long file_size;
|
|
char *file_buffer;
|
|
unsigned char result[MD5LEN];
|
|
|
|
file_descript = open(filepath, O_RDONLY);
|
|
if (file_descript < 0)
|
|
return 1;
|
|
|
|
file_size = get_size_by_fd(file_descript);
|
|
|
|
file_buffer =
|
|
(char *)mmap(0, file_size, PROT_READ, MAP_SHARED, file_descript, 0);
|
|
|
|
CC_MD5_CTX context;
|
|
CC_MD5_Init(&context);
|
|
CC_MD5_Update(&context, file_buffer, (CC_LONG)file_size);
|
|
CC_MD5_Final(result, &context);
|
|
|
|
munmap(file_buffer, file_size);
|
|
close(file_descript);
|
|
|
|
to_hex((char *)result, lastHash);
|
|
return 0;
|
|
}
|
|
#endif
|
|
#ifdef LIN
|
|
int websocket::generateMD5(const char *filepath)
|
|
{
|
|
int file_descriptor;
|
|
unsigned long file_size;
|
|
char *file_buffer;
|
|
unsigned char result[MD5LEN];
|
|
|
|
file_descriptor = open(filepath, O_RDONLY);
|
|
if (file_descriptor < 0)
|
|
return 1;
|
|
|
|
file_size = get_size_by_fd(file_descriptor);
|
|
|
|
file_buffer = (char *)
|
|
mmap(nullptr, file_size, PROT_READ, MAP_SHARED, file_descriptor, 0);
|
|
|
|
MD5((unsigned char *)file_buffer, file_size, result);
|
|
|
|
munmap(file_buffer, file_size);
|
|
close(file_descriptor);
|
|
|
|
to_hex((char *)result, lastHash);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#if defined APL || defined LIN
|
|
unsigned long get_size_by_fd(int fd)
|
|
{
|
|
struct stat buf {
|
|
};
|
|
if (fstat(fd, &buf) < 0)
|
|
exit(-1);
|
|
return buf.st_size;
|
|
}
|
|
#endif
|
|
void to_hex(const char *hash, char *buffer)
|
|
{
|
|
for (int i = 0; i < MD5LEN; i++) {
|
|
if (buffer != nullptr) {
|
|
sprintf(&buffer[2 * i], "%02x", hash[i] & 0xff);
|
|
}
|
|
}
|
|
} |