pfix-srsd: add a -I option
[apps/pfixtools.git] / 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 CONTRIBUTORS ``AS IS'' AND ANY EXPRESS   */
20 /*  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED         */
21 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE    */
22 /*  DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY         */
23 /*  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL        */
24 /*  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS   */
25 /*  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)     */
26 /*  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,       */
27 /*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN  */
28 /*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE           */
29 /*  POSSIBILITY OF SUCH DAMAGE.                                               */
30 /*                                                                            */
31 /*   Copyright (c) 2006-2008 the Authors                                      */
32 /*   see AUTHORS and source files for details                                 */
33 /******************************************************************************/
34
35 /*
36  * Copyright © 2007 Pierre Habouzit
37  * Copyright © 2008 Florent Bruneau
38  */
39
40 #include <fcntl.h>
41 #include <grp.h>
42 #include <pwd.h>
43 #include <sys/un.h>
44
45 #include "common.h"
46
47 bool daemon_process   = true;
48 int  log_level        = LOG_INFO;
49 bool log_syslog       = false;
50 const char *log_state = "";
51
52 static FILE *pidfile = NULL;
53
54 void common_sighandler(int sig)
55 {
56     switch (sig) {
57       default:
58         err("Killed (got signal %d)...", sig);
59         exit(-1);
60     }
61 }
62
63 int setnonblock(int sock)
64 {
65     int res = fcntl(sock, F_GETFL);
66
67     if (res < 0) {
68         UNIXERR("fcntl");
69         return -1;
70     }
71
72     if (fcntl(sock, F_SETFL, res | O_NONBLOCK) < 0) {
73         UNIXERR("fcntl");
74         return -1;
75     }
76
77     return 0;
78 }
79
80 int tcp_bind(const struct sockaddr *addr, socklen_t len)
81 {
82     int sock;
83
84     switch (addr->sa_family) {
85       case AF_UNIX:
86         unlink(((struct sockaddr_un *)addr)->sun_path);
87         sock = socket(PF_UNIX, SOCK_STREAM, 0);
88         break;
89       case AF_INET:
90         sock = socket(PF_INET, SOCK_STREAM, 0);
91         break;
92       case AF_INET6:
93         sock = socket(PF_INET6, SOCK_STREAM, 0);
94         break;
95       default:
96         errno = EINVAL;
97         return -1;
98     }
99
100     if (sock < 0) {
101         UNIXERR("socket");
102         return -1;
103     }
104
105     if (addr->sa_family != AF_UNIX) {
106         int v = 1;
107         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(v)) < 0) {
108             UNIXERR("setsockopt(SO_REUSEADDR)");
109             close(sock);
110             return -1;
111         }
112     }
113
114     if (bind(sock, addr, len) < 0) {
115         UNIXERR("bind");
116         close(sock);
117         return -1;
118     }
119
120     return sock;
121 }
122
123 int tcp_listen(const struct sockaddr *addr, socklen_t len)
124 {
125     int sock = tcp_bind(addr, len);
126     if (listen(sock, 0) < 0) {
127         UNIXERR("bind");
128         close(sock);
129         return -1;
130     }
131     return sock;
132 }
133
134 int tcp_listen_nonblock(const struct sockaddr *addr, socklen_t len)
135 {
136     int sock = tcp_bind(addr, len);
137     if (setnonblock(sock)) {
138         close(sock);
139         return -1;
140     }
141     if (listen(sock, 0) < 0) {
142         UNIXERR("bind");
143         close(sock);
144         return -1;
145     }
146     return sock;
147 }
148
149 int accept_nonblock(int fd)
150 {
151     int sock = accept(fd, NULL, 0);
152
153     if (sock < 0) {
154         UNIXERR("accept");
155         return -1;
156     }
157
158     if (setnonblock(sock)) {
159         close(sock);
160         return -1;
161     }
162
163     return sock;
164 }
165
166 int xwrite(int fd, const char *s, size_t l)
167 {
168     while (l > 0) {
169         int nb = write(fd, s, l);
170         if (nb < 0) {
171             if (errno == EINTR || errno == EAGAIN)
172                 continue;
173             return -1;
174         }
175         l -= nb;
176     }
177     return 0;
178 }
179
180 int daemon_detach(void)
181 {
182     pid_t pid;
183
184     close(STDIN_FILENO);
185     close(STDOUT_FILENO);
186     close(STDERR_FILENO);
187
188     open("/dev/null", O_RDWR);
189     open("/dev/null", O_RDWR);
190     open("/dev/null", O_RDWR);
191
192     pid = fork();
193     if (pid < 0) {
194         return -1;
195     }
196     if (pid) {
197         daemon_process = false;
198         exit(0);
199     }
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     if (name) {
233         pidfile = fopen(name, "w");
234         if (!pidfile)
235             return -1;
236         fprintf(pidfile, "%d\n", getpid());
237         return fflush(pidfile);
238     }
239     return 0;
240 }
241
242 int pidfile_refresh(void)
243 {
244     if (pidfile) {
245         rewind(pidfile);
246         ftruncate(fileno(pidfile), 0);
247         fprintf(pidfile, "%d\n", getpid());
248         return fflush(pidfile);
249     }
250     return 0;
251 }
252
253 static void pidfile_close(void)
254 {
255     if (pidfile) {
256         if (daemon_process) {
257             rewind(pidfile);
258             ftruncate(fileno(pidfile), 0);
259         }
260         fclose(pidfile);
261         pidfile = NULL;
262     }
263 }
264
265 int common_setup(const char* pidfilename, bool unsafe, const char* runas_user,
266                  const char* runas_group, bool daemonize)
267 {
268     if (pidfile_open(pidfilename) < 0) {
269         crit("unable to write pidfile %s", pidfilename);
270         return EXIT_FAILURE;
271     }
272
273     if (!unsafe && drop_privileges(runas_user, runas_group) < 0) {
274         crit("unable to drop privileges");
275         return EXIT_FAILURE;
276     }
277
278     if (daemonize && daemon_detach() < 0) {
279         crit("unable to fork");
280         return EXIT_FAILURE;
281     }
282
283     pidfile_refresh();
284     return EXIT_SUCCESS;
285 }
286
287 #include "array.h"
288
289 ARRAY(exitcall_t)
290
291 static A(exitcall_t) __exit = ARRAY_INIT;
292
293 void common_register_exit(exitcall_t exitcall)
294 {
295     array_add(__exit, exitcall);
296 }
297
298 static void common_shutdown(void)
299 {
300     log_state = "stopping ";
301     if (daemon_process && log_syslog) {
302         info("");
303     }
304     pidfile_close();
305     for (int i = array_len(__exit) - 1 ; i >= 0 ; --i) {
306         array_elt(__exit, i)();
307     }
308     array_wipe(__exit);
309 }
310
311 void common_init(void)
312 {
313     static bool __ran = false;
314     if (__ran) {
315         return;
316     }
317     log_state = "starting ";
318     if (atexit(common_shutdown)) {
319         fputs("Cannot hook my atexit function, quitting !\n", stderr);
320         abort();
321     }
322     __ran = true;
323 }
324