1 /*
2  * Copyright (c) 2023 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include "gmid.h"
18 
19 #include <sys/stat.h>
20 
21 #include <fcntl.h>
22 #include <limits.h>
23 #include <string.h>
24 
25 #include <openssl/pem.h>
26 
27 #include "log.h"
28 #include "proc.h"
29 
30 struct conf *
31 config_new(void)
32 {
33 	struct conf *conf;
34 
35 	conf = xcalloc(1, sizeof(*conf));
36 
37 	TAILQ_INIT(&conf->fcgi);
38 	TAILQ_INIT(&conf->hosts);
39 	TAILQ_INIT(&conf->pkis);
40 	TAILQ_INIT(&conf->addrs);
41 
42 	conf->protos = TLS_PROTOCOL_TLSv1_2 | TLS_PROTOCOL_TLSv1_3;
43 
44 	init_mime(&conf->mime);
45 
46 	conf->prefork = 3;
47 
48 #ifdef __OpenBSD__
49 	conf->use_privsep_crypto = 1;
50 #endif
51 
52 	return conf;
53 }
54 
55 void
56 config_purge(struct conf *conf)
57 {
58 	struct privsep *ps;
59 	struct fcgi *f, *tf;
60 	struct vhost *h, *th;
61 	struct location *l, *tl;
62 	struct proxy *p, *tp;
63 	struct envlist *e, *te;
64 	struct alist *a, *ta;
65 	struct pki *pki, *tpki;
66 	struct address *addr, *taddr;
67 	int use_privsep_crypto;
68 
69 	ps = conf->ps;
70 	use_privsep_crypto = conf->use_privsep_crypto;
71 
72 	free_mime(&conf->mime);
73 	TAILQ_FOREACH_SAFE(f, &conf->fcgi, fcgi, tf) {
74 		TAILQ_REMOVE(&conf->fcgi, f, fcgi);
75 		free(f);
76 	}
77 
78 	TAILQ_FOREACH_SAFE(h, &conf->hosts, vhosts, th) {
79 		free(h->cert_path);
80 		free(h->key_path);
81 		free(h->ocsp_path);
82 		free(h->cert);
83 		free(h->key);
84 		free(h->ocsp);
85 
86 		TAILQ_FOREACH_SAFE(addr, &h->addrs, addrs, taddr) {
87 			TAILQ_REMOVE(&h->addrs, addr, addrs);
88 			free(addr);
89 		}
90 
91 		TAILQ_FOREACH_SAFE(l, &h->locations, locations, tl) {
92 			TAILQ_REMOVE(&h->locations, l, locations);
93 
94 			if (l->dirfd != -1)
95 				close(l->dirfd);
96 
97 			free(l->reqca_path);
98 			X509_STORE_free(l->reqca);
99 			free(l);
100 		}
101 
102 		TAILQ_FOREACH_SAFE(e, &h->params, envs, te) {
103 			TAILQ_REMOVE(&h->params, e, envs);
104 			free(e);
105 		}
106 
107 		TAILQ_FOREACH_SAFE(a, &h->aliases, aliases, ta) {
108 			TAILQ_REMOVE(&h->aliases, a, aliases);
109 			free(a);
110 		}
111 
112 		TAILQ_FOREACH_SAFE(p, &h->proxies, proxies, tp) {
113 			TAILQ_REMOVE(&h->proxies, p, proxies);
114 			free(p->cert_path);
115 			free(p->cert);
116 			free(p->key_path);
117 			free(p->key);
118 			free(p->reqca_path);
119 			X509_STORE_free(p->reqca);
120 			free(p);
121 		}
122 
123 		TAILQ_REMOVE(&conf->hosts, h, vhosts);
124 		free(h);
125 	}
126 
127 	TAILQ_FOREACH_SAFE(pki, &conf->pkis, pkis, tpki) {
128 		TAILQ_REMOVE(&conf->pkis, pki, pkis);
129 		free(pki->hash);
130 		EVP_PKEY_free(pki->pkey);
131 		free(pki);
132 	}
133 
134 	TAILQ_FOREACH_SAFE(addr, &conf->addrs, addrs, taddr) {
135 		TAILQ_REMOVE(&conf->addrs, addr, addrs);
136 		if (addr->sock != -1) {
137 			close(addr->sock);
138 			event_del(&addr->evsock);
139 			tls_free(addr->ctx);
140 		}
141 		free(addr);
142 	}
143 
144 	memset(conf, 0, sizeof(*conf));
145 
146 	conf->ps = ps;
147 	conf->use_privsep_crypto = use_privsep_crypto;
148 	conf->protos = TLS_PROTOCOL_TLSv1_2 | TLS_PROTOCOL_TLSv1_3;
149 	init_mime(&conf->mime);
150 	TAILQ_INIT(&conf->fcgi);
151 	TAILQ_INIT(&conf->hosts);
152 	TAILQ_INIT(&conf->pkis);
153 }
154 
155 static int
156 config_send_file(struct privsep *ps, enum privsep_procid id, int type,
157     int fd, void *data, size_t l)
158 {
159 	int	 n, m, d;
160 
161 	n = -1;
162 	proc_range(ps, id, &n, &m);
163 	for (n = 0; n < m; ++n) {
164 		d = -1;
165 		if (fd != -1 && (d = dup(fd)) == -1)
166 			fatal("dup %d", fd);
167 		if (proc_compose_imsg(ps, id, n, type, -1, d, data, l)
168 		    == -1)
169 			return -1;
170 	}
171 
172 	if (fd != -1)
173 		close(fd);
174 
175 	/* avoid fd rampage */
176 	if (proc_flush_imsg(ps, id, -1) == -1) {
177 		log_warn("%s: proc_fush_imsg", __func__);
178 		return -1;
179 	}
180 
181 	return 0;
182 }
183 
184 static int
185 config_open_send(struct privsep *ps, enum privsep_procid id, int type,
186     const char *path)
187 {
188 	int fd;
189 
190 	log_debug("sending %s", path);
191 
192 	if ((fd = open(path, O_RDONLY)) == -1)
193 		fatal("can't open %s", path);
194 
195 	return config_send_file(ps, id, type, fd, NULL, 0);
196 }
197 
198 static int
199 config_send_kp(struct privsep *ps, int cert_type, int key_type,
200     const char *cert, const char *key)
201 {
202 	struct conf *conf = ps->ps_env;
203 	int fd, d, key_target;
204 
205 	log_debug("sending %s", cert);
206 	if ((fd = open(cert, O_RDONLY)) == -1)
207 		fatal("can't open %s", cert);
208 	if ((d = dup(fd)) == -1)
209 		fatal("fd");
210 
211 	if (config_send_file(ps, PROC_SERVER, cert_type, fd, NULL, 0) == -1) {
212 		close(d);
213 		return -1;
214 	}
215 	if (conf->use_privsep_crypto &&
216 	    config_send_file(ps, PROC_CRYPTO, cert_type, d, NULL, 0) == -1)
217 		return -1;
218 
219 	key_target = PROC_CRYPTO;
220 	if (!conf->use_privsep_crypto)
221 		key_target = PROC_SERVER;
222 
223 	if (config_open_send(ps, key_target, key_type, key) == -1)
224 		return -1;
225 
226 	return 0;
227 }
228 
229 static int
230 config_send_socks(struct conf *conf)
231 {
232 	struct privsep	*ps = conf->ps;
233 	struct address	*addr, a;
234 	int		 sock, v;
235 
236 	TAILQ_FOREACH(addr, &conf->addrs, addrs) {
237 		sock = socket(addr->ai_family, addr->ai_socktype,
238 		    addr->ai_protocol);
239 		if (sock == -1)
240 			fatal("socket");
241 
242 		v = 1;
243 		if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(v))
244 		    == -1)
245 			fatal("setsockopt(SO_REUSEADDR)");
246 
247 		v = 1;
248 		if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &v, sizeof(v))
249 		    == -1)
250 			fatal("setsockopt(SO_REUSEPORT)");
251 
252 		mark_nonblock(sock);
253 
254 		if (bind(sock, (struct sockaddr *)&addr->ss, addr->slen)
255 		    == -1)
256 			fatal("bind");
257 
258 		if (listen(sock, 16) == -1)
259 			fatal("listen");
260 
261 		memcpy(&a, addr, sizeof(a));
262 		a.conf = NULL;
263 		a.sock = -1;
264 		memset(&a.evsock, 0, sizeof(a.evsock));
265 		memset(&a.addrs, 0, sizeof(a.addrs));
266 
267 		if (config_send_file(ps, PROC_SERVER, IMSG_RECONF_SOCK, sock,
268 		    &a, sizeof(a)) == -1)
269 			return -1;
270 	}
271 
272 	return 0;
273 }
274 
275 int
276 config_send(struct conf *conf)
277 {
278 	struct privsep	*ps = conf->ps;
279 	struct etm	*m;
280 	struct fcgi	*fcgi;
281 	struct vhost	*h;
282 	struct location	*l;
283 	struct proxy	*p;
284 	struct envlist	*e;
285 	struct alist	*a;
286 	size_t		 i;
287 
288 	for (i = 0; i < conf->mime.len; ++i) {
289 		m = &conf->mime.t[i];
290 		if (proc_compose(ps, PROC_SERVER, IMSG_RECONF_MIME,
291 		    m, sizeof(*m)) == -1)
292 			return -1;
293 	}
294 
295 	if (proc_compose(ps, PROC_SERVER, IMSG_RECONF_PROTOS,
296 	    &conf->protos, sizeof(conf->protos)) == -1)
297 		return -1;
298 
299 	if (config_send_socks(conf) == -1)
300 		return -1;
301 
302 	TAILQ_FOREACH(fcgi, &conf->fcgi, fcgi) {
303 		log_debug("sending fastcgi %s", fcgi->path);
304 		if (proc_compose(ps, PROC_SERVER, IMSG_RECONF_FCGI,
305 		    fcgi, sizeof(*fcgi)) == -1)
306 			return -1;
307 	}
308 
309 	TAILQ_FOREACH(h, &conf->hosts, vhosts) {
310 		struct vhost vcopy;
311 		struct address *addr, acopy;
312 
313 		memcpy(&vcopy, h, sizeof(vcopy));
314 		vcopy.cert_path = NULL;
315 		vcopy.key_path = NULL;
316 		vcopy.ocsp_path = NULL;
317 
318 		log_debug("sending host %s", h->domain);
319 
320 		if (proc_compose(ps, PROC_SERVER, IMSG_RECONF_HOST,
321 		    &vcopy, sizeof(vcopy)) == -1)
322 			return -1;
323 
324 		if (config_send_kp(ps, IMSG_RECONF_CERT, IMSG_RECONF_KEY,
325 		    h->cert_path, h->key_path) == -1)
326 			return -1;
327 
328 		if (h->ocsp_path != NULL) {
329 			if (config_open_send(ps, PROC_SERVER, IMSG_RECONF_OCSP,
330 			    h->ocsp_path) == -1)
331 				return -1;
332 		}
333 
334 		TAILQ_FOREACH(addr, &h->addrs, addrs) {
335 			memcpy(&acopy, addr, sizeof(acopy));
336 			memset(&acopy.addrs, 0, sizeof(acopy.addrs));
337 
338 			if (proc_compose(ps, PROC_SERVER,
339 			    IMSG_RECONF_HOST_ADDR, &acopy, sizeof(acopy))
340 			    == -1)
341 				return -1;
342 		}
343 
344 		if (proc_flush_imsg(ps, PROC_SERVER, -1) == -1) {
345 			log_warn("%s: proc_fush_imsg", __func__);
346 			return -1;
347 		}
348 
349 		TAILQ_FOREACH(l, &h->locations, locations) {
350 			struct location lcopy;
351 			int fd = -1;
352 
353 			memcpy(&lcopy, l, sizeof(lcopy));
354 			lcopy.reqca_path = NULL;
355 			lcopy.reqca = NULL;
356 			lcopy.dirfd = -1;
357 			memset(&lcopy.locations, 0, sizeof(lcopy.locations));
358 
359 			if (l->reqca_path != NULL &&
360 			    (fd = open(l->reqca_path, O_RDONLY)) == -1)
361 				fatal("can't open %s", l->reqca_path);
362 
363 			if (config_send_file(ps, PROC_SERVER, IMSG_RECONF_LOC,
364 			    fd, &lcopy, sizeof(lcopy)) == -1)
365 				return -1;
366 		}
367 
368 		TAILQ_FOREACH(e, &h->params, envs) {
369 			if (proc_compose(ps, PROC_SERVER, IMSG_RECONF_ENV,
370 			    e, sizeof(*e)) == -1)
371 				return -1;
372 		}
373 
374 		if (proc_flush_imsg(ps, PROC_SERVER, -1) == -1)
375 			return -1;
376 
377 		TAILQ_FOREACH(a, &h->aliases, aliases) {
378 			if (proc_compose(ps, PROC_SERVER, IMSG_RECONF_ALIAS,
379 			    a, sizeof(*a)) == -1)
380 				return -1;
381 		}
382 
383 		if (proc_flush_imsg(ps, PROC_SERVER, -1) == -1)
384 			return -1;
385 
386 		TAILQ_FOREACH(p, &h->proxies, proxies) {
387 			struct proxy pcopy;
388 			int fd = -1;
389 
390 			memcpy(&pcopy, p, sizeof(pcopy));
391 			pcopy.cert_path = NULL;
392 			pcopy.cert = NULL;
393 			pcopy.certlen = 0;
394 			pcopy.key_path = NULL;
395 			pcopy.key = NULL;
396 			pcopy.keylen = 0;
397 			pcopy.reqca_path = NULL;
398 			pcopy.reqca = NULL;
399 
400 			if (p->reqca_path != NULL) {
401 				fd = open(p->reqca_path, O_RDONLY);
402 				if (fd == -1)
403 					fatal("can't open %s", p->reqca_path);
404 			}
405 
406 			if (config_send_file(ps, PROC_SERVER, IMSG_RECONF_PROXY,
407 			    fd, &pcopy, sizeof(pcopy)) == -1)
408 				return -1;
409 
410 			if (p->cert_path == NULL || p->key_path == NULL)
411 				continue;
412 
413 			if (config_open_send(ps, PROC_SERVER,
414 			    IMSG_RECONF_PROXY_CERT, p->cert_path) == -1 ||
415 			    config_open_send(ps, PROC_SERVER,
416 			    IMSG_RECONF_PROXY_KEY, p->key_path) == -1)
417 				return -1;
418 		}
419 	}
420 
421 	return 0;
422 }
423 
424 static int
425 load_file(int fd, uint8_t **data, size_t *len)
426 {
427 	struct stat	 sb;
428 	ssize_t		 r;
429 
430 	if (fstat(fd, &sb) == -1)
431 		fatal("fstat");
432 
433 	if (sb.st_size < 0 /* || sb.st_size > SIZE_MAX */) {
434 		log_warnx("file too large");
435 		close(fd);
436 		return -1;
437 	}
438 	*len = sb.st_size;
439 
440 	if ((*data = malloc(*len)) == NULL)
441 		fatal("malloc");
442 
443 	r = pread(fd, *data, *len, 0);
444 	if (r == -1 || (size_t)r != *len) {
445 		log_warn("read failed");
446 		close(fd);
447 		free(*data);
448 		return -1;
449 	}
450 
451 	close(fd);
452 	return 0;
453 }
454 
455 static int
456 config_crypto_recv_kp(struct conf *conf, struct imsg *imsg)
457 {
458 	static struct pki *pki;
459 	uint8_t *d;
460 	size_t len;
461 
462 	/* XXX: check for duplicates */
463 
464 	if (imsg->fd == -1)
465 		fatalx("no fd for imsg %d", imsg->hdr.type);
466 
467 	switch (imsg->hdr.type) {
468 	case IMSG_RECONF_CERT:
469 		if (pki != NULL)
470 			fatalx("imsg in wrong order; pki is not NULL");
471 		if ((pki = calloc(1, sizeof(*pki))) == NULL)
472 			fatal("calloc");
473 		if (load_file(imsg->fd, &d, &len) == -1)
474 			fatalx("can't load file");
475 		if ((pki->hash = ssl_pubkey_hash(d, len)) == NULL)
476 			fatalx("failed to compute cert hash");
477 		free(d);
478 		TAILQ_INSERT_TAIL(&conf->pkis, pki, pkis);
479 		break;
480 
481 	case IMSG_RECONF_KEY:
482 		if (pki == NULL)
483 			fatalx("got key without cert beforehand %d",
484 			    imsg->hdr.type);
485 		if (load_file(imsg->fd, &d, &len) == -1)
486 			fatalx("failed to load private key");
487 		if ((pki->pkey = ssl_load_pkey(d, len)) == NULL)
488 			fatalx("failed load private key");
489 		free(d);
490 		pki = NULL;
491 		break;
492 
493 	default:
494 		return -1;
495 	}
496 
497 	return 0;
498 }
499 
500 int
501 config_recv(struct conf *conf, struct imsg *imsg)
502 {
503 	static struct vhost *h;
504 	static struct proxy *p;
505 	struct privsep	*ps = conf->ps;
506 	struct etm	 m;
507 	struct fcgi	*fcgi;
508 	struct vhost	*vh, vht;
509 	struct location	*loc;
510 	struct envlist	*env;
511 	struct alist	*alias;
512 	struct proxy	*proxy;
513 	struct address	*addr;
514 	uint8_t		*d;
515 	size_t		 len, datalen;
516 
517 	datalen = IMSG_DATA_SIZE(imsg);
518 
519 	switch (imsg->hdr.type) {
520 	case IMSG_RECONF_START:
521 		config_purge(conf);
522 		h = NULL;
523 		p = NULL;
524 		break;
525 
526 	case IMSG_RECONF_MIME:
527 		IMSG_SIZE_CHECK(imsg, &m);
528 		memcpy(&m, imsg->data, datalen);
529 		if (m.mime[sizeof(m.mime) - 1] != '\0' ||
530 		    m.ext[sizeof(m.ext) - 1] != '\0')
531 			fatal("received corrupted IMSG_RECONF_MIME");
532 		if (add_mime(&conf->mime, m.mime, m.ext) == -1)
533 			fatal("failed to add mime mapping %s -> %s",
534 			    m.mime, m.ext);
535 		break;
536 
537 	case IMSG_RECONF_PROTOS:
538 		IMSG_SIZE_CHECK(imsg, &conf->protos);
539 		memcpy(&conf->protos, imsg->data, datalen);
540 		break;
541 
542 	case IMSG_RECONF_SOCK:
543 		addr = xcalloc(1, sizeof(*addr));
544 		IMSG_SIZE_CHECK(imsg, addr);
545 		memcpy(addr, imsg->data, sizeof(*addr));
546 		if (imsg->fd == -1)
547 			fatalx("missing socket for IMSG_RECONF_SOCK");
548 		addr->conf = conf;
549 		addr->sock = imsg->fd;
550 		event_set(&addr->evsock, addr->sock, EV_READ|EV_PERSIST,
551 		    do_accept, addr);
552 		if ((addr->ctx = tls_server()) == NULL)
553 			fatal("tls_server failure");
554 		TAILQ_INSERT_HEAD(&conf->addrs, addr, addrs);
555 		break;
556 
557 	case IMSG_RECONF_FCGI:
558 		IMSG_SIZE_CHECK(imsg, fcgi);
559 		fcgi = xcalloc(1, sizeof(*fcgi));
560 		memcpy(fcgi, imsg->data, datalen);
561 		log_debug("received fcgi %s", fcgi->path);
562 		TAILQ_INSERT_TAIL(&conf->fcgi, fcgi, fcgi);
563 		break;
564 
565 	case IMSG_RECONF_HOST:
566 		IMSG_SIZE_CHECK(imsg, &vht);
567 		memcpy(&vht, imsg->data, datalen);
568 		vh = new_vhost();
569 		strlcpy(vh->domain, vht.domain, sizeof(vh->domain));
570 		h = vh;
571 		TAILQ_INSERT_TAIL(&conf->hosts, h, vhosts);
572 
573 		/* reset proxy */
574 		p = NULL;
575 		break;
576 
577 	case IMSG_RECONF_CERT:
578 		log_debug("receiving cert");
579 		if (privsep_process == PROC_CRYPTO)
580 			return config_crypto_recv_kp(conf, imsg);
581 		if (h == NULL)
582 			fatalx("recv'd cert without host");
583 		if (h->cert != NULL)
584 			fatalx("cert already received");
585 		if (imsg->fd == -1)
586 			fatalx("no fd for IMSG_RECONF_CERT");
587 		if (load_file(imsg->fd, &h->cert, &h->certlen) == -1)
588 			fatalx("failed to load cert for %s",
589 			    h->domain);
590 		break;
591 
592 	case IMSG_RECONF_KEY:
593 		log_debug("receiving key");
594 		if (privsep_process == PROC_CRYPTO)
595 			return config_crypto_recv_kp(conf, imsg);
596 		if (h == NULL)
597 			fatalx("recv'd key without host");
598 		if (h->key != NULL)
599 			fatalx("key already received");
600 		if (imsg->fd == -1)
601 			fatalx("no fd for IMSG_RECONF_KEY");
602 		if (load_file(imsg->fd, &h->key, &h->keylen) == -1)
603 			fatalx("failed to load key for %s",
604 			    h->domain);
605 		break;
606 
607 	case IMSG_RECONF_OCSP:
608 		log_debug("receiving ocsp");
609 		if (h == NULL)
610 			fatalx("recv'd ocsp without host");
611 		if (h->ocsp != NULL)
612 			fatalx("ocsp already received");
613 		if (imsg->fd == -1)
614 			fatalx("no fd for IMSG_RECONF_OCSP");
615 		if (load_file(imsg->fd, &h->ocsp, &h->ocsplen) == -1)
616 			fatalx("failed to load ocsp for %s",
617 			    h->domain);
618 		break;
619 
620 	case IMSG_RECONF_HOST_ADDR:
621 		log_debug("receiving host addr");
622 		if (h == NULL)
623 			fatalx("recv'd host address withouth host");
624 		IMSG_SIZE_CHECK(imsg, addr);
625 		addr = xcalloc(1, sizeof(*addr));
626 		memcpy(addr, imsg->data, datalen);
627 		TAILQ_INSERT_TAIL(&h->addrs, addr, addrs);
628 		break;
629 
630 	case IMSG_RECONF_LOC:
631 		if (h == NULL)
632 			fatalx("recv'd location without host");
633 		IMSG_SIZE_CHECK(imsg, loc);
634 		loc = xcalloc(1, sizeof(*loc));
635 		memcpy(loc, imsg->data, datalen);
636 
637 		if (imsg->fd != -1) {
638 			if (load_file(imsg->fd, &d, &len) == -1)
639 				fatal("load_file");
640 			loc->reqca = load_ca(d, len);
641 			if (loc->reqca == NULL)
642 				fatalx("failed to load CA");
643 			free(d);
644 		}
645 
646 		TAILQ_INSERT_TAIL(&h->locations, loc, locations);
647 		break;
648 
649 	case IMSG_RECONF_ENV:
650 		if (h == NULL)
651 			fatalx("recv'd env without host");
652 		IMSG_SIZE_CHECK(imsg, env);
653 		env = xcalloc(1, sizeof(*env));
654 		memcpy(env, imsg->data, datalen);
655 		TAILQ_INSERT_TAIL(&h->params, env, envs);
656 		break;
657 
658 	case IMSG_RECONF_ALIAS:
659 		if (h == NULL)
660 			fatalx("recv'd alias without host");
661 		IMSG_SIZE_CHECK(imsg, alias);
662 		alias = xcalloc(1, sizeof(*alias));
663 		memcpy(alias, imsg->data, datalen);
664 		TAILQ_INSERT_TAIL(&h->aliases, alias, aliases);
665 		break;
666 
667 	case IMSG_RECONF_PROXY:
668 		log_debug("receiving proxy");
669 		if (h == NULL)
670 			fatalx("recv'd proxy without host");
671 		IMSG_SIZE_CHECK(imsg, proxy);
672 		proxy = xcalloc(1, sizeof(*proxy));
673 		memcpy(proxy, imsg->data, datalen);
674 
675 		if (imsg->fd != -1) {
676 			if (load_file(imsg->fd, &d, &len) == -1)
677 				fatal("load_file");
678 			proxy->reqca = load_ca(d, len);
679 			if (proxy->reqca == NULL)
680 				fatal("failed to load CA");
681 			free(d);
682 		}
683 
684 		TAILQ_INSERT_TAIL(&h->proxies, proxy, proxies);
685 		p = proxy;
686 		break;
687 
688 	case IMSG_RECONF_PROXY_CERT:
689 		log_debug("receiving proxy cert");
690 		if (p == NULL)
691 			fatalx("recv'd proxy cert without proxy");
692 		if (p->cert != NULL)
693 			fatalx("proxy cert already received");
694 		if (imsg->fd == -1)
695 			fatalx("no fd for IMSG_RECONF_PROXY_CERT");
696 		if (load_file(imsg->fd, &p->cert, &p->certlen) == -1)
697 			fatalx("failed to load cert for proxy %s of %s",
698 			    p->host, h->domain);
699 		break;
700 
701 	case IMSG_RECONF_PROXY_KEY:
702 		log_debug("receiving proxy key");
703 		if (p == NULL)
704 			fatalx("recv'd proxy key without proxy");
705 		if (p->key != NULL)
706 			fatalx("proxy key already received");
707 		if (imsg->fd == -1)
708 			fatalx("no fd for IMSG_RECONF_PROXY_KEY");
709 		if (load_file(imsg->fd, &p->key, &p->keylen) == -1)
710 			fatalx("failed to load key for proxy %s of %s",
711 			    p->host, h->domain);
712 		break;
713 
714 	case IMSG_RECONF_END:
715 		if (proc_compose(ps, PROC_PARENT, IMSG_RECONF_DONE,
716 		    NULL, 0) == -1)
717 			return -1;
718 		break;
719 
720 	default:
721 		return -1;
722 	}
723 
724 	return 0;
725 }