Estou escrevendo um programa de servidor multiplataforma em C ++ usando o Boost.Asio. Seguindo o exemplo do servidor HTTP emesta página, Gostaria de lidar com uma solicitação de encerramento do usuário sem usar APIs específicas da implementação. Inicialmente, tentei usar a biblioteca de sinais C padrão, mas não consegui encontrar um padrão de design adequado para o Asio. oExemplos do Windows o design parece assemelhar-se à biblioteca de sinais mais próxima, mas há uma condição de corrida em que o manipulador de ctrl do console pode ser chamado após a destruição do objeto do servidor. Estou tentando evitar um comportamento indefinido, conforme especificado pelo padrão C ++.

Existe uma maneira padrão (e correta) de parar o servidor?

Para ilustrar problemas com o uso da biblioteca de sinais C:

#include <csignal>
#include <functional>
#include <boost/asio.hpp>

using std::signal;
using boost::asio::io_service;

namespace
{
    std::function<void ()> sighandler;
}

extern "C"
{
    static void handle_signal(int);
}

void handle_signal(int)
{
    // error - undefined behavior
    sighandler();
}

int main()
{
    io_service s;
    sighandler = std::bind(&io_service::stop, &s);
    auto old_sigint = signal(SIGINT, &handle_signal);
    if (old_sigint == SIG_IGN)
        // race condition?  raise SIGINT before I can set ignore back
        signal(SIGINT, SIG_IGN);
    auto old_sigterm = signal(SIGTERM, &handle_signal);
    if (old_sigterm == SIG_IGN)
        // race condition?  raise SIGTERM before I can set ignore back
        signal(SIGTERM, SIG_IGN);
    s.run();
    // reset signals so I can clear reference to io_service
    if (old_sigterm != SIG_IGN)
        signal(SIGTERM, SIG_DFL);
    if (old_sigint != SIG_IGN)
        signal(SIGINT, SIG_DFL);
    // clear reference to io_service, but can I be sure that handle_signal
    // isn't being executed?
    sighandler = nullptr;
    // io_service is destroyed
}