1 

     2 #include "signals.h"

     3 #include "log.h"

     4 

     5 #define _GNU_SOURCE

     6 

     7 #include <string.h>

     8 #include <signal.h>

     9 #include <stdlib.h>

    10 #include <assert.h>

    11 

    12 struct signals {

    13     /** The libevent base to use */

    14     struct event_base *ev_base;

    15     

    16     /** Information about up to MAX_SIGNALS signals */

    17     struct signal {

    18         /** The event we use to handle the signal */

    19         struct event *ev;

    20 

    21     } sig_list[MAX_SIGNALS];

    22     

    23     /** Number of used sig_list slots */

    24     int sig_count;

    25 };

    26 

    27 void signals_loopexit (int signal, short event, void *arg) 

    28 {

    29     struct signals *signals = arg;

    30 

    31     (void) event;

    32 

    33     log_info("caught %s: exiting", /* strsignal(signal) */ "xxx");

    34     

    35     if (event_base_loopexit(signals->ev_base, NULL))

    36         FATAL("event_base_loopexit");

    37 }

    38 

    39 void signals_ignore (int signal, short event, void *arg)

    40 {

    41     struct signals *signals = arg;

    42     

    43     (void) signal;

    44     (void) event;

    45     (void) arg;

    46     (void) signals;

    47     

    48     /* ignore */

    49 }

    50 

    51 err_t signals_create (struct signals **signals_ptr, struct event_base *ev_base)

    52 {

    53     struct signals *signals;

    54 

    55     if ((signals = calloc(1, sizeof(*signals))) == NULL)

    56         return ERR_CALLOC;

    57     

    58     // simple attributes

    59     signals->ev_base = ev_base;

    60 

    61     // done

    62     *signals_ptr = signals;

    63 

    64     return SUCCESS;

    65 }

    66 

    67 err_t signals_add (struct signals *signals, int sigval, void (*sig_handler)(evutil_socket_t, short, void *), void *arg) 

    68 {

    69     struct signal *sig_info;

    70     

    71     // find our sig_info

    72     assert(signals->sig_count < MAX_SIGNALS);

    73     sig_info = signals->sig_list + (signals->sig_count++);

    74     

    75     // set up the libevent signal events

    76     if ((sig_info->ev = evsignal_new(signals->ev_base, sigval, sig_handler, arg)) == NULL)

    77         return ERR_EVENT_NEW;

    78 

    79     if (evsignal_add(sig_info->ev, NULL))

    80         return ERR_EVENT_ADD;

    81 

    82     // ok

    83     return SUCCESS;

    84 }

    85 

    86 err_t signal_ignore (int signum, struct error_info *err)

    87 {

    88     struct sigaction act = {

    89         .sa_handler     = SIG_IGN,

    90     };

    91     

    92     // signall the handler

    93     if (sigaction(signum, &act, NULL))

    94         RETURN_SET_ERROR_ERRNO(err, ERR_SIGACTION);

    95 

    96     // ok

    97     return SUCCESS;

    98 }

    99 

   100 struct signals *signals_default (struct event_base *ev_base) 

   101 {

   102     struct signals *signals = NULL;

   103     struct error_info err;

   104     

   105     // alloc signals

   106     if (signals_create(&signals, ev_base))

   107         return NULL;

   108     

   109     // add the set of default signals

   110     if (signal_ignore(SIGPIPE, &err))

   111         log_error(&err, "signal_ignore(SIGPIPE)");

   112 

   113     if ((ERROR_CODE(&err) = signals_add(signals, SIGINT, &signals_loopexit, signals))) {

   114         log_error(&err, "signals_add(SIGINT)");

   115         goto error;

   116     }

   117 

   118     // ok

   119     return signals;

   120 

   121 error:

   122     signals_free(signals);

   123 

   124     return NULL;

   125 }   

   126 

   127 void signals_free (struct signals *signals) 

   128 {

   129     int i;

   130     

   131     // free all events

   132     for (i = 0; i < signals->sig_count; i++) {

   133         event_free(signals->sig_list[i].ev);

   134     }

   135     

   136     // free the info itself

   137     free(signals);

   138 }

   139