message_header.hxx

Go to the documentation of this file.

#pragma once
 
// C++
#include <cstring>
#include <optional>
 
// Cosmos
#include <cosmos/dso_export.h>
#include <cosmos/error/RuntimeError.hxx>
#include <cosmos/io/iovector.hxx>
#include <cosmos/net/SocketAddress.hxx>
#include <cosmos/net/types.hxx>
 
namespace cosmos {
 
 
struct msghdr_const {
        const void *msg_name;
        socklen_t msg_namelen;
        const struct iovec *msg_iov;
        size_t msg_iovlen;
        const void *msg_control;
        size_t msg_controllen;
        int msg_flags;
};
struct msghdr_const {…};
 
 
template <typename MSGHDR>
class MessageHeaderBase {
public: // functions
 
        MessageHeaderBase() {
                clear();
                // by default mark file descriptor received via unix domain
                // sockets CLOEXEC.
                setIOFlags(MessageFlags{MessageFlag::CLOEXEC});
        }
        MessageHeaderBase() {…}
 
        void clear() {
                std::memset(&m_header, 0, sizeof(m_header));
        }
        void clear() {…}
 
 
        void setIOFlags(const MessageFlags flags) {
                m_io_flags = flags;
        }
        void setIOFlags(const MessageFlags flags) {…}
 
protected: // functions
 
        void resetAddress() {
                m_header.msg_name = nullptr;
                m_header.msg_namelen = 0;
        }
        void resetAddress() {…}
 
        template <typename IOVEC>
        void setIov(IOVEC &iovec) {
                if (iovec.empty()) {
                        m_header.msg_iov = nullptr;
                        m_header.msg_iovlen = 0;
                } else {
                        m_header.msg_iov = iovec.raw();
                        m_header.msg_iovlen = iovec.size();
                }
        }
        void setIov(IOVEC &iovec) {…}
 
        MessageFlags ioFlags() const {
                return m_io_flags;
        }
        MessageFlags ioFlags() const  {…}
 
protected: // data
 
        MSGHDR m_header;
        MessageFlags m_io_flags;
};
class MessageHeaderBase {…};
 
 
class SendMessageHeader :
                public MessageHeaderBase<msghdr_const> {
        friend class Socket;
public: // types
 
 
        class ControlMessage {
                template <OptLevel, typename MSG_TYPE>
                friend class AncillaryMessage;
                friend class SendMessageHeader;
        protected: // functions
 
 
                ControlMessage(const OptLevel level, int type, const size_t data_len);
 
 
                uint8_t* data() {
                        return CMSG_DATA(m_header);
                }
                uint8_t* data() {…}
 
                const uint8_t* data() const {
                        return CMSG_DATA(m_header);
                }
 
                size_t dataSpace() const {
                        return data() - reinterpret_cast<const uint8_t*>(raw());
                }
                size_t dataSpace() const  {…}
 
                const void* raw() const {
                        return m_buffer.data();
                }
                const void* raw() const  {…}
 
                size_t size() const {
                        return m_buffer.size();
                }
                size_t size() const  {…}
 
        protected: // data
 
                std::vector<uint8_t> m_buffer;
                struct cmsghdr *m_header = nullptr;
        };
        class ControlMessage {…};
 
public: // data
 
        WriteIOVector iovec;
        std::optional<ControlMessage> control_msg;
 
protected: // functions
 
        void prepareSend(const SocketAddress *addr);
 
        void postSend(size_t sent) {
                iovec.update(sent);
                control_msg.reset();
        }
        void postSend(size_t sent) {…}
 
        void setAddress(const SocketAddress &addr);
 
        const struct msghdr* rawHeader() const {
                return reinterpret_cast<const struct msghdr*>(&m_header);
        }
        const struct msghdr* rawHeader() const  {…}
};
class SendMessageHeader : {…};
 
 
class COSMOS_API ReceiveMessageHeader :
                public MessageHeaderBase<msghdr> {
        friend class Socket;
public: // types
 
        class ControlMessage {
                template <OptLevel, typename MSG_TYPE>
                friend class AncillaryMessage;
        protected: // functions
 
                int type() const {
                        return m_header.cmsg_type;
                }
                int type() const  {…}
 
                auto length() const {
                        return m_header.cmsg_len;
                }
                auto length() const  {…}
 
        public: // functions
 
 
                OptLevel level() const {
                        return OptLevel{m_header.cmsg_level};
                }
                OptLevel level() const  {…}
 
                std::optional<UnixMessage> asUnixMessage() const {
                        if (level() == OptLevel::SOCKET) {
                                return UnixMessage{type()};
                        }
 
                        return std::nullopt;
                }
                std::optional<UnixMessage> asUnixMessage() const  {…}
 
                std::optional<IP4Message> asIP4Message() const {
                        if (level() == OptLevel::IP) {
                                return IP4Message{type()};
                        }
 
                        return std::nullopt;
                }
 
                std::optional<IP6Message> asIP6Message() const {
                        if (level() == OptLevel::IPV6) {
                                return IP6Message{type()};
                        }
 
                        return std::nullopt;
                }
 
 
                const void* data() const {
                        return CMSG_DATA(&m_header);
                }
                const void* data() const  {…}
 
                size_t dataLength() const {
                        return length() - sizeof(m_header);
                }
                size_t dataLength() const  {…}
 
        protected: // data
 
                struct cmsghdr m_header;
        };
        class ControlMessage {…};
 
        class ControlMessageIterator {
        public: // functions
 
                ControlMessageIterator() {}
 
 
                explicit ControlMessageIterator(const ReceiveMessageHeader &header) :
                                m_pos{CMSG_FIRSTHDR(&header.m_header)},
                                m_header{&header} {
                }
                explicit ControlMessageIterator(const ReceiveMessageHeader &header) : {…}
 
                auto& operator++() {
                        if (m_pos) {
                                const msghdr *hdr = m_header->rawHeader();
                                const cmsghdr *chdr = m_pos;
                                m_pos = CMSG_NXTHDR(const_cast<msghdr*>(hdr), const_cast<cmsghdr*>(chdr));
                        } else {
                                cosmos_throw (RuntimeError("Attempt to increment ControlMessageIterator past the end"));
                        }
 
                        return *this;
                }
                auto& operator++() {…}
 
                bool operator==(const ControlMessageIterator &other) const {
                        return m_pos == other.m_pos;
                }
 
                bool operator!=(const ControlMessageIterator &other) const {
                        return !(*this == other);
                }
 
                const ControlMessage& operator*() {
                        if (!m_pos) {
                                cosmos_throw (RuntimeError("Attempt to dereference an invalid ControlMessageIterator"));
                        }
 
                        return *reinterpret_cast<const ControlMessage*>(m_pos);
                }
                const ControlMessage& operator*() {…}
 
        protected: // data
 
                const cmsghdr *m_pos = nullptr;
                const ReceiveMessageHeader *m_header = nullptr;
        };
        class ControlMessageIterator {…};
 
 
public: // data
 
        ReadIOVector iovec;
 
public: // functions
 
        MessageFlags flags() const {
                return MessageFlags{m_header.msg_flags};
        }
        MessageFlags flags() const  {…}
 
 
        void setControlBufferSize(const size_t bytes);
 
        void clearControlBuffer() {
                setControlBufferSize(0);
        }
        void clearControlBuffer() {…}
 
        ControlMessageIterator begin() {
                return ControlMessageIterator{*this};
        }
 
        ControlMessageIterator end() {
                return ControlMessageIterator{};
        }
 
protected: // functions
 
        void prepareReceive(SocketAddress *addr);
 
        void postReceive(size_t received) {
                iovec.update(received);
        }
        void postReceive(size_t received) {…}
 
        void setAddress(SocketAddress &addr);
 
        struct msghdr* rawHeader() {
                return &m_header;
        }
 
        const struct msghdr* rawHeader() const {
                return &m_header;
        }
 
protected: // data
 
        std::vector<uint8_t> m_control_buffer;
};
class COSMOS_API ReceiveMessageHeader : {…};
 
 
template <OptLevel level, typename MSG_TYPE>
class AncillaryMessage {
protected: // functions
 
        SendMessageHeader::ControlMessage createMsg(MSG_TYPE type, const size_t data_len) const {
                return SendMessageHeader::ControlMessage{level, to_integral(type), data_len};
        }
 
        void checkMsg(const ReceiveMessageHeader::ControlMessage &msg, MSG_TYPE type) const {
                if (msg.level() != level || type != MSG_TYPE(msg.type())) {
                        cosmos_throw(RuntimeError("ancillary message type mismatch"));
                }
        }
 
        uint8_t* data(SendMessageHeader::ControlMessage &msg) const {
                return msg.data();
        }
};
class AncillaryMessage {…};
 
} // end ns