tcp.hpp

Go to the documentation of this file.

#pragma once

#include <functional>
#include <memory>
#include <string>
#include <optional>

namespace tcp {

struct exception {};
struct connection_failure : public exception {};

class socket {
    int sock;

    explicit socket(int _sock) : sock(_sock), remote_ip() {}
    explicit socket(int _sock, std::string remote_ip)
            : sock(_sock), remote_ip(remote_ip) {}

    friend class connection_listener;
    std::string remote_ip;

public:

    socket() : sock(-1), remote_ip() {}
    socket(std::string server_ip, uint16_t server_port);
    socket(socket&& s);

    socket& operator=(socket& s) = delete;
    socket& operator=(socket&& s);

    ~socket();

    bool is_empty() const;
    std::string get_self_ip();
    std::string get_remote_ip() const { return remote_ip; }

    int try_connect(std::string servername, int port, int timeout_ms = 20000);

    bool read(char* buffer, size_t size);

    ssize_t read_partial(char* buffer, size_t max_size);

    bool probe();

    bool write(const char* buffer, size_t size);

    template <typename T>
    bool write(const T& obj) {
        return write(reinterpret_cast<const char*>(&obj), sizeof(obj));
    }

    template <typename T>
    bool read(T& obj) {
        return read(reinterpret_cast<char*>(&obj), sizeof(obj));
    }

    template <class T>
    bool exchange(T local, T& remote) {
        static_assert(std::is_pod<T>::value,
                      "Can't send non-pod type over TCP");

        if(sock < 0) {
            fprintf(stderr, "WARNING: Attempted to write to closed socket\n");
            return false;
        }

        return write((char*)&local, sizeof(T)) && read((char*)&remote, sizeof(T));
    }
};

class connection_listener {
    std::unique_ptr<int, std::function<void(int*)>> fd;

public:
    explicit connection_listener(uint16_t port);
    socket accept();

    std::optional<socket> try_accept(int timeout_ms);
};
}  // namespace tcp