Traitement du signal en C

Lorsque vous traitez des signaux POSIX, vous disposez de deux moyens. Tout d’abord, la méthode facile (mais obsolète), signal () . Deuxièmement, la manière la plus élégante, actuelle mais complexe, sigaction () . Veuillez utiliser sigaction () à moins que vous ne trouviez qu’il n’est pas disponible sur certaines plates-formes sur lesquelles vous devez travailler.

Ce chapitre du manuel glibc explique les différences entre les deux et donne un bon exemple de code sur la manière d’utiliser les deux. Il répertorie également les signaux pouvant être manipulés, recommande leur traitement et approfondit la manière de déterminer comment un signal donné est (ou non) actuellement traité. C’est beaucoup plus de code que je voudrais coller dans une réponse ici, d’où les liens.

Il vaut vraiment la peine de lire les liens et de parcourir les exemples. La gestion des signaux (en particulier dans les programmes démodés) est extrêmement importante. Un bon programme devrait traiter tous les signaux fatals pouvant être traités (par exemple, SIGHUP) et ignorer explicitement les signaux qu’il pourrait ne pas utiliser (par exemple, SIGUSR1 / SIGUSR2).

Il ne sera pas mal non plus d’étudier la différence entre les signaux normaux et en temps réel, du moins jusqu’à la compréhension de la manière dont le kernel fusionne le précédent et non le dernier.

Une fois que vous l’utilisez, vous serez probablement enclin à écrire un ensemble de fonctions faciles à modifier pour gérer vos signaux et réutiliser ce code encore et encore.

Désolé de ne pas donner un extrait de code rapide et sale pour vous montrer comment résoudre votre besoin immédiat, mais ce n’est pas un sujet rapide et sale 🙂

Tout d’abord, Ctrl + D est un indicateur EOF que vous ne pouvez pas intercepter, lorsqu’un programme attend une entrée, appuyez sur Ctrl + D pour indiquer la fin du fichier et ne plus attendre d’entrée. D’un autre côté, utiliser Ctrl + C pour terminer un programme, c’est-à-dire SIGINT, qui peut être intercepté en procédant ainsi:

 #include  #include  #include  #include  static void signal_handler(int); static void cleanup(void); void init_signals(void); void panic(const char *, ...); struct sigaction sigact; char *progname; int main(int argc, char **argv){ char *s; progname = *(argv); atexit(cleanup); init_signals(); // do the work exit(0); } void init_signals(void){ sigact.sa_handler = signal_handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = 0; sigaction(SIGINT, &sigact, (struct sigaction *)NULL); } static void signal_handler(int sig){ if (sig == SIGINT) panic("Caught signal for Ctrl+C\n"); } void panic(const char *fmt, ...){ char buf[50]; va_list argptr; va_start(argptr, fmt); vsprintf(buf, fmt, argptr); va_end(argptr); fprintf(stderr, buf); exit(-1); } void cleanup(void){ sigemptyset(&sigact.sa_mask); /* Do any cleaning up chores here */ } 

Dans votre exemple, il semble que vous n’ayez absolument pas besoin de CTRL-C. Un “signal (SIGINT, SIG_IGN)” vous semble suffisant, sauf si votre application doit gérer un SIGINT provenant d’une autre source. CTRL-D ne génère généralement pas de signaux, il communique simplement la condition EOF. Vous pouvez en général contrôler le comportement de votre terminal (nous parlons de l’entrée de la console, ce n’est pas le cas?) En utilisant la bibliothèque termios (également ici ). Vous pouvez activer, redéfinir ou désactiver le caractère “interruption” (CTRL-C), le caractère EOF et bien d’autres (XON, XOFF, contrôle du modem …)

Cordialement

Ceci est un programme pour gérer le signal lorsque vous appuyez sur Ctrl + c

La syntaxe de la fonction de signal est la suivante: signal(signal name, function name);

 #include #include // for handling signal void signal_handler() { printf("Signal Handled here\n"); } main() { printf("In main function..\n"); // SIGINT is signal name create when Ctrl+c will pressed signal(SIGINT,signal_handler); sleep(15); printf("In main after called from signal_handle \n"); } 

 #include #include #include void signal_catch() { printf("hi,Your signal catched Here"); } int main() { signal(SIGINT,signal_catch); //press ctrl+c sleep(10); return 0; }//end main //if you want to simply ignore ctrl+c interrupt use following code in main int main() { signal(SIGINT,SIG_IGN); sleep(100); return 0; }//end main //this program wont accept ctrl+c interrupt for 100 seconds.