FileDescriptor.hxx

#pragma once
 
// C++
#include <optional>
#include <tuple>
 
// Linux
#include <fcntl.h>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/fs/types.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/thread/thread.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
class FileLock;
 
using CloseOnExec = NamedBool<struct cloexec_t, true>;
 
 
class COSMOS_API FileDescriptor {
public: // types
 
        enum class DescFlag : int {
                NONE    = 0,
                CLOEXEC = FD_CLOEXEC
        };
 
        using DescFlags = BitMask<DescFlag>;
 
        enum class SealFlag : unsigned int {
                SEAL         = F_SEAL_SEAL,         
                SHRINK       = F_SEAL_SHRINK,       
                GROW         = F_SEAL_GROW,         
                WRITE        = F_SEAL_WRITE,        
                FUTURE_WRITE = F_SEAL_FUTURE_WRITE  
        };
 
        using SealFlags = BitMask<SealFlag>;
 
 
        enum class LeaseType : int {
                READ   = F_RDLCK,
                WRITE  = F_WRLCK,
                UNLOCK = F_UNLCK
        };
 
 
        struct Owner {
 
                /*
                 * Contrary to what the man page says this is not an int, but
                 * an enum in the system headers.
                 *
                 * The type field being an old school enum complicates things
                 * for us here, we cannot use to_integral() to assign. Instead
                 * perform a static cast to the declaration type to make this
                 * work.
                 */
                using RawType = decltype(f_owner_ex::type);
 
        public: // types
 
                enum class Type : std::underlying_type<RawType>::type {
                        THREAD  = F_OWNER_TID,
                        PROCESS = F_OWNER_PID,
                        GROUP   = F_OWNER_PGRP
                };
 
        public: // functions
 
                Owner() {
                        invalidate();
                }
 
                explicit Owner(ProcessID pid) {
                        set(pid);
                }
 
                explicit Owner(ProcessGroupID pgid) {
                        set(pgid);
                }
 
                explicit Owner(ThreadID tid) {
                        set(tid);
                }
 
                Type type() const {
                        return Type{m_raw.type};
                }
 
                bool isTID() const {
                        return type() == Type::THREAD;
                }
 
                bool isPID() const {
                        return type() == Type::PROCESS;
                }
 
                bool isPGID() const {
                        return type() == Type::GROUP;
                }
 
                bool valid() const {
                        // if not owner was ever set then the PID will be zero
                        return m_raw.pid != 0 && (isTID() || isPID() || isPGID());
                }
 
                void invalidate() {
                        m_raw.type = (RawType)-1;
                        m_raw.pid = -1;
                }
 
                void set(ProcessID pid) {
                        m_raw.type = static_cast<RawType>(Type::PROCESS);
                        m_raw.pid = to_integral(pid);
                }
 
                void set(ProcessGroupID pgid) {
                        m_raw.type = static_cast<RawType>(Type::GROUP);
                        m_raw.pid = to_integral(pgid);
                }
 
                void set(ThreadID tid) {
                        m_raw.type = static_cast<RawType>(Type::THREAD);
                        m_raw.pid = to_integral(tid);
                }
 
                std::optional<ProcessID> asPID() const {
                        return isPID() ? std::make_optional(ProcessID{m_raw.pid}) : std::nullopt;
                }
 
                std::optional<ProcessGroupID> asPGID() const {
                        return isPGID() ? std::make_optional(ProcessGroupID{m_raw.pid}) : std::nullopt;
                }
 
                std::optional<ThreadID> asTID() const {
                        return isTID() ? std::make_optional(ThreadID{m_raw.pid}) : std::nullopt;
                }
 
                auto raw() {
                        return &m_raw;
                }
 
                auto raw() const {
                        return &m_raw;
                }
 
        protected: // data
 
                f_owner_ex m_raw;
        };
 
public: // functions
 
        constexpr FileDescriptor() = default;
 
        explicit constexpr FileDescriptor(FileNum fd) :
                        m_fd{fd} {}
 
        bool valid() const { return m_fd != FileNum::INVALID; }
        bool invalid() const { return !valid(); }
 
 
        void setFD(const FileNum fd) { m_fd = fd; }
 
 
        void reset() { m_fd = FileNum::INVALID; }
 
 
        void close();
 
 
        void duplicate(const FileDescriptor new_fd, const CloseOnExec cloexec = CloseOnExec{true}) const;
 
 
        FileDescriptor duplicate(
                        const FileNum lowest = FileNum{0},
                        const CloseOnExec cloexec = CloseOnExec{true}) const;
 
        DescFlags getFlags() const;
 
        void setFlags(const DescFlags flags);
 
        void setCloseOnExec(bool on_off) {
                setFlags({on_off ? DescFlag::CLOEXEC : DescFlag::NONE});
        }
 
        std::tuple<OpenMode, OpenFlags> getStatusFlags() const;
 
 
        void setStatusFlags(const OpenFlags flags);
 
 
        void sync();
 
 
        void dataSync();
 
 
        void addSeals(const SealFlags flags);
 
        SealFlags getSeals() const;
 
        int getPipeSize() const;
 
 
        int setPipeSize(const int new_size);
 
        FileNum raw() const { return m_fd; }
 
        bool operator==(const FileDescriptor &other) const {
                return m_fd == other.m_fd;
        }
 
        bool operator!=(const FileDescriptor &other) const {
                return !(*this == other);
        }
 
 
        bool getLock(FileLock &lock) const;
 
 
        bool setLock(const FileLock &lock) const;
 
 
        void setLockWait(const FileLock &lock) const;
 
        bool getOFDLock(FileLock &lock) const;
 
        bool setOFDLock(const FileLock &lock) const;
 
        void setOFDLockWait(const FileLock &lock) const;
 
 
        void getOwner(Owner &owner) const;
 
 
        void setOwner(const Owner owner);
 
 
        std::optional<Signal> getSignal() const;
 
 
        void setSignal(std::optional<Signal> sig);
 
 
        LeaseType getLease() const;
 
 
        void setLease(const LeaseType lease);
 
protected: // functions
 
        int fcntl(int cmd) const;
 
        template <typename T>
        int fcntl(int cmd, T val) const;
 
protected: // data
 
        FileNum m_fd = FileNum::INVALID;
};
 
extern COSMOS_API FileDescriptor stdout;
extern COSMOS_API FileDescriptor stderr;
extern COSMOS_API FileDescriptor stdin;
 
} // end ns