common.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "SocketException.hpp"
 
#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 <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>   //for 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>       //for struct addrinfo
#include <netinet/in.h>  //for sockaddr_in and 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
 
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, [[maybe_unused]] bool gaiStrerror = false);

std::string SocketErrorMessageWrap(int error, [[maybe_unused]] bool gaiStrerror = false);

enum class ShutdownMode
{
    Read,  
    Write, 
    Both   
};

using Port = std::uint16_t;

inline constexpr std::size_t DefaultBufferSize = 4096;

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;
}
 
} // 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