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

struct signals *signals_default (struct event_base *ev_base) 

    86

{

    87

    struct signals *signals = NULL;

    88

    89

    // alloc signals

    90

    if (signals_create(&signals, ev_base))

    91

        return NULL;

    92

    93

    // add the set of default signals

    94

    if (    signals_add(signals,    SIGPIPE,    &signals_ignore,        signals)

    95

        ||  signals_add(signals,    SIGINT,     &signals_loopexit,      signals)

    96

    ) 

    97

        goto error;

    98

    99

    // ok

   100

    return signals;

   101

   102

error:

   103

    if (signals)

   104

        signals_free(signals);

   105

   106

    return NULL;

   107

}   

   108

   109

void signals_free (struct signals *signals) 

   110

{

   111

    int i;

   112

   113

    // free all events

   114

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

   115

        if (evsignal_del(signals->sig_list[i].ev))

   116

            log_warn("evsignal_del failed");

   117

    }

   118

   119

    // free the info itself

   120

    free(signals);

   121

}

   122