socket.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <functional>
#include <vector>
#include <cstdint>
 
#ifdef _WIN32
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #ifdef _MSC_VER
        #pragma comment(lib, "ws2_32.lib")
    #endif
    typedef SOCKET socket_t;
    #define INVALID_SOCKET_VALUE INVALID_SOCKET
    #define SOCKET_ERROR_VALUE SOCKET_ERROR
#else
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <unistd.h>
    typedef int socket_t;
    #define INVALID_SOCKET_VALUE -1
    #define SOCKET_ERROR_VALUE -1
    #define closesocket close
#endif
 
namespace librats {
 
enum class AddressFamily {
    IPv4,       // IPv4 only
    IPv6,       // IPv6 only
    DualStack   // IPv6 socket with IPv4 support (default)
};
 
struct Peer {
    std::string ip;
    uint16_t port;
    
    Peer() : port(0) {}
    Peer(const std::string& ip, uint16_t port) : ip(ip), port(port) {}
    
    bool operator==(const Peer& other) const {
        return ip == other.ip && port == other.port;
    }
    
    bool operator!=(const Peer& other) const {
        return !(*this == other);
    }
};
 
// Socket Library Initialization
bool init_socket_library();
 
void cleanup_socket_library();
 
// TCP Socket Functions
socket_t create_tcp_client(const std::string& host, int port, int timeout_ms = 0);
 
socket_t create_tcp_server(int port, int backlog = 5, const std::string& bind_address = "",
                           AddressFamily af = AddressFamily::DualStack);
 
socket_t accept_client(socket_t server_socket);
 
std::string get_peer_address(socket_t socket);
 
int send_tcp_data(socket_t socket, const std::vector<uint8_t>& data);
 
std::vector<uint8_t> receive_tcp_data(socket_t socket, size_t buffer_size = 1024);
 
int send_tcp_message(socket_t socket, const std::vector<uint8_t>& message);
 
std::vector<uint8_t> receive_tcp_message(socket_t socket);
 
int send_tcp_string(socket_t socket, const std::string& data);
 
// UDP Socket Functions
socket_t create_udp_socket(int port = 0, const std::string& bind_address = "",
                           AddressFamily af = AddressFamily::DualStack);
 
int send_udp_data(socket_t socket, const std::vector<uint8_t>& data, const std::string& host, int port,
                  AddressFamily af = AddressFamily::DualStack);
 
std::vector<uint8_t> receive_udp_data(socket_t socket, size_t buffer_size, Peer& sender_peer,
                                      int timeout_ms = -1);
 
// Common Socket Functions
void close_socket(socket_t socket, bool force = false);
 
bool is_valid_socket(socket_t socket);
 
bool set_socket_nonblocking(socket_t socket);
 
bool set_socket_blocking(socket_t socket);
 
bool connect_with_timeout(socket_t socket, struct sockaddr* addr, socklen_t addr_len, int timeout_ms);
 
int get_bound_port(socket_t socket);
 
} // namespace librats