nmdb/net.c

   1
   2 #include <signal.h>             /* signal constants */
   3 #include <stdlib.h>             /* exit() */
   4
   5 /* Workaround for libevent 1.1a: the header assumes u_char is typedef'ed to an
   6  * unsigned char, and that "struct timeval" is in scope. */
   7 typedef unsigned char u_char;
   8 #include <sys/time.h>
   9 #include <event.h>
  10
  11 #include "common.h"
  12 #include "tipc.h"
  13 #include "tcp.h"
  14 #include "udp.h"
  15 #include "sctp.h"
  16 #include "net.h"
  17 #include "log.h"
  18
  19
  20 static void exit_sighandler(int fd, short event, void *arg)
  21 {
  22         wlog("Got signal! Puf!\n");
  23         event_loopexit(NULL);
  24 }
  25
  26 static void passive_to_active_sighandler(int fd, short event, void *arg)
  27 {
  28         wlog("Passive toggle!\n");
  29         settings.passive = !settings.passive;
  30 }
  31
  32 static void logfd_reopen_sighandler(int fd, short event, void *arg)
  33 {
  34         if (log_reopen())
  35                 wlog("Log reopened\n");
  36 }
  37
  38 static void enable_read_only_sighandler(int fd, short event, void *arg)
  39 {
  40         if (!settings.read_only) {
  41                 wlog("Changing to read-only mode\n");
  42                 settings.read_only = 1;
  43         } else {
  44                 wlog("Got signal, but already in read-only mode\n");
  45         }
  46 }
  47
  48 void net_loop(void)
  49 {
  50         int tipc_fd = -1;
  51         int tcp_fd = -1;
  52         int udp_fd = -1;
  53         int sctp_fd = -1;
  54         struct event tipc_evt, tcp_evt, udp_evt, sctp_evt,
  55                      sigterm_evt, sigint_evt,
  56                      sighup_evt, sigusr1_evt, sigusr2_evt;
  57
  58         event_init();
  59
  60         /* ENABLE_* are preprocessor constants defined on the command line by
  61          * make. */
  62
  63         if (ENABLE_TIPC) {
  64                 tipc_fd = tipc_init();
  65                 if (tipc_fd < 0) {
  66                         errlog("Error initializing TIPC");
  67                         exit(1);
  68                 }
  69
  70                 event_set(&tipc_evt, tipc_fd, EV_READ | EV_PERSIST, tipc_recv,
  71                                 &tipc_evt);
  72                 event_add(&tipc_evt, NULL);
  73         }
  74
  75         if (ENABLE_TCP) {
  76                 tcp_fd = tcp_init();
  77                 if (tcp_fd < 0) {
  78                         errlog("Error initializing TCP");
  79                         exit(1);
  80                 }
  81
  82                 event_set(&tcp_evt, tcp_fd, EV_READ | EV_PERSIST,
  83                                 tcp_newconnection, &tcp_evt);
  84                 event_add(&tcp_evt, NULL);
  85         }
  86
  87         if (ENABLE_UDP) {
  88                 udp_fd = udp_init();
  89                 if (udp_fd < 0) {
  90                         errlog("Error initializing UDP");
  91                         exit(1);
  92                 }
  93
  94                 event_set(&udp_evt, udp_fd, EV_READ | EV_PERSIST, udp_recv,
  95                                 &udp_evt);
  96                 event_add(&udp_evt, NULL);
  97         }
  98
  99         if (ENABLE_SCTP) {
 100                 sctp_fd = sctp_init();
 101                 if (sctp_fd < 0) {
 102                         errlog("Error initializing SCTP");
 103                         exit(1);
 104                 }
 105
 106                 event_set(&sctp_evt, sctp_fd, EV_READ | EV_PERSIST, sctp_recv,
 107                                 &sctp_evt);
 108                 event_add(&sctp_evt, NULL);
 109         }
 110
 111         signal_set(&sigterm_evt, SIGTERM, exit_sighandler, &sigterm_evt);
 112         signal_add(&sigterm_evt, NULL);
 113         signal_set(&sigint_evt, SIGINT, exit_sighandler, &sigint_evt);
 114         signal_add(&sigint_evt, NULL);
 115         signal_set(&sighup_evt, SIGHUP, logfd_reopen_sighandler,
 116                         &sighup_evt);
 117         signal_add(&sighup_evt, NULL);
 118         signal_set(&sigusr1_evt, SIGUSR1, enable_read_only_sighandler,
 119                         &sigusr1_evt);
 120         signal_add(&sigusr1_evt, NULL);
 121         signal_set(&sigusr2_evt, SIGUSR2, passive_to_active_sighandler,
 122                         &sigusr2_evt);
 123         signal_add(&sigusr2_evt, NULL);
 124
 125         event_dispatch();
 126
 127         if (ENABLE_TIPC)
 128                 event_del(&tipc_evt);
 129         if (ENABLE_TCP)
 130                 event_del(&tcp_evt);
 131         if (ENABLE_UDP)
 132                 event_del(&udp_evt);
 133         if (ENABLE_SCTP)
 134                 event_del(&sctp_evt);
 135
 136         signal_del(&sigterm_evt);
 137         signal_del(&sigint_evt);
 138         signal_del(&sigusr1_evt);
 139         signal_del(&sigusr2_evt);
 140
 141         tipc_close(tipc_fd);
 142         tcp_close(tcp_fd);
 143         udp_close(udp_fd);
 144         sctp_close(sctp_fd);
 145 }
 146
 147