signalclasses.h.html

    // Copyright (c) 1999-2000 David Muse
    // See the COPYING file for more information.

    #ifndef SIGNALCLASSES_H
    #define SIGNALCLASSES_H

    #include <sys/types.h>
    #include <signal.h>

    // Signals are a means for processes to interrupt each other.
    //
    // Many signals will cause a process to exit unless they are explicitly
    // handled by a callback function.
    //
    // Different architectures have different signals, but most have the following
    // signals:

    // A signalset it just a collection of signals.  Many signal-related functions
    // take signalsets for arguments.  The signalset class makes signalsets
    // easy to manage.
    class signalset {
            public:
                    int     addSignal(int signum);
                            // add the signal "signum" to the set
                    int     addAllSignals();
                            // add all signals to the set
                    int     removeSignal(int signum);
                            // remove the signal "signum" from the set
                    int     removeAllSignals();
                            // remove all signals from the set
                    int     signalIsInSet(int signum);
                            // returns 1 if the signal "signum" is in the
                            // set and 0 if it is not

                    sigset_t        *getSignalSet();
                                    // returns the set of signals

            private:
                    #include <rudiments/private/signalset.h>
    };

    // The signalmanager class provides methods for sending, blocking and waiting
    // for signals.
    class signalmanager {
            public:
                    static  int     sendSignal(pid_t processid, int signum);
                                    // send singal "signum" to process "processid"
                    static  int     raiseSignal(int signum);
                                    // send singal "signum" to self
                    static  int     ignoreSignals(sigset_t *sigset);
                                    // ignore signal "signum"
                    static  int     waitForSignals(sigset_t *mask);
                                    // wait until a signal NOT in the signal set
                                    // "mask" is received
                    static  int     examineBlockedSignals(sigset_t *sigset);
                                    // sets "sigset" to the set of signals that
                                    // were raised, but blocked during a call to
                                    // waitForSignals()
    };

    // The signalhandler class provides methods for catching and handling signals.
    class signalhandler {
            public:
                            signalhandler();
                            signalhandler(int signum, void *handler);
                            // calls the setSignal() and setHandler() methods
                            // below during instantiation
                    virtual ~signalhandler();

                    void    setSignal(int signum);
                            // sets which signal this handler will respond to
                    void    setHandler(void *inthandler);
                            // sets the function to call when the process
                            // receives the signal

                    int     handleSignal();
                            // Instructs the program to actually handle the signal.
                            // After calling this method, if any other methods
                            // are called, this method must be called again.

                    // Signal flags modify the behavior of the signal handling
                    // process.
                    void    removeAllFlags();
                            // remove all flags
                    void    addFlag(int flag);
                            // add "flag" to the set of flags modifying the
                            // behavior of this signal handler
                    int     getFlags();
                            // return the set of flags modifying the behavior of
                            // this signal handler

                    // A signal mask is the set of signals that are blocked while
                    // the signal handler function is being called.  Masking
                    // signals can ensure that the function executes without
                    // interruption.
                    int             addSignalToMask(int signum);
                                    // add the signal "signum" to the mask
                    int             addAllSignalsToMask();
                                    // mask all signals
                    int             removeSignalFromMask(int signum);
                                    // remove the signal "signum" from the mask
                    int             removeAllSignalsFromMask();
                                    // mask no signals
                    int             signalIsInMask(int signum);
                                    // returns 1 if the signal "signum" is masked
                                    // and 0 if it is not
                    void            setMask(sigset_t sigset);
                                    // explicitly sets the mask to "sigset"
                    sigset_t        *getMask();
                                    // returns the set of signals currently masked

            private:
                    #include <rudiments/private/signalhandler.h>

    };

    #endif