common/common.c

   1 /******************************************************************************/
   2 /*          pfixtools: a collection of postfix related tools                  */
   3 /*          ~~~~~~~~~                                                         */
   4 /*  ________________________________________________________________________  */
   5 /*                                                                            */
   6 /*  Redistribution and use in source and binary forms, with or without        */
   7 /*  modification, are permitted provided that the following conditions        */
   8 /*  are met:                                                                  */
   9 /*                                                                            */
  10 /*  1. Redistributions of source code must retain the above copyright         */
  11 /*     notice, this list of conditions and the following disclaimer.          */
  12 /*  2. Redistributions in binary form must reproduce the above copyright      */
  13 /*     notice, this list of conditions and the following disclaimer in the    */
  14 /*     documentation and/or other materials provided with the distribution.   */
  15 /*  3. The names of its contributors may not be used to endorse or promote    */
  16 /*     products derived from this software without specific prior written     */
  17 /*     permission.                                                            */
  18 /*                                                                            */
  19 /*  THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND   */
  20 /*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     */
  21 /*  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        */
  22 /*  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS    */
  23 /*  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR    */
  24 /*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF      */
  25 /*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  */
  26 /*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN   */
  27 /*  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   */
  28 /*  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF    */
  29 /*  THE POSSIBILITY OF SUCH DAMAGE.                                           */
  30 /******************************************************************************/
  31
  32 /*
  33  * Copyright © 2007 Pierre Habouzit
  34  * Copyright © 2008 Florent Bruneau
  35  */
  36
  37 #include <fcntl.h>
  38 #include <grp.h>
  39 #include <pwd.h>
  40 #include <sys/un.h>
  41
  42 #include "common.h"
  43
  44 bool daemon_process  = true;
  45 int  log_level       = LOG_INFO;
  46 bool log_syslog      = false;
  47
  48 static FILE *pidfile = NULL;
  49
  50 void common_sighandler(int sig)
  51 {
  52     switch (sig) {
  53       default:
  54         err("Killed (got signal %d)...", sig);
  55         exit(-1);
  56     }
  57 }
  58
  59 int setnonblock(int sock)
  60 {
  61     int res = fcntl(sock, F_GETFL);
  62
  63     if (res < 0) {
  64         UNIXERR("fcntl");
  65         return -1;
  66     }
  67
  68     if (fcntl(sock, F_SETFL, res | O_NONBLOCK) < 0) {
  69         UNIXERR("fcntl");
  70         return -1;
  71     }
  72
  73     return 0;
  74 }
  75
  76 int tcp_bind(const struct sockaddr *addr, socklen_t len)
  77 {
  78     int sock;
  79
  80     switch (addr->sa_family) {
  81       case AF_UNIX:
  82         unlink(((struct sockaddr_un *)addr)->sun_path);
  83         sock = socket(PF_UNIX, SOCK_STREAM, 0);
  84         break;
  85       case AF_INET:
  86         sock = socket(PF_INET, SOCK_STREAM, 0);
  87         break;
  88       case AF_INET6:
  89         sock = socket(PF_INET6, SOCK_STREAM, 0);
  90         break;
  91       default:
  92         errno = EINVAL;
  93         return -1;
  94     }
  95
  96     if (sock < 0) {
  97         UNIXERR("socket");
  98         return -1;
  99     }
 100
 101     if (addr->sa_family != AF_UNIX) {
 102         int v = 1;
 103         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(v)) < 0) {
 104             UNIXERR("setsockopt(SO_REUSEADDR)");
 105             close(sock);
 106             return -1;
 107         }
 108     }
 109
 110     if (bind(sock, addr, len) < 0) {
 111         UNIXERR("bind");
 112         close(sock);
 113         return -1;
 114     }
 115
 116     return sock;
 117 }
 118
 119 int tcp_listen(const struct sockaddr *addr, socklen_t len)
 120 {
 121     int sock = tcp_bind(addr, len);
 122     if (listen(sock, 0) < 0) {
 123         UNIXERR("bind");
 124         close(sock);
 125         return -1;
 126     }
 127     return sock;
 128 }
 129
 130 int tcp_listen_nonblock(const struct sockaddr *addr, socklen_t len)
 131 {
 132     int sock = tcp_bind(addr, len);
 133     if (setnonblock(sock)) {
 134         close(sock);
 135         return -1;
 136     }
 137     if (listen(sock, 0) < 0) {
 138         UNIXERR("bind");
 139         close(sock);
 140         return -1;
 141     }
 142     return sock;
 143 }
 144
 145 int accept_nonblock(int fd)
 146 {
 147     int sock = accept(fd, NULL, 0);
 148
 149     if (sock < 0) {
 150         UNIXERR("accept");
 151         return -1;
 152     }
 153
 154     if (setnonblock(sock)) {
 155         close(sock);
 156         return -1;
 157     }
 158
 159     return sock;
 160 }
 161
 162 int xwrite(int fd, const char *s, size_t l)
 163 {
 164     while (l > 0) {
 165         int nb = write(fd, s, l);
 166         if (nb < 0) {
 167             if (errno == EINTR || errno == EAGAIN)
 168                 continue;
 169             return -1;
 170         }
 171         l -= nb;
 172     }
 173     return 0;
 174 }
 175
 176 int daemon_detach(void)
 177 {
 178     pid_t pid;
 179
 180     close(STDIN_FILENO);
 181     close(STDOUT_FILENO);
 182     close(STDERR_FILENO);
 183
 184     open("/dev/null", O_RDWR);
 185     open("/dev/null", O_RDWR);
 186     open("/dev/null", O_RDWR);
 187
 188     pid = fork();
 189     if (pid < 0) {
 190         return -1;
 191     }
 192     if (pid) {
 193         daemon_process = false;
 194         exit(0);
 195     }
 196
 197     setsid();
 198     return 0;
 199 }
 200
 201 int drop_privileges(const char *user, const char *group)
 202 {
 203     if (!geteuid()) {
 204         struct passwd *pw;
 205         struct group *gr;
 206
 207         if (group) {
 208             gr = getgrnam(group);
 209             if (!gr)
 210                 return -1;
 211             setgid(gr->gr_gid);
 212         }
 213
 214         pw = getpwnam(user);
 215         if (!pw)
 216             return -1;
 217         if (!group) {
 218             setgid(pw->pw_gid);
 219         }
 220         setuid(pw->pw_uid);
 221     }
 222
 223     return 0;
 224 }
 225
 226 int pidfile_open(const char *name)
 227 {
 228     if (name) {
 229         pidfile = fopen(name, "w");
 230         if (!pidfile)
 231             return -1;
 232         fprintf(pidfile, "%d\n", getpid());
 233         return fflush(pidfile);
 234     }
 235     return 0;
 236 }
 237
 238 int pidfile_refresh(void)
 239 {
 240     if (pidfile) {
 241         rewind(pidfile);
 242         ftruncate(fileno(pidfile), 0);
 243         fprintf(pidfile, "%d\n", getpid());
 244         return fflush(pidfile);
 245     }
 246     return 0;
 247 }
 248
 249 static void pidfile_close(void)
 250 {
 251     if (pidfile) {
 252         if (daemon_process) {
 253             rewind(pidfile);
 254             ftruncate(fileno(pidfile), 0);
 255         }
 256         fclose(pidfile);
 257         pidfile = NULL;
 258     }
 259 }
 260
 261 int common_setup(const char* pidfilename, bool unsafe, const char* runas_user,
 262                  const char* runas_group, bool daemonize)
 263 {
 264     if (pidfile_open(pidfilename) < 0) {
 265         crit("unable to write pidfile %s", pidfilename);
 266         return EXIT_FAILURE;
 267     }
 268
 269     if (!unsafe && drop_privileges(runas_user, runas_group) < 0) {
 270         crit("unable to drop privileges");
 271         return EXIT_FAILURE;
 272     }
 273
 274     if (daemonize && daemon_detach() < 0) {
 275         crit("unable to fork");
 276         return EXIT_FAILURE;
 277     }
 278
 279     pidfile_refresh();
 280     return EXIT_SUCCESS;
 281 }
 282
 283 #include "array.h"
 284
 285 ARRAY(exitcall_t)
 286
 287 static A(exitcall_t) __exit = ARRAY_INIT;
 288
 289 void common_register_exit(exitcall_t exitcall)
 290 {
 291     array_add(__exit, exitcall);
 292 }
 293
 294 static void common_shutdown(void)
 295 {
 296     if (daemon_process && log_syslog) {
 297         info("stopping...");
 298     }
 299     pidfile_close();
 300     for (int i = array_len(__exit) - 1 ; i >= 0 ; --i) {
 301         array_elt(__exit, i)();
 302     }
 303     array_wipe(__exit);
 304 }
 305
 306 void common_init(void)
 307 {
 308     static bool __ran = false;
 309     if (__ran) {
 310         return;
 311     }
 312     if (atexit(common_shutdown)) {
 313         fputs("Cannot hook my atexit function, quitting !\n", stderr);
 314         abort();
 315     }
 316     __ran = true;
 317 }
 318