señales - que hace sigusr1

Manejo de señal en C

Question

¿Cómo puedo implementar el manejo de señales para Ctrl-C y Ctrl-D en C ...? Así que si se presiona Ctrl-C, el programa ignorará e intentará obtener la entrada del usuario nuevamente ... presionado entonces el programa terminará ...

Mi programa sigue:

int main(){
 char msg[400];

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

Gracias,

Dave

Answer 1

Cuando se trata de señales POSIX, tiene dos medios a su disposición. Primero, la manera fácil (pero desaprobada), la signal() . En segundo lugar, la forma más elegante, actual pero compleja, sigaction() . Use sigaction () a menos que encuentre que no está disponible en alguna plataforma en la que necesite trabajar.

Este capítulo del manual de glibc explica las diferencias entre los dos y proporciona un buen código de ejemplo sobre cómo usar ambos. También enumera las señales que pueden manejarse, recomienda cómo deben manejarse y profundiza en cómo saber cómo se está manejando (o no) una señal determinada. Eso es mucho más código del que quisiera pegar en una respuesta aquí, de ahí los enlaces.

Realmente vale la pena una o dos horas para leer los enlaces y trabajar con los ejemplos. El manejo de la señal (especialmente en programas que se demonizan) es extremadamente importante. Un buen programa debe manejar todas las señales fatales que pueden manejarse (es decir, SIGHUP) e ignorar explícitamente las señales que podría no estar usando (es decir, SIGUSR1 / SIGUSR2).

Tampoco le hará daño estudiar la diferencia entre las señales de tiempo normal y real, al menos hasta la comprensión de cómo el núcleo fusiona lo anterior y no lo último.

Una vez que lo haga, probablemente se sentirá inclinado a redactar un conjunto de funciones fácil de modificar para manejar sus señales y reutilizar ese código una y otra vez.

Lo siento por no dar un fragmento de código rápido y sucio para mostrarle cómo resolver su necesidad inmediata, pero este no es un tema rápido y sucio :)

Answer 2

En primer lugar, Ctrl + D es un indicador EOF que no puede interceptar, cuando un programa está esperando una entrada, presionar Ctrl + D significa el final del archivo y no esperar más entrada. Por otro lado, usar Ctrl + C para terminar un programa, es decir SIGINT, que puede quedar atrapado al hacer esto:

#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 */
}

Answer 3

En su ejemplo, parece que no necesita CTRL-C handlind en absoluto. Una "señal (SIGINT, SIG_IGN)" parece suficiente para usted, a menos que su aplicación deba manejar un SIGINT proveniente de alguna otra fuente. CTRL-D no suele generar señales, simplemente comunica la condición EOF. En general, puede controlar el comportamiento de su terminal (estamos hablando de entrada de consola, ¿no es así?) Utilizando la biblioteca de termios (también here ). Puede habilitar, redefinir o deshabilitar el carácter de "interrupción" (CTRL-C), el EOF uno y muchos otros (XON, XOFF, control de módem ...)

Saludos

Answer 4

Este es un programa para manejar la señal cuando se presiona Ctrl + c

La sintaxis para la función de señal es: 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");

}

Answer 5

#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.