1

#define _GNU_SOURCE

     2

     3

#include "signals.h"

     4

#include "log.h"

     5

     6

#include <string.h>

     7

#include <signal.h>

     8

#include <stdlib.h>

     9

#include <assert.h>

    10

    11

struct signals {

    12

    /** The libevent base to use */

    13

    struct event_base *ev_base;

    14

    15

    /** Information about up to MAX_SIGNALS signals */

    16

    struct signal {

    17

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

    18

        struct event *ev;

    19

    20

    } sig_list[MAX_SIGNALS];

    21

    22

    /** Number of used sig_list slots */

    23

    int sig_count;

    24

};

    25

    26

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

    27

{

    28

    struct signals *signals = arg;

    29

    30

    (void) event;

    31

    32

    log_info("caught %s: exiting", strsignal(signal));

    33

    34

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

    35

        FATAL("event_base_loopexit");

    36

}

    37

    38

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

    39

{

    40

    struct signals *signals = arg;

    41

    42

    (void) signal;

    43

    (void) event;

    44

    (void) arg;

    45

    (void) signals;

    46

    47

    /* ignore */

    48

}

    49

    50

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

    51

{

    52

    struct signals *signals;

    53

    54

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

    55

        return ERR_CALLOC;

    56

    57

    // simple attributes

    58

    signals->ev_base = ev_base;

    59

    60

    // done

    61

    *signals_ptr = signals;

    62

    63

    return SUCCESS;

    64

}

    65

    66

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

    67

{

    68

    struct signal *sig_info;

    69

    70

    // find our sig_info

    71

    assert(signals->sig_count < MAX_SIGNALS);

    72

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

    73

    74

    // set up the libevent signal events

    75

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

    76

        return ERR_EVENT_NEW;

    77

    78

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

    79

        return ERR_EVENT_ADD;

    80

    81

    // ok

    82

    return SUCCESS;

    83

}

    84

    85

err_t signal_ignore (int signum, struct error_info *err)

    86

{

    87

    struct sigaction act = {

    88

        .sa_handler     = SIG_IGN,

    89

    };

    90

    91

    // signall the handler

    92

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

    93

        RETURN_SET_ERROR_ERRNO(err, ERR_SIGACTION);

    94

    95

    // ok

    96

    return SUCCESS;

    97

}

    98

    99

struct signals *signals_default (struct event_base *ev_base) 

   100

{

   101

    struct signals *signals = NULL;

   102

    struct error_info err;

   103

   104

    // alloc signals

   105

    if (signals_create(&signals, ev_base))

   106

        return NULL;

   107

   108

    // add the set of default signals

   109

    if (signal_ignore(SIGPIPE, &err))

   110

        log_err_info(&err, "signal_ignore(SIGPIPE)");

   111

   112

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

   113

        log_err_info(&err, "signals_add(SIGINT)");

   114

        goto error;

   115

    }

   116

   117

    // ok

   118

    return signals;

   119

   120

error:

   121

    signals_free(signals);

   122

   123

    return NULL;

   124

}   

   125

   126

void signals_free (struct signals *signals) 

   127

{

   128

    int i;

   129

   130

    // free all events

   131

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

   132

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

   133

    }

   134

   135

    // free the info itself

   136

    free(signals);

   137

}

   138