SocketError.hxx

#pragma once
 
// C++
#include <cstdint>
#include <optional>
#include <type_traits>
#include <utility>
 
// Linux
#include <sys/time.h>
#include <linux/errqueue.h>
 
// Cosmos
#include <cosmos/error/errno.hxx>
#include <cosmos/net/IPAddress.hxx>
#include <cosmos/net/traits.hxx>
#include <cosmos/net/types.hxx>
 
namespace cosmos {
 
 
template <SocketFamily FAMILY>
class SocketErrorT :
                protected sock_extended_err {
public: // types
 
        using IPAddress = typename FamilyTraits<FAMILY>::Address;
 
        enum class Origin : uint8_t {
                NONE     = SO_EE_ORIGIN_NONE,
                LOCAL    = SO_EE_ORIGIN_LOCAL,
                ICMP     = SO_EE_ORIGIN_ICMP,
                ICMP6    = SO_EE_ORIGIN_ICMP6,
                TXSTATUS = SO_EE_ORIGIN_TXSTATUS,
                ZEROCOPY = SO_EE_ORIGIN_ZEROCOPY,
                TXTIME   = SO_EE_ORIGIN_TXTIME
        };
 
        enum class ZeroCopyCode : uint8_t {
                ZEROCOPY_COPIED      = SO_EE_CODE_ZEROCOPY_COPIED,
        };
 
        enum class TxTimeCode : uint8_t {
                TXTIME_INVALID_PARAM = SO_EE_CODE_TXTIME_INVALID_PARAM,
                TXTIME_MISSED        = SO_EE_CODE_TXTIME_MISSED
        };
 
public: // functions
 
        Origin origin() const {
                return Origin{this->ee_origin};
        }
 
        Errno errnum() const {
                // ee_errno is unsigned, while errno is signed
                return Errno{static_cast<std::underlying_type<Errno>::type>(this->ee_errno)};
        }
 
        std::optional<uint32_t> discoveredMTU() const {
                if (errnum() == Errno::MSG_TOO_LARGE) {
                        return this->ee_info;
                }
 
                return std::nullopt;
        }
 
        std::optional<ZeroCopyCode> zeroCopyCode() const {
                if (origin() == Origin::ZEROCOPY) {
                        return ZeroCopyCode{this->ee_code};
                }
 
                return std::nullopt;
        }
 
        std::optional<TxTimeCode> txTimeCode() const {
                if (origin() == Origin::TXTIME) {
                        return TxTimeCode{this->ee_code};
                }
 
                return std::nullopt;
        }
 
 
        std::optional<std::pair<uint32_t, uint32_t>> zeroCopyRange() const {
                if (origin() == Origin::ZEROCOPY) {
                        return std::make_pair(this->ee_info, this->ee_data);
                }
 
                return std::nullopt;
        }
 
        bool originIsICMP() const {
                return origin() == Origin::ICMP || origin() == Origin::ICMP6;
        }
 
        std::optional<uint8_t> icmpType() const {
                if (originIsICMP()) {
                        return this->ee_type;
                }
 
                return std::nullopt;
        }
 
        std::optional<uint8_t> icmpCode() const {
                if (originIsICMP()) {
                        return this->ee_code;
                }
 
                return std::nullopt;
        }
 
        SocketFamily offenderAddressFamily() const {
                return SocketFamily(offenderAddr()->sa_family);
        }
 
 
        bool hasOffenderAddress() const {
                return offenderAddressFamily() != SocketFamily::UNSPEC;
        }
 
        std::optional<IPAddress> offenderAddress() const {
                if (offenderAddressFamily() != FAMILY)
                        return std::nullopt;
 
                using RawAddr = typename FamilyTraits<FAMILY>::RawAddr;
                return IPAddress{*reinterpret_cast<const RawAddr*>(offenderAddr())};
        }
 
protected: // functions
 
        const struct sockaddr* offenderAddr() const {
                // this is piggyback data found after the end of the struct
                // sock_extended_err. It is only valid if sa_family !=
                // AF_UNSPEC.
                return SO_EE_OFFENDER(this);
        }
};
 
using IP4SocketError = SocketErrorT<SocketFamily::INET>;
using IP6SocketError = SocketErrorT<SocketFamily::INET6>;
 
} // end ns