Signal Handling (c++)

Question

I have this simple code that loops the word "SIGNALS ARE COOL" I'm trying to make it take signals like (SIGFPE. SIGABRT, SIGINT, SIGSEGV.) and show the signal type and the time I made this code that takes "SIGINT" signal how do I add more signals and how to control what my program show when the signals are triggered by the user.

// ConsoleApplication3.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <csignal>

using namespace std;

void signalHandler(int signum) {
    cout << "Interrupt signal (" << signum << ") received.\n";

    // cleanup and close up stuff here  
    // terminate program  

    exit(signum);
}

int main() {
    // register signal SIGINT and signal handler  
    signal(SIGINT, signalHandler);
    

    while (1) {
        cout << "SIGNALS ARE COOL" << endl;
        
    }
    

    return 0;
}

Answer 1

I see that this looks like an assignment; so what I'm saying may not be relevant to you (but might be to someone someday).

--EDIT--

I see you've also got stdafx.h, which I think is a Visual Studio Windows thing, and here I am suggesting a POSIX solution (not pure C++). I didn't read carefully enough, and that invalidates my whole answer (I think). You probably can't use my suggestion, and for that I'm sorry.

However, I'm going to leave it here in case someone one day finds this and needs to work with signals in a Unix system.

--

I've found that it's often a lot more practical to avoid signal handling functions like this altogether, and take signals on your own terms. As noted by others, there's a lot of rules about what you can and can't do within a signal handler, because they can be invoked at any time, in any thread, unless you take extra precautions. I've seen this result in a lot of messy code, things like 'have a global bool got_signal that gets checked by things all over the application to know if they're supposed to shut down'. There's obviously nice ways to do signal handling, but at this point I try to avoid it altogether in favor of other options.

The functions pthread_sigmask and sigwait can be used to invert control here and allow you to accept signals within the defined flow of program execution where you want it, and then you don't need to worry about taking invalid actions when you handle them. Using pthread_sigmask you can tell the OS not to interrupt your program to deliver signals and instead queue them up, and then sigwait can be used to handle them at an appropriate time. You can't do this with all signals (some things like kill -9 and a SEGFAULT can't/shouldn't be ignored), but it works well for most of them.

Using an approach like this, it's really easy to interact with signals in a larger application too. You can block signals at the start of main, and that will propagate to all children threads, and then you can designate one specific child thread to just wait for signals an pass events into the rest of the application in whatever method is appropriate for the framework of your application.

#include <signal.h>
#include <unistd.h>

#include <initializer_list>
#include <functional>
#include <algorithm>
#include <iostream>

sigset_t make_sigset(std::initializer_list<int32_t> signals)
{
    sigset_t set;
    const int32_t result = sigemptyset(&set);

    std::for_each(signals.begin(), signals.end(), std::bind(&sigaddset, &set, std::placeholders::_1));

    return set;
}

int main()
{
    const auto signal_list = make_sigset({SIGTERM, SIGSEGV, SIGINT, SIGABRT});

    pthread_sigmask(SIG_BLOCK, &signal_list, nullptr);

    int32_t last_signal;
    do
    {
        sigwait(&signal_list, &last_signal);
        std::cout << "Got signal " << last_signal << std::endl;

        // Exit on sigint so ctrl+c still works
    } while (last_signal != SIGINT);

    return 0;
}

Answer 2

As already mentioned by @Eljay in the comments, you have to be careful with the things you do in a signal handler.

I'd also suggest not using namespace std, but that's a story for another time link.

I'd recommend you this page which explains a lot about what signals can and cannot do, according to the c++ standard. Now what they actually do in your compiler (which I assume is MSVC) may be different.

Some of the important bits, as already mentioned, you shouldn't do I/O, you shouldn't throw, etc...

To answer your question, you were on the right track, adding other signals can be done via:

// catch SIGTERM
std::signal(SIGTERM, signalHandler);
std::signal(SIGSEGV, signalHandler);
std::signal(SIGINT, signalHandler);
std::signal(SIGABRT, signalHandler);
// insert others

Then, what I'd suggest is storing the value of your signal into some atomic variable, like: gSignalThatStoppedMe.

std::atomic<int> gSignalThatStoppedMe = -1;

// I also added 'extern "C"' because the standard says so
extern "C" void signalHandler(int signum) {
  gSignalThatStoppedMe.store(signum);
}

Then, your while loop would check for != -1, or pick another value for this, I've not checked if some implementations use -1 as a valid value for signals

// ...
while(gSignalThatStoppedMe.load() == -1)
{
  // your old code
}

Now, do a switch of sorts, with the values inside and output the signal that stopped it, something like:

switch(gSignalThatStoppedMe.load())
{
  case SIGINT:
    std::puts("It was SIGINT");
    break;
  case SIGTERM:
    std::puts("It was SIGTERM");
    break;
  default:
    break;
}

I think this has less undefined behavior, which is always a good thing.

EDIT: here's a compiler explorer link

The output with CTRL-C:

SIGNALS ARE COOL
SIGNALS ARE COOL
SIGNALS ARE COOL
SIGNALS ARE COOL
SIGNALS ARE COOL
SIGNALS ARE COOL
SIGNALS ARE COOL
SIGNALS ARE COOL
SIGNALS ARE COOL
Interrupt signal SIGINT (2) received.