Llamada a funciones de Qt desde gestionadores de señales de Unix
No se pueden llamar a funciones de Qt desde los manejadores de señales de Unix. Se aplica la norma estándar de POSIX: solo se pueden llamar a funciones «async-signal-safe» desde los manejadores de señales. Consulte Acciones de señales para ver la lista completa de funciones a las que se puede llamar desde los manejadores de señales de Unix.
Pero no te desesperes, hay una forma de utilizar los controladores de señales de Unix con Qt. La estrategia consiste en hacer que tu controlador de señales de Unix realice alguna acción que, en última instancia, provoque la emisión de una señal de Qt; a continuación, simplemente sal del controlador de señales de Unix. De vuelta en tu programa de Qt, esa señal de Qt se emite y, a continuación, la recibe tu función de slot de Qt, donde puedes realizar con total seguridad cualquier operación de Qt que no te estuviera permitida en el controlador de señales de Unix.
Una forma sencilla de conseguirlo es declarar un par de sockets en tu clase para cada señal de Unix que quieras gestionar. Los pares de sockets se declaran como miembros de datos estáticos. También se crea un « QSocketNotifier » para supervisar el extremo de lectura de cada par de sockets, se declaran los controladores de señales de Unix como métodos estáticos de clase y se declara una función de ranura correspondiente a cada uno de los controladores de señales de Unix. En este ejemplo, pretendemos gestionar tanto la señal SIGHUP como la SIGTERM. Nota: Deberías leer las páginas del manual de socketpair(2) y sigaction(2) antes de repasar los siguientes fragmentos de código.
class MyDaemon : public QObject
{
Q_OBJECT
public:
MyDaemon(QObject *parent = 0);
~MyDaemon();
// Unix signal handlers.
static void hupSignalHandler(int unused);
static void termSignalHandler(int unused);
public slots:
// Qt signal handlers.
void handleSigHup();
void handleSigTerm();
private:
static int sighupFd[2];
static int sigtermFd[2];
QSocketNotifier *snHup;
QSocketNotifier *snTerm;
};En el constructor de MyDaemon, utiliza la función socketpair(2) para inicializar cada par de descriptores de archivo y, a continuación, crea el objeto « QSocketNotifier » para supervisar el extremo de lectura de cada par. La señal «activated()» de cada objeto « QSocketNotifier » se conecta a la función de ranura correspondiente, lo que convierte efectivamente la señal de Unix en la señal « QSocketNotifier::activated()».
MyDaemon::MyDaemon(QObject*parent)
: QObject(parent)
{
if (::socketpair(AF_UNIX, SOCK_STREAM, 0, sighupFd))
qFatal("Couldn't create HUP socketpair");
if (::socketpair(AF_UNIX, SOCK_STREAM, 0, sigtermFd))
qFatal("Couldn't create TERM socketpair");
snHup = new QSocketNotifier(sighupFd[1], QSocketNotifier::Read, this);
connect(snHup, &QSocketNotifier::activated, this, &MyDaemon::handleSigHup);
snTerm = new QSocketNotifier(sigtermFd[1], QSocketNotifier::Read, this);
connect(snTerm, &QSocketNotifier::activated, this, &MyDaemon::handleSigTerm);
...
}Inicializa los miembros estáticos en el archivo de implementación:
int MyDaemon::sighupFd[2] = {0, 0};
int MyDaemon::sigtermFd[2] = {0, 0};En algún otro lugar del código de inicio, se instalan los controladores de señales de Unix con sigaction(2).
static int setup_unix_signal_handlers()
{
struct sigaction hup, term;
hup.sa_handler = MyDaemon::hupSignalHandler;
sigemptyset(&hup.sa_mask);
hup.sa_flags = 0;
hup.sa_flags |= SA_RESTART;
if (sigaction(SIGHUP, &hup, 0))
return 1;
term.sa_handler = MyDaemon::termSignalHandler;
sigemptyset(&term.sa_mask);
term.sa_flags = 0;
term.sa_flags |= SA_RESTART;
if (sigaction(SIGTERM, &term, 0))
return 2;
return 0;
}En tus controladores de señales de Unix, escribes un byte en el extremo de escritura de un par de sockets y regresas. Esto hará que el objeto « QSocketNotifier » correspondiente emita su señal «activated()», lo que a su vez provocará que se ejecute la función de slot de Qt adecuada.
void MyDaemon::hupSignalHandler(int)
{
char a = 1;
::write(sighupFd[0], &a, sizeof(a));
}
void MyDaemon::termSignalHandler(int)
{
char a = 1;
::write(sigtermFd[0], &a, sizeof(a));
}En las funciones de slot conectadas a las señales de QSocketNotifier::activated(), lees el byte. Ahora ya estás de vuelta en Qt de forma segura con tu señal, y puedes realizar todas las operaciones de Qt que no te estaba permitido hacer en el controlador de señales de Unix.
void MyDaemon::handleSigTerm()
{
snTerm->setEnabled(false);
char tmp;
::read(sigtermFd[1], &tmp, sizeof(tmp));
// do Qt stuff
snTerm->setEnabled(true);
}
void MyDaemon::handleSigHup()
{
snHup->setEnabled(false);
char tmp;
::read(sighupFd[1], &tmp, sizeof(tmp));
// do Qt stuff
snHup->setEnabled(true);
}© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.