SignalFD.hxx

#pragma once
 
// Linux
#include <sys/signalfd.h>
 
// cosmos
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/proc/SigInfo.hxx>
#include <cosmos/proc/SigSet.hxx>
#include <cosmos/proc/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API SignalFD {
public: // types
 
        class Info;
 
public: // functions
 
        SignalFD() {}
 
        ~SignalFD();
 
        explicit SignalFD(const SigSet &mask) {
                create(mask);
        }
 
        explicit SignalFD(const std::initializer_list<Signal> siglist) {
                create(SigSet{siglist});
        }
 
        explicit SignalFD(const Signal s) {
                create(SigSet{{s}});
        }
 
        // Prevent copying due to the file descriptor ownership.
        SignalFD(const SignalFD&) = delete;
        SignalFD& operator=(const SignalFD&) = delete;
 
 
        void create(const SigSet &mask);
 
        void close() { m_fd.close(); }
 
        auto valid() const { return m_fd.valid(); }
 
 
        void adjustMask(const SigSet &mask);
 
 
        void readEvent(Info &info);
 
        auto fd() { return m_fd; }
 
protected: // data
 
        FileDescriptor m_fd;
};
 
 
class COSMOS_API SignalFD::Info {
public: // types
 
        /* reuse the sub-structures as is */
 
        using Source       = SigInfo::Source;
        using ProcessCtx   = SigInfo::ProcessCtx;
        using UserSigData  = SigInfo::UserSigData;
        using QueueSigData = SigInfo::QueueSigData;
        using MsgQueueData = SigInfo::MsgQueueData;
        using TimerData    = SigInfo::TimerData;
        using ChildData    = SigInfo::ChildData;
        using SysData      = SigInfo::SysData;
        using PollData     = SigInfo::PollData;
 
public: // functions
 
        Info() {
                clear();
        }
 
 
        Info(const no_init_t) {}
 
        const signalfd_siginfo* raw() const {
                return &m_raw;
        }
 
        signalfd_siginfo* raw() {
                return &m_raw;
        }
 
        Signal sigNr() const {
                // ssi_signo is unsigned, while in sigaction it's signed.
                return Signal{SignalNr{static_cast<int>(m_raw.ssi_signo)}};
        }
 
 
        Source source() const;
 
 
        bool isTrustedSource() const {
                return m_raw.ssi_code >= 0;
        }
 
        std::optional<const UserSigData> userSigData() const;
 
        std::optional<const QueueSigData> queueSigData() const;
 
        std::optional<const MsgQueueData> msgQueueData() const;
 
        std::optional<const TimerData> timerData() const;
 
 
        std::optional<const SysData> sysData() const;
 
 
        std::optional<const ChildData> childData() const;
 
 
        std::optional<const PollData> pollData() const;
 
        void clear() {
                zero_object(m_raw);
        }
 
protected: // functions
 
 
        Errno error() const {
                return Errno{m_raw.ssi_errno};
        }
 
        ProcessCtx procCtx() const {
                return ProcessCtx{pid(), uid()};
        }
 
        ProcessID pid() const {
                // ssi_pid is unsigned while pid_t is signed
                return ProcessID{static_cast<pid_t>(m_raw.ssi_pid)};
        }
 
        UserID uid() const {
                return UserID{m_raw.ssi_uid};
        }
 
protected: // data
 
        signalfd_siginfo m_raw;
};
 
} // end ns