be_error_signal_manager.h

Go to the documentation of this file.

/******************************************************************************
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 ******************************************************************************/
#ifndef __BE_ERROR_SIGNAL_MANAGER_H__
#define __BE_ERROR_SIGNAL_MANAGER_H__
 
#include <csetjmp>
#include <csignal>
 
#include <be_error_exception.h>
 
/*
 * Macros that are used by applications to indicate the start and end of
 * a signal handling block.
 */
#define BEGIN_SIGNAL_BLOCK(_sigmgr, _blockname) do {                    \
        if (!(_sigmgr)->isEnabled())                                    \
                break;                                                  \
        (_sigmgr)->clearSigHandled();                                   \
        (_sigmgr)->stop();                                              \
        if (sigsetjmp(                                                  \
            BiometricEvaluation::Error::SignalManager::_sigJumpBuf, 1) != 0) \
         {                                                              \
                (_sigmgr)->setSigHandled();                             \
                goto _blockname ## _end;                                \
        }                                                               \
        (_sigmgr)->start();                                             \
} while (0)
 
#define END_SIGNAL_BLOCK(_sigmgr, _blockname) do {                      \
        if (!(_sigmgr)->isEnabled())                                    \
                break;                                                  \
        _blockname ## _end:                                             \
        (_sigmgr)->stop();                                              \
} while (0);
 
#define ABORT_SIGNAL_MANAGER(_sigmgr) do {                              \
        if (!(_sigmgr)->isEnabled())                                    \
                break;                                                  \
        (_sigmgr)->stop();                                              \
} while (0);
 
namespace BiometricEvaluation {
 
        namespace Error {
 
                class SignalManager {
 
                public:
                        
                        SignalManager();
 
                        SignalManager(
                            const sigset_t signalSet);
 
                        void setSignalSet(
                            const sigset_t signalSet);
 
                        void clearSignalSet();
 
                        void setDefaultSignalSet();
 
                        bool sigHandled();
 
                        void start();
 
                        void stop();
 
                        void setSigHandled();
 
                        void clearSigHandled();
 
                        void setEnabled(
                            const bool enabled);
 
                        bool isEnabled() const;
 
                        static bool _canSigJump;
                        static sigjmp_buf _sigJumpBuf;
 
                protected:
 
                private:
                        bool _enabled{true};
 
                        sigset_t _signalSet;
 
                        bool _sigHandled{false};
                };
 
                /*
                * Declaration of the signal handler, a function with C linkage
                * that will handle all signals managed by this object,
                * conditionally jumping to a jump block within the application
                * process. This function is of no interest to applications,
                * which should use the BEGIN_SIGNAL_BLOCK()/END_SIGNAL_BLOCK()
                * macro pair to take advantage of signal handling.
                */
                extern "C" {
                        void SignalManagerSighandler(int signo,
                            siginfo_t *info, void *uap);
                }
        }
}
#endif  /* __BE_ERROR_SIGNAL_MANAGER_H__ */