PRSONA/prsona/src/networking.cpp

#include <random>
#include <algorithm>
#include <iostream>
#include <cstring>

#include "networking.hpp"

std::string random_string(std::default_random_engine& generator, size_t length)
{
    auto randchar = [&]() -> char
    {
        const char charset[] =
        "0123456789_-"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";
        const size_t max_index = (sizeof(charset) - 1);
        std::uniform_int_distribution<int> dist(0, max_index - 1);
        return charset[ dist(generator) ];
    };
    std::string str(length,0);
    std::generate_n(str.begin(), length, randchar);
    return str;
}

char *set_temp_filename(
    std::default_random_engine& generator,
    struct mg_connection *conn)
{
    std::string filename = random_string(generator, TMP_FILE_SIZE);
    
    char *c_filename = new char[TMP_FILE_SIZE+TMP_DIR_SIZE+1];
    strncpy(c_filename, TMP_DIR, TMP_DIR_SIZE);
    for (size_t i = 0; i < TMP_FILE_SIZE; i++)
        c_filename[i + TMP_DIR_SIZE] = filename[i];
    c_filename[TMP_DIR_SIZE + TMP_FILE_SIZE] = 0;

    if (conn)
        mg_set_user_connection_data(conn, c_filename);

    return c_filename;
}

bool RemoteControlHandler::handleGet(CivetServer *server, struct mg_connection *conn)
{
    std::unique_lock<std::mutex> lck(sync->mtx);

    mg_printf(conn,
              "HTTP/1.1 200 OK\r\nContent-Type: "
              "text/plain\r\nConnection: close\r\n\r\n");
    if (message.empty())
        mg_printf(conn, "Event triggered.\n");
    else
        mg_printf(conn, "%s\n", message.c_str());

    sync->val++;
    sync->cv.notify_all();

    return true;
}

bool AltRemoteControlHandler::handleGet(CivetServer *server, struct mg_connection *conn)
{
    std::unique_lock<std::mutex> lck(sync->mtx);

    const struct mg_request_info *info = mg_get_request_info(conn);
    if (info->query_string)
        query = info->query_string;

    mg_printf(conn,
              "HTTP/1.1 200 OK\r\nContent-Type: "
              "text/plain\r\nConnection: close\r\n\r\n");
    if (message.empty())
        mg_printf(conn, "Event triggered.\n");
    else
        mg_printf(conn, "%s\n", message.c_str());

    sync->val2 = value;
    sync->cv.notify_all();

    return true;
}

std::string AltRemoteControlHandler::getQuery() const
{
    return query;
}

int empty_websocket_data_handler(
    struct mg_connection *conn,
    int bits,
    char *data,
    size_t data_len,
    void *user_data)
{ return false; }

void empty_websocket_close_handler(
    const struct mg_connection *conn,
    void *user_data)
{ /* */ }

int synchro_websocket_data_handler(
    struct mg_connection *conn,
    int bits,
    char *data,
    size_t data_len,
    void *user_data)
{
    if ((bits & 0xf) == MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE)
        return false;

    if ((bits & 0xf) == MG_WEBSOCKET_OPCODE_DATACOMPLETE)
    {
        struct synchronization_tool *sync = (struct synchronization_tool *) user_data;

        std::unique_lock<std::mutex> lck(sync->mtx);
        sync->val++;

        return false;
    }

    std::cerr << "Unknown response when trying to get update lock." << std::endl;
    return false;    
}

void synchro_websocket_close_handler(
    const struct mg_connection *conn,
    void *user_data)
{
    struct synchronization_tool *synch = (struct synchronization_tool *) user_data;

    std::unique_lock<std::mutex> lck(synch->mtx);
    synch->val2 = 1;
    synch->cv.notify_all();
}

int file_websocket_data_handler(
    struct mg_connection *conn,
    int bits,
    char *data,
    size_t data_len,
    void *user_data)
{
    if ((bits & 0xf) == MG_WEBSOCKET_OPCODE_CONNECTION_CLOSE || (bits & 0xf) == MG_WEBSOCKET_OPCODE_DATACOMPLETE)
        return false;

    if ((bits & 0xf) != MG_WEBSOCKET_OPCODE_BINARY && (bits & 0xf) != MG_WEBSOCKET_OPCODE_CONTINUATION)
    {
        std::cerr << "Unknown opcode: failing." << std::endl;
        return false;
    }

    struct synchronization_tool *sync = (struct synchronization_tool *) user_data;
    char *filename = (char *) mg_get_user_connection_data(conn);

    std::unique_lock<std::mutex> lck(sync->mtx);
    FILE *currFile = fopen(filename, "ab");
    fwrite(data, sizeof(char), data_len, currFile);
    fclose(currFile);

    return true;
}

void file_websocket_close_handler(
    const struct mg_connection *conn,
    void *user_data)
{
    struct synchronization_tool *sync = (struct synchronization_tool *) user_data;

    std::unique_lock<std::mutex> lck(sync->mtx);
    sync->val = 1;
    sync->val2 = 1;
    sync->cv.notify_all();
}