1 /*
2  * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
3  * Copyright (c) 2006 - 2015 Reyk Floeter <reyk@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include <sys/types.h>
19 #include <sys/queue.h>
20 #include <sys/tree.h>
21 #include <sys/socket.h>
22 #include <sys/uio.h>
23 
24 #include <netinet/in.h>
25 #include <arpa/inet.h>
26 #include <netdb.h>
27 
28 #include <asr.h>
29 #include <ctype.h>
30 #include <errno.h>
31 #include <event.h>
32 #include <fnmatch.h>
33 #include <limits.h>
34 #include <stdlib.h>
35 #include <stdint.h>
36 #include <stdio.h>
37 #include <string.h>
38 #include <imsg.h>
39 #include <tls.h>
40 #include <unistd.h>
41 
42 #include "config.h"
43 #include "log.h"
44 #include "proc.h"
45 #include "tmpl.h"
46 
47 #include "galileo.h"
48 
49 #define MINIMUM(a, b)	((a) < (b) ? (a) : (b))
50 
51 #if HAVE_LIBEVENT2
52 # define G_TOUT(t)	((t).tv_sec)
53 #else
54 # define G_TOUT(t)	(t)
55 #endif
56 
57 /* provided by OpenBSD' base libevent but not in any header? */
58 extern void	 bufferevent_read_pressure_cb(struct evbuffer *, size_t,
59 		    size_t, void *);
60 
61 void	proxy_init(struct privsep *, struct privsep_proc *, void *);
62 int	proxy_launch(struct galileo *);
63 void	proxy_inflight_dec(const char *);
64 int	proxy_dispatch_parent(int, struct privsep_proc *, struct imsg *);
65 int	proxy_resurl(struct client *, const char *, char *, size_t);
66 void	proxy_translate_gemtext(struct client *);
67 void	proxy_resolved(struct asr_result *, void *);
68 void	proxy_connect(int, short, void *);
69 int	proxy_start_reply(struct client *, int, const char *);
70 void	proxy_read(struct bufferevent *, void *);
71 void	proxy_write(struct bufferevent *, void *);
72 void	proxy_error(struct bufferevent *, short, void *);
73 int	proxy_bufferevent_add(struct event *, int);
74 void	proxy_tls_writecb(int, short, void *);
75 void	proxy_tls_readcb(int, short, void *);
76 
77 static struct privsep_proc procs[] = {
78 	{ "parent",	PROC_PARENT, proxy_dispatch_parent },
79 };
80 
81 volatile int proxy_clients;
82 volatile int proxy_inflight;
83 uint32_t proxy_fcg_id;
84 
85 void
86 proxy(struct privsep *ps, struct privsep_proc *p)
87 {
88 	proc_run(ps, p, procs, nitems(procs), proxy_init, NULL);
89 }
90 
91 void
92 proxy_init(struct privsep *ps, struct privsep_proc *p, void *arg)
93 {
94 	if (config_init(ps->ps_env) == -1)
95 		fatal("failed to initialize configuration");
96 
97 	/* We use a custom shutdown callback */
98 	/* p->p_shutdown = proxy_shutdown */
99 
100 	if (pledge("stdio recvfd unix inet dns", NULL) == -1)
101 		fatal("pledge");
102 }
103 
104 int
105 proxy_launch(struct galileo *env)
106 {
107 	event_add(&env->sc_evsock, NULL);
108 	return (0);
109 }
110 
111 void
112 proxy_purge(struct proxy *pr)
113 {
114 	free(pr);
115 }
116 
117 void
118 proxy_inflight_dec(const char *why)
119 {
120 	proxy_inflight--;
121 	log_debug("%s: inflight decremented, now %d, %s",
122 	    __func__, proxy_inflight, why);
123 }
124 
125 int
126 proxy_dispatch_parent(int fd, struct privsep_proc *p, struct imsg *imsg)
127 {
128 	struct privsep	*ps = p->p_ps;
129 	struct galileo	*env = ps->ps_env;
130 
131 	switch (imsg->hdr.type) {
132 	case IMSG_CFG_SRV:
133 		if (config_getproxy(env, imsg) == -1)
134 			fatal("config_getproxy");
135 		break;
136 	case IMSG_CFG_SOCK:
137 		/* XXX: improve */
138 
139 		env->sc_sock_fd = config_getsock(env, imsg);
140 		if (env->sc_sock_fd == -1)
141 			fatal("config_getsock");
142 
143 		event_set(&env->sc_evsock, env->sc_sock_fd,
144 		    EV_READ | EV_PERSIST, fcgi_accept, env);
145 		evtimer_set(&env->sc_evpause, fcgi_accept, env);
146 		break;
147 	case IMSG_CFG_DONE:
148 		config_getcfg(env, imsg);
149 		proxy_launch(env);
150 		break;
151 	case IMSG_CTL_START:
152 		break;
153 	case IMSG_CTL_RESET:
154 		config_getreset(env, imsg);
155 		break;
156 	default:
157 		return (-1);
158 	}
159 
160 	return (0);
161 }
162 
163 static int
164 portok(const char **url, struct client *clt)
165 {
166 	const char		*u = *url;
167 	const char		*port = clt->clt_pc->proxy_port;
168 	size_t			 len;
169 
170 	len = strlen(port);
171 
172 	if (*u == '\0' || *u == '/' || *u == '?' || *u == '#')
173 		return (1);
174 	if (*u != ':')
175 		return (0);
176 	u++;
177 	if (strncmp(u, port, len) != 0)
178 		return (0);
179 	u += len;
180 	if (*u != '\0' && *u != '/' && *u != '?' && *u != '#')
181 		return (0);
182 	*url = u;
183 	return (1);
184 }
185 
186 int
187 proxy_resurl(struct client *clt, const char *url, char *buf, size_t len)
188 {
189 	const char		*tmp;
190 	size_t			 l;
191 
192 	if (clt->clt_server_name == NULL)
193 		return (-1);
194 
195 	l = strlen(clt->clt_server_name);
196 
197 	if (len == 0) {
198 		log_warn("%s: zero-sized buffer!", __func__);
199 		return (-1);
200 	}
201 
202 	/* look if it's an absolute URI */
203 	if (strncmp(url, "//", 2) == 0) {
204 		tmp = url + 2;
205 		if (strncmp(tmp, clt->clt_server_name, l) != 0)
206 			goto done;
207 
208 		tmp += l;
209 		if (!portok(&tmp, clt))
210 			goto done;
211 		url = tmp;
212 	} else if (strncmp(url, "gemini://", 9) == 0) {
213 		tmp = url + 9;
214 		if (strncmp(tmp, clt->clt_server_name, l) != 0)
215 			goto done;
216 
217 		tmp += l;
218 		if (!portok(&tmp, clt))
219 			goto done;
220 		url = tmp;
221 	} else {
222 		tmp = url;
223 		while (isalpha((unsigned char)*tmp) || *tmp == '+')
224 			tmp++;
225 		if (strncmp(tmp, "://", 3) == 0)
226 			goto done;
227 	}
228 
229 	/* maybe it's an absolute path? */
230 	if (*url == '\0' || *url == '/') {
231 		if (strlcpy(buf, clt->clt_script_name, len) >= len)
232 			return (-1);
233 		if (strlcat(buf, url + 1, len) >= len)
234 			return (-1);
235 		return (0);
236 	}
237 
238 	/* otherwise, leave it as it is */
239  done:
240 	if (strlcpy(buf, url, len) >= len)
241 		return (-1);
242 	return (0);
243 }
244 
245 static inline int
246 match_image_heur(const char *url)
247 {
248 	return (fnmatch("*.jpg", url, 0) == 0 ||
249 	    fnmatch("*.jpeg", url, 0) == 0 ||
250 	    fnmatch("*.gif", url, 0) == 0 ||
251 	    fnmatch("*.png", url, 0) == 0 ||
252 	    fnmatch("*.svg", url, 0) == 0 ||
253 	    fnmatch("*.webp", url, 0) == 0);
254 }
255 
256 static int
257 gemtext_translate_line(struct client *clt, char *line)
258 {
259 	struct template	*tp = clt->clt_tp;
260 	char		 buf[1025];
261 	char		*url;
262 
263 	/* preformatted line / closing */
264 	if (clt->clt_translate & TR_PRE) {
265 		if (!strncmp(line, "```", 3)) {
266 			clt->clt_translate &= ~TR_PRE;
267 			return (tp_pre_close(clt->clt_tp));
268 		}
269 
270 		if (tp_htmlescape(clt->clt_tp, line) == -1)
271 			return (-1);
272 		return (tp_write(tp, "\n", 1));
273 	}
274 
275 	/* bullet */
276 	if (!strncmp(line, "* ", 2)) {
277 		if (clt->clt_translate & TR_NAV) {
278 			if (tp_writes(tp, "</ul></nav>") == -1)
279 				return (-1);
280 			clt->clt_translate &= ~TR_NAV;
281 		}
282 
283 		if (!(clt->clt_translate & TR_LIST)) {
284 			if (tp_writes(tp, "<ul>") == -1)
285 				return (-1);
286 			clt->clt_translate |= TR_LIST;
287 		}
288 
289 		if (tp_writes(tp, "<li>") == -1 ||
290 		    tp_htmlescape(clt->clt_tp, line + 2) == -1 ||
291 		    tp_writes(tp, "</li>") == -1)
292 			return (-1);
293 		return (0);
294 	}
295 
296 	if (clt->clt_translate & TR_LIST) {
297 		if (tp_writes(tp, "</ul>") == -1)
298 			return (-1);
299 		clt->clt_translate &= ~TR_LIST;
300 	}
301 
302 	/* link */
303 	if (!strncmp(line, "=>", 2)) {
304 		char *label;
305 
306 		line += 2;
307 		line += strspn(line, " \t");
308 
309 		label = line + strcspn(line, " \t");
310 		if (*label == '\0')
311 			label = line;
312 		else {
313 			*label++ = '\0';
314 			label += strspn(label, " \t");
315 			if (*label == '\0')
316 				label = line;
317 		}
318 
319 		if (proxy_resurl(clt, line, buf, sizeof(buf)) == 0)
320 			url = buf;
321 		else
322 			url = line; /* leave the URL as it is */
323 
324 		if (!(clt->clt_pc->flags & PROXY_NO_IMGPRV) &&
325 		    match_image_heur(url)) {
326 			if (clt->clt_translate & TR_NAV) {
327 				if (tp_writes(tp, "</ul></nav>") == -1)
328 					return (-1);
329 				clt->clt_translate &= ~TR_NAV;
330 			}
331 
332 			if (tp_figure(tp, url, label) == -1)
333 				return (-1);
334 
335 			return (0);
336 		}
337 
338 		if (!(clt->clt_translate & TR_NAV)) {
339 			if (tp_writes(tp, "<nav><ul>") == -1)
340 				return (-1);
341 			clt->clt_translate |= TR_NAV;
342 		}
343 
344 		if (tp_writes(tp, "<li><a href='") == -1)
345 			return (-1);
346 
347 		if (tp_urlescape(clt->clt_tp, url) == -1 ||
348 		    tp_writes(tp, "'>") == -1 ||
349 		    tp_htmlescape(clt->clt_tp, label) == -1 ||
350 		    tp_writes(tp, "</a></li>") == -1)
351 			return (-1);
352 
353 		return (0);
354 	}
355 
356 	if (clt->clt_translate & TR_NAV) {
357 		if (tp_writes(tp, "</ul></nav>") == -1)
358 			return (-1);
359 		clt->clt_translate &= ~TR_NAV;
360 	}
361 
362 	/* pre opening */
363 	if (!strncmp(line, "```", 3)) {
364 		line += 3;
365 		line += strspn(line, " \t");
366 
367 		clt->clt_translate |= TR_PRE;
368 		return (tp_pre_open(tp, line));
369 	}
370 
371 	/* citation block */
372 	if (*line == '>') {
373 		if (tp_writes(tp, "<blockquote>") == -1 ||
374 		    tp_htmlescape(clt->clt_tp, line + 1) == -1 ||
375 		    tp_writes(tp, "</blockquote>") == -1)
376 			return (-1);
377 		return (0);
378 	}
379 
380 	/* headings */
381 	if (!strncmp(line, "###", 3)) {
382 		if (tp_writes(tp, "<h3>") == -1 ||
383 		    tp_htmlescape(clt->clt_tp, line + 3) == -1 ||
384 		    tp_writes(tp, "</h3>") == -1)
385 			return (-1);
386 		return (0);
387 	}
388 	if (!strncmp(line, "##", 2)) {
389 		if (tp_writes(tp, "<h2>") == -1 ||
390 		    tp_htmlescape(clt->clt_tp, line + 2) == -1 ||
391 		    tp_writes(tp, "</h2>") == -1)
392 			return (-1);
393 		return (0);
394 	}
395 	if (!strncmp(line, "#", 1)) {
396 		if (tp_writes(tp, "<h1>") == -1 ||
397 		    tp_htmlescape(clt->clt_tp, line + 1) == -1 ||
398 		    tp_writes(tp, "</h1>") == -1)
399 			return (-1);
400 		return (0);
401 	}
402 
403 	/* Not following strictly the gemini specification... */
404 	if (*line == '\0')
405 		return (0);
406 
407 	/* paragraph */
408 	if (tp_writes(tp, "<p>") == -1 ||
409 	    tp_htmlescape(clt->clt_tp, line) == -1 ||
410 	    tp_writes(tp, "</p>") == -1)
411 		return (-1);
412 
413 	return (0);
414 }
415 
416 void
417 proxy_translate_gemtext(struct client *clt)
418 {
419 	struct bufferevent	*bev = clt->clt_bev;
420 	struct evbuffer		*src = EVBUFFER_INPUT(bev);
421 	char			*line;
422 	size_t			 len;
423 	int			 r;
424 
425 	for (;;) {
426 		line = evbuffer_readln(src, &len, EVBUFFER_EOL_CRLF);
427 		if (line == NULL)
428 			return;
429 
430 		r = gemtext_translate_line(clt, line);
431 		free(line);
432 		if (r == -1)
433 			return;
434 	}
435 }
436 
437 struct proxy_config *
438 proxy_match(struct galileo *env, const char *name)
439 {
440 	struct proxy		*pr;
441 
442 	if (name == NULL)
443 		return (NULL);
444 
445 	TAILQ_FOREACH(pr, &env->sc_proxies, pr_entry) {
446 		if (!strcmp(name, pr->pr_conf.host))
447 			return (&pr->pr_conf);
448 	}
449 
450 	return (NULL);
451 }
452 
453 int
454 proxy_start_request(struct galileo *env, struct client *clt)
455 {
456 	struct addrinfo		 hints;
457 	struct asr_query	*query;
458 	int			 r;
459 	char			*url;
460 
461 	if (clt->clt_path_info == NULL) {
462 		log_warnx("PATH_INFO not defined!");
463 		if (proxy_start_reply(clt, 501, "text/html") == -1)
464 			return (-1);
465 		if (tp_error(clt->clt_tp, -1, "internal server error") == -1)
466 			return (-1);
467 		return (fcgi_end_request(clt, 1));
468 	}
469 
470 	if ((clt->clt_pc = proxy_match(env, clt->clt_server_name)) == NULL) {
471 		if (proxy_start_reply(clt, 501, "text/html") == -1)
472 			return (-1);
473 		if (tp_error(clt->clt_tp, -1, "unknown server") == -1)
474 			return (-1);
475 		return (fcgi_end_request(clt, 1));
476 	}
477 
478 	if (clt->clt_bodylen != 0 && clt->clt_body == NULL) {
479 		if (proxy_start_reply(clt, 400, "text/html") == -1)
480 			return (-1);
481 		if (tp_error(clt->clt_tp, -1, "bad request") == -1)
482 			return (-1);
483 		return (fcgi_end_request(clt, 1));
484 	}
485 
486 	if (clt->clt_body) {
487 		r = asprintf(&url, "%s%s?%s", clt->clt_script_name,
488 		    clt->clt_path_info + 1, clt->clt_body);
489 		if (r == -1)
490 			return (fcgi_end_request(clt, 1));
491 
492 		if (proxy_start_reply(clt, 302, url) == -1 ||
493 		    fcgi_end_request(clt, 1) == -1) {
494 			free(url);
495 			return (-1);
496 		}
497 		free(url);
498 		return (0);
499 	}
500 
501 	memset(&hints, 0, sizeof(hints));
502 	hints.ai_family = AF_UNSPEC;
503 	hints.ai_socktype = SOCK_STREAM;
504 
505 	query = getaddrinfo_async(clt->clt_pc->proxy_addr,
506 	    clt->clt_pc->proxy_port, &hints, NULL);
507 	if (query == NULL) {
508 		log_warn("getaddrinfo_async");
509 		return (fcgi_abort_request(clt));
510 	}
511 
512 	clt->clt_evasr = event_asr_run(query, proxy_resolved, clt);
513 	if (clt->clt_evasr == NULL) {
514 		log_warn("event_asr_run");
515 		asr_abort(query);
516 		return (fcgi_abort_request(clt));
517 	}
518 
519 	return (0);
520 }
521 
522 void
523 proxy_resolved(struct asr_result *res, void *d)
524 {
525 	struct client		*clt = d;
526 	struct proxy_config	*pc = clt->clt_pc;
527 
528 	clt->clt_evasr = NULL;
529 
530 	if (res->ar_gai_errno != 0) {
531 		log_warnx("failed to resolve %s:%s: %s",
532 		    pc->proxy_addr, pc->proxy_port,
533 		    gai_strerror(res->ar_gai_errno));
534 		if (proxy_start_reply(clt, 501, "text/html") == -1)
535 			return;
536 		if (tp_error(clt->clt_tp, -1, "Can't resolve host") == -1)
537 			return;
538 		fcgi_end_request(clt, 1);
539 		return;
540 	}
541 
542 	clt->clt_addrinfo = res->ar_addrinfo;
543 	clt->clt_p = clt->clt_addrinfo;
544 	proxy_connect(-1, 0, clt);
545 }
546 
547 void
548 proxy_connect(int fd, short ev, void *d)
549 {
550 	struct client		*clt = d;
551 	struct evbuffer		*out;
552 	struct addrinfo		*p;
553 	struct tls_config	*conf;
554 	struct timeval		 conntv = {5, 0};
555 	int			 err = 0;
556 	socklen_t		 len = sizeof(err);
557 
558 again:
559 	if (clt->clt_p == NULL)
560 		goto err;
561 
562 	if (clt->clt_fd != -1) {
563 		if (getsockopt(clt->clt_fd, SOL_SOCKET, SO_ERROR, &err, &len)
564 		    == -1)
565 			goto err;
566 		if (err != 0) {
567 			errno = err;
568 			goto err;
569 		}
570 		goto done;
571 	}
572 
573 	p = clt->clt_p;
574 	clt->clt_fd = socket(p->ai_family, p->ai_socktype | SOCK_NONBLOCK,
575 	    p->ai_protocol);
576 	if (clt->clt_fd == -1) {
577 		clt->clt_p = clt->clt_p->ai_next;
578 		goto again;
579 	}
580 
581 	if (connect(clt->clt_fd, p->ai_addr, p->ai_addrlen) == 0)
582 		goto done;
583 
584 	clt->clt_evconn_live = 1;
585 	event_set(&clt->clt_evconn, clt->clt_fd, EV_WRITE, proxy_connect, clt);
586 	event_add(&clt->clt_evconn, &conntv);
587 	return;
588 
589 done:
590 	clt->clt_evconn_live = 0;
591 	freeaddrinfo(clt->clt_addrinfo);
592 	clt->clt_addrinfo = clt->clt_p = NULL;
593 
594 	clt->clt_bev = bufferevent_new(clt->clt_fd, proxy_read, proxy_write,
595 	    proxy_error, clt);
596 	if (clt->clt_bev == NULL) {
597 		log_warn("bufferevent_new");
598 		goto err;
599 	}
600 
601 	if (!(clt->clt_pc->flags & PROXY_NO_TLS)) {
602 		/* initialize TLS for Gemini */
603 		if ((conf = tls_config_new()) == NULL) {
604 			log_warn("tls_config_new failed");
605 			goto err;
606 		}
607 
608 		tls_config_insecure_noverifycert(conf);
609 
610 		if ((clt->clt_ctx = tls_client()) == NULL) {
611 			log_warnx("tls_client failed");
612 			tls_config_free(conf);
613 			goto err;
614 		}
615 
616 		if (tls_configure(clt->clt_ctx, conf) == -1) {
617 			log_warnx("tls_configure failed");
618 			tls_config_free(conf);
619 			goto err;
620 		}
621 
622 		tls_config_free(conf);
623 
624 		if (tls_connect_socket(clt->clt_ctx, clt->clt_fd,
625 			clt->clt_pc->proxy_name) == -1) {
626 			log_warnx("tls_connect_socket failed");
627 			goto err;
628 		}
629 
630 		event_set(&clt->clt_bev->ev_read, clt->clt_fd, EV_READ,
631 		    proxy_tls_readcb, clt->clt_bev);
632 		event_set(&clt->clt_bev->ev_write, clt->clt_fd, EV_WRITE,
633 		    proxy_tls_writecb, clt->clt_bev);
634 
635 #if HAVE_LIBEVENT2
636 		evbuffer_unfreeze(clt->clt_bev->input, 0);
637 		evbuffer_unfreeze(clt->clt_bev->output, 1);
638 #endif
639 	}
640 
641 	/* bufferevent_settimeout(); */
642 	bufferevent_enable(clt->clt_bev, EV_READ|EV_WRITE);
643 
644 	/* TODO: compute the URL */
645 	out = EVBUFFER_OUTPUT(clt->clt_bev);
646 	if (evbuffer_add_printf(out, "gemini://%s/%s",
647 	    clt->clt_pc->proxy_name, clt->clt_path_info) == -1) {
648 		log_warn("bufferevent_printf failed");
649 		goto err;
650 	}
651 
652 	if (clt->clt_query &&
653 	    evbuffer_add_printf(out, "?%s", clt->clt_query) == -1) {
654 		log_warn("bufferevent_printf failed");
655 		goto err;
656 	}
657 
658 	if (evbuffer_add(out, "\r\n", 2) == -1) {
659 		log_warn("bufferevent_add failed");
660 		goto err;
661 	}
662 
663 	return;
664 
665 err:
666 	log_warn("failed to connect to %s:%s",
667 	    clt->clt_pc->proxy_addr, clt->clt_pc->proxy_port);
668 	if (proxy_start_reply(clt, 501, "text/html") == -1)
669 		return;
670 	if (tp_error(clt->clt_tp, -1, "Can't connect") == -1)
671 		return;
672 	fcgi_end_request(clt, 1);
673 }
674 
675 static inline int
676 parse_mime(struct client *clt, char *mime, char *lang, size_t len)
677 {
678 	char			*t, *semi;
679 
680 	memset(lang, 0, len);
681 
682 	if (strncmp(mime, "text/gemini", 11) != 0)
683 		return (0);
684 
685 	clt->clt_translate = TR_ENABLED;
686 
687 	if ((mime = strchr(mime, ';')) == NULL)
688 		return (0);
689 
690 	*mime++ = '\0';
691 	while ((t = strsep(&mime, ";")) != NULL) {
692 		if (!strncmp(t, "charset=", 8)) {
693 			t += 8;
694 			if (!strncasecmp(t, "utf8", 4) ||
695 			    !strncasecmp(t, "utf-8", 5) ||
696 			    !strncasecmp(t, "ascii", 5)) {
697 				log_debug("unknown charset %s", t);
698 				return (-1);
699 			}
700 			continue;
701 		}
702 
703 		if (!strncmp(t, "lang=", 5)) {
704 			t += 5;
705 			if ((semi = strchr(t, ';')) != NULL)
706 				*semi = '\0';
707 
708 			if (strlcpy(lang, t, len) >= len) {
709 				log_debug("lang too long: %s", t);
710 				*lang = '\0';
711 			}
712 
713 			if (semi)
714 				*semi = ';';
715 			continue;
716 		}
717 	}
718 
719 	return (0);
720 }
721 
722 int
723 proxy_start_reply(struct client *clt, int status, const char *ctype)
724 {
725 	struct template	*tp = clt->clt_tp;
726 	const char	*csp;
727 
728 	csp = "Content-Security-Policy: default-src 'self'; "
729 	    "script-src 'none'; object-src 'none';\r\n";
730 
731 	if (status != 200 &&
732 	    tp_writef(tp, "Status: %d\r\n", status) == -1)
733 		return (-1);
734 
735 	if (tp_writes(tp, csp) == -1)
736 		return (-1);
737 
738 	if (status == 302) {
739 		/* use "ctype" as redirect target */
740 		if (tp_writef(tp, "Location: %s\r\n", ctype) == -1)
741 			return (-1);
742 		if (tp_writes(tp, "\r\n") == -1)
743 			return (-1);
744 		return (0);
745 	}
746 
747 	if (ctype != NULL) {
748 		if (!strcmp(ctype, "text/html"))
749 			ctype = "text/html;charset=utf-8";
750 		if (tp_writef(tp, "Content-Type: %s\r\n", ctype)
751 		    == -1)
752 			return (-1);
753 	}
754 
755 	if (tp_writes(tp, "\r\n") == -1)
756 		return (-1);
757 
758 	return (0);
759 }
760 
761 void
762 proxy_read(struct bufferevent *bev, void *d)
763 {
764 	struct client		*clt = d;
765 	struct evbuffer		*src = EVBUFFER_INPUT(bev);
766 	const char		*ctype;
767 	char			 buf[1025];
768 	char			 lang[16];
769 	char			*hdr, *mime;
770 	size_t			 len;
771 	int			 code;
772 
773 	if (clt->clt_headersdone) {
774 		if (clt->clt_translate)
775 			proxy_translate_gemtext(clt);
776 		else
777 			clt_write_bufferevent(clt, bev);
778 		return;
779 	}
780 
781 	hdr = evbuffer_readln(src, &len, EVBUFFER_EOL_CRLF_STRICT);
782 	if (hdr == NULL) {
783 		if (EVBUFFER_LENGTH(src) >= 1026)
784 			proxy_error(bev, EV_READ, clt);
785 		return;
786 	}
787 
788 	if (len < 4 ||
789 	    !isdigit((unsigned char)hdr[0]) ||
790 	    !isdigit((unsigned char)hdr[1]) ||
791 	    hdr[2] != ' ') {
792 		log_warnx("invalid ");
793 		proxy_error(bev, EV_READ, clt);
794 		goto err;
795 	}
796 
797 	code = (hdr[0] - '0') * 10 + (hdr[1] - '0');
798 
799 	switch (hdr[0]) {
800 	case '1':
801 		if (proxy_start_reply(clt, 200, "text/html") == -1)
802 			goto err;
803 		if (tp_inputpage(clt->clt_tp, &hdr[3]) == -1)
804 			goto err;
805 		fcgi_end_request(clt, 0);
806 		goto err;
807 	case '2':
808 		/* handled below */
809 		break;
810 	case '3':
811 		if (proxy_resurl(clt, &hdr[3], buf, sizeof(buf)) == 0) {
812 			if (proxy_start_reply(clt, 302, buf) == -1)
813 				goto err;
814 			fcgi_end_request(clt, 0);
815 			goto err;
816 		}
817 		/* fallthrough */
818 	default:
819 		if (proxy_start_reply(clt, 501, "text/html") == -1)
820 			goto err;
821 		if (tp_error(clt->clt_tp, code, &hdr[3]) == -1)
822 			goto err;
823 		fcgi_end_request(clt, 1);
824 		goto err;
825 	}
826 
827 	mime = hdr + 2 + strspn(hdr + 2, " \t");
828 	if (parse_mime(clt, mime, lang, sizeof(lang)) == -1) {
829 		if (proxy_start_reply(clt, 501, "text/html") == -1)
830 			goto err;
831 		if (tp_error(clt->clt_tp, -1, "Bad response") == -1)
832 			goto err;
833 		fcgi_end_request(clt, 1);
834 		goto err;
835 	}
836 
837 	if (clt->clt_translate)
838 		ctype = "text/html;charset=utf-8";
839 	else
840 		ctype = mime;
841 
842 	if (tp_writef(clt->clt_tp, "Content-Type: %s\r\n\r\n", ctype) == -1)
843 		goto err;
844 
845 	clt->clt_headersdone = 1;
846 
847 	if (clt->clt_translate &&
848 	    tp_head(clt->clt_tp, lang, NULL) == -1)
849 		goto err;
850 
851 	/*
852 	 * Trigger the read again so we proceed with the response
853 	 * body, if any.
854 	 */
855 	free(hdr);
856 	proxy_read(bev, d);
857 	return;
858 
859 err:
860 	free(hdr);
861 }
862 
863 void
864 proxy_write(struct bufferevent *bev, void *d)
865 {
866 	return;
867 }
868 
869 void
870 proxy_error(struct bufferevent *bev, short err, void *d)
871 {
872 	struct client		*clt = d;
873 	struct template		*tp = clt->clt_tp;
874 	int			 status = !(err & EVBUFFER_EOF);
875 
876 	log_debug("proxy error, shutting down the connection (err: %x)",
877 	    err);
878 
879 	if (!clt->clt_headersdone) {
880 		if (proxy_start_reply(clt, 501, "text/html") == -1)
881 			return;
882 		if (tp_error(clt->clt_tp, -1, "Proxy error") == -1)
883 			return;
884 	} else if (status == 0) {
885 		if (clt->clt_translate & TR_PRE) {
886 			if (tp_pre_close(clt->clt_tp))
887 				return;
888 			clt->clt_translate &= ~TR_PRE;
889 		}
890 
891 		if (clt->clt_translate & TR_LIST) {
892 			if (tp_writes(tp, "</ul>") == -1)
893 				return;
894 			clt->clt_translate &= ~TR_LIST;
895 		}
896 
897 		if (clt->clt_translate & TR_NAV) {
898 			if (tp_writes(tp, "</ul></nav>") == -1)
899 				return;
900 			clt->clt_translate &= ~TR_NAV;
901 		}
902 
903 		if (clt->clt_translate &&
904 		    tp_foot(clt->clt_tp) == -1)
905 			return;
906 	}
907 
908 	fcgi_end_request(clt, status);
909 }
910 
911 void
912 proxy_tls_readcb(int fd, short event, void *arg)
913 {
914 	struct bufferevent	*bufev = arg;
915 	struct client		*clt = bufev->cbarg;
916 	char			 rbuf[IBUF_READ_SIZE];
917 	int			 what = EVBUFFER_READ;
918 	int			 howmuch = IBUF_READ_SIZE;
919 	ssize_t			 ret;
920 	size_t			 len;
921 
922 	if (event == EV_TIMEOUT) {
923 		what |= EVBUFFER_TIMEOUT;
924 		goto err;
925 	}
926 
927 	if (bufev->wm_read.high != 0)
928 		howmuch = MINIMUM(sizeof(rbuf), bufev->wm_read.high);
929 
930 	ret = tls_read(clt->clt_ctx, rbuf, howmuch);
931 	if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) {
932 		goto retry;
933 	} else if (ret == -1) {
934 		what |= EVBUFFER_ERROR;
935 		goto err;
936 	}
937 	len = ret;
938 
939 	if (len == 0) {
940 		what |= EVBUFFER_EOF;
941 		goto err;
942 	}
943 
944 	if (evbuffer_add(bufev->input, rbuf, len) == -1) {
945 		what |= EVBUFFER_ERROR;
946 		goto err;
947 	}
948 
949 	proxy_bufferevent_add(&bufev->ev_read, G_TOUT(bufev->timeout_read));
950 
951 	len = EVBUFFER_LENGTH(bufev->input);
952 	if (bufev->wm_read.low != 0 && len < bufev->wm_read.low)
953 		return;
954 	if (bufev->wm_read.high != 0 && len > bufev->wm_read.high) {
955 		struct evbuffer *buf = bufev->input;
956 		event_del(&bufev->ev_read);
957 		evbuffer_setcb(buf, bufferevent_read_pressure_cb, bufev);
958 		return;
959 	}
960 
961 	if (bufev->readcb != NULL)
962 		(*bufev->readcb)(bufev, bufev->cbarg);
963 	return;
964 
965 retry:
966 	proxy_bufferevent_add(&bufev->ev_read, G_TOUT(bufev->timeout_read));
967 	return;
968 
969 err:
970 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
971 }
972 
973 int
974 proxy_bufferevent_add(struct event *ev, int timeout)
975 {
976 	struct timeval tv, *ptv = NULL;
977 
978 	if (timeout) {
979 		timerclear(&tv);
980 		tv.tv_sec = timeout;
981 		ptv = &tv;
982 	}
983 
984 	return (event_add(ev, ptv));
985 }
986 
987 void
988 proxy_tls_writecb(int fd, short event, void *arg)
989 {
990 	struct bufferevent	*bufev = arg;
991 	struct client		*clt = bufev->cbarg;
992 	ssize_t			 ret;
993 	short			 what = EVBUFFER_WRITE;
994 	size_t			 len;
995 
996 	if (event == EV_TIMEOUT) {
997 		what |= EVBUFFER_TIMEOUT;
998 		goto err;
999 	}
1000 
1001 	if (EVBUFFER_LENGTH(bufev->output)) {
1002 		ret = tls_write(clt->clt_ctx,
1003 		    EVBUFFER_DATA(bufev->output),
1004 		    EVBUFFER_LENGTH(bufev->output));
1005 		if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) {
1006 			goto retry;
1007 		} else if (ret == -1) {
1008 			what |= EVBUFFER_ERROR;
1009 			goto err;
1010 		}
1011 		len = ret;
1012 		evbuffer_drain(bufev->output, len);
1013 	}
1014 
1015 	if (EVBUFFER_LENGTH(bufev->output) != 0)
1016 		proxy_bufferevent_add(&bufev->ev_write,
1017 		    G_TOUT(bufev->timeout_write));
1018 
1019 	if (bufev->writecb != NULL &&
1020 	    EVBUFFER_LENGTH(bufev->output) <= bufev->wm_write.low)
1021 		(*bufev->writecb)(bufev, bufev->cbarg);
1022 	return;
1023 
1024 retry:
1025 	proxy_bufferevent_add(&bufev->ev_write, G_TOUT(bufev->timeout_write));
1026 	return;
1027 
1028 err:
1029 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
1030 }
1031 
1032 void
1033 proxy_client_free(struct client *clt)
1034 {
1035 	if (clt->clt_evasr)
1036 		event_asr_abort(clt->clt_evasr);
1037 
1038 	if (clt->clt_addrinfo)
1039 		freeaddrinfo(clt->clt_addrinfo);
1040 
1041 	if (clt->clt_evconn_live)
1042 		event_del(&clt->clt_evconn);
1043 
1044 	if (clt->clt_fd != -1)
1045 		close(clt->clt_fd);
1046 
1047 	if (clt->clt_ctx)
1048 		tls_free(clt->clt_ctx);
1049 
1050 	if (clt->clt_bev)
1051 		bufferevent_free(clt->clt_bev);
1052 
1053 	template_free(clt->clt_tp);
1054 
1055 	free(clt->clt_body);
1056 	free(clt->clt_server_name);
1057 	free(clt->clt_script_name);
1058 	free(clt->clt_path_info);
1059 	free(clt->clt_query);
1060 	free(clt);
1061 }