web-dev-qa-db-fra.com

Traitement du signal en C

Comment puis-je implémenter le traitement du signal pour Ctrl-C et Ctrl-D en C .... Donc, si on appuie sur Ctrl-C, le programme ignorera et tentera à nouveau d'obtenir la saisie de l'utilisateur ... Si Ctrl-D est appuyez sur puis le programme se terminera ...

Mon programme suit: 

int main(){
 char msg[400];

 while(1){
   printf("Enter: ");
   fgets(msg,400,stdin);
   printf("%s\n",msg); 
 }
}

Merci, 

Dave

cunixshellsignals
19
Dave

Lorsque vous utilisez des signaux POSIX, vous disposez de deux moyens. Tout d’abord, le moyen facile (mais déconseillé), signal () . Deuxièmement, la manière la plus élégante, actuelle mais complexe, sigaction () . Veuillez utiliser sigaction () sauf si vous constatez qu’il n’est pas disponible sur une plate-forme sur laquelle 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 de les utiliser. Il répertorie également les signaux qui peuvent être traités, recommande la manière dont ils devrait être traités et explique plus en détail comment un signal donné est (ou n'est pas) actuellement en cours / . C'est beaucoup plus de code que ce que je voudrais coller dans une réponse ici, d'où les liens.

Il vous faut vraiment une heure ou deux pour lire les liens et passer en revue les exemples. La gestion du signal (en particulier dans les programmes qui démonalisent) est extrêmement importante. Un bon programme doit gérer tous les signaux fatals pouvant être traités (c’est-à-dire SIGHUP) et ignorer explicitement les signaux qu’il pourrait ne pas utiliser (c.-à-d. SIGUSR1/SIGUSR2).

Il ne sera pas plus mal non plus d’étudier la différence entre les signaux temps normal et temps réel, du moins jusqu’à comprendre comment le noyau fusionne l’antérieur et non le dernier. 

Une fois que vous avez travaillé dessus, vous serez probablement enclin à écrire un ensemble de fonctions facile à modifier pour gérer vos signaux et à réutiliser ce code encore et encore.

Désolé de ne pas avoir donné d'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 :)

31
Tim Post

Tout d'abord, Ctrl + D est un indicateur EOF que vous ne pouvez pas intercepter, lorsqu'un programme attend une entrée, appuyer sur Ctrl + D signifie fin du fichier et n'attend plus d'autre entrée. D'autre part, en utilisant Ctrl + C pour terminer un programme - c'est-à-dire SIGINT, qui peut être piégé en procédant comme suit:

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <stdarg.h>

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 */
}
14
t0mm13b

Dans votre exemple, il semble que vous n’ayez absolument pas besoin du traitement manuel CTRL-C. Un "signal (SIGINT, SIG_IGN)" semble suffisant pour vous, 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, mais communique simplement le EOF condition. Vous pouvez généralement contrôler le comportement de votre terminal (nous parlons d’entrée de console, ce n’est pas?) en utilisant la bibliothèque termios (aussi ici ). Vous pouvez activer, redéfinir ou désactiver le caractère "interruption" (CTRL-C), le EOF et bien d'autres (XON, XOFF, contrôle du modem ...)

Cordialement 

2
Giuseppe Guerrini

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

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

#include<stdio.h>
#include<signal.h>  // 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");

}
2
RUSHIKESH KARDE
#include<signal.h>
#include<unistd.h>
#include<stdio.h>
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.
0
Sherlock