common.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "SocketException.hpp"
 
#include <cstddef> // std::size_t
#include <source_location>
#include <span>
#include <string>
#include <utility> // std::pair
 
#ifdef __GNUC__
#define QUOTE(s) #s
#define DIAGNOSTIC_PUSH() _Pragma("GCC diagnostic push")
#define DIAGNOSTIC_IGNORE(warning) _Pragma(QUOTE(GCC diagnostic ignored warning))
#define DIAGNOSTIC_POP() _Pragma("GCC diagnostic pop")
#else
#define DIAGNOSTIC_PUSH()
#define DIAGNOSTIC_IGNORE(warning)
#define DIAGNOSTIC_POP()
#endif
 
#include <cstring> // Use std::memset()
#include <exception>
#include <iostream>
#include <limits>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#ifdef _WIN32
 
// Do not reorder includes here, because Windows headers have specific order requirements.
// clang-format off
#include <winsock2.h> // Must come first: socket, bind, listen, accept, etc.
#include <ws2tcpip.h> // TCP/IP functions: getaddrinfo, getnameinfo, inet_ntop, inet_pton
#include <windows.h>  // General Windows headers (e.g., FormatMessageA)
#include <iphlpapi.h> // GetAdaptersInfo, network adapter info
// clang-format on
 
// https://msdn.microsoft.com/en-us/library/6sehtctf.aspx
#if !defined(WINVER) || (WINVER < _WIN32_WINNT_WINXP)
#error WINVER must be defined to something equal or above to 0x0501 // Win XP
#endif // WINVER
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < _WIN32_WINNT_WINXP)
#error _WIN32_WINNT must be defined to something equal or above to 0x0501 // Win XP
#endif // _WIN32_WINNT
 
/* If compiled with Visual C++
 * https://msdn.microsoft.com/en-us/library/windows/desktop/ms737629%28v=vs.85%29.aspx
 * http://stackoverflow.com/questions/3484434/what-does-pragma-comment-mean
 * http://stackoverflow.com/questions/70013/how-to-detect-if-im-compiling-code-with-visual-studio-2008
 */
#ifdef _MSC_VER
#pragma comment(lib, "Ws2_32.lib")   // Winsock library
#pragma comment(lib, "iphlpapi.lib") // GetAdaptersInfo
#endif
 
#else
 
// Assuming Linux
#include <arpa/inet.h>   //inet_ntoa
#include <cerrno>        //errno
#include <cstring>       //strerror
#include <fcntl.h>       //fcntl
#include <ifaddrs.h>     //getifaddrs
#include <net/if.h>      //if_nametoindex
#include <netdb.h>       //addrinfo
#include <netinet/in.h>  //sockaddr_in, sockaddr_in6
#include <netinet/tcp.h> //TCP_NODELAY, TCP_MAXSEG
#include <poll.h>        //poll
#include <sys/ioctl.h>   //ioctl
#include <sys/select.h>  //select
#include <sys/socket.h>  //socket
#include <sys/time.h>    //timeval
#include <sys/types.h>   //socket
#include <sys/uio.h>     //writev,readv,iovec
#include <sys/un.h>      //for Unix domain sockets
#include <unistd.h>      //close
 
#endif










namespace jsocketpp
{
#ifdef _WIN32
 
typedef long ssize_t;
 
inline int InitSockets()
{
    WSADATA WSAData;
    return WSAStartup(MAKEWORD(2, 2), &WSAData);
}
 
inline int CleanupSockets()
{
    return WSACleanup();
}
 
inline int GetSocketError()
{
    return WSAGetLastError();
}
 
// NOLINTNEXTLINE(misc-const-correctness) - changes socket state
inline int CloseSocket(SOCKET fd)
{
    return closesocket(fd);
}
 
const char* inet_ntop_aux(int af, const void* src, char* dst, socklen_t size);
 
#define JSOCKETPP_TIMEOUT_CODE WSAETIMEDOUT
 
#else
 
typedef int SOCKET;
constexpr SOCKET INVALID_SOCKET = -1;
constexpr SOCKET SOCKET_ERROR = -1;
typedef sockaddr_un SOCKADDR_UN;
 
#define JSOCKETPP_TIMEOUT_CODE ETIMEDOUT
 
constexpr int InitSockets()
{
    return 0;
}
constexpr int CleanupSockets()
{
    return 0;
}
inline int GetSocketError()
{
    return errno;
}
inline int CloseSocket(const SOCKET fd)
{
    return close(fd);
}
 
inline int ioctlsocket(const SOCKET fd, const long cmd, u_long* argp)
{
    return ioctl(fd, static_cast<unsigned long>(cmd), argp);
}
 
#endif

std::vector<std::string> getHostAddr();

std::string SocketErrorMessage(int error, bool gaiStrerror = false);

enum class ShutdownMode
{
    Read,  
    Write, 
    Both   
};

using Port = std::uint16_t;

inline constexpr std::size_t DefaultBufferSize = 4096;

inline constexpr std::size_t DefaultDatagramReceiveSize = 8192;

inline constexpr std::size_t MaxDatagramPayloadSafe = 65507;

inline constexpr std::size_t MaxUdpPayloadIPv4 = 65507;

inline constexpr std::size_t MaxUdpPayloadIPv6 = 65527;

inline bool isIPv4MappedIPv6(const sockaddr_in6* addr6)
{
    return IN6_IS_ADDR_V4MAPPED(&addr6->sin6_addr);
}

inline sockaddr_in convertIPv4MappedIPv6ToIPv4(const sockaddr_in6& addr6)
{
    sockaddr_in addr4{};
    addr4.sin_family = AF_INET;
    addr4.sin_port = addr6.sin6_port;
    std::memcpy(&addr4.sin_addr.s_addr, addr6.sin6_addr.s6_addr + 12, sizeof(addr4.sin_addr.s_addr));
    return addr4;
}

std::string ipFromSockaddr(const sockaddr* addr, bool convertIPv4Mapped = true);

Port portFromSockaddr(const sockaddr* addr);

std::string addressToString(const sockaddr_storage& addr);

void stringToAddress(const std::string& str, sockaddr_storage& addr);
 
} // namespace jsocketpp

namespace jsocketpp::net
{

inline uint16_t toNetwork(const uint16_t val)
{
    return htons(val);
}

inline uint32_t toNetwork(const uint32_t val)
{
    return htonl(val);
}

inline uint16_t fromNetwork(const uint16_t val)
{
    return ntohs(val);
}

inline uint32_t fromNetwork(const uint32_t val)
{
    return ntohl(val);
}
 
} // namespace jsocketpp::net
 
namespace jsocketpp::internal
{

struct AddrinfoDeleter
{
    void operator()(addrinfo* p) const noexcept
    {
        if (p)
            freeaddrinfo(p);
    }
};

using AddrinfoPtr = std::unique_ptr<addrinfo, AddrinfoDeleter>;

[[nodiscard]] inline AddrinfoPtr resolveAddress(const std::string_view host, const Port port, const int family,
                                                const int socktype, const int protocol, const int flags = 0)
{
    addrinfo hints{};
    hints.ai_family = family;
    hints.ai_socktype = socktype;
    hints.ai_protocol = protocol;
    hints.ai_flags = flags;
 
    const std::string portStr = std::to_string(port);
 
    // Ensure NUL-terminated host for getaddrinfo
    const std::string hostStr = host.empty() ? std::string{} : std::string(host);
    const char* hostC = hostStr.empty() ? nullptr : hostStr.c_str();
 
    addrinfo* raw = nullptr;
    if (const int ret = ::getaddrinfo(hostC, portStr.c_str(), &hints, &raw); ret != 0)
    {
        throw SocketException(ret, SocketErrorMessage(ret, true));
    }
 
    return AddrinfoPtr{raw};
}

[[nodiscard]] std::string getBoundLocalIp(SOCKET sockFd);

[[nodiscard]] bool ipAddressesEqual(const std::string& ip1, const std::string& ip2);

void sendExact(SOCKET fd, const void* data, std::size_t size);

void sendExactTo(SOCKET fd, const void* data, std::size_t size, const sockaddr* addr, socklen_t addrLen,
                 void (*afterSuccess)(void* ctx), void* ctx);

inline bool tryCloseNoexcept(const SOCKET fd) noexcept
{
    if (fd == INVALID_SOCKET)
        return true;
    if (CloseSocket(fd) != 0)
    {
        // Optional: hook for logging, left silent per policy
        return false;
    }
    return true;
}

inline void closeOrThrow(const SOCKET fd)
{
    if (fd == INVALID_SOCKET)
        return;
    if (CloseSocket(fd) != 0)
    {
        const int error = GetSocketError();
        throw SocketException(error, SocketErrorMessage(error));
    }
}

inline std::size_t nextDatagramSize(SOCKET fd) noexcept
{
#if defined(_WIN32)
    u_long pending = 0;
    return (ioctlsocket(fd, FIONREAD, &pending) == 0 && pending > 0) ? static_cast<std::size_t>(pending) : 0;
#else
    int pending = 0;
    if (ioctl(fd, FIONREAD, &pending) == 0 && pending > 0)
        return static_cast<std::size_t>(pending);
 
    // POSIX: MSG_PEEK|MSG_TRUNC returns exact datagram length without consuming it.
    sockaddr_storage tmp{};
    socklen_t tmpLen = static_cast<socklen_t>(sizeof(tmp));
    const ssize_t peekN = ::recvfrom(fd, nullptr, 0, MSG_PEEK | MSG_TRUNC, reinterpret_cast<sockaddr*>(&tmp), &tmpLen);
    return (peekN > 0) ? static_cast<std::size_t>(peekN) : 0;
#endif
}

inline ssize_t recvInto(const SOCKET fd, std::span<std::byte> dst, const int flags, sockaddr_storage* src,
                        socklen_t* srcLen)
{
    if (src && srcLen)
    {
        return ::recvfrom(fd, reinterpret_cast<char*>(dst.data()),
#if defined(_WIN32)
                          static_cast<int>(dst.size()),
#else
                          dst.size(),
#endif
                          flags, reinterpret_cast<sockaddr*>(src), srcLen);
    }
 
    return ::recv(fd, reinterpret_cast<char*>(dst.data()),
#if defined(_WIN32)
                  static_cast<int>(dst.size()),
#else
                  dst.size(),
#endif
                  flags);
}

[[noreturn]] inline void throwLastSockError(const std::source_location& loc = std::source_location::current())
{
    const int err = GetSocketError();
#if JSOCKETPP_INCLUDE_ERROR_CONTEXT
    std::string msg = SocketErrorMessage(err);
    msg.append(" [at ")
        .append(loc.file_name())
        .append(":")
        .append(std::to_string(loc.line()))
        .append(" ")
        .append(loc.function_name())
        .append("]");
    throw SocketException(err, std::move(msg));
#else
    (void) loc;
    throw SocketException(err, SocketErrorMessage(err));
#endif
}

inline void resolveNumericHostPort(const sockaddr* sa, const socklen_t len, std::string& host, Port& port)
{
    char hostBuf[NI_MAXHOST]{};
    char servBuf[NI_MAXSERV]{};
 
    int flags = NI_NUMERICHOST | NI_NUMERICSERV;
#ifdef NI_NUMERICSCOPE
    flags |= NI_NUMERICSCOPE; // ensure scope id stays numeric on IPv6 link-local
#endif
 
    if (const int ret = ::getnameinfo(sa, len, hostBuf, sizeof(hostBuf), servBuf, sizeof(servBuf), flags); ret != 0)
    {
        throw SocketException(ret, SocketErrorMessage(ret, true));
    }
 
    // service is numeric due to NI_NUMERICSERV; parse without locale.
    const auto raw = std::strtoul(servBuf, nullptr, 10);
    if (raw > static_cast<unsigned long>((std::numeric_limits<Port>::max)()))
        throw SocketException("Port out of range for Port type.");
 
    host.assign(hostBuf);
    port = static_cast<Port>(raw);
}
 
} // namespace jsocketpp::internal