MNSignals.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_OSS_SIGNALS_H
#define MN_OSS_SIGNALS_H

#if 0

#include "MNList.h"
#include "MNThread.h"
#include "MNMsg.h"

/*
 * REQUIRES:
 * gcc to define _THREAD_SAFE when compiling multi-threading
 * configure to define HAVE_STRERROR_R is strerror_r exists
 * configure for signal.h
 * configure for string.h
 */

#include <signal.h>  /* for the signals */

/***********************************************************************
 * Type: Class
 * Name: MNSigHandler
 * Short: handle Unix signals that were caught by MNSigMgr
 */

class MNSigHandler
{
public:
    /*******************************************************************
     * Name: MNSigHandler
     * Short: constructor
     */

    MNSigHandler() { }

    /*******************************************************************
     * Name: bool raise()
     * Short: pure virtual function implemented for this signal
     */

    virtual bool raise() = 0;
};


/***********************************************************************
 * Type: Class
 * Name: MNSigMgr
 * Short: handle various Unix signals and direct to MNSigHandlers
 */

class MNSigMgr
    : public MNThread
{
    sigset_t _oldset;

public:
    /***********************************************************************
     * Type: Enum
     * Name: MNSignal
     * Short: enum of existing signals, assigned to system's signal id
     */

    enum MNSignal
    {
        MNSigNONE    = 0,          /* not a signal */

        /*
         * POSIX signals - supported by medianode
         */
        MNSigHUP     = SIGHUP,     /* hangup, generated when terminal disconnects */
        MNSigINT     = SIGINT,     /* interrupt, generated from terminal special char */
        MNSigQUIT    = SIGQUIT,    /* (*) quit, generated from terminal special char */
        MNSigILL     = SIGILL,     /* (*) illegal instruction (not reset when caught)*/
        MNSigTRAP    = SIGTRAP,    /* (*) trace trap (not reset when caught) */
        MNSigABRt    = SIGABRT,    /* (*) abort process */
        MNSigFPE     = SIGFPE,     /* (*) floating point exception */
        MNSigKILL    = SIGKILL,    /* kill (cannot be caught or ignored) */
        MNSigBUS     = SIGBUS,     /* (*) bus error (specification exception) */
        MNSigSEGV    = SIGSEGV,    /* (*) segmentation violation */
        MNSigPIPE    = SIGPIPE,    /* write on a pipe with no one to read it */
        MNSigALRM    = SIGALRM,    /* alarm clock timeout */
        MNSigTERM    = SIGTERM,    /* software termination signal */
        MNSigCHLD    = SIGCHLD,    /* (+) sent to parent on child stop or exit */
        MNSigUSR1    = SIGUSR1,    /* user defined signal 1 */
        MNSigUSR2    = SIGUSR2,    /* user defined signal 2 */

        /*
         * POSIX signals - supported by medianode
         */
        MNSigURG     = SIGURG,     /* (+) urgent contition on I/O channel */
        MNSigSTOP    = SIGSTOP,    /* (@) stop (cannot be caught or ignored) */
        MNSigTSTP    = SIGTSTP,    /* (@) interactive stop */
        MNSigCONT    = SIGCONT,    /* (!) continue (cannot be caught or ignored) */
        MNSigTTIN    = SIGTTIN,    /* (@) background read attempted from control terminal*/
        MNSigTTOU    = SIGTTOU,    /* (@) background write attempted to control terminal */
        MNSigIO      = SIGIO,      /* (+) I/O possible, or completed */
        MNSigXCPU    = SIGXCPU,    /* cpu time limit exceeded (see setrlimit()) */
        MNSigXFSZ    = SIGXFSZ,    /* file size limit exceeded (see setrlimit()) */
        MNSigWINCH   = SIGWINCH,   /* (+) window size changed */
        MNSigPROF    = SIGPROF,    /* profiling time alarm (see setitimer) */
        MNSigVTALRM  = SIGVTALRM,  /* virtual time alarm (see setitimer) */
#if defined(_AIX) || defined(linux)
        MNSigPWR     = SIGPWR,     /* (+) power-fail restart */
#endif
#ifdef _AIX
        MNSigEMT     = SIGEMT,     /* EMT intruction */
        MNSigSYS     = SIGSYS,     /* (*) bad argument to system call */
        MNSigMSG     = SIGMSG,     /* input data is in the ring buffer */
        MNSigDANGER  = SIGDANGER,  /* system crash imminent; free up some page space */
        MNSigMIGRATE = SIGMIGRATE, /* migrate process */
        MNSigPRE     = SIGPRE,     /* programming exception */
        MNSigVIRT    = SIGVIRT,    /* AIX virtual time alarm */
        MNSigALRM1   = SIGALRM1,   /* m:n condition variables */
        MNSigWAITING = SIGWAITING, /* m:n scheduling */
        MNSigKAP     = SIGKAP,     /* keep alive poll from native keyboard */
        MNSigRETRACT = SIGRETRACT, /* monitor mode should be relinguished */
        MNSigSOUND   = SIGSOUND,   /* sound control has completed */
        MNSigSAK     = SIGSAK      /* secure attention key */
#endif
    };

private:
    /*******************************************************************
     * Name: bool _activeHandler[]
     * Short: indicates whether a thread has registered a private handler
     */

    bool _activeHandler[17];

    /*******************************************************************
     * Name: MNList<MNSigHandler*> _handlerList[]
     * Short: lists of active handlers, indexed by signal index
     */

    MNList<MNSigHandler*> _handlerList[17];

    /*******************************************************************
     * Name: const char* mapSigToName( MNSignal )
     * Short: returns a name for a signal id
     */

    const char* mapSigToName( MNSignal s ) const;

    /*******************************************************************
     * Name: int mapSigToIndex( MNSignal )
     * Short: returns an integer for a signal id
     */

    inline int mapSigToIndex( MNSignal s ) const
    {
        switch ( s )
        {
        case MNSigHUP  : return 1; break;
        case MNSigINT  : return 2; break;
        case MNSigQUIT : return 3; break;
        case MNSigILL  : return 4; break;
        case MNSigTRAP : return 5; break;
        case MNSigABRt : return 6; break;
        case MNSigFPE  : return 7; break;
        case MNSigKILL : return 8; break;
        case MNSigBUS  : return 9; break;
        case MNSigSEGV : return 10; break;
        case MNSigPIPE : return 11; break;
        case MNSigALRM : return 12; break;
        case MNSigTERM : return 13; break;
        case MNSigCHLD : return 14; break;
        case MNSigUSR1 : return 15; break;
        case MNSigUSR2 : return 16; break;
        default:
        // I moved the return to end of file because xlC got
        // confused here, below as well.
        // cg 24nov1999
            break;
        }
        MN_FATAL("uncaught signal map-to-index");
        return -1;
    }

    /*******************************************************************
     * Name: MNSignal mapIndexToSig( int )
     * Short: returns a signal id for an integer
     */

    inline MNSignal mapIndexToSig( int i ) const
    {
        switch ( i )
        {
        case  1: return MNSigHUP; break;
        case  2: return MNSigINT; break;
        case  3: return MNSigQUIT; break;
        case  4: return MNSigILL; break;
        case  5: return MNSigTRAP; break;
        case  6: return MNSigABRt; break;
        case  7: return MNSigFPE; break;
        case  8: return MNSigKILL; break;
        case  9: return MNSigBUS; break;
        case 10: return MNSigSEGV; break;
        case 11: return MNSigPIPE; break;
        case 12: return MNSigALRM; break;
        case 13: return MNSigTERM; break;
        case 14: return MNSigCHLD; break;
        case 15: return MNSigUSR1; break;
        case 16: return MNSigUSR2; break;
        default:
            break;
        }
        MN_FATAL("uncaught signal map-to-signal");
        return MNSigNONE;
    }

public:
    /*******************************************************************
     * Name: MNSigMgr
     * Short: constructor
     */
    MNSigMgr();

    /*******************************************************************
     * Name: bool init_before_thread_start()
     * Short: we can not really block signals on Solaris
     */
    bool init_before_thread_start();

    /*******************************************************************
     * Name: void reg( MNSignal, MNSigHandler* )
     * Short: registers a Handler for a signal
     */

    void reg( MNSignal s, MNSigHandler* handler );

    /*******************************************************************
     * Name: void dereg( MNSignal, MNSigHandler* )
     * Short: removes a handler for a signal
     */

    void dereg( MNSignal s, MNSigHandler* handler );

    /*******************************************************************
     * Name: virtual void run ();
     * Short: body of the thread that waits for signals
     */

    virtual void run ();
};

#endif /* 0 */

#endif /* MN_OSS_SIGNALS_H */

---