#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <signal.h>
#include <pthread.h>
#include <stdlib.h>


void* gestoreSIGUSR(void* arg) {

    /* Creo la maschera dei segnali */
    sigset_t setSIGUSR, setFULL; int sig;
    sigemptyset(&setSIGUSR);
    sigaddset(&setSIGUSR, SIGUSR1);
    sigfillset(&setFULL);

    /* Maschero i segnali */
    pthread_sigmask(SIG_SETMASK,&setFULL,NULL);

    for (;;) {
        /* Attendo un segnale */
        sigwait(&setSIGUSR,&sig);
        printf("\nSignal received: Svolgo operazioni...\n");

        /* COMPIE OPERAZIONI */
    }

    return NULL;
}

void* gestoreCleanup(void* arg) {

    /* Creo la maschera dei segnali */
    sigset_t setEND, setFULL; int sig;
    sigemptyset(&setEND);
    sigaddset(&setEND, SIGINT);
    sigaddset(&setEND, SIGTERM);
    sigaddset(&setEND, SIGQUIT);
    sigfillset(&setFULL);

    /* Maschero i segnali */
    pthread_sigmask(SIG_SETMASK,&setFULL,NULL);

    /* Attendo una terminazione */
    sigwait(&setEND,&sig);
    printf("\nSignal received: Svolgo cleanup...\n");

    /* Termino il thread gestore dei SIGUSR */
    pthread_cancel(*(pthread_t*)arg);

    /* SVOLGO IL CLEANUP */

    /* Termino il processo */
    exit(EXIT_SUCCESS);
    return NULL;
}

int main(int argc, char **argv)
{

    sigset_t setFULL;
    sigfillset(&setFULL);

    /* Maschero i segnali */
    pthread_sigmask(SIG_SETMASK,&setFULL,NULL);

    /* [***]  Creo il thread gestore di SIGUSR ↓ ↓ ↓ ↓ ↓ */
    pthread_t tidGestSIGUSR;

    /*      Imposto gli attributi */
    pthread_attr_t attrGestSIGUSR;
    if (pthread_attr_init(&attrGestSIGUSR))
        { fprintf(stderr, "pthread_attr_init &attrGestSIGUSR FALLITA\n"); return -1; }
    if (pthread_attr_setdetachstate(&attrGestSIGUSR, PTHREAD_CREATE_DETACHED))
        { fprintf(stderr, "pthread_attr_setdetachstate &attrGestSIGUSR FALLITA\n"); return -1; }

    /*      Lancio il thread */
    if(pthread_create(&tidGestSIGUSR, &attrGestSIGUSR, &gestoreSIGUSR, NULL)) {
        fprintf(stderr, "pthread_create Gestore SIGUSR FALLITA\n");
        return -1;
    } else {
        //pthread_detach(tidGestSIGUSR);
        pthread_attr_destroy(&attrGestSIGUSR);
    } /* ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ */


    /*  [***] Creo il thread gestore del cleanup ↓ ↓ ↓ ↓ ↓ */
    pthread_t tidGestCLEANUP;

    /*      Imposto gli attributi */
    pthread_attr_t attrGestCleanup;
    if (pthread_attr_init(&attrGestCleanup))
        { fprintf(stderr, "pthread_attr_init &attrGestCleanup FALLITA\n"); return -1; }
    if (pthread_attr_setdetachstate(&attrGestCleanup, PTHREAD_CREATE_DETACHED))
        { fprintf(stderr, "pthread_attr_setdetachstate &attrGestCleanup FALLITA\n"); return -1; }

    /*      Lancio il thread */
    if(pthread_create(&tidGestCLEANUP, NULL, &gestoreCleanup, (void*)&tidGestSIGUSR)) {
        fprintf(stderr, "pthread_create Gestore Cleanup FALLITA\n");
        return -1;
    } else {
        //pthread_detach(tidGestCLEANUP);
        pthread_attr_destroy(&attrGestCleanup);
    } /* ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ */


    pthread_join(tidGestCLEANUP, NULL);

    return 0;
}