Blame
Date:
Wed Oct 5 10:41:54 2022 UTC
Message:
retire fcgi' prog field spawning programs was a hidden feature used only for testing. It's gross and when got removed, I forgot to remove the field as well.
001
2020-10-02
op
/*
002
2022-07-04
op
* Copyright (c) 2020, 2021, 2022 Omar Polo <op@omarpolo.com>
003
2020-10-02
op
*
004
2020-10-02
op
* Permission to use, copy, modify, and distribute this software for any
005
2020-10-02
op
* purpose with or without fee is hereby granted, provided that the above
006
2020-10-02
op
* copyright notice and this permission notice appear in all copies.
007
2020-10-02
op
*
008
2020-10-02
op
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
009
2020-10-02
op
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
010
2020-10-02
op
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
011
2020-10-02
op
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
012
2020-10-02
op
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
013
2020-10-02
op
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
014
2020-10-02
op
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
015
2020-10-02
op
*/
016
2021-02-12
op
017
2021-02-12
op
#include "gmid.h"
018
2020-10-02
op
019
2021-01-25
op
#include <sys/stat.h>
020
2021-01-25
op
021
2020-10-07
op
#include <errno.h>
022
2020-10-02
op
#include <fcntl.h>
023
2021-06-29
op
#include <getopt.h>
024
2021-03-31
op
#include <libgen.h>
025
2021-02-01
op
#include <limits.h>
026
2021-01-25
op
#include <pwd.h>
027
2020-11-03
op
#include <signal.h>
028
2020-10-02
op
#include <string.h>
029
2020-10-07
op
030
2022-09-08
op
static const char *opts = "D:df:hnP:Vv";
031
2021-06-29
op
032
2022-03-19
op
static const struct option longopts[] = {
033
2021-06-29
op
{"help", no_argument, NULL, 'h'},
034
2021-06-29
op
{"version", no_argument, NULL, 'V'},
035
2021-06-29
op
{NULL, 0, NULL, 0},
036
2021-06-29
op
};
037
2021-06-29
op
038
2021-05-09
op
struct fcgi fcgi[FCGI_MAX];
039
2021-05-09
op
040
2021-03-31
op
struct vhosthead hosts;
041
2021-01-15
op
042
2021-03-19
op
int sock4, sock6;
043
2021-02-03
op
044
2022-09-10
op
struct imsgbuf logibuf, servibuf[PROC_MAX];
045
2021-02-23
op
046
2022-09-08
op
const char *config_path = "/etc/gmid.conf";
047
2022-09-08
op
const char *pidfile;
048
2021-01-16
op
049
2021-01-15
op
struct conf conf;
050
2021-01-15
op
051
2021-02-04
op
struct tls_config *tlsconf;
052
2021-01-25
op
struct tls *ctx;
053
2021-01-20
op
054
2021-03-20
op
static void
055
2021-03-20
op
dummy_handler(int signo)
056
2021-03-20
op
{
057
2021-03-20
op
return;
058
2021-03-20
op
}
059
2021-03-20
op
060
2021-01-25
op
void
061
2021-01-25
op
load_vhosts(void)
062
2020-10-02
op
{
063
2021-04-30
op
struct vhost *h;
064
2021-04-30
op
struct location *l;
065
2021-01-15
op
066
2021-03-31
op
TAILQ_FOREACH(h, &hosts, vhosts) {
067
2021-04-30
op
TAILQ_FOREACH(l, &h->locations, locations) {
068
2021-04-30
op
if (l->dir == NULL)
069
2021-04-30
op
continue;
070
2021-04-30
op
if ((l->dirfd = open(l->dir, O_RDONLY | O_DIRECTORY)) == -1)
071
2021-10-07
op
fatal("open %s for domain %s: %s", l->dir, h->domain,
072
2021-10-07
op
strerror(errno));
073
2021-04-30
op
}
074
2021-01-13
op
}
075
2021-01-13
op
}
076
2020-10-07
op
077
2020-10-02
op
int
078
2020-10-15
op
make_socket(int port, int family)
079
2020-10-02
op
{
080
2020-10-02
op
int sock, v;
081
2020-10-15
op
struct sockaddr_in addr4;
082
2020-10-15
op
struct sockaddr_in6 addr6;
083
2020-10-15
op
struct sockaddr *addr;
084
2020-10-15
op
socklen_t len;
085
2020-10-02
op
086
2021-09-24
op
switch (family) {
087
2020-10-15
op
case AF_INET:
088
2021-09-24
op
memset(&addr4, 0, sizeof(addr4));
089
2020-10-15
op
addr4.sin_family = family;
090
2020-10-15
op
addr4.sin_port = htons(port);
091
2020-10-15
op
addr4.sin_addr.s_addr = INADDR_ANY;
092
2020-10-15
op
addr = (struct sockaddr*)&addr4;
093
2020-10-15
op
len = sizeof(addr4);
094
2020-10-15
op
break;
095
2020-10-15
op
096
2020-10-15
op
case AF_INET6:
097
2021-09-24
op
memset(&addr6, 0, sizeof(addr6));
098
2020-10-15
op
addr6.sin6_family = AF_INET6;
099
2020-10-15
op
addr6.sin6_port = htons(port);
100
2020-10-15
op
addr6.sin6_addr = in6addr_any;
101
2020-10-15
op
addr = (struct sockaddr*)&addr6;
102
2020-10-15
op
len = sizeof(addr6);
103
2020-10-15
op
break;
104
2020-10-15
op
105
2020-10-15
op
default:
106
2020-10-15
op
/* unreachable */
107
2020-10-15
op
abort();
108
2020-10-15
op
}
109
2020-10-15
op
110
2020-10-15
op
if ((sock = socket(family, SOCK_STREAM, 0)) == -1)
111
2021-01-10
op
fatal("socket: %s", strerror(errno));
112
2020-10-02
op
113
2020-10-02
op
v = 1;
114
2020-10-02
op
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(v)) == -1)
115
2021-01-10
op
fatal("setsockopt(SO_REUSEADDR): %s", strerror(errno));
116
2020-10-02
op
117
2020-10-02
op
v = 1;
118
2020-10-02
op
if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &v, sizeof(v)) == -1)
119
2021-01-10
op
fatal("setsockopt(SO_REUSEPORT): %s", strerror(errno));
120
2020-10-02
op
121
2020-10-07
op
mark_nonblock(sock);
122
2020-10-07
op
123
2020-10-15
op
if (bind(sock, addr, len) == -1)
124
2021-01-10
op
fatal("bind: %s", strerror(errno));
125
2020-10-02
op
126
2020-10-02
op
if (listen(sock, 16) == -1)
127
2021-01-10
op
fatal("listen: %s", strerror(errno));
128
2020-10-02
op
129
2020-10-02
op
return sock;
130
2020-10-02
op
}
131
2020-10-02
op
132
2021-10-15
op
static void
133
2021-10-15
op
add_keypair(struct vhost *h)
134
2021-10-15
op
{
135
2021-10-15
op
if (h->ocsp == NULL) {
136
2021-10-15
op
if (tls_config_add_keypair_file(tlsconf, h->cert, h->key) == -1)
137
2021-10-15
op
fatal("failed to load the keypair (%s, %s)",
138
2021-10-15
op
h->cert, h->key);
139
2021-10-15
op
} else {
140
2021-10-15
op
if (tls_config_add_keypair_ocsp_file(tlsconf, h->cert, h->key,
141
2021-10-15
op
h->ocsp) == -1)
142
2021-10-15
op
fatal("failed to load the keypair (%s, %s, %s)",
143
2021-10-15
op
h->cert, h->key, h->ocsp);
144
2021-10-15
op
}
145
2021-10-15
op
}
146
2021-10-15
op
147
2021-01-25
op
void
148
2021-01-25
op
setup_tls(void)
149
2021-01-16
op
{
150
2021-01-25
op
struct vhost *h;
151
2021-01-16
op
152
2021-01-16
op
if ((tlsconf = tls_config_new()) == NULL)
153
2021-01-18
op
fatal("tls_config_new");
154
2021-01-16
op
155
2021-01-16
op
/* optionally accept client certs, but don't try to verify them */
156
2021-01-16
op
tls_config_verify_client_optional(tlsconf);
157
2021-01-16
op
tls_config_insecure_noverifycert(tlsconf);
158
2021-01-16
op
159
2021-01-16
op
if (tls_config_set_protocols(tlsconf, conf.protos) == -1)
160
2021-01-18
op
fatal("tls_config_set_protocols");
161
2021-01-16
op
162
2021-01-16
op
if ((ctx = tls_server()) == NULL)
163
2021-01-18
op
fatal("tls_server failure");
164
2021-01-16
op
165
2021-03-31
op
h = TAILQ_FIRST(&hosts);
166
2021-03-31
op
167
2021-01-25
op
/* we need to set something, then we can add how many key we want */
168
2021-03-31
op
if (tls_config_set_keypair_file(tlsconf, h->cert, h->key))
169
2021-02-04
op
fatal("tls_config_set_keypair_file failed for (%s, %s)",
170
2021-03-31
op
h->cert, h->key);
171
2021-10-15
op
172
2021-10-15
op
/* same for OCSP */
173
2021-10-15
op
if (h->ocsp != NULL &&
174
2021-10-15
op
tls_config_set_ocsp_staple_file(tlsconf, h->ocsp) == -1)
175
2021-10-15
op
fatal("tls_config_set_ocsp_staple_file failed for (%s)",
176
2021-10-15
op
h->ocsp);
177
2021-01-16
op
178
2021-10-15
op
while ((h = TAILQ_NEXT(h, vhosts)) != NULL)
179
2021-10-15
op
add_keypair(h);
180
2021-01-25
op
181
2021-01-16
op
if (tls_configure(ctx, tlsconf) == -1)
182
2021-01-18
op
fatal("tls_configure: %s", tls_error(ctx));
183
2021-01-25
op
}
184
2021-01-16
op
185
2021-02-03
op
static int
186
2021-03-19
op
listener_main(struct imsgbuf *ibuf)
187
2021-01-25
op
{
188
2021-02-07
op
drop_priv();
189
2022-09-10
op
if (load_default_mime(&conf.mime) == -1)
190
2022-04-08
op
fatal("load_default_mime: %s", strerror(errno));
191
2022-04-08
op
sort_mime(&conf.mime);
192
2021-01-25
op
load_vhosts();
193
2021-03-19
op
loop(ctx, sock4, sock6, ibuf);
194
2021-01-16
op
return 0;
195
2020-10-02
op
}
196
2020-10-02
op
197
2021-01-24
op
void
198
2021-01-24
op
init_config(void)
199
2020-10-02
op
{
200
2021-03-31
op
TAILQ_INIT(&hosts);
201
2020-12-21
op
202
2021-01-15
op
conf.port = 1965;
203
2021-01-15
op
conf.ipv6 = 0;
204
2021-01-15
op
conf.protos = TLS_PROTOCOL_TLSv1_2 | TLS_PROTOCOL_TLSv1_3;
205
2021-01-11
op
206
2021-01-21
op
init_mime(&conf.mime);
207
2021-01-25
op
208
2021-02-07
op
conf.prefork = 3;
209
2021-01-24
op
}
210
2021-01-18
op
211
2021-01-25
op
void
212
2021-02-04
op
free_config(void)
213
2021-02-04
op
{
214
2021-03-31
op
struct vhost *h, *th;
215
2021-03-31
op
struct location *l, *tl;
216
2021-01-02
op
struct proxy *p, *tp;
217
2021-04-28
op
struct envlist *e, *te;
218
2021-04-29
op
struct alist *a, *ta;
219
2021-05-09
op
int v, i;
220
2021-02-04
op
221
2021-04-28
op
v = conf.verbose;
222
2021-04-28
op
223
2022-04-08
op
free_mime(&conf.mime);
224
2021-02-04
op
memset(&conf, 0, sizeof(conf));
225
2021-04-28
op
226
2021-04-28
op
conf.verbose = v;
227
2021-02-04
op
228
2021-03-31
op
TAILQ_FOREACH_SAFE(h, &hosts, vhosts, th) {
229
2021-03-31
op
TAILQ_FOREACH_SAFE(l, &h->locations, locations, tl) {
230
2021-03-31
op
TAILQ_REMOVE(&h->locations, l, locations);
231
2021-02-04
op
232
2021-02-04
op
free((char*)l->match);
233
2021-02-04
op
free((char*)l->lang);
234
2021-02-04
op
free((char*)l->default_mime);
235
2021-02-04
op
free((char*)l->index);
236
2021-02-06
op
free((char*)l->block_fmt);
237
2021-04-30
op
free((char*)l->dir);
238
2021-04-30
op
239
2021-04-30
op
if (l->dirfd != -1)
240
2021-04-30
op
close(l->dirfd);
241
2021-04-30
op
242
2021-03-31
op
free(l);
243
2021-06-12
op
}
244
2021-06-12
op
245
2021-06-12
op
TAILQ_FOREACH_SAFE(e, &h->params, envs, te) {
246
2021-06-12
op
TAILQ_REMOVE(&h->params, e, envs);
247
2021-06-12
op
248
2021-04-28
op
free(e->name);
249
2021-04-28
op
free(e->value);
250
2021-04-28
op
free(e);
251
2021-04-29
op
}
252
2021-04-29
op
253
2021-04-29
op
TAILQ_FOREACH_SAFE(a, &h->aliases, aliases, ta) {
254
2021-06-12
op
TAILQ_REMOVE(&h->aliases, a, aliases);
255
2021-06-12
op
256
2021-04-29
op
free(a->alias);
257
2021-04-29
op
free(a);
258
2021-01-02
op
}
259
2021-01-02
op
260
2021-01-02
op
TAILQ_FOREACH_SAFE(p, &h->proxies, proxies, tp) {
261
2021-01-02
op
TAILQ_REMOVE(&h->proxies, p, proxies);
262
2021-01-02
op
263
2021-01-02
op
free(p->match_proto);
264
2021-01-02
op
free(p->match_host);
265
2021-01-02
op
free(p->host);
266
2022-01-30
op
free(p->sni);
267
2021-01-02
op
tls_unload_file(p->cert, p->certlen);
268
2021-01-02
op
tls_unload_file(p->key, p->keylen);
269
2021-01-02
op
free(p);
270
2021-04-28
op
}
271
2021-04-28
op
272
2021-04-30
op
free((char*)h->domain);
273
2021-04-30
op
free((char*)h->cert);
274
2021-04-30
op
free((char*)h->key);
275
2021-10-24
op
free((char*)h->ocsp);
276
2021-04-30
op
277
2021-03-31
op
TAILQ_REMOVE(&hosts, h, vhosts);
278
2021-03-31
op
free(h);
279
2021-05-09
op
}
280
2021-05-09
op
281
2021-05-09
op
for (i = 0; i < FCGI_MAX; ++i) {
282
2022-10-05
op
if (fcgi[i].path == NULL)
283
2021-05-09
op
break;
284
2021-05-09
op
free(fcgi[i].path);
285
2021-05-09
op
free(fcgi[i].port);
286
2021-07-06
op
287
2021-07-06
op
fcgi[i].path = NULL;
288
2021-07-06
op
fcgi[i].port = NULL;
289
2021-02-04
op
}
290
2021-02-04
op
291
2021-02-04
op
tls_free(ctx);
292
2021-02-04
op
tls_config_free(tlsconf);
293
2021-02-04
op
}
294
2021-02-04
op
295
2021-03-20
op
static int
296
2021-03-20
op
wait_signal(void)
297
2021-02-04
op
{
298
2021-02-04
op
sigset_t mask;
299
2021-02-04
op
int signo;
300
2021-02-04
op
301
2021-02-04
op
sigemptyset(&mask);
302
2021-02-04
op
sigaddset(&mask, SIGHUP);
303
2021-03-20
op
sigaddset(&mask, SIGINT);
304
2021-03-20
op
sigaddset(&mask, SIGTERM);
305
2021-02-04
op
sigwait(&mask, &signo);
306
2021-03-20
op
307
2021-03-20
op
return signo == SIGHUP;
308
2021-02-04
op
}
309
2021-02-04
op
310
2021-02-04
op
void
311
2021-01-25
op
drop_priv(void)
312
2021-01-25
op
{
313
2021-01-25
op
struct passwd *pw = NULL;
314
2021-01-25
op
315
2022-09-10
op
if (*conf.chroot != '\0' && *conf.user == '\0')
316
2021-01-25
op
fatal("can't chroot without an user to switch to after.");
317
2021-01-25
op
318
2022-09-10
op
if (*conf.user != '\0') {
319
2021-01-25
op
if ((pw = getpwnam(conf.user)) == NULL)
320
2021-01-25
op
fatal("can't find user %s", conf.user);
321
2021-01-25
op
}
322
2021-01-25
op
323
2022-09-10
op
if (*conf.chroot != '\0') {
324
2021-01-25
op
if (chroot(conf.chroot) != 0 || chdir("/") != 0)
325
2021-01-25
op
fatal("%s: %s", conf.chroot, strerror(errno));
326
2021-01-25
op
}
327
2021-01-25
op
328
2021-01-25
op
if (pw != NULL) {
329
2021-01-25
op
if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) == -1)
330
2021-01-25
op
fatal("setresuid(%d): %s", pw->pw_uid,
331
2021-01-25
op
strerror(errno));
332
2021-01-25
op
}
333
2021-01-25
op
334
2021-01-25
op
if (getuid() == 0)
335
2021-02-07
op
log_warn(NULL, "not a good idea to run a network daemon as root");
336
2021-01-25
op
}
337
2021-02-03
op
338
2021-02-07
op
static void
339
2021-06-29
op
usage(void)
340
2021-02-07
op
{
341
2021-02-07
op
fprintf(stderr,
342
2021-06-29
op
"Version: " GMID_STRING "\n"
343
2022-09-08
op
"Usage: %s [-dhnVv] [-D macro=value] [-f config] [-P pidfile]\n",
344
2021-06-29
op
getprogname());
345
2021-02-07
op
}
346
2021-02-07
op
347
2021-02-23
op
static void
348
2021-02-23
op
logger_init(void)
349
2021-02-23
op
{
350
2021-02-23
op
int p[2];
351
2021-02-23
op
352
2021-02-23
op
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, p) == -1)
353
2021-02-23
op
err(1, "socketpair");
354
2021-02-23
op
355
2021-02-23
op
switch (fork()) {
356
2021-02-23
op
case -1:
357
2021-02-23
op
err(1, "fork");
358
2021-02-23
op
case 0:
359
2021-03-19
op
signal(SIGHUP, SIG_IGN);
360
2021-02-23
op
close(p[0]);
361
2021-02-23
op
setproctitle("logger");
362
2021-03-19
op
imsg_init(&logibuf, p[1]);
363
2021-02-23
op
drop_priv();
364
2021-03-19
op
_exit(logger_main(p[1], &logibuf));
365
2021-02-23
op
default:
366
2021-02-23
op
close(p[1]);
367
2021-03-19
op
imsg_init(&logibuf, p[0]);
368
2021-02-23
op
return;
369
2021-02-23
op
}
370
2021-02-23
op
}
371
2021-02-23
op
372
2022-09-06
op
static void
373
2022-09-06
op
serve(void)
374
2021-02-03
op
{
375
2022-09-06
op
int i, p[2];
376
2021-01-25
op
377
2021-02-03
op
/* setup tls before dropping privileges: we don't want user
378
2021-02-03
op
* to put private certs inside the chroot. */
379
2021-02-03
op
setup_tls();
380
2021-02-03
op
381
2021-03-03
op
for (i = 0; i < conf.prefork; ++i) {
382
2021-03-03
op
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC,
383
2021-03-03
op
PF_UNSPEC, p) == -1)
384
2021-03-03
op
fatal("socketpair: %s", strerror(errno));
385
2021-02-03
op
386
2021-03-03
op
switch (fork()) {
387
2021-03-03
op
case -1:
388
2021-03-03
op
fatal("fork: %s", strerror(errno));
389
2021-03-03
op
case 0: /* child */
390
2021-03-03
op
close(p[0]);
391
2022-09-10
op
imsg_init(&servibuf[i], p[1]);
392
2021-03-03
op
setproctitle("server");
393
2022-09-10
op
_exit(listener_main(&servibuf[i]));
394
2021-03-03
op
default:
395
2021-03-03
op
close(p[1]);
396
2021-03-19
op
imsg_init(&servibuf[i], p[0]);
397
2021-03-03
op
}
398
2021-02-03
op
}
399
2021-02-03
op
}
400
2021-04-28
op
401
2021-04-28
op
static int
402
2021-04-28
op
write_pidfile(const char *pidfile)
403
2021-04-28
op
{
404
2021-04-28
op
struct flock lock;
405
2021-04-28
op
int fd;
406
2021-02-03
op
407
2021-04-28
op
if (pidfile == NULL)
408
2021-04-28
op
return -1;
409
2021-04-28
op
410
2021-04-28
op
if ((fd = open(pidfile, O_WRONLY|O_CREAT|O_CLOEXEC, 0600)) == -1)
411
2021-04-28
op
fatal("can't open pidfile %s: %s", pidfile, strerror(errno));
412
2021-04-28
op
413
2021-04-28
op
lock.l_start = 0;
414
2021-04-28
op
lock.l_len = 0;
415
2021-04-28
op
lock.l_type = F_WRLCK;
416
2021-04-28
op
lock.l_whence = SEEK_SET;
417
2021-04-28
op
418
2021-04-28
op
if (fcntl(fd, F_SETLK, &lock) == -1)
419
2021-04-28
op
fatal("can't lock %s, gmid is already running?", pidfile);
420
2021-04-28
op
421
2021-04-28
op
if (ftruncate(fd, 0) == -1)
422
2021-04-28
op
fatal("ftruncate: %s: %s", pidfile, strerror(errno));
423
2021-04-28
op
424
2021-04-28
op
dprintf(fd, "%d\n", getpid());
425
2021-04-28
op
426
2021-04-28
op
return fd;
427
2021-04-28
op
}
428
2021-04-28
op
429
2021-01-24
op
int
430
2021-01-24
op
main(int argc, char **argv)
431
2021-01-24
op
{
432
2022-09-08
op
int i, ch, conftest = 0;
433
2021-04-28
op
int pidfd, old_ipv6, old_port;
434
2021-01-24
op
435
2021-07-07
op
logger_init();
436
2021-01-24
op
init_config();
437
2021-01-24
op
438
2021-06-29
op
while ((ch = getopt_long(argc, argv, opts, longopts, NULL)) != -1) {
439
2020-10-02
op
switch (ch) {
440
2021-06-29
op
case 'D':
441
2021-06-29
op
if (cmdline_symset(optarg) == -1)
442
2021-07-07
op
fatal("could not parse macro definition: %s",
443
2021-07-07
op
optarg);
444
2021-06-29
op
break;
445
2022-09-08
op
case 'd':
446
2021-02-07
op
conf.foreground = 1;
447
2021-01-27
op
break;
448
2022-09-08
op
case 'f':
449
2022-09-08
op
config_path = absolutify_path(optarg);
450
2022-09-08
op
break;
451
2020-10-02
op
case 'h':
452
2021-06-29
op
usage();
453
2020-10-02
op
return 0;
454
2021-01-15
op
case 'n':
455
2021-10-09
op
conftest++;
456
2020-11-18
op
break;
457
2021-04-28
op
case 'P':
458
2021-04-28
op
pidfile = optarg;
459
2021-04-28
op
break;
460
2021-06-29
op
case 'V':
461
2021-06-29
op
puts("Version: " GMID_STRING);
462
2021-06-29
op
return 0;
463
2021-01-27
op
case 'v':
464
2021-02-07
op
conf.verbose++;
465
2021-01-27
op
break;
466
2020-10-02
op
default:
467
2021-06-29
op
usage();
468
2020-10-02
op
return 1;
469
2020-10-02
op
}
470
2020-10-02
op
}
471
2021-01-25
op
argc -= optind;
472
2021-01-25
op
argv += optind;
473
2020-10-02
op
474
2022-09-08
op
if (argc != 0)
475
2022-09-06
op
usage();
476
2022-09-06
op
477
2022-09-08
op
parse_conf(config_path);
478
2021-02-03
op
479
2021-01-18
op
if (conftest) {
480
2021-10-09
op
fprintf(stderr, "config OK\n");
481
2021-10-09
op
if (conftest > 1)
482
2021-10-09
op
print_conf();
483
2021-01-18
op
return 0;
484
2021-01-18
op
}
485
2020-12-28
op
486
2022-09-08
op
if (!conf.foreground) {
487
2021-07-07
op
/* log to syslog */
488
2021-07-07
op
imsg_compose(&logibuf, IMSG_LOG_TYPE, 0, 0, -1, NULL, 0);
489
2021-07-07
op
imsg_flush(&logibuf);
490
2021-07-07
op
491
2021-01-17
op
if (daemon(1, 1) == -1)
492
2021-07-07
op
fatal("daemon: %s", strerror(errno));
493
2021-01-17
op
}
494
2020-12-28
op
495
2021-02-03
op
sock4 = make_socket(conf.port, AF_INET);
496
2021-02-03
op
sock6 = -1;
497
2021-02-03
op
if (conf.ipv6)
498
2021-02-03
op
sock6 = make_socket(conf.port, AF_INET6);
499
2020-10-02
op
500
2021-04-20
op
signal(SIGPIPE, SIG_IGN);
501
2021-04-20
op
502
2021-04-28
op
pidfd = write_pidfile(pidfile);
503
2021-04-28
op
504
2021-07-07
op
/*
505
2021-07-07
op
* Linux seems to call the event handlers even when we're
506
2021-04-26
op
* doing a sigwait. These dummy handlers are here to avoid
507
2021-07-07
op
* being terminated on SIGHUP, SIGINT or SIGTERM.
508
2021-07-07
op
*/
509
2021-03-20
op
signal(SIGHUP, dummy_handler);
510
2021-03-20
op
signal(SIGINT, dummy_handler);
511
2021-03-20
op
signal(SIGTERM, dummy_handler);
512
2021-03-20
op
513
2021-02-04
op
/* wait a sighup and reload the daemon */
514
2021-02-04
op
for (;;) {
515
2022-09-06
op
serve();
516
2021-02-04
op
517
2022-09-08
op
if (!wait_signal())
518
2021-03-20
op
break;
519
2021-03-20
op
520
2021-02-07
op
log_info(NULL, "reloading configuration %s", config_path);
521
2021-02-04
op
522
2022-09-06
op
/* close the servers */
523
2022-09-06
op
for (i = 0; i < conf.prefork; ++i) {
524
2022-09-06
op
imsg_compose(&servibuf[i], IMSG_QUIT, 0, 0, -1, NULL, 0);
525
2022-09-06
op
imsg_flush(&servibuf[i]);
526
2022-09-06
op
close(servibuf[i].fd);
527
2022-09-06
op
}
528
2021-03-19
op
529
2021-02-04
op
old_ipv6 = conf.ipv6;
530
2021-02-04
op
old_port = conf.port;
531
2021-02-04
op
532
2021-02-04
op
free_config();
533
2021-02-04
op
init_config();
534
2021-02-04
op
parse_conf(config_path);
535
2021-02-04
op
536
2021-02-04
op
if (old_port != conf.port) {
537
2021-02-04
op
close(sock4);
538
2021-02-04
op
close(sock6);
539
2021-02-04
op
sock4 = -1;
540
2021-02-04
op
sock6 = -1;
541
2021-02-04
op
}
542
2021-02-04
op
543
2021-02-04
op
if (sock6 != -1 && old_ipv6 != conf.ipv6) {
544
2021-02-04
op
close(sock6);
545
2021-02-04
op
sock6 = -1;
546
2021-02-04
op
}
547
2021-02-04
op
548
2021-02-04
op
if (sock4 == -1)
549
2021-02-04
op
sock4 = make_socket(conf.port, AF_INET);
550
2021-02-04
op
if (sock6 == -1 && conf.ipv6)
551
2021-02-04
op
sock6 = make_socket(conf.port, AF_INET6);
552
2021-02-04
op
}
553
2021-03-20
op
554
2022-09-10
op
for (i = 0; i < conf.prefork; ++i) {
555
2022-09-10
op
imsg_compose(&servibuf[i], IMSG_QUIT, 0, 0, -1, NULL, 0);
556
2022-09-10
op
imsg_flush(&servibuf[i]);
557
2022-09-10
op
close(servibuf[i].fd);
558
2022-09-10
op
}
559
2021-03-20
op
560
2021-03-20
op
imsg_compose(&logibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
561
2021-03-20
op
imsg_flush(&logibuf);
562
2022-09-10
op
close(logibuf.fd);
563
2021-03-20
op
564
2021-04-28
op
if (pidfd != -1)
565
2021-04-28
op
close(pidfd);
566
2021-04-28
op
567
2021-03-20
op
return 0;
568
2020-10-02
op
}
Omar Polo