1 /*
2  * Copyright (c) 2021, 2024 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 "compat.h"
18 
19 #include <sys/mman.h>
20 #include <sys/types.h>
21 #include <sys/socket.h>
22 #include <sys/stat.h>
23 
24 #include <netinet/in.h>
25 
26 #include <ctype.h>
27 #include <errno.h>
28 #include <netdb.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <tls.h>
34 #include <unistd.h>
35 
36 #if HAVE_ASR_RUN
37 # include <asr.h>
38 #endif
39 
40 #include "bufio.h"
41 #include "ev.h"
42 #include "imsgev.h"
43 #include "telescope.h"
44 #include "utils.h"
45 #include "xwrapper.h"
46 
47 static struct imsgev		*iev_ui;
48 
49 enum conn_state {
50 	CONN_CONNECTING,
51 	CONN_HANDSHAKE,
52 	CONN_HEADER,
53 	CONN_BODY,
54 	CONN_CLOSE,
55 	CONN_ERROR,
56 };
57 
58 /* a pending request */
59 struct req {
60 	uint32_t		 id;
61 	enum conn_state		 state;
62 	int			 proto;
63 	int			 fd;
64 	char			*host;
65 	char			*port;
66 	char			*req;
67 	size_t			 len;
68 	void			*ccert;
69 	size_t			 ccert_len;
70 	int			 ccert_fd;
71 
72 	int			 eof;
73 	unsigned int		 timer;
74 	struct bufio		 bio;
75 
76 	int			 conn_error;
77 	const char		*cause;
78 
79 	struct addrinfo		*servinfo, *p;
80 #if HAVE_ASR_RUN
81 	struct asr_query	*q;
82 	int			 ar_fd;
83 #endif
84 
85 	TAILQ_ENTRY(req)	 reqs;
86 };
87 
88 static struct req	*req_by_id(uint32_t);
89 
90 static void	 die(void) __attribute__((__noreturn__));
91 
92 static void	 close_with_err(struct req*, const char*);
93 static void	 close_with_errf(struct req*, const char*, ...)
94     __attribute__((format(printf, 2, 3)));
95 
96 static int	 try_to_connect(struct req *);
97 static int	 gemini_parse_reply(struct req *, const char *);
98 static void	 net_ev(int, int, void *);
99 static void	 handle_dispatch_imsg(int, int, void*);
100 
101 static int	 net_send_ui(int, uint32_t, const void *, uint16_t);
102 
103 /* TODO: making this customizable */
104 struct timeval timeout_for_handshake = { 5, 0 };
105 
106 TAILQ_HEAD(, req) reqhead;
107 
108 static struct req *
109 req_by_id(uint32_t id)
110 {
111 	struct req *r;
112 
113 	TAILQ_FOREACH(r, &reqhead, reqs) {
114 		if (r->id == id)
115 			return r;
116 	}
117 
118 	return NULL;
119 }
120 
121 static void __attribute__((__noreturn__))
122 die(void)
123 {
124 	abort(); 		/* TODO */
125 }
126 
127 static inline int
128 req_bio_ev(struct req *req)
129 {
130 	int	 ret, ev;
131 
132 	ret = 0;
133 	ev = bufio_ev(&req->bio);
134 	if (ev & BUFIO_WANT_READ)
135 		ret |= EV_READ;
136 	if (ev & BUFIO_WANT_WRITE)
137 		ret |= EV_WRITE;
138 	return (ret);
139 }
140 
141 static void
142 close_conn(int fd, int ev, void *d)
143 {
144 	struct req	*req = d;
145 
146 	if (req->state != CONN_ERROR)
147 		req->state = CONN_CLOSE;
148 
149 #if HAVE_ASR_RUN
150 	if (req->q) {
151 		asr_abort(req->q);
152 		ev_del(req->ar_fd);
153 	}
154 #endif
155 
156 	if (req->timer != 0) {
157 		ev_timer_cancel(req->timer);
158 		req->timer = 0;
159 	}
160 
161 	if (req->state == CONN_CLOSE &&
162 	    req->fd != -1 &&
163 	    bufio_close(&req->bio) == -1 &&
164 	    errno == EAGAIN) {
165 		ev_add(req->fd, req_bio_ev(req), close_conn, req);
166 		return;
167 	}
168 
169 	if (req->servinfo)
170 		freeaddrinfo(req->servinfo);
171 
172 	bufio_free(&req->bio);
173 
174 	if (req->ccert != NULL) {
175 		munmap(req->ccert, req->ccert_len);
176 		close(req->ccert_fd);
177 	}
178 
179 	free(req->host);
180 	free(req->port);
181 	free(req->req);
182 
183 	TAILQ_REMOVE(&reqhead, req, reqs);
184 	if (req->fd != -1) {
185 		ev_del(req->fd);
186 		close(req->fd);
187 	}
188 	free(req);
189 }
190 
191 static void
192 close_with_err(struct req *req, const char *err)
193 {
194 	req->state = CONN_ERROR;
195 	net_send_ui(IMSG_ERR, req->id, err, strlen(err)+1);
196 	close_conn(0, 0, req);
197 }
198 
199 static void
200 close_with_errf(struct req *req, const char *fmt, ...)
201 {
202 	va_list	 ap;
203 	char	*s;
204 
205 	va_start(ap, fmt);
206 	if (vasprintf(&s, fmt, ap) == -1)
207 		abort();
208 	va_end(ap);
209 
210 	close_with_err(req, s);
211 	free(s);
212 }
213 
214 #if HAVE_ASR_RUN
215 static void
216 req_resolve(int fd, int ev, void *d)
217 {
218 	struct req		*req = d;
219 	struct addrinfo		 hints;
220 	struct asr_result	 ar;
221 	struct timeval		 tv;
222 
223 	if (req->q == NULL) {
224 		memset(&hints, 0, sizeof(hints));
225 		hints.ai_family = AF_UNSPEC;
226 		hints.ai_socktype = SOCK_STREAM;
227 
228 		req->q = getaddrinfo_async(req->host, req->port, &hints, NULL);
229 		if (req->q == NULL) {
230 			close_with_errf(req, "getaddrinfo_async: %s",
231 			    strerror(errno));
232 			return;
233 		}
234 	}
235 
236 	if (fd != -1)
237 		ev_del(fd);
238 	if (req->timer) {
239 		ev_timer_cancel(req->timer);
240 		req->timer = 0;
241 	}
242 
243 	if (asr_run(req->q, &ar) == 0) {
244 		ev = 0;
245 		if (ar.ar_cond & ASR_WANT_READ)
246 			ev |= EV_READ;
247 		if (ar.ar_cond & ASR_WANT_WRITE)
248 			ev |= EV_WRITE;
249 
250 		req->ar_fd = ar.ar_fd;
251 		if (ev_add(req->ar_fd, ev, req_resolve, req) == -1) {
252 			close_with_errf(req, "ev_add failure: %s",
253 			    strerror(errno));
254 			return;
255 		}
256 
257 		tv.tv_sec = ar.ar_timeout / 1000;
258 		tv.tv_usec = (ar.ar_timeout % 1000) * 1000;
259 		req->timer = ev_timer(&tv, req_resolve, req);
260 		if (req->timer == 0)
261 			close_with_errf(req, "ev_timer failure: %s",
262 			    strerror(errno));
263 		return;
264 	}
265 
266 	req->ar_fd = -1;
267 	req->q = NULL;
268 
269 	if (ar.ar_gai_errno) {
270 		close_with_errf(req, "failed to resolve %s: %s",
271 		    req->host, gai_strerror(ar.ar_gai_errno));
272 		return;
273 	}
274 
275 	req->servinfo = ar.ar_addrinfo;
276 
277 	req->p = req->servinfo;
278 	net_ev(-1, EV_READ, req);
279 }
280 #else
281 static void
282 req_resolve(int fd, int ev, struct req *req)
283 {
284 	struct addrinfo		 hints;
285 	int			 s;
286 
287 	memset(&hints, 0, sizeof(hints));
288 	hints.ai_family = AF_UNSPEC;
289 	hints.ai_socktype = SOCK_STREAM;
290 
291 	s = getaddrinfo(req->host, req->port, &hints, &req->servinfo);
292 	if (s != 0) {
293 		close_with_errf(req, "failed to resolve %s: %s",
294 		    req->host, gai_strerror(s));
295 		return;
296 	}
297 
298 	req->fd = -1;
299 	req->p = req->servinfo;
300 	net_ev(-1, EV_READ, req);
301 }
302 #endif
303 
304 static int
305 try_to_connect(struct req *req)
306 {
307 	int		 error;
308 	socklen_t	 len = sizeof(error);
309 
310  again:
311 	if (req->p == NULL)
312 		return (-1);
313 
314 	if (req->fd != -1) {
315 		if (getsockopt(req->fd, SOL_SOCKET, SO_ERROR, &error,
316 		    &len) == -1) {
317 			req->conn_error = errno;
318 			req->cause = "getsockopt";
319 			return (-1);
320 		}
321 
322 		if (error == 0) /* connected */
323 			return (0);
324 
325 		req->conn_error = error;
326 		req->cause = "connect";
327 		close(req->fd);
328 		req->fd = -1;
329 		req->p = req->p->ai_next;
330 		goto again;
331 	}
332 
333 	req->fd = socket(req->p->ai_family, req->p->ai_socktype,
334 	    req->p->ai_protocol);
335 	if (req->fd == -1) {
336 		req->conn_error = errno;
337 		req->cause = "socket";
338 		req->p = req->p->ai_next;
339 		goto again;
340 	}
341 
342 	if (!mark_nonblock_cloexec(req->fd)) {
343 		req->conn_error = errno;
344 		req->cause = "setsockopt";
345 		return (-1);
346 	}
347 
348 	if (connect(req->fd, req->p->ai_addr, req->p->ai_addrlen) == 0)
349 		return (0);
350 	errno = EAGAIN;
351 	return (-1);
352 }
353 
354 static int
355 gemini_parse_reply(struct req *req, const char *header)
356 {
357 	struct ibuf	*ibuf;
358 	size_t		 len;
359 	int		 code;
360 
361 	if (!isdigit(header[0]) || !isdigit(header[1]))
362 		return -1;
363 
364 	code = (header[0] - '0')*10 + (header[1] - '0');
365 	if (header[2] != ' ')
366 		return -1;
367 
368 	header += 3;
369 	len = strlen(header) + 1;
370 
371 	if ((ibuf = imsg_create(&iev_ui->ibuf, IMSG_REPLY, req->id, 0,
372 	    sizeof(code) + len)) == NULL)
373 		die();
374 	if (imsg_add(ibuf, &code, sizeof(code)) == -1 ||
375 	    imsg_add(ibuf, header, len) == -1)
376 		die();
377 	imsg_close(&iev_ui->ibuf, ibuf);
378 	imsg_event_add(iev_ui);
379 	return code;
380 }
381 
382 static inline int
383 net_send_req(struct req *req)
384 {
385 	return (bufio_compose(&req->bio, req->req, req->len));
386 }
387 
388 static void
389 net_ev(int fd, int ev, void *d)
390 {
391 	static char	 buf[4096];
392 	struct req	*req = d;
393 	const char	*hash;
394 	ssize_t		 read;
395 	size_t		 len;
396 	char		*header;
397 	int		 code;
398 
399 	if (ev == EV_TIMEOUT) {
400 		close_with_err(req, "Timeout loading page");
401 		return;
402 	}
403 
404 	if (req->state == CONN_CONNECTING) {
405 		ev_del(req->fd);
406 		if (try_to_connect(req) == -1) {
407 			if (req->fd != -1 && errno == EAGAIN) {
408 				ev_add(req->fd, EV_WRITE, net_ev, req);
409 				return;
410 			}
411 			close_with_errf(req, "failed to connect to %s"
412 			    " (%s: %s)", req->host, req->cause,
413 			    strerror(req->conn_error));
414 			return;
415 		}
416 
417 		bufio_set_fd(&req->bio, req->fd);
418 
419 		switch (req->proto) {
420 		case PROTO_FINGER:
421 		case PROTO_GOPHER:
422 			/* finger and gopher don't have a header nor TLS */
423 			req->state = CONN_BODY;
424 			if (net_send_req(req) == -1) {
425 				close_with_err(req, "failed to send request");
426 				return;
427 			}
428 			break;
429 		case PROTO_GEMINI:
430 			req->state = CONN_HANDSHAKE;
431 			if (bufio_starttls(&req->bio, req->host, 1,
432 			    req->ccert, req->ccert_len,
433 			    req->ccert, req->ccert_len) == -1) {
434 				close_with_err(req, "failed to setup TLS");
435 				return;
436 			}
437 			req->timer = ev_timer(&timeout_for_handshake,
438 			    net_ev, req);
439 			if (req->timer == 0) {
440 				close_with_err(req, "failed to setup"
441 				    " handshake timer");
442 				return;
443 			}
444 			break;
445 		}
446 	}
447 
448 	if (req->state == CONN_HANDSHAKE) {
449 		if (bufio_handshake(&req->bio) == -1 && errno == EAGAIN) {
450 			ev_add(req->fd, req_bio_ev(req), net_ev, req);
451 			return;
452 		}
453 
454 		ev_timer_cancel(req->timer);
455 		req->timer = 0;
456 
457 		req->state = CONN_HEADER;
458 
459 		/* pause until we've told the certificate is OK */
460 		ev_del(req->fd);
461 
462 		hash = tls_peer_cert_hash(req->bio.ctx);
463 		if (hash == NULL) {
464 			close_with_errf(req, "handshake failed: %s",
465 			    tls_error(req->bio.ctx));
466 			return;
467 		}
468 
469 		net_send_ui(IMSG_CHECK_CERT, req->id, hash, strlen(hash)+1);
470 		return;
471 	}
472 
473 	if (ev & EV_READ) {
474 		read = bufio_read(&req->bio);
475 		if (read == -1 && errno != EAGAIN) {
476 			req->eof = 1;
477 			net_send_ui(IMSG_FAULTY_GEMSERVER, req->id, NULL, 0);
478 		}
479 		if (read == 0)
480 			req->eof = 1;
481 	}
482 
483 	if ((ev & EV_WRITE) && bufio_write(&req->bio) == -1 &&
484 	    errno != EAGAIN) {
485 		close_with_errf(req, "bufio_write: %s", strerror(errno));
486 		return;
487 	}
488 
489 	if (req->state == CONN_HEADER) {
490 		header = buf_getdelim(&req->bio.rbuf, "\r\n", &len);
491 		if (header == NULL && req->bio.rbuf.len >= 1024) {
492 			close_with_err(req, "Invalid gemini reply (too long)");
493 			return;
494 		}
495 		if (header == NULL && req->eof) {
496 			close_with_err(req, "Invalid gemini reply.");
497 			return;
498 		}
499 		if (header == NULL) {
500 			ev_add(req->fd, req_bio_ev(req), net_ev, req);
501 			return;
502 		}
503 		req->state = CONN_BODY;
504 		if ((code = gemini_parse_reply(req, header)) == -1) {
505 			close_with_err(req, "Malformed gemini reply");
506 			return;
507 		}
508 		if (code < 20 || code >= 30) {
509 			close_conn(0, 0, req);
510 			return;
511 		}
512 
513 		buf_drain(&req->bio.rbuf, len);
514 
515 		/* pause until we've been told to go ahead */
516 		ev_del(req->fd);
517 		return;
518 	}
519 	
520 	/*
521 	 * Split data into chunks before sending.  imsg can't handle
522 	 * message that are "too big".
523 	 */
524 	for (;;) {
525 		if ((len = bufio_drain(&req->bio, buf, sizeof(buf))) == 0)
526 			break;
527 		net_send_ui(IMSG_BUF, req->id, buf, len);
528 	}
529 
530 	if (req->eof) {
531 		net_send_ui(IMSG_EOF, req->id, NULL, 0);
532 		close_conn(0, 0, req);
533 		return;
534 	}
535 
536 	ev_add(req->fd, req_bio_ev(req), net_ev, req);
537 }
538 
539 static int
540 load_cert(struct imsg *imsg, struct req *req)
541 {
542 	struct stat	 sb;
543 	int		 fd;
544 
545 	if ((fd = imsg_get_fd(imsg)) == -1)
546 		return (0);
547 
548 	if (fstat(fd, &sb) == -1)
549 		return (-1);
550 
551 #if 0
552 	if (sb.st_size >= (off_t)SIZE_MAX) {
553 		close(fd);
554 		return (-1);
555 	}
556 #endif
557 
558 	req->ccert = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
559 	if (req->ccert == MAP_FAILED) {
560 		req->ccert = NULL;
561 		close(fd);
562 		return (-1);
563 	}
564 
565 	req->ccert_len = sb.st_size;
566 	req->ccert_fd = fd;
567 
568 	return (0);
569 }
570 
571 static void
572 handle_dispatch_imsg(int fd, int event, void *d)
573 {
574 	struct imsgev	*iev = d;
575 	struct imsgbuf	*ibuf = &iev->ibuf;
576 	struct imsg	 imsg;
577 	struct req	*req;
578 	struct get_req	 r;
579 	ssize_t		 n;
580 	int		 certok;
581 
582 	if (event & EV_READ) {
583 		if (imsgbuf_read(ibuf) == -1) {
584 			if (errno == EPIPE)
585 				errx(1, "connection closed");
586 			else
587 				err(1, "imsg_read failure");
588 		}
589 	}
590 	if (event & EV_WRITE) {
591 		if (imsgbuf_write(ibuf) == -1 && errno != EAGAIN)
592 			err(1, "msgbuf_write");
593 	}
594 
595 	for (;;) {
596 		if ((n = imsg_get(ibuf, &imsg)) == -1)
597 			err(1, "imsg_get");
598 		if (n == 0)
599 			break;
600 		switch (imsg_get_type(&imsg)) {
601 		case IMSG_GET:
602 			if (imsg_get_data(&imsg, &r, sizeof(r)) == -1 ||
603 			    r.host[sizeof(r.host) - 1] != '\0' ||
604 			    r.port[sizeof(r.port) - 1] != '\0' ||
605 			    r.req[sizeof(r.req) - 1] != '\0')
606 				die();
607 			if (r.proto != PROTO_FINGER &&
608 			    r.proto != PROTO_GEMINI &&
609 			    r.proto != PROTO_GOPHER)
610 				die();
611 
612 			req = xcalloc(1, sizeof(*req));
613 
614 			req->fd = -1;
615 #if HAVE_ASR_RUN
616 			req->ar_fd = -1;
617 #endif
618 			req->ccert_fd = -1;
619 			req->id = imsg_get_id(&imsg);
620 			TAILQ_INSERT_HEAD(&reqhead, req, reqs);
621 
622 			req->host = xstrdup(r.host);
623 			req->port = xstrdup(r.port);
624 			req->req = xstrdup(r.req);
625 			if (load_cert(&imsg, req) == -1)
626 				die();
627 			if (bufio_init(&req->bio) == -1)
628 				die();
629 
630 			req->len = strlen(req->req);
631 			req->proto = r.proto;
632 			req_resolve(-1, 0, req);
633 			break;
634 
635 		case IMSG_CERT_STATUS:
636 			if ((req = req_by_id(imsg_get_id(&imsg))) == NULL)
637 				break;
638 
639 			if (imsg_get_data(&imsg, &certok, sizeof(certok)) ==
640 			    -1)
641 				die();
642 			if (!certok) {
643 				close_conn(0, 0, req);
644 				break;
645 			}
646 
647 			if (net_send_req(req) == -1) {
648 				close_with_err(req, "failed to send request");
649 				break;
650 			}
651 
652 			if (ev_add(req->fd, EV_WRITE, net_ev, req) == -1) {
653 				close_with_err(req,
654 				    "failed to register event.");
655 				break;
656 			}
657 			break;
658 
659 		case IMSG_PROCEED:
660 			if ((req = req_by_id(imsg_get_id(&imsg))) == NULL)
661 				break;
662 			ev_add(req->fd, EV_READ, net_ev, req);
663 			net_ev(req->fd, 0, req);
664 			break;
665 
666 		case IMSG_STOP:
667 			if ((req = req_by_id(imsg_get_id(&imsg))) == NULL)
668 				break;
669 			close_conn(0, 0, req);
670 			break;
671 
672 		case IMSG_QUIT:
673 			ev_break();
674 			imsg_free(&imsg);
675 			return;
676 
677 		default:
678 			errx(1, "got unknown imsg %d", imsg_get_type(&imsg));
679 		}
680 
681 		imsg_free(&imsg);
682 	}
683 
684 	imsg_event_add(iev);
685 }
686 
687 static int
688 net_send_ui(int type, uint32_t peerid, const void *data,
689     uint16_t datalen)
690 {
691 	return imsg_compose_event(iev_ui, type, peerid, 0, -1,
692 	    data, datalen);
693 }
694 
695 int
696 net_main(void)
697 {
698 	setproctitle("net");
699 
700 	TAILQ_INIT(&reqhead);
701 
702 	if (ev_init() == -1)
703 		exit(1);
704 
705 	/* Setup pipe and event handler to the main process */
706 	iev_ui = xmalloc(sizeof(*iev_ui));
707 	if (imsgbuf_init(&iev_ui->ibuf, 3) == -1)
708 		err(1, "imsgbuf_init failed");
709 	imsgbuf_allow_fdpass(&iev_ui->ibuf);
710 	iev_ui->handler = handle_dispatch_imsg;
711 	iev_ui->events = EV_READ;
712 	ev_add(iev_ui->ibuf.fd, iev_ui->events, iev_ui->handler, iev_ui);
713 
714 	sandbox_net_process();
715 
716 	ev_loop();
717 
718 	imsgbuf_clear(&iev_ui->ibuf);
719 	close(iev_ui->ibuf.fd);
720 	free(iev_ui);
721 
722 	return 0;
723 }