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