Blame
Date:
Mon Jul 4 09:48:39 2022 UTC
Message:
copyright years
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
2021-06-29
op
static const char *opts = "6c:D:d:fH:hnP:p:Vvx:";
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
2021-03-19
op
struct imsgbuf logibuf, exibuf, servibuf[PROC_MAX];
045
2021-02-23
op
046
2021-05-01
op
const char *config_path, *certs_dir, *hostname, *pidfile, *cgi;
047
2021-01-16
op
048
2021-01-15
op
struct conf conf;
049
2021-01-15
op
050
2021-02-04
op
struct tls_config *tlsconf;
051
2021-01-25
op
struct tls *ctx;
052
2021-01-20
op
053
2021-03-20
op
static void
054
2021-03-20
op
dummy_handler(int signo)
055
2021-03-20
op
{
056
2021-03-20
op
return;
057
2021-03-20
op
}
058
2021-03-20
op
059
2021-03-31
op
/* wrapper around dirname(3). dn must be PATH_MAX+1 at least. */
060
2021-03-31
op
static void
061
2021-03-31
op
pdirname(const char *path, char *dn)
062
2021-01-25
op
{
063
2021-03-31
op
char p[PATH_MAX+1];
064
2021-03-31
op
char *t;
065
2021-03-31
op
066
2021-03-31
op
strlcpy(p, path, sizeof(p));
067
2021-03-31
op
t = dirname(p);
068
2021-03-31
op
memmove(dn, t, strlen(t)+1);
069
2021-03-31
op
}
070
2021-03-31
op
071
2021-03-31
op
static void
072
2021-03-31
op
mkdirs(const char *path, mode_t mode)
073
2021-03-31
op
{
074
2021-03-31
op
char dname[PATH_MAX+1];
075
2021-03-31
op
076
2021-03-31
op
pdirname(path, dname);
077
2021-03-31
op
if (!strcmp(dname, "/"))
078
2021-03-31
op
return;
079
2021-03-31
op
mkdirs(dname, mode);
080
2021-03-31
op
if (mkdir(path, mode) != 0 && errno != EEXIST)
081
2021-01-25
op
fatal("can't mkdir %s: %s", path, strerror(errno));
082
2021-01-25
op
}
083
2021-01-25
op
084
2021-01-25
op
/* $XDG_DATA_HOME/gmid */
085
2021-01-25
op
char *
086
2021-01-25
op
data_dir(void)
087
2021-01-25
op
{
088
2021-01-25
op
const char *home, *xdg;
089
2021-01-25
op
char *t;
090
2021-01-25
op
091
2021-01-25
op
if ((xdg = getenv("XDG_DATA_HOME")) == NULL) {
092
2021-01-25
op
if ((home = getenv("HOME")) == NULL)
093
2021-01-25
op
errx(1, "XDG_DATA_HOME and HOME both empty");
094
2021-01-25
op
if (asprintf(&t, "%s/.local/share/gmid", home) == -1)
095
2021-01-25
op
err(1, "asprintf");
096
2021-03-31
op
} else {
097
2021-03-31
op
if (asprintf(&t, "%s/gmid", xdg) == -1)
098
2021-03-31
op
err(1, "asprintf");
099
2021-01-25
op
}
100
2021-01-25
op
101
2021-03-31
op
mkdirs(t, 0755);
102
2021-01-25
op
return t;
103
2021-01-17
op
}
104
2020-11-10
op
105
2021-01-17
op
void
106
2021-01-25
op
load_local_cert(const char *hostname, const char *dir)
107
2021-01-25
op
{
108
2021-01-25
op
char *cert, *key;
109
2021-03-31
op
struct vhost *h;
110
2021-01-25
op
111
2021-01-25
op
if (asprintf(&cert, "%s/%s.cert.pem", dir, hostname) == -1)
112
2021-01-25
op
errx(1, "asprintf");
113
2021-01-25
op
if (asprintf(&key, "%s/%s.key.pem", dir, hostname) == -1)
114
2021-01-25
op
errx(1, "asprintf");
115
2021-01-25
op
116
2021-01-25
op
if (access(cert, R_OK) == -1 || access(key, R_OK) == -1)
117
2021-01-25
op
gen_certificate(hostname, cert, key);
118
2021-01-25
op
119
2021-03-31
op
h = TAILQ_FIRST(&hosts);
120
2021-03-31
op
h->cert = cert;
121
2021-03-31
op
h->key = key;
122
2021-03-31
op
h->domain = hostname;
123
2021-01-25
op
}
124
2021-01-25
op
125
2021-01-25
op
void
126
2021-01-25
op
load_vhosts(void)
127
2020-10-02
op
{
128
2021-04-30
op
struct vhost *h;
129
2021-04-30
op
struct location *l;
130
2021-01-15
op
131
2021-03-31
op
TAILQ_FOREACH(h, &hosts, vhosts) {
132
2021-04-30
op
TAILQ_FOREACH(l, &h->locations, locations) {
133
2021-04-30
op
if (l->dir == NULL)
134
2021-04-30
op
continue;
135
2021-04-30
op
if ((l->dirfd = open(l->dir, O_RDONLY | O_DIRECTORY)) == -1)
136
2021-10-07
op
fatal("open %s for domain %s: %s", l->dir, h->domain,
137
2021-10-07
op
strerror(errno));
138
2021-04-30
op
}
139
2021-01-13
op
}
140
2021-01-13
op
}
141
2020-10-07
op
142
2020-10-02
op
int
143
2020-10-15
op
make_socket(int port, int family)
144
2020-10-02
op
{
145
2020-10-02
op
int sock, v;
146
2020-10-15
op
struct sockaddr_in addr4;
147
2020-10-15
op
struct sockaddr_in6 addr6;
148
2020-10-15
op
struct sockaddr *addr;
149
2020-10-15
op
socklen_t len;
150
2020-10-02
op
151
2021-09-24
op
switch (family) {
152
2020-10-15
op
case AF_INET:
153
2021-09-24
op
memset(&addr4, 0, sizeof(addr4));
154
2020-10-15
op
addr4.sin_family = family;
155
2020-10-15
op
addr4.sin_port = htons(port);
156
2020-10-15
op
addr4.sin_addr.s_addr = INADDR_ANY;
157
2020-10-15
op
addr = (struct sockaddr*)&addr4;
158
2020-10-15
op
len = sizeof(addr4);
159
2020-10-15
op
break;
160
2020-10-15
op
161
2020-10-15
op
case AF_INET6:
162
2021-09-24
op
memset(&addr6, 0, sizeof(addr6));
163
2020-10-15
op
addr6.sin6_family = AF_INET6;
164
2020-10-15
op
addr6.sin6_port = htons(port);
165
2020-10-15
op
addr6.sin6_addr = in6addr_any;
166
2020-10-15
op
addr = (struct sockaddr*)&addr6;
167
2020-10-15
op
len = sizeof(addr6);
168
2020-10-15
op
break;
169
2020-10-15
op
170
2020-10-15
op
default:
171
2020-10-15
op
/* unreachable */
172
2020-10-15
op
abort();
173
2020-10-15
op
}
174
2020-10-15
op
175
2020-10-15
op
if ((sock = socket(family, SOCK_STREAM, 0)) == -1)
176
2021-01-10
op
fatal("socket: %s", strerror(errno));
177
2020-10-02
op
178
2020-10-02
op
v = 1;
179
2020-10-02
op
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(v)) == -1)
180
2021-01-10
op
fatal("setsockopt(SO_REUSEADDR): %s", strerror(errno));
181
2020-10-02
op
182
2020-10-02
op
v = 1;
183
2020-10-02
op
if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &v, sizeof(v)) == -1)
184
2021-01-10
op
fatal("setsockopt(SO_REUSEPORT): %s", strerror(errno));
185
2020-10-02
op
186
2020-10-07
op
mark_nonblock(sock);
187
2020-10-07
op
188
2020-10-15
op
if (bind(sock, addr, len) == -1)
189
2021-01-10
op
fatal("bind: %s", strerror(errno));
190
2020-10-02
op
191
2020-10-02
op
if (listen(sock, 16) == -1)
192
2021-01-10
op
fatal("listen: %s", strerror(errno));
193
2020-10-02
op
194
2020-10-02
op
return sock;
195
2020-10-02
op
}
196
2020-10-02
op
197
2021-10-15
op
static void
198
2021-10-15
op
add_keypair(struct vhost *h)
199
2021-10-15
op
{
200
2021-10-15
op
if (h->ocsp == NULL) {
201
2021-10-15
op
if (tls_config_add_keypair_file(tlsconf, h->cert, h->key) == -1)
202
2021-10-15
op
fatal("failed to load the keypair (%s, %s)",
203
2021-10-15
op
h->cert, h->key);
204
2021-10-15
op
} else {
205
2021-10-15
op
if (tls_config_add_keypair_ocsp_file(tlsconf, h->cert, h->key,
206
2021-10-15
op
h->ocsp) == -1)
207
2021-10-15
op
fatal("failed to load the keypair (%s, %s, %s)",
208
2021-10-15
op
h->cert, h->key, h->ocsp);
209
2021-10-15
op
}
210
2021-10-15
op
}
211
2021-10-15
op
212
2021-01-25
op
void
213
2021-01-25
op
setup_tls(void)
214
2021-01-16
op
{
215
2021-01-25
op
struct vhost *h;
216
2021-01-16
op
217
2021-01-16
op
if ((tlsconf = tls_config_new()) == NULL)
218
2021-01-18
op
fatal("tls_config_new");
219
2021-01-16
op
220
2021-01-16
op
/* optionally accept client certs, but don't try to verify them */
221
2021-01-16
op
tls_config_verify_client_optional(tlsconf);
222
2021-01-16
op
tls_config_insecure_noverifycert(tlsconf);
223
2021-01-16
op
224
2021-01-16
op
if (tls_config_set_protocols(tlsconf, conf.protos) == -1)
225
2021-01-18
op
fatal("tls_config_set_protocols");
226
2021-01-16
op
227
2021-01-16
op
if ((ctx = tls_server()) == NULL)
228
2021-01-18
op
fatal("tls_server failure");
229
2021-01-16
op
230
2021-03-31
op
h = TAILQ_FIRST(&hosts);
231
2021-03-31
op
232
2021-01-25
op
/* we need to set something, then we can add how many key we want */
233
2021-03-31
op
if (tls_config_set_keypair_file(tlsconf, h->cert, h->key))
234
2021-02-04
op
fatal("tls_config_set_keypair_file failed for (%s, %s)",
235
2021-03-31
op
h->cert, h->key);
236
2021-10-15
op
237
2021-10-15
op
/* same for OCSP */
238
2021-10-15
op
if (h->ocsp != NULL &&
239
2021-10-15
op
tls_config_set_ocsp_staple_file(tlsconf, h->ocsp) == -1)
240
2021-10-15
op
fatal("tls_config_set_ocsp_staple_file failed for (%s)",
241
2021-10-15
op
h->ocsp);
242
2021-01-16
op
243
2021-10-15
op
while ((h = TAILQ_NEXT(h, vhosts)) != NULL)
244
2021-10-15
op
add_keypair(h);
245
2021-01-25
op
246
2021-01-16
op
if (tls_configure(ctx, tlsconf) == -1)
247
2021-01-18
op
fatal("tls_configure: %s", tls_error(ctx));
248
2021-01-25
op
}
249
2021-01-16
op
250
2021-02-03
op
static int
251
2021-03-19
op
listener_main(struct imsgbuf *ibuf)
252
2021-01-25
op
{
253
2021-02-07
op
drop_priv();
254
2022-04-08
op
if (!conf.mime.skip_defaults && load_default_mime(&conf.mime) == -1)
255
2022-04-08
op
fatal("load_default_mime: %s", strerror(errno));
256
2022-04-08
op
sort_mime(&conf.mime);
257
2021-01-25
op
load_vhosts();
258
2021-03-19
op
loop(ctx, sock4, sock6, ibuf);
259
2021-01-16
op
return 0;
260
2020-10-02
op
}
261
2020-10-02
op
262
2021-01-24
op
void
263
2021-01-24
op
init_config(void)
264
2020-10-02
op
{
265
2021-03-31
op
TAILQ_INIT(&hosts);
266
2020-12-21
op
267
2021-01-15
op
conf.port = 1965;
268
2021-01-15
op
conf.ipv6 = 0;
269
2021-01-15
op
conf.protos = TLS_PROTOCOL_TLSv1_2 | TLS_PROTOCOL_TLSv1_3;
270
2021-01-11
op
271
2021-01-21
op
init_mime(&conf.mime);
272
2021-01-25
op
273
2021-01-25
op
conf.chroot = NULL;
274
2021-01-25
op
conf.user = NULL;
275
2021-02-07
op
276
2021-02-07
op
conf.prefork = 3;
277
2021-01-24
op
}
278
2021-01-18
op
279
2021-01-25
op
void
280
2021-02-04
op
free_config(void)
281
2021-02-04
op
{
282
2021-03-31
op
struct vhost *h, *th;
283
2021-03-31
op
struct location *l, *tl;
284
2021-01-02
op
struct proxy *p, *tp;
285
2021-04-28
op
struct envlist *e, *te;
286
2021-04-29
op
struct alist *a, *ta;
287
2021-05-09
op
int v, i;
288
2021-02-04
op
289
2021-04-28
op
v = conf.verbose;
290
2021-04-28
op
291
2022-04-08
op
free_mime(&conf.mime);
292
2021-02-04
op
free(conf.chroot);
293
2021-02-04
op
free(conf.user);
294
2021-02-04
op
memset(&conf, 0, sizeof(conf));
295
2021-04-28
op
296
2021-04-28
op
conf.verbose = v;
297
2021-02-04
op
298
2021-03-31
op
TAILQ_FOREACH_SAFE(h, &hosts, vhosts, th) {
299
2021-03-31
op
TAILQ_FOREACH_SAFE(l, &h->locations, locations, tl) {
300
2021-03-31
op
TAILQ_REMOVE(&h->locations, l, locations);
301
2021-02-04
op
302
2021-02-04
op
free((char*)l->match);
303
2021-02-04
op
free((char*)l->lang);
304
2021-02-04
op
free((char*)l->default_mime);
305
2021-02-04
op
free((char*)l->index);
306
2021-02-06
op
free((char*)l->block_fmt);
307
2021-04-30
op
free((char*)l->dir);
308
2021-04-30
op
309
2021-04-30
op
if (l->dirfd != -1)
310
2021-04-30
op
close(l->dirfd);
311
2021-04-30
op
312
2021-03-31
op
free(l);
313
2021-02-04
op
}
314
2021-03-31
op
315
2021-04-28
op
TAILQ_FOREACH_SAFE(e, &h->env, envs, te) {
316
2021-06-12
op
TAILQ_REMOVE(&h->env, e, envs);
317
2021-06-12
op
318
2021-06-12
op
free(e->name);
319
2021-06-12
op
free(e->value);
320
2021-06-12
op
free(e);
321
2021-06-12
op
}
322
2021-06-12
op
323
2021-06-12
op
TAILQ_FOREACH_SAFE(e, &h->params, envs, te) {
324
2021-06-12
op
TAILQ_REMOVE(&h->params, e, envs);
325
2021-06-12
op
326
2021-04-28
op
free(e->name);
327
2021-04-28
op
free(e->value);
328
2021-04-28
op
free(e);
329
2021-04-29
op
}
330
2021-04-29
op
331
2021-04-29
op
TAILQ_FOREACH_SAFE(a, &h->aliases, aliases, ta) {
332
2021-06-12
op
TAILQ_REMOVE(&h->aliases, a, aliases);
333
2021-06-12
op
334
2021-04-29
op
free(a->alias);
335
2021-04-29
op
free(a);
336
2021-01-02
op
}
337
2021-01-02
op
338
2021-01-02
op
TAILQ_FOREACH_SAFE(p, &h->proxies, proxies, tp) {
339
2021-01-02
op
TAILQ_REMOVE(&h->proxies, p, proxies);
340
2021-01-02
op
341
2021-01-02
op
free(p->match_proto);
342
2021-01-02
op
free(p->match_host);
343
2021-01-02
op
free(p->host);
344
2022-01-30
op
free(p->sni);
345
2021-01-02
op
tls_unload_file(p->cert, p->certlen);
346
2021-01-02
op
tls_unload_file(p->key, p->keylen);
347
2021-01-02
op
free(p);
348
2021-04-28
op
}
349
2021-04-28
op
350
2021-04-30
op
free((char*)h->domain);
351
2021-04-30
op
free((char*)h->cert);
352
2021-04-30
op
free((char*)h->key);
353
2021-10-24
op
free((char*)h->ocsp);
354
2021-04-30
op
free((char*)h->cgi);
355
2021-04-30
op
free((char*)h->entrypoint);
356
2021-04-30
op
357
2021-03-31
op
TAILQ_REMOVE(&hosts, h, vhosts);
358
2021-03-31
op
free(h);
359
2021-05-09
op
}
360
2021-05-09
op
361
2021-05-09
op
for (i = 0; i < FCGI_MAX; ++i) {
362
2021-05-09
op
if (fcgi[i].path == NULL && fcgi[i].prog == NULL)
363
2021-05-09
op
break;
364
2021-05-09
op
free(fcgi[i].path);
365
2021-05-09
op
free(fcgi[i].port);
366
2021-05-09
op
free(fcgi[i].prog);
367
2021-07-06
op
368
2021-07-06
op
fcgi[i].path = NULL;
369
2021-07-06
op
fcgi[i].port = NULL;
370
2021-07-06
op
fcgi[i].prog = NULL;
371
2021-02-04
op
}
372
2021-02-04
op
373
2021-02-04
op
tls_free(ctx);
374
2021-02-04
op
tls_config_free(tlsconf);
375
2021-02-04
op
}
376
2021-02-04
op
377
2021-03-20
op
static int
378
2021-03-20
op
wait_signal(void)
379
2021-02-04
op
{
380
2021-02-04
op
sigset_t mask;
381
2021-02-04
op
int signo;
382
2021-02-04
op
383
2021-02-04
op
sigemptyset(&mask);
384
2021-02-04
op
sigaddset(&mask, SIGHUP);
385
2021-03-20
op
sigaddset(&mask, SIGINT);
386
2021-03-20
op
sigaddset(&mask, SIGTERM);
387
2021-02-04
op
sigwait(&mask, &signo);
388
2021-03-20
op
389
2021-03-20
op
return signo == SIGHUP;
390
2021-02-04
op
}
391
2021-02-04
op
392
2021-02-04
op
void
393
2021-01-25
op
drop_priv(void)
394
2021-01-25
op
{
395
2021-01-25
op
struct passwd *pw = NULL;
396
2021-01-25
op
397
2021-01-25
op
if (conf.chroot != NULL && conf.user == NULL)
398
2021-01-25
op
fatal("can't chroot without an user to switch to after.");
399
2021-01-25
op
400
2021-01-25
op
if (conf.user != NULL) {
401
2021-01-25
op
if ((pw = getpwnam(conf.user)) == NULL)
402
2021-01-25
op
fatal("can't find user %s", conf.user);
403
2021-01-25
op
}
404
2021-01-25
op
405
2021-01-25
op
if (conf.chroot != NULL) {
406
2021-01-25
op
if (chroot(conf.chroot) != 0 || chdir("/") != 0)
407
2021-01-25
op
fatal("%s: %s", conf.chroot, strerror(errno));
408
2021-01-25
op
}
409
2021-01-25
op
410
2021-01-25
op
if (pw != NULL) {
411
2021-01-25
op
if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) == -1)
412
2021-01-25
op
fatal("setresuid(%d): %s", pw->pw_uid,
413
2021-01-25
op
strerror(errno));
414
2021-01-25
op
}
415
2021-01-25
op
416
2021-01-25
op
if (getuid() == 0)
417
2021-02-07
op
log_warn(NULL, "not a good idea to run a network daemon as root");
418
2021-01-25
op
}
419
2021-02-03
op
420
2021-02-07
op
static void
421
2021-06-29
op
usage(void)
422
2021-02-07
op
{
423
2021-02-07
op
fprintf(stderr,
424
2021-06-29
op
"Version: " GMID_STRING "\n"
425
2021-06-29
op
"Usage: %s [-fnv] [-c config] [-D macro=value] [-P pidfile]\n"
426
2021-06-29
op
" %s [-6hVv] [-d certs-dir] [-H hostname] [-p port] [-x cgi] [dir]\n",
427
2021-06-29
op
getprogname(),
428
2021-06-29
op
getprogname());
429
2021-02-07
op
}
430
2021-02-07
op
431
2021-02-23
op
static void
432
2021-02-23
op
logger_init(void)
433
2021-02-23
op
{
434
2021-02-23
op
int p[2];
435
2021-02-23
op
436
2021-02-23
op
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, p) == -1)
437
2021-02-23
op
err(1, "socketpair");
438
2021-02-23
op
439
2021-02-23
op
switch (fork()) {
440
2021-02-23
op
case -1:
441
2021-02-23
op
err(1, "fork");
442
2021-02-23
op
case 0:
443
2021-03-19
op
signal(SIGHUP, SIG_IGN);
444
2021-02-23
op
close(p[0]);
445
2021-02-23
op
setproctitle("logger");
446
2021-03-19
op
imsg_init(&logibuf, p[1]);
447
2021-02-23
op
drop_priv();
448
2021-03-19
op
_exit(logger_main(p[1], &logibuf));
449
2021-02-23
op
default:
450
2021-02-23
op
close(p[1]);
451
2021-03-19
op
imsg_init(&logibuf, p[0]);
452
2021-02-23
op
return;
453
2021-02-23
op
}
454
2021-02-23
op
}
455
2021-02-23
op
456
2021-02-03
op
static int
457
2021-03-19
op
serve(int argc, char **argv, struct imsgbuf *ibuf)
458
2021-02-03
op
{
459
2021-03-31
op
char path[PATH_MAX];
460
2021-03-31
op
int i, p[2];
461
2021-03-31
op
struct vhost *h;
462
2021-03-31
op
struct location *l;
463
2021-02-03
op
464
2021-09-24
op
if (config_path == NULL) {
465
2021-02-03
op
if (hostname == NULL)
466
2021-02-03
op
hostname = "localhost";
467
2021-02-03
op
if (certs_dir == NULL)
468
2021-02-03
op
certs_dir = data_dir();
469
2021-02-03
op
load_local_cert(hostname, certs_dir);
470
2021-02-03
op
471
2021-03-31
op
h = TAILQ_FIRST(&hosts);
472
2021-03-31
op
h->domain = "*";
473
2021-02-03
op
474
2021-03-31
op
l = TAILQ_FIRST(&h->locations);
475
2021-03-31
op
l->auto_index = 1;
476
2021-03-31
op
l->match = "*";
477
2021-03-31
op
478
2021-02-03
op
switch (argc) {
479
2021-02-03
op
case 0:
480
2021-04-30
op
l->dir = getcwd(path, sizeof(path));
481
2021-02-03
op
break;
482
2021-02-03
op
case 1:
483
2021-04-30
op
l->dir = absolutify_path(argv[0]);
484
2021-02-03
op
break;
485
2021-02-03
op
default:
486
2021-06-29
op
usage();
487
2021-02-03
op
return 1;
488
2021-02-03
op
}
489
2021-01-25
op
490
2021-04-30
op
log_notice(NULL, "serving %s on port %d", l->dir, conf.port);
491
2021-02-03
op
}
492
2021-02-03
op
493
2021-02-03
op
/* setup tls before dropping privileges: we don't want user
494
2021-02-03
op
* to put private certs inside the chroot. */
495
2021-02-03
op
setup_tls();
496
2021-02-03
op
497
2021-03-03
op
for (i = 0; i < conf.prefork; ++i) {
498
2021-03-03
op
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC,
499
2021-03-03
op
PF_UNSPEC, p) == -1)
500
2021-03-03
op
fatal("socketpair: %s", strerror(errno));
501
2021-02-03
op
502
2021-03-03
op
switch (fork()) {
503
2021-03-03
op
case -1:
504
2021-03-03
op
fatal("fork: %s", strerror(errno));
505
2021-03-03
op
case 0: /* child */
506
2021-03-03
op
close(p[0]);
507
2021-03-19
op
imsg_init(&exibuf, p[1]);
508
2021-03-03
op
setproctitle("server");
509
2021-03-19
op
_exit(listener_main(&exibuf));
510
2021-03-03
op
default:
511
2021-03-03
op
close(p[1]);
512
2021-03-19
op
imsg_init(&servibuf[i], p[0]);
513
2021-03-03
op
}
514
2021-02-03
op
}
515
2021-03-03
op
516
2021-03-03
op
setproctitle("executor");
517
2021-03-03
op
drop_priv();
518
2021-03-19
op
_exit(executor_main(ibuf));
519
2021-02-03
op
}
520
2021-04-28
op
521
2021-04-28
op
static int
522
2021-04-28
op
write_pidfile(const char *pidfile)
523
2021-04-28
op
{
524
2021-04-28
op
struct flock lock;
525
2021-04-28
op
int fd;
526
2021-02-03
op
527
2021-04-28
op
if (pidfile == NULL)
528
2021-04-28
op
return -1;
529
2021-04-28
op
530
2021-04-28
op
if ((fd = open(pidfile, O_WRONLY|O_CREAT|O_CLOEXEC, 0600)) == -1)
531
2021-04-28
op
fatal("can't open pidfile %s: %s", pidfile, strerror(errno));
532
2021-04-28
op
533
2021-04-28
op
lock.l_start = 0;
534
2021-04-28
op
lock.l_len = 0;
535
2021-04-28
op
lock.l_type = F_WRLCK;
536
2021-04-28
op
lock.l_whence = SEEK_SET;
537
2021-04-28
op
538
2021-04-28
op
if (fcntl(fd, F_SETLK, &lock) == -1)
539
2021-04-28
op
fatal("can't lock %s, gmid is already running?", pidfile);
540
2021-04-28
op
541
2021-04-28
op
if (ftruncate(fd, 0) == -1)
542
2021-04-28
op
fatal("ftruncate: %s: %s", pidfile, strerror(errno));
543
2021-04-28
op
544
2021-04-28
op
dprintf(fd, "%d\n", getpid());
545
2021-04-28
op
546
2021-04-28
op
return fd;
547
2021-04-28
op
}
548
2021-04-28
op
549
2021-03-31
op
static void
550
2021-03-31
op
setup_configless(int argc, char **argv, const char *cgi)
551
2021-03-31
op
{
552
2021-03-31
op
struct vhost *host;
553
2021-03-31
op
struct location *loc;
554
2021-03-31
op
555
2021-03-31
op
host = xcalloc(1, sizeof(*host));
556
2021-03-31
op
host->cgi = cgi;
557
2021-03-31
op
TAILQ_INSERT_HEAD(&hosts, host, vhosts);
558
2021-03-31
op
559
2021-03-31
op
loc = xcalloc(1, sizeof(*loc));
560
2021-07-19
op
loc->fcgi = -1;
561
2021-03-31
op
TAILQ_INSERT_HEAD(&host->locations, loc, locations);
562
2021-06-15
op
563
2021-03-31
op
serve(argc, argv, NULL);
564
2021-06-15
op
565
2021-03-31
op
imsg_compose(&logibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
566
2021-03-31
op
imsg_flush(&logibuf);
567
2021-07-09
op
}
568
2021-07-09
op
569
2021-07-09
op
static int
570
2021-07-09
op
parse_portno(const char *p)
571
2021-07-09
op
{
572
2021-07-09
op
const char *errstr;
573
2021-07-09
op
int n;
574
2021-07-09
op
575
2021-07-09
op
n = strtonum(p, 0, UINT16_MAX, &errstr);
576
2021-07-09
op
if (errstr != NULL)
577
2021-07-09
op
yyerror("port number is %s: %s", errstr, p);
578
2021-07-09
op
return n;
579
2021-03-31
op
}
580
2021-03-31
op
581
2021-01-24
op
int
582
2021-01-24
op
main(int argc, char **argv)
583
2021-01-24
op
{
584
2021-03-20
op
struct imsgbuf exibuf;
585
2021-03-03
op
int ch, conftest = 0, configless = 0;
586
2021-04-28
op
int pidfd, old_ipv6, old_port;
587
2021-01-24
op
588
2021-07-07
op
logger_init();
589
2021-01-24
op
init_config();
590
2021-01-24
op
591
2021-06-29
op
while ((ch = getopt_long(argc, argv, opts, longopts, NULL)) != -1) {
592
2020-10-02
op
switch (ch) {
593
2021-01-11
op
case '6':
594
2021-01-15
op
conf.ipv6 = 1;
595
2021-01-25
op
configless = 1;
596
2021-01-11
op
break;
597
2021-01-11
op
598
2020-10-02
op
case 'c':
599
2021-02-04
op
config_path = absolutify_path(optarg);
600
2020-10-02
op
break;
601
2020-10-02
op
602
2021-06-29
op
case 'D':
603
2021-06-29
op
if (cmdline_symset(optarg) == -1)
604
2021-07-07
op
fatal("could not parse macro definition: %s",
605
2021-07-07
op
optarg);
606
2021-06-29
op
break;
607
2021-06-29
op
608
2020-10-02
op
case 'd':
609
2021-01-25
op
certs_dir = optarg;
610
2021-01-25
op
configless = 1;
611
2020-10-02
op
break;
612
2020-10-02
op
613
2021-01-27
op
case 'f':
614
2021-02-07
op
conf.foreground = 1;
615
2021-01-27
op
break;
616
2021-01-27
op
617
2021-01-25
op
case 'H':
618
2021-01-25
op
hostname = optarg;
619
2021-01-25
op
configless = 1;
620
2020-12-02
op
break;
621
2020-12-02
op
622
2020-10-02
op
case 'h':
623
2021-06-29
op
usage();
624
2020-10-02
op
return 0;
625
2020-10-02
op
626
2021-01-15
op
case 'n':
627
2021-10-09
op
conftest++;
628
2020-11-18
op
break;
629
2020-11-18
op
630
2021-04-28
op
case 'P':
631
2021-04-28
op
pidfile = optarg;
632
2021-04-28
op
break;
633
2021-04-28
op
634
2021-01-15
op
case 'p':
635
2021-01-15
op
conf.port = parse_portno(optarg);
636
2021-01-25
op
configless = 1;
637
2021-01-17
op
break;
638
2021-01-15
op
639
2021-06-29
op
case 'V':
640
2021-06-29
op
puts("Version: " GMID_STRING);
641
2021-06-29
op
return 0;
642
2021-06-29
op
643
2021-01-27
op
case 'v':
644
2021-02-07
op
conf.verbose++;
645
2021-01-27
op
break;
646
2021-01-27
op
647
2020-11-06
op
case 'x':
648
2021-01-15
op
/* drop the starting / (if any) */
649
2021-01-15
op
if (*optarg == '/')
650
2021-01-15
op
optarg++;
651
2021-03-31
op
cgi = optarg;
652
2021-01-25
op
configless = 1;
653
2020-11-06
op
break;
654
2020-11-06
op
655
2020-10-02
op
default:
656
2021-06-29
op
usage();
657
2020-10-02
op
return 1;
658
2020-10-02
op
}
659
2020-10-02
op
}
660
2021-01-25
op
argc -= optind;
661
2021-01-25
op
argv += optind;
662
2020-10-02
op
663
2021-02-03
op
if (config_path == NULL) {
664
2021-01-27
op
configless = 1;
665
2021-02-07
op
conf.foreground = 1;
666
2021-03-03
op
conf.prefork = 1;
667
2021-02-07
op
conf.verbose++;
668
2021-01-15
op
}
669
2021-01-15
op
670
2021-02-03
op
if (config_path != NULL && (argc > 0 || configless))
671
2021-07-07
op
fatal("can't specify options in config mode.");
672
2021-02-03
op
673
2021-01-18
op
if (conftest) {
674
2021-08-23
op
if (config_path == NULL)
675
2021-08-23
op
fatal("missing configuration");
676
2021-02-03
op
parse_conf(config_path);
677
2021-10-09
op
fprintf(stderr, "config OK\n");
678
2021-10-09
op
if (conftest > 1)
679
2021-10-09
op
print_conf();
680
2021-01-18
op
return 0;
681
2021-01-18
op
}
682
2020-12-28
op
683
2021-02-07
op
if (!conf.foreground && !configless) {
684
2021-07-07
op
/* log to syslog */
685
2021-07-07
op
imsg_compose(&logibuf, IMSG_LOG_TYPE, 0, 0, -1, NULL, 0);
686
2021-07-07
op
imsg_flush(&logibuf);
687
2021-07-07
op
688
2021-01-17
op
if (daemon(1, 1) == -1)
689
2021-07-07
op
fatal("daemon: %s", strerror(errno));
690
2021-01-17
op
}
691
2020-12-28
op
692
2021-02-03
op
if (config_path != NULL)
693
2021-02-03
op
parse_conf(config_path);
694
2020-12-02
op
695
2021-02-03
op
sock4 = make_socket(conf.port, AF_INET);
696
2021-02-03
op
sock6 = -1;
697
2021-02-03
op
if (conf.ipv6)
698
2021-02-03
op
sock6 = make_socket(conf.port, AF_INET6);
699
2020-10-02
op
700
2021-04-20
op
signal(SIGPIPE, SIG_IGN);
701
2021-04-20
op
signal(SIGCHLD, SIG_IGN);
702
2021-04-20
op
703
2021-03-19
op
if (configless) {
704
2021-03-31
op
setup_configless(argc, argv, cgi);
705
2021-03-19
op
return 0;
706
2021-03-19
op
}
707
2021-02-04
op
708
2021-04-28
op
pidfd = write_pidfile(pidfile);
709
2021-04-28
op
710
2021-07-07
op
/*
711
2021-07-07
op
* Linux seems to call the event handlers even when we're
712
2021-04-26
op
* doing a sigwait. These dummy handlers are here to avoid
713
2021-07-07
op
* being terminated on SIGHUP, SIGINT or SIGTERM.
714
2021-07-07
op
*/
715
2021-03-20
op
signal(SIGHUP, dummy_handler);
716
2021-03-20
op
signal(SIGINT, dummy_handler);
717
2021-03-20
op
signal(SIGTERM, dummy_handler);
718
2021-03-20
op
719
2021-02-04
op
/* wait a sighup and reload the daemon */
720
2021-02-04
op
for (;;) {
721
2021-03-19
op
int p[2];
722
2021-02-04
op
723
2021-03-19
op
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC,
724
2021-03-19
op
PF_UNSPEC, p) == -1)
725
2021-03-19
op
fatal("socketpair: %s", strerror(errno));
726
2021-03-19
op
727
2021-02-04
op
switch (fork()) {
728
2021-02-04
op
case -1:
729
2021-02-04
op
fatal("fork: %s", strerror(errno));
730
2021-02-04
op
case 0:
731
2021-03-19
op
close(p[0]);
732
2021-03-19
op
imsg_init(&exibuf, p[1]);
733
2021-03-19
op
_exit(serve(argc, argv, &exibuf));
734
2021-02-04
op
}
735
2021-02-04
op
736
2021-03-19
op
close(p[1]);
737
2021-03-19
op
imsg_init(&exibuf, p[0]);
738
2021-03-19
op
739
2021-03-20
op
if (!wait_signal())
740
2021-03-20
op
break;
741
2021-03-20
op
742
2021-02-07
op
log_info(NULL, "reloading configuration %s", config_path);
743
2021-02-04
op
744
2021-03-19
op
/* close the executor (it'll close the servers too) */
745
2021-03-19
op
imsg_compose(&exibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
746
2021-03-19
op
imsg_flush(&exibuf);
747
2021-03-19
op
close(p[0]);
748
2021-03-19
op
749
2021-02-04
op
old_ipv6 = conf.ipv6;
750
2021-02-04
op
old_port = conf.port;
751
2021-02-04
op
752
2021-02-04
op
free_config();
753
2021-02-04
op
init_config();
754
2021-02-04
op
parse_conf(config_path);
755
2021-02-04
op
756
2021-02-04
op
if (old_port != conf.port) {
757
2021-02-04
op
close(sock4);
758
2021-02-04
op
close(sock6);
759
2021-02-04
op
sock4 = -1;
760
2021-02-04
op
sock6 = -1;
761
2021-02-04
op
}
762
2021-02-04
op
763
2021-02-04
op
if (sock6 != -1 && old_ipv6 != conf.ipv6) {
764
2021-02-04
op
close(sock6);
765
2021-02-04
op
sock6 = -1;
766
2021-02-04
op
}
767
2021-02-04
op
768
2021-02-04
op
if (sock4 == -1)
769
2021-02-04
op
sock4 = make_socket(conf.port, AF_INET);
770
2021-02-04
op
if (sock6 == -1 && conf.ipv6)
771
2021-02-04
op
sock6 = make_socket(conf.port, AF_INET6);
772
2021-02-04
op
}
773
2021-03-20
op
774
2021-03-20
op
imsg_compose(&exibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
775
2021-03-20
op
imsg_flush(&exibuf);
776
2021-03-20
op
777
2021-03-20
op
imsg_compose(&logibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
778
2021-03-20
op
imsg_flush(&logibuf);
779
2021-03-20
op
780
2021-04-28
op
if (pidfd != -1)
781
2021-04-28
op
close(pidfd);
782
2021-04-28
op
783
2021-03-20
op
return 0;
784
2020-10-02
op
}
Omar Polo