#ifndef RTKBASE_H
#define RTKBASE_H

#include <sys/socket.h>
#include <signal.h>

#include <QCoreApplication>
#include <QList>
#include <QTimer>
#include <QStringList>


#include "server.h"
#include "gpsdevice.h"

class RtkBase : public QCoreApplication
{
    Q_OBJECT

    public:
	RtkBase(int argc, char **argv);
	~RtkBase(void);

	// Unix signal handlers.
	static void hupSignalHandler(int unused);
	static void termSignalHandler(int unused);

    public slots:
	// Qt signal handlers.
	void slotHandleSigHup();
	void slotHandleSigTerm();

    private:
	static int sighupFd[2];
	static int sigtermFd[2];
	Server *mServer;
	GpsDevice *mGpsDevice;

	QSocketNotifier *snHup;
	QSocketNotifier *snTerm;
};

#endif


...and the .cpp:



#include "rtkbase.h"

int RtkBase::sighupFd[] = {0,0};
int RtkBase::sigtermFd[] = {0,0};


static int setup_unix_signal_handlers()
{
    qDebug() << "setup_unix_signal_handlers()";
    struct sigaction hup, term;

    hup.sa_handler = RtkBase::hupSignalHandler;
    sigemptyset(&hup.sa_mask);
    hup.sa_flags = 0;
    hup.sa_flags |= SA_RESTART;

    if (sigaction(SIGHUP, &hup, 0) > 0)
       return 1;

    term.sa_handler = RtkBase::termSignalHandler;
    sigemptyset(&term.sa_mask);
    term.sa_flags |= SA_RESTART;

    if (sigaction(SIGTERM, &term, 0) > 0)
       return 2;

    return 0;
}

RtkBase::RtkBase(int argc, char **argv) : QCoreApplication(argc, argv)
{
    // set up signal handling
    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, SIGNAL(activated(int)), SLOT(slotHandleSigHup()));
    snTerm = new QSocketNotifier(sigtermFd[1], QSocketNotifier::Read, this);
    connect(snTerm, SIGNAL(activated(int)), SLOT(slotHandleSigTerm()));


...
}

RtkBase::~RtkBase()
{
...
}

void RtkBase::hupSignalHandler(int)
{
    char a = 1;
    qDebug() << "RtkBase::hupSignalHandler(int)";
    ::write(sighupFd[0], &a, sizeof(a));
}

void RtkBase::termSignalHandler(int)
{
    char a = 1;
    qDebug() << "RtkBase::termSignalHandler(int)";
    ::write(sigtermFd[0], &a, sizeof(a));
}

void RtkBase::slotHandleSigTerm()
 {
     snTerm->setEnabled(false);
     char tmp;
     ::read(sigtermFd[1], &tmp, sizeof(tmp));

     // do Qt stuff
     qFatal("Wheee, SIGTERM pressed!");

     snTerm->setEnabled(true);
 }

 void RtkBase::slotHandleSigHup()
 {
     snHup->setEnabled(false);
     char tmp;
     ::read(sighupFd[1], &tmp, sizeof(tmp));

     // do Qt stuff
     qFatal("Wheee, SIGHUP pressed!");

     snHup->setEnabled(true);
 }


int main(int argc, char **argv)
{
	RtkBase rtkBase(argc, argv);
	setup_unix_signal_handlers();

	return rtkBase.exec();
}