networking.cpp

#include "networking.h"
#include <ctime>

//#define DEBUG

SocketError::SocketError( const std::string & m ) :
    exception(),
    msg( m )
{
}

SocketError::~SocketError() throw()
{
}

const char * SocketError::what() const throw()
{
    return msg.c_str();
}


LocalHost::LocalHost()
    : connected(false)
    , running(false)
    , socket_fd(-1)
{
    memset(&header, 0, sizeof(header));
    header.version_major = PROTOCOL_MAJOR;
    header.version_minor = PROTOCOL_MINOR;
}

int LocalHost::connect(const char* path)
{

    struct sockaddr_un addr;

    socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);

#ifdef DEBUG
    std::cout << "LocalHost::connect(): " << path << std::endl;
    std::cout << "socket_fd: " << socket_fd << std::endl;
#endif

    if (socket_fd == -1)
        throw SocketError("Error: socket creation failed.");

    if (remove(path) == -1 && errno != ENOENT)
        throw SocketError("Error: File path already exists.");

    memset(&addr, 0, sizeof(struct sockaddr_un));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);

    if (bind(socket_fd, (struct sockaddr*)&addr, sizeof(struct sockaddr_un)) == -1)
        throw SocketError("Error: socket binding failed.");


    connected = true;
    return socket_fd;
}

void LocalHost::run_server()
{
#ifdef DEBUG
    std::cout << "LocalHost::run_server(): " << std::endl;
    std::cout << "socket_fd: " << socket_fd << std::endl;
#endif

    ssize_t numRead;

    char payload_buf[1024 * 4];

    int size_src_addr = sizeof(struct sockaddr_un);
    struct sockaddr_un src_addr;
    memset(&src_addr, 0, sizeof(struct sockaddr_un));
    src_addr.sun_family = AF_UNIX;

    pollfd pfd = {0};
    pfd.fd = socket_fd;
    pfd.events = POLLIN;

    running.store(true);

    while (running.load())
    {
        int ret = poll(&pfd, 1, 100);

        if (ret <= 0)
            continue;

        if (pfd.revents & POLLIN)
        {
            numRead = recvfrom(socket_fd, buffer, sizeof(buffer) - 1, 0,  (struct sockaddr*)&src_addr, (socklen_t*)&size_src_addr);

            if (numRead == -1)
            {
                std::cerr << "recvfrom() failed: " << errno << " - " << strerror(errno) << std::endl;
                continue;
            }

            deserialize(header, payload_buf, buffer);

            std::cout << "recvfrom() numRead: " << numRead << std::endl;
            std::cout << "recvfrom() header.payload_size: " << header.payload_size << '\n' << std::endl;

            switch (header.type)
            {
            case MessageType::Text:
            {
                std::cout << "case MessageType::Text" << std::endl;


                emit msg_recieved(payload_buf, src_addr.sun_path);

                break;
            }
            case MessageType::Ping:
            {
                std::cout << "case MessageType::Ping" << std::endl;

                header.type = MessageType::Pong;

                std::time_t now = std::time(nullptr);
                header.ping = now - header.timestamp;
                header.flags = 0;

                header.timestamp = now;
                header.payload_size = 0; // Crucial

                uint32_t msg_size = serialize(header, nullptr, buffer);

                ssize_t return_val = sendto(socket_fd, (void *)buffer, msg_size, 0, reinterpret_cast<struct sockaddr*>(&src_addr), sizeof(src_addr));


                if (return_val == -1)
                    std::cerr << "sendto() failed: " << errno << " - " << strerror(errno) << std::endl;

                break;
            }
            case MessageType::Pong:
            {
                std::cout << "case MessageType::Pong" << std::endl;

                emit ping(header.ping);

                break;
            }
            case MessageType::LoginResponse:
            {
                break;
            }
            case MessageType::Broadcast:
            {
                if (header.flags & 1)
                {
                    emit availability_changed(true, src_addr.sun_path);
                }
                else if (header.flags & 2)
                {
                    emit availability_changed(false, src_addr.sun_path);
                }

                break;
            }
            }

        }
    }

    if (close(socket_fd) == -1)
        throw SocketError("Error: socket close failed.");


    emit finished();
}


RemoteHost::RemoteHost()
    : connected(false)
    , localhost_fd(-1)
{
    memset(&header, 0, sizeof(header));
    header.id = 1000;
    header.version_major = PROTOCOL_MAJOR;
    header.version_minor = PROTOCOL_MINOR;
}

int RemoteHost::connect(const char *local_username, const char *remote_username, const char *remote_path)
{

//    strncpy(header.sender, local_username, sizeof(header.sender) - 1);
//    strncpy(header.receiver, remote_username, sizeof(header.receiver) - 1);


    memset(&dest_addr, 0, sizeof(struct sockaddr_un));
    dest_addr.sun_family = AF_UNIX;
    strncpy(dest_addr.sun_path, remote_path, sizeof(dest_addr.sun_path) - 1);

    header.timestamp = std::time(nullptr);

    header.id++;
    header.type = MessageType::Ping;
    header.flags = 0;
    header.timestamp = std::time(nullptr);
    header.payload_size = 0; // Crucial

    uint32_t msg_size = serialize(header, nullptr, buffer);

    ssize_t return_val = sendto(localhost_fd, (void *)buffer, msg_size, 0, reinterpret_cast<struct sockaddr*>(&dest_addr), sizeof(dest_addr));

    if (return_val == -1)
        std::cerr << "sendto() failed: " << errno << " - " << strerror(errno) << std::endl;

#ifdef DEBUG
    std::cout << "RemoteHost::connect() local_username: " << local_username << std::endl;
    std::cout << "RemoteHost::connect() remote_username: " << remote_username << std::endl;
    std::cout << "RemoteHost::connect() localhost_fd: " << localhost_fd << std::endl;
    std::cout << "RemoteHost::connect() addr.sun_path: " << dest_addr.sun_path << std::endl;
#endif

    connected = true;
}

ssize_t RemoteHost::send_message(const char *msg, int length)
{

    std::cerr << "sizeof(header):" << sizeof(header) << '\n' << std::endl;

    if (sizeof(header) + length > sizeof(buffer))
    {
        std::cerr << "Error: Message too long!" << std::endl;
        return -1;
    }

    header.id++;
    header.flags = 0;
    header.type = MessageType::Text;
    header.timestamp = std::time(nullptr);
    header.payload_size = length; // Crucial

    uint32_t msg_size = serialize(header, msg, buffer);

    ssize_t return_val = sendto(localhost_fd, (void *)buffer, msg_size, 0, reinterpret_cast<struct sockaddr*>(&dest_addr), sizeof(dest_addr));

#ifdef DEBUG
    std::cout << "RemoteHost::message(): " << msg << std::endl;
    std::cout << "length: " << length << std::endl;

    std::cout << "fd: " << localhost_fd << std::endl;
    std::cout << "family: " << dest_addr.sun_family << std::endl;
    std::cout << "path: [" << dest_addr.sun_path << "]" << std::endl;
    std::cout << "return_val: " << return_val << std::endl;
#endif

    if (return_val == -1)
        std::cerr << "sendto() failed: " << errno << " - " << strerror(errno) << std::endl;

    // sendto() failed: 111 - Connection refused
    // Error above shows that we can use return_val to find out if the
    // user is online or not. But the problem is:
    // If the user is online, then that message will show up for him.

    return return_val;
}

bool RemoteHost::check_user_availability(const char *path)
{
    sockaddr_un addr = {0};
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, path, sizeof(addr.sun_path));

    header.type = MessageType::LoginRequest;
    header.timestamp = std::time(nullptr);
    header.flags = 0;
    header.payload_size = 0; // Crucial

    uint32_t msg_size = serialize(header, nullptr, buffer);

    ssize_t return_val = sendto(localhost_fd, (void *)buffer, msg_size, 0, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));

    if (return_val == -1)
    {
        std::cerr << "sendto() failed: " << errno << " - " << strerror(errno) << std::endl;
//        if (errno == 111 || errno == 2)
        return false;
    }

    return true;
}

bool RemoteHost::broadcast_availability(bool is_available, const char *path)
{
    sockaddr_un addr = {0};
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, path, sizeof(addr.sun_path));

    header.type = MessageType::Broadcast;
    header.timestamp = std::time(nullptr);
    header.flags = is_available ? header.flags | 1 : header.flags | 2;
    header.payload_size = 0; // Crucial

    uint32_t msg_size = serialize(header, nullptr, buffer);

    ssize_t return_val = sendto(localhost_fd, (void *)buffer, msg_size, 0, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));

    if (return_val == -1)
    {
        std::cerr << "sendto() failed: " << errno << " - " << strerror(errno) << std::endl;
        return false;
    }

    return true;
}

void RemoteHost::set_localhost_fd(int new_localhost_fd)
{
    localhost_fd = new_localhost_fd;
}