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 sig_atomic_t sigint  = false;
  45 sig_atomic_t sighup  = false;
  46
  47 static FILE *pidfile = NULL;
  48
  49 void common_sighandler(int sig)
  50 {
  51     switch (sig) {
  52       case SIGINT:
  53         sigint = true;
  54         return;
  55
  56       case SIGHUP:
  57         sighup = true;
  58         return;
  59
  60       default:
  61         syslog(LOG_ERR, "Killed (got signal %d)...", sig);
  62         exit(-1);
  63     }
  64 }
  65
  66 static int setnonblock(int sock)
  67 {
  68     int res = fcntl(sock, F_GETFL);
  69
  70     if (res < 0) {
  71         UNIXERR("fcntl");
  72         return -1;
  73     }
  74
  75     if (fcntl(sock, F_SETFL, res | O_NONBLOCK) < 0) {
  76         UNIXERR("fcntl");
  77         return -1;
  78     }
  79
  80     return 0;
  81 }
  82
  83 int tcp_bind(const struct sockaddr *addr, socklen_t len)
  84 {
  85     int sock;
  86
  87     switch (addr->sa_family) {
  88       case AF_UNIX:
  89         unlink(((struct sockaddr_un *)addr)->sun_path);
  90         sock = socket(PF_UNIX, SOCK_STREAM, 0);
  91         break;
  92       case AF_INET:
  93         sock = socket(PF_INET, SOCK_STREAM, 0);
  94         break;
  95       case AF_INET6:
  96         sock = socket(PF_INET6, SOCK_STREAM, 0);
  97         break;
  98       default:
  99         errno = EINVAL;
 100         return -1;
 101     }
 102
 103     if (sock < 0) {
 104         UNIXERR("socket");
 105         return -1;
 106     }
 107
 108     if (addr->sa_family != AF_UNIX) {
 109         int v = 1;
 110         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(v)) < 0) {
 111             UNIXERR("setsockopt(SO_REUSEADDR)");
 112             close(sock);
 113             return -1;
 114         }
 115     }
 116
 117     if (bind(sock, addr, len) < 0) {
 118         UNIXERR("bind");
 119         close(sock);
 120         return -1;
 121     }
 122
 123     return sock;
 124 }
 125
 126 int tcp_listen(const struct sockaddr *addr, socklen_t len)
 127 {
 128     int sock = tcp_bind(addr, len);
 129     if (listen(sock, 0) < 0) {
 130         UNIXERR("bind");
 131         close(sock);
 132         return -1;
 133     }
 134     return sock;
 135 }
 136
 137 int tcp_listen_nonblock(const struct sockaddr *addr, socklen_t len)
 138 {
 139     int sock = tcp_bind(addr, len);
 140     if (setnonblock(sock)) {
 141         close(sock);
 142         return -1;
 143     }
 144     if (listen(sock, 0) < 0) {
 145         UNIXERR("bind");
 146         close(sock);
 147         return -1;
 148     }
 149     return sock;
 150 }
 151
 152 int accept_nonblock(int fd)
 153 {
 154     int sock = accept(fd, NULL, 0);
 155
 156     if (sock < 0) {
 157         UNIXERR("accept");
 158         return -1;
 159     }
 160
 161     if (setnonblock(sock)) {
 162         close(sock);
 163         return -1;
 164     }
 165
 166     return sock;
 167 }
 168
 169 int xwrite(int fd, const char *s, size_t l)
 170 {
 171     while (l > 0) {
 172         int nb = write(fd, s, l);
 173         if (nb < 0) {
 174             if (errno == EINTR || errno == EAGAIN)
 175                 continue;
 176             return -1;
 177         }
 178         l -= nb;
 179     }
 180     return 0;
 181 }
 182
 183 int daemon_detach(void)
 184 {
 185     pid_t pid;
 186
 187     close(STDIN_FILENO);
 188     close(STDOUT_FILENO);
 189     close(STDERR_FILENO);
 190
 191     open("/dev/null", O_RDWR);
 192     open("/dev/null", O_RDWR);
 193     open("/dev/null", O_RDWR);
 194
 195     pid = fork();
 196     if (pid < 0)
 197         return -1;
 198     if (pid)
 199         exit(0);
 200
 201     setsid();
 202     return 0;
 203 }
 204
 205 int drop_privileges(const char *user, const char *group)
 206 {
 207     if (!geteuid()) {
 208         struct passwd *pw;
 209         struct group *gr;
 210
 211         if (group) {
 212             gr = getgrnam(group);
 213             if (!gr)
 214                 return -1;
 215             setgid(gr->gr_gid);
 216         }
 217
 218         pw = getpwnam(user);
 219         if (!pw)
 220             return -1;
 221         if (!group) {
 222             setgid(pw->pw_gid);
 223         }
 224         setuid(pw->pw_uid);
 225     }
 226
 227     return 0;
 228 }
 229
 230 int pidfile_open(const char *name)
 231 {
 232                 struct flock lock;
 233                 p_clear(&lock, 1);
 234                 lock.l_type = F_WRLCK;
 235     if (name) {
 236         pidfile = fopen(name, "w");
 237         if (!pidfile)
 238             return -1;
 239                                 if (fcntl(fileno(pidfile), F_SETLK, &lock) == -1) {
 240                                                 syslog(LOG_ERR, "program already started");
 241                                                 fclose(pidfile);
 242                                                 pidfile = NULL;
 243                                                 return -1;
 244                                 }
 245                                 fprintf(pidfile, "%d\n", getpid());
 246         return fflush(pidfile);
 247     }
 248     return 0;
 249 }
 250
 251 int pidfile_refresh(void)
 252 {
 253     if (pidfile) {
 254         rewind(pidfile);
 255         ftruncate(fileno(pidfile), 0);
 256         fprintf(pidfile, "%d\n", getpid());
 257         return fflush(pidfile);
 258     }
 259     return 0;
 260 }
 261
 262 static void pidfile_close(void)
 263 {
 264                 struct flock lock;
 265                 p_clear(&lock, 1);
 266                 lock.l_type = F_UNLCK;
 267     if (pidfile) {
 268         rewind(pidfile);
 269         ftruncate(fileno(pidfile), 0);
 270         fcntl(fileno(pidfile), F_SETLK, &lock);
 271                                 fclose(pidfile);
 272         pidfile = NULL;
 273     }
 274 }
 275
 276 int common_setup(const char* pidfilename, bool unsafe, const char* runas_user,
 277                  const char* runas_group, bool daemonize)
 278 {
 279     if (pidfile_open(pidfilename) < 0) {
 280         syslog(LOG_CRIT, "unable to write pidfile %s", pidfilename);
 281         return EXIT_FAILURE;
 282     }
 283
 284     if (!unsafe && drop_privileges(runas_user, runas_group) < 0) {
 285         syslog(LOG_CRIT, "unable to drop privileges");
 286         return EXIT_FAILURE;
 287     }
 288
 289     if (daemonize && daemon_detach() < 0) {
 290         syslog(LOG_CRIT, "unable to fork");
 291         return EXIT_FAILURE;
 292     }
 293
 294     pidfile_refresh();
 295     return EXIT_SUCCESS;
 296 }
 297
 298 extern initcall_t __madinit[];
 299 extern exitcall_t __madexit[];
 300
 301 static void common_shutdown(void)
 302 {
 303     syslog(LOG_INFO, "Stopping...");
 304     pidfile_close();
 305
 306     for (int i = -1; __madexit[i]; i--) {
 307         (*__madexit[i])();
 308     }
 309 }
 310
 311 static void __attribute__((__constructor__,__used__))
 312 common_initialize(void)
 313 {
 314     if (atexit(common_shutdown)) {
 315         fputs("Cannot hook my atexit function, quitting !\n", stderr);
 316         abort();
 317     }
 318
 319     for (int i = 0; __madinit[i]; i++) {
 320         if ((*__madinit[i])()) {
 321             exit(EXIT_FAILURE);
 322         }
 323     }
 324 }
 325