SocketOptions.hxx

#pragma once
 
// C++
#include <chrono>
 
// cosmos
#include <cosmos/dso_export.h>
#include <cosmos/error/errno.hxx>
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/net/SockOptBase.hxx>
#include <cosmos/net/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API SocketOptions :
                public SockOptBase<OptLevel::SOCKET> {
public: // types
 
 
        struct Linger :
                        protected ::linger {
 
                friend SocketOptions;
 
                Linger() :
                                Linger{false, std::chrono::seconds{0}}
                {}
 
                Linger(const bool on_off, const std::chrono::seconds time) {
                        setEnabled(on_off);
                        setTime(time);
                }
 
                bool isEnabled() const {
                        return l_onoff == 0 ? false : true;
                }
 
                void setEnabled(const bool on_off) {
                        l_onoff = on_off ? 1 : 0;
                }
 
                void setTime(const std::chrono::seconds time) {
                        l_linger = time.count();
                }
 
                std::chrono::seconds time() const {
                        return std::chrono::seconds{l_linger};
                }
        };
 
public: // functions
 
        bool acceptsConnections() const {
                return getBoolOption(OptName{SO_ACCEPTCONN});
        }
 
 
        void bindToDevice(const SysString ifname);
 
        std::string boundDevice() const;
 
        void unbindDevice() {
                bindToDevice("");
        }
 
 
        void enableDebug(const bool on_off) {
                setBoolOption(OptName{SO_DEBUG}, on_off);
        }
 
        SocketFamily family() const {
                const auto family = getIntOption(OptName{SO_DOMAIN});
                return SocketFamily{family};
        }
 
        SocketType type() const {
                const auto type = getIntOption(OptName{SO_TYPE});
                return SocketType{type};
        }
 
        SocketProtocol protocol() const {
                const auto protocol = getIntOption(OptName{SO_PROTOCOL});
                return SocketProtocol{protocol};
        }
 
 
        Errno lastError() {
                const auto error = getIntOption(OptName{SO_ERROR});
                return Errno{error};
        }
 
 
        void setReuseAddress(const bool on_off) {
                setBoolOption(OptName{SO_REUSEADDR}, on_off);
        }
 
 
        void setReusePort(const bool on_off) {
                setBoolOption(OptName{SO_REUSEPORT}, on_off);
        }
 
 
        void setKeepalive(const bool on_off) {
                setBoolOption(OptName{SO_KEEPALIVE}, on_off);
        }
 
 
        void setMark(const uint32_t mark);
 
 
        Linger getLinger() const;
 
 
        void setLinger(const Linger &linger);
 
 
        void setZeroCopy(const bool on_off) {
                setBoolOption(OptName{SO_ZEROCOPY}, on_off);
        }
 
 
        void setReceiveLowerBound(const int bytes) {
                setIntOption(OptName{SO_RCVLOWAT}, bytes);
        }
 
protected: // functions
 
        friend class Socket;
 
        explicit SocketOptions(FileDescriptor fd) : SockOptBase{fd} {}
};
 
}; // end ns