|
// 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
|