Est-il valable pour plusieurs gestionnaires de signaux pour un même signal?

Comme dit par d'autres, seulement un gestionnaire de signal peut être défini, qui est le dernier. Il vous faudra alors gérer appelant les deux fonctions vous-même. Le sigaction fonction peut renvoyer précédemment installé gestionnaire de signal qui vous pouvez appeler vous-même.

Quelque chose comme ceci (code non testé):

/* other signal handlers */
static void (*lib1_sighandler)(int) = NULL;
static void (*lib2_sighandler)(int) = NULL;

static void aggregate_handler(int signum)
{
    /* your own cleanup */
    if (lib1_sighandler)
        lib1_sighandler(signum);
    if (lib2_sighandler)
        lib2_sighandler(signum);
}

... (later in main)
struct sigaction sa;
struct sigaction old;

lib1_init(...);
/* retrieve lib1's sig handler */
sigaction(SIGINT, NULL, &old);
lib1_sighandler = old.sa_handler;

lib2_init(...);
/* retrieve lib2's sig handler */
sigaction(SIGINT, NULL, &old);
lib2_sighandler = old.sa_handler;

/* set our own sig handler */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = aggregate_handler;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);

OriginalL'auteur Shahbaz

nous pouvons gérer de multiples signal avec un seul gestionnaire de signal, mais
mais il n'est pas possible d'avoir de multiples gestionnaire de signal pour un même signal.

void sig_handler(int signo)
{
if (signo == SIGINT)
printf("received SIGINT 1\n"); 
}
void sig(int signo)
{
     if (signo == SIGINT)
        printf("received SIGINT 2\n");
}
   int main(void)
  {
      if(signal(SIGINT, sig_handler) == SIG_ERR)
          printf("\ncan't catch SIGINT\n");

      if (signal(SIGINT, sig) == SIG_ERR)
          printf("\ncan't catch SIGINT\n");
  //A long long wait so that we can easily issue a signal to this process
     while(1) 
       sleep(1);
     return 0;
  }

si u essayez d'exécuter ce code u trouverez que la dernière gestionnaire de signal est défini pour ce signal.
je pense qu'il n'est pas possible d'avoir un multiple gestionnaire de signal pour un même signal.

OriginalL'auteur Kushagra Jaiswal

Shabaz frappé le clou sur la tête. Cependant, si vous cherchez quelque chose de vos bibliothèques pourraient utiliser (à condition d'avoir accès au code source), vous pouvez faire quelque chose le long des lignes suivantes:

linked_list* sigint_handlers = NULL;

void sighand_init(sighand_config_t* config) {
    struct sigaction action;
    memset(&signalaction, 0, sizeof(signalaction));
    action.sa_handler = &sighand_main;

    //Order is important, in case we get a signal during start-up
    sigint_handlers = linked_list_new();
    sigaction(SIGINT, &action);
}

void sighand_main(int signum) {
    if (signum == SIGINT) {
        linked_list_node* node = linked_list_head(sigint_handlers);
        while ((node = node->next) != NULL) {
            node->object(signum);
        }
        if (sighand_config.exitonint) {
            app_exit(0);
        }
    }
}

void sighand_add_int_handler(void (*handler)(int)) {
    if (handler == NULL) return;
    linked_list_add(sigint_handlers, handler);
}

void sighand_destroy() {
    ...
    linked_list_destroy(signint_handlers);
    ...
}

Ou, vous pouvez utiliser vous-même, et après le chargement de chaque bibliothèque, obtenir le gestionnaire et, plus tard, appel add_handler. Quelque chose le long des lignes de:

loadlibrary(lib1.so);
sigaction1 = signalget(SIGINT);

loadlibrary(lib2.so);
sigaction2 = signalget(SIGINT);

sighand_init(...);
sighand_add_int_handler(sigaction1.sa_handler);
sighand_add_int_handler(sigaction2.sa_handler);

Juste quelques pensées,
Anthony

OriginalL'auteur Borgboy