sockets.hpp

Go to the documentation of this file.

//
// libcppwrap - A collection of C++ wrappers for native APIs
// Copyright (C) 2021-2023 David A. Norris <danorris@gmail.com>
// Published under the MIT license - https://opensource.org/licenses/MIT
//
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <stdexcept>
 
#include <ifaddrs.h>
#include <netinet/ip6.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
 
#include <w/handle.hpp>
#include <w/iterators.hpp>
#include <w/posix.hpp>
 
namespace w
{
    struct ipv4_address : sockaddr_in
    {
        ipv4_address(std::uint16_t port = 0);
 
        ipv4_address(const char *address, std::uint16_t port = 0);
 
        ipv4_address(const in_addr& address, std::uint16_t port = 0);
    };
 
    struct ipv6_address : sockaddr_in6
    {
        ipv6_address(std::uint16_t port = 0);
 
        ipv6_address(const char *address, std::uint16_t port = 0);
 
        ipv6_address(const char *address, std::uint16_t port, unsigned interface_index);
 
        ipv6_address(const char *address, std::uint16_t port, const char *interface_name);
 
        ipv6_address(const in6_addr& address, std::uint16_t port = 0);
 
        ipv6_address(const in6_addr& address, std::uint16_t port, unsigned interface_index);
 
        ipv6_address(const in6_addr& address, std::uint16_t port, const char *interface_name);
    };
 
    struct unix_domain_address : sockaddr_un
    {
        unix_domain_address(const char *path);
    };
 
    w::fd accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
 
    template <typename Address>
    w::fd accept(int sockfd, Address& addr)
    {
        socklen_t addrlen = sizeof(addr);
        w::fd fd = w::accept(sockfd, reinterpret_cast<struct sockaddr *>(&addr), &addrlen);
 
        if (addrlen != sizeof(addr))
            throw std::runtime_error(
                "provided structure is not the correct size to hold receive connect address");
 
        return fd;
    }
 
    void bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
 
    template <typename Address>
    void bind(int sockfd, const Address& addr)
    {
        w::bind(sockfd, reinterpret_cast<const struct sockaddr *>(&addr), sizeof(addr));
    }
 
    void connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
 
    template <typename Address>
    void connect(int sockfd, const Address& addr)
    {
        w::connect(sockfd, reinterpret_cast<const struct sockaddr *>(&addr), sizeof(addr));
    }
 
    w::handle<struct ifaddrs *, nullptr, ::freeifaddrs> getifaddrs();
 
    int getsockopt(int sockfd, int level, int optname,
        void *optval = nullptr, socklen_t *optlen = nullptr);
 
    template <typename Value>
    Value getsockopt(int sockfd, int level, int optname)
    {
        Value optval;
        socklen_t optlen = sizeof(optval);
        w::getsockopt(sockfd, level, optname, &optval, &optlen);
        if (optlen != sizeof(optval))
            throw std::runtime_error(
                "wrong size value expected for socket option");
        return optval;
    }
 
    unsigned if_nametoindex(const char *ifname);
 
    char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
 
    void *inet_pton(int af, const char *src, void *dst);
 
    template <typename Address>
    Address& inet_pton(int af, const char *src, Address& dst)
    {
        w::inet_pton(af, src, static_cast<void *>(&dst));
        return dst;
    }
 
    void listen(int sockfd, int backlog);
 
    std::size_t recv(int sockfd, void *buf, std::size_t len, int flags = 0);
 
    std::size_t recvmsg(int sockfd, struct msghdr *msg, int flags = 0);
 
    std::size_t recvfrom(int sockfd, void *buf, std::size_t len, int flags,
        struct sockaddr *src_addr = nullptr, socklen_t *addrlen = nullptr);
 
    template <typename Address>
    std::size_t recvfrom(int sockfd, void *buf, std::size_t len, int flags, Address& src_addr)
    {
        socklen_t addrlen = sizeof(src_addr);
        std::size_t rv = w::recvfrom(sockfd, buf, len, flags,
            reinterpret_cast<struct sockaddr *>(&src_addr), &addrlen);
 
        if (addrlen != sizeof(src_addr))
            throw std::runtime_error(
                "provided structure is not the correct size to hold receive source address");
 
        return rv;
    }
 
    std::size_t send(int sockfd, const void *buf, std::size_t len, int flags = 0);
 
    std::size_t sendmsg(int sockfd, const struct msghdr *msg, int flags = 0);
 
    std::size_t sendto(int sockfd, const void *buf, std::size_t len,
        int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
 
    template <typename Address>
    std::size_t sendto(int sockfd, const void *buf, std::size_t len,
        int flags, const Address& dest_addr)
    {
        return w::sendto(sockfd, buf, len, flags,
            reinterpret_cast<const struct sockaddr *>(&dest_addr), sizeof(dest_addr));
    }
 
    int setsockopt(int sockfd, int level, int optname,
        const void *optval = nullptr, socklen_t optlen = 0);
 
    template <typename Value>
    void setsockopt(int sockfd, int level, int optname, const Value& optval)
    {
        w::setsockopt(sockfd, level, optname, &optval, sizeof(optval));
    }
 
    void shutdown(int sockfd, int how);
 
    w::fd socket(int domain, int type, int protocol = 0);
}
 
namespace w::detail
{
    inline const struct ifaddrs *get_next_ifaddrs(const struct ifaddrs *cur)
    {
        return cur->ifa_next;
    }
}
 
inline auto begin(const struct ifaddrs *ptr) noexcept
{
    return w::const_list_iterator<struct ifaddrs, w::detail::get_next_ifaddrs>(ptr);
}
 
inline auto end(const struct ifaddrs *ptr) noexcept
{
    return w::const_list_iterator<struct ifaddrs, w::detail::get_next_ifaddrs>();
}
 
inline bool operator==(const in6_addr& a, const in6_addr& b) noexcept
{
    return 0 == std::memcmp(&a, &b, sizeof(in6_addr));
}
 
inline bool operator!=(const in6_addr& a, const in6_addr& b) noexcept
{
    return !(a == b);
}
 
inline bool operator<(const in6_addr& a, const in6_addr& b) noexcept
{
    return std::memcmp(&a, &b, sizeof(in6_addr)) < 0;
}