op public repos

Blob

Date:: Wed Sep 22 16:48:26 2021 UTC
Message:: proposal: show custom message when the capsule is not reachable As discussed in the mailing list, this is a quick draft for a (imho) neat functionality: if there's an error connecting to a capsule, try to do a TXT query at _offline.$hostname (this is subject to change) and show the message to the user. It's a nice way to communicate to the user that a certain capsule is, for example, supposed to be offline in certain situations.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021 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/types.h>
20 #include <sys/socket.h>
21 
22 #include <netinet/in.h>
23 
24 #include <assert.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <netdb.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <tls.h>
33 #include <unistd.h>
34 
35 #if HAVE_ASR_RUN
36 # include <asr.h>
37 #endif
38 
39 #define DNS_RDATACLASS_IN	1
40 #define DNS_RDATATYPE_TXT	16
41 
42 #include "telescope.h"
43 
44 static struct imsgev		*iev_ui;
45 static struct tls_config	*tlsconf;
46 
47 /* a pending request */
48 struct req {
49 	struct phos_uri		 url;
50 	uint32_t		 id;
51 	int			 proto;
52 	int			 fd;
53 	struct tls		*ctx;
54 	char			 req[1024];
55 	size_t			 len;
56 	int			 done_header;
57 	struct bufferevent	*bev;
58 
59 	struct addrinfo		*servinfo, *p;
60 #if HAVE_ASR_RUN
61 	struct addrinfo		 hints;
62 	struct event_asr	*asrev;
63 #endif
64 
65 	TAILQ_ENTRY(req)	 reqs;
66 };
67 
68 static struct req	*req_by_id(uint32_t);
69 
70 static void	 die(void) __attribute__((__noreturn__));
71 
72 static void	 try_to_connect(int, short, void*);
73 
74 static void	 offline_dns_done(struct rrsetinfo *, struct req *);
75 static void	 offline_dns_query(struct req *);
76 
77 #if HAVE_ASR_RUN
78 static void	 query_done(struct asr_result*, void*);
79 static void	 async_conn_towards(struct req*);
80 static void	 offline_query_done(struct asr_result *, void *);
81 #else
82 static void	 blocking_conn_towards(struct req*);
83 #endif
84 
85 static void	 close_with_err(struct req*, const char*);
86 static void	 close_with_errf(struct req*, const char*, ...)
87     __attribute__((format(printf, 2, 3)));
88 
89 static void	 net_tls_handshake(int, short, void *);
90 static void	 net_tls_readcb(int, short, void *);
91 static void	 net_tls_writecb(int, short, void *);
92 
93 static int	 gemini_parse_reply(struct req *, const char *, size_t);
94 
95 static void	 net_ready(struct req *req);
96 static void	 net_read(struct bufferevent *, void *);
97 static void	 net_write(struct bufferevent *, void *);
98 static void	 net_error(struct bufferevent *, short, void *);
99 
100 static void	 handle_get_raw(struct imsg *, size_t);
101 static void	 handle_cert_status(struct imsg*, size_t);
102 static void	 handle_proceed(struct imsg*, size_t);
103 static void	 handle_stop(struct imsg*, size_t);
104 static void	 handle_quit(struct imsg*, size_t);
105 static void	 handle_dispatch_imsg(int, short, void*);
106 
107 static int	 net_send_ui(int, uint32_t, const void *, uint16_t);
108 
109 /* TODO: making this customizable */
110 struct timeval timeout_for_handshake = { 5, 0 };
111 
112 static imsg_handlerfn *handlers[] = {
113 	[IMSG_GET_RAW]		= handle_get_raw,
114 	[IMSG_CERT_STATUS]	= handle_cert_status,
115 	[IMSG_PROCEED]		= handle_proceed,
116 	[IMSG_STOP]		= handle_stop,
117 	[IMSG_QUIT]		= handle_quit,
118 };
119 
120 typedef void (*statefn)(int, short, void*);
121 
122 TAILQ_HEAD(, req) reqhead;
123 
124 static inline void
125 yield_r(struct req *req, statefn fn, struct timeval *tv)
126 {
127 	event_once(req->fd, EV_READ, fn, req, tv);
128 }
129 
130 static inline void
131 yield_w(struct req *req, statefn fn, struct timeval *tv)
132 {
133 	event_once(req->fd, EV_WRITE, fn, req, tv);
134 }
135 
136 static struct req *
137 req_by_id(uint32_t id)
138 {
139 	struct req *r;
140 
141 	TAILQ_FOREACH(r, &reqhead, reqs) {
142 		if (r->id == id)
143 			return r;
144 	}
145 
146 	return NULL;
147 }
148 
149 static void __attribute__((__noreturn__))
150 die(void)
151 {
152 	abort(); 		/* TODO */
153 }
154 
155 static void
156 try_to_connect(int fd, short ev, void *d)
157 {
158 	struct req	*req = d;
159 	int		 error = 0;
160 	socklen_t	 len = sizeof(error);
161 
162 again:
163 	if (req->p == NULL)
164 		goto err;
165 
166 	if (req->fd != -1) {
167 		if (getsockopt(req->fd, SOL_SOCKET, SO_ERROR, &error,
168 		    &len) == -1)
169 			goto err;
170 		if (error != 0) {
171 			errno = error;
172 			goto err;
173 		}
174 		goto done;
175 	}
176 
177 	req->fd = socket(req->p->ai_family, req->p->ai_socktype,
178 	    req->p->ai_protocol);
179 	if (req->fd == -1) {
180 		req->p = req->p->ai_next;
181 		goto again;
182 	} else {
183 		mark_nonblock(req->fd);
184 		if (connect(req->fd, req->p->ai_addr, req->p->ai_addrlen) == 0)
185 			goto done;
186 		yield_w(req, try_to_connect, NULL);
187 	}
188 	return;
189 
190 err:
191 	freeaddrinfo(req->servinfo);
192 	offline_dns_query(req);
193 	return;
194 
195 done:
196 	freeaddrinfo(req->servinfo);
197 
198 	switch (req->proto) {
199 	case PROTO_FINGER:
200 	case PROTO_GOPHER:
201 		/* finger and gopher don't have a header nor TLS */
202 		req->done_header = 1;
203 		net_ready(req);
204 		break;
205 
206 	case PROTO_GEMINI:
207 		/* prepare tls */
208 		if ((req->ctx = tls_client()) == NULL) {
209 			close_with_errf(req, "tls_client: %s",
210 			    strerror(errno));
211 			return;
212 		}
213 		if (tls_configure(req->ctx, tlsconf) == -1) {
214 			close_with_errf(req, "tls_configure: %s",
215 			    tls_error(req->ctx));
216 			return;
217 		}
218 		if (tls_connect_socket(req->ctx, req->fd, req->url.host)
219 		    == -1) {
220 			close_with_errf(req, "tls_connect_socket: %s",
221 			    tls_error(req->ctx));
222 			return;
223 		}
224 		yield_w(req, net_tls_handshake, &timeout_for_handshake);
225 		break;
226 
227 	default:
228 		die();
229 	}
230 }
231 
232 static void
233 offline_dns_done(struct rrsetinfo *res, struct req *req)
234 {
235 	size_t		 i, len;
236 	const char	*reason = NULL;
237 
238 	for (i = 0; i < res->rri_nrdatas; ++i) {
239 		if (res->rri_rdatas[i].rdi_length <= 1)
240 			continue;
241 
242 		len = *(uint8_t*)res->rri_rdatas[i].rdi_data;
243 		reason = res->rri_rdatas[i].rdi_data+1;
244 		break;
245 	}
246 
247 	if (reason == NULL)
248 		close_with_errf(req, "failed to connect to %s", req->url.host);
249 	else
250 		close_with_errf(req,
251 		    "failed to connect to %s\n\nThe site says: %*s\n",
252 		    req->url.host, (int)len, reason);
253 
254 	freerrset(res);
255 }
256 
257 static void
258 offline_dns_query(struct req *req)
259 {
260 	char		hostname[254];
261 
262 	strlcpy(hostname, "_offline.", sizeof(hostname));
263 	strlcat(hostname, req->url.host, sizeof(hostname));
264 
265 #if HAVE_ASR_RUN
266 	{
267 		struct asr_query *q;
268 
269 		q = getrrsetbyname_async(hostname, DNS_RDATACLASS_IN,
270 		    DNS_RDATATYPE_TXT, 0, NULL);
271 		req->asrev = event_asr_run(q, offline_query_done, req);
272 	}
273 #else
274 	{
275 		struct rrsetinfo *res;
276 
277 		if (getrrsetbyname(hostname, DNS_RDATACLASS_IN,
278 		    DNS_RDATATYPE_TXT, 0, &res))
279 			close_with_errf(req, "failed to connect to %s",
280 			    req->url.host);
281 		else
282 			offline_dns_done(res, req);
283 	}
284 #endif
285 }
286 
287 #if HAVE_ASR_RUN
288 static void
289 query_done(struct asr_result *res, void *d)
290 {
291 	struct req	*req = d;
292 
293 	req->asrev = NULL;
294 	if (res->ar_gai_errno != 0) {
295 		close_with_errf(req, "failed to resolve %s: %s",
296 		    req->url.host, gai_strerror(res->ar_gai_errno));
297 		return;
298 	}
299 
300 	req->fd = -1;
301 	req->servinfo = res->ar_addrinfo;
302 	req->p = res->ar_addrinfo;
303 	try_to_connect(0, 0, req);
304 }
305 
306 static void
307 async_conn_towards(struct req *req)
308 {
309 	struct asr_query	*q;
310 	const char		*proto = "1965";
311 
312 	if (*req->url.port != '\0')
313 		proto = req->url.port;
314 
315 	req->hints.ai_family = AF_UNSPEC;
316 	req->hints.ai_socktype = SOCK_STREAM;
317 	q = getaddrinfo_async(req->url.host, proto, &req->hints, NULL);
318 	req->asrev = event_asr_run(q, query_done, req);
319 }
320 
321 static void
322 offline_query_done(struct asr_result *res, void *d)
323 {
324 	struct req		*req = d;
325 
326 	req->asrev = NULL;
327 	if (res->ar_rrset_errno != 0) {
328 		close_with_errf(req, "failed to resolve %s", req->url.host);
329 		return;
330 	}
331 
332 	offline_dns_done(res->ar_rrsetinfo, req);
333 }
334 
335 #else
336 static void
337 blocking_conn_towards(struct req *req)
338 {
339 	struct addrinfo	 hints;
340 	struct phos_uri	*url = &req->url;
341 	int		 status;
342 	const char	*proto = "1965";
343 
344 	if (*url->port != '\0')
345 		proto = url->port;
346 
347 	memset(&hints, 0, sizeof(hints));
348 	hints.ai_family = AF_UNSPEC;
349 	hints.ai_socktype = SOCK_STREAM;
350 
351 	if ((status = getaddrinfo(url->host, proto, &hints, &req->servinfo))) {
352 		close_with_errf(req, "failed to resolve %s: %s",
353 		    url->host, gai_strerror(status));
354 		return;
355 	}
356 
357 	req->fd = -1;
358 	req->p = req->servinfo;
359 	try_to_connect(0, 0, req);
360 }
361 #endif
362 
363 static void
364 close_conn(int fd, short ev, void *d)
365 {
366 	struct req	*req = d;
367 
368 #if HAVE_ASR_RUN
369 	if (req->asrev != NULL)
370 		event_asr_abort(req->asrev);
371 #endif
372 
373 	if (req->bev != NULL) {
374 		bufferevent_free(req->bev);
375 		req->bev = NULL;
376 	}
377 
378 	if (req->ctx != NULL) {
379 		switch (tls_close(req->ctx)) {
380 		case TLS_WANT_POLLIN:
381 			yield_r(req, close_conn, NULL);
382 			return;
383 		case TLS_WANT_POLLOUT:
384 			yield_w(req, close_conn, NULL);
385 			return;
386 		}
387 
388 		tls_free(req->ctx);
389 		req->ctx = NULL;
390 	}
391 
392 	TAILQ_REMOVE(&reqhead, req, reqs);
393 	if (req->fd != -1)
394 		close(req->fd);
395 	free(req);
396 }
397 
398 static void
399 close_with_err(struct req *req, const char *err)
400 {
401 	net_send_ui(IMSG_ERR, req->id, err, strlen(err)+1);
402 	close_conn(0, 0, req);
403 }
404 
405 static void
406 close_with_errf(struct req *req, const char *fmt, ...)
407 {
408 	va_list	 ap;
409 	char	*s;
410 
411 	va_start(ap, fmt);
412 	if (vasprintf(&s, fmt, ap) == -1)
413 		abort();
414 	va_end(ap);
415 
416 	close_with_err(req, s);
417 	free(s);
418 }
419 
420 static void
421 net_tls_handshake(int fd, short event, void *d)
422 {
423 	struct req	*req = d;
424 	const char	*hash;
425 
426 	if (event == EV_TIMEOUT) {
427 		close_with_err(req, "Timeout loading page");
428 		return;
429 	}
430 
431 	switch (tls_handshake(req->ctx)) {
432 	case TLS_WANT_POLLIN:
433 		yield_r(req, net_tls_handshake, NULL);
434 		return;
435 	case TLS_WANT_POLLOUT:
436 		yield_w(req, net_tls_handshake, NULL);
437 		return;
438 	}
439 
440 	hash = tls_peer_cert_hash(req->ctx);
441 	if (hash == NULL) {
442 		close_with_errf(req, "handshake failed: %s",
443 		    tls_error(req->ctx));
444 		return;
445 	}
446 	net_send_ui(IMSG_CHECK_CERT, req->id, hash, strlen(hash)+1);
447 }
448 
449 static void
450 net_tls_readcb(int fd, short event, void *d)
451 {
452 	struct bufferevent	*bufev = d;
453 	struct req		*req = bufev->cbarg;
454 	char			 buf[IBUF_READ_SIZE];
455 	int			 what = EVBUFFER_READ;
456 	int			 howmuch = IBUF_READ_SIZE;
457 	int			 res;
458 	ssize_t			 ret;
459 	size_t			 len;
460 
461 	if (event == EV_TIMEOUT) {
462 		what |= EVBUFFER_TIMEOUT;
463 		goto err;
464 	}
465 
466 	if (bufev->wm_read.high != 0)
467 		howmuch = MIN(sizeof(buf), bufev->wm_read.high);
468 
469 	switch (ret = tls_read(req->ctx, buf, howmuch)) {
470 	case TLS_WANT_POLLIN:
471 	case TLS_WANT_POLLOUT:
472 		goto retry;
473 	case -1:
474 		what |= EVBUFFER_ERROR;
475 		goto err;
476 	}
477 	len = ret;
478 
479 	if (len == 0) {
480 		what |= EVBUFFER_EOF;
481 		goto err;
482 	}
483 
484 	res = evbuffer_add(bufev->input, buf, len);
485 	if (res == -1) {
486 		what |= EVBUFFER_ERROR;
487 		goto err;
488 	}
489 
490 	event_add(&bufev->ev_read, NULL);
491 
492 	len = EVBUFFER_LENGTH(bufev->input);
493 	if (bufev->wm_read.low != 0 && len < bufev->wm_read.low)
494 		return;
495 
496 	if (bufev->readcb != NULL)
497 		(*bufev->readcb)(bufev, bufev->cbarg);
498 	return;
499 
500 retry:
501 	event_add(&bufev->ev_read, NULL);
502 	return;
503 
504 err:
505 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
506 }
507 
508 static void
509 net_tls_writecb(int fd, short event, void *d)
510 {
511 	struct bufferevent	*bufev = d;
512 	struct req		*req = bufev->cbarg;
513 	ssize_t			 ret;
514 	size_t			 len;
515 	short			 what = EVBUFFER_WRITE;
516 
517 	if (event & EV_TIMEOUT) {
518 		what |= EVBUFFER_TIMEOUT;
519 		goto err;
520 	}
521 
522 	if (EVBUFFER_LENGTH(bufev->output) != 0) {
523 		ret = tls_write(req->ctx, EVBUFFER_DATA(bufev->output),
524 		    EVBUFFER_LENGTH(bufev->output));
525 		switch (ret) {
526 		case TLS_WANT_POLLIN:
527 		case TLS_WANT_POLLOUT:
528 			goto retry;
529 		case -1:
530 			what |= EVBUFFER_ERROR;
531 			goto err;
532 		}
533 		len = ret;
534 
535 		evbuffer_drain(bufev->output, len);
536 	}
537 
538 	if (EVBUFFER_LENGTH(bufev->output) != 0)
539 		event_add(&bufev->ev_write, NULL);
540 
541 	if (bufev->writecb != NULL &&
542 	    EVBUFFER_LENGTH(bufev->output) <= bufev->wm_write.low)
543 		(*bufev->writecb)(bufev, bufev->cbarg);
544 	return;
545 
546 retry:
547 	event_add(&bufev->ev_write, NULL);
548 	return;
549 
550 err:
551 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
552 }
553 
554 static int
555 gemini_parse_reply(struct req *req, const char *header, size_t len)
556 {
557 	int		 code;
558 	const char	*t;
559 
560 	if (len < 4)
561 		return 0;
562 
563 	if (!isdigit(header[0]) || !isdigit(header[1]))
564 		return 0;
565 
566 	code = (header[0] - '0')*10 + (header[1] - '0');
567 	if (header[2] != ' ')
568 		return 0;
569 
570 	t = header + 3;
571 
572 	net_send_ui(IMSG_GOT_CODE, req->id, &code, sizeof(code));
573 	net_send_ui(IMSG_GOT_META, req->id, t, strlen(t)+1);
574 
575 	bufferevent_disable(req->bev, EV_READ|EV_WRITE);
576 
577 	if (code < 20 || code >= 30)
578 		close_conn(0, 0, req);
579 	return 1;
580 }
581 
582 /* called when we're ready to read/write */
583 static void
584 net_ready(struct req *req)
585 {
586 	req->bev = bufferevent_new(req->fd, net_read, net_write, net_error,
587 	    req);
588 	if (req->bev == NULL)
589 		die();
590 
591 #if HAVE_EVENT2
592 	evbuffer_unfreeze(req->bev->input, 0);
593 	evbuffer_unfreeze(req->bev->output, 1);
594 #endif
595 
596 	/* setup tls i/o layer */
597 	if (req->ctx != NULL) {
598 		event_set(&req->bev->ev_read, req->fd, EV_READ,
599 		    net_tls_readcb, req->bev);
600 		event_set(&req->bev->ev_write, req->fd, EV_WRITE,
601 		    net_tls_writecb, req->bev);
602 	}
603 
604 	/* TODO: adjust watermarks */
605 	bufferevent_setwatermark(req->bev, EV_WRITE, 1, 0);
606 	bufferevent_setwatermark(req->bev, EV_READ,  1, 0);
607 
608 	bufferevent_enable(req->bev, EV_READ|EV_WRITE);
609 
610 	bufferevent_write(req->bev, req->req, req->len);
611 }
612 
613 /* called after a read has been done */
614 static void
615 net_read(struct bufferevent *bev, void *d)
616 {
617 	struct req	*req = d;
618 	struct evbuffer	*src = EVBUFFER_INPUT(bev);
619 	void		*data;
620 	size_t		 len, chunk;
621 	int		 r;
622 	char		*header;
623 
624 	if (!req->done_header) {
625 		header = evbuffer_readln(src, &len, EVBUFFER_EOL_CRLF_STRICT);
626 		if (header == NULL && EVBUFFER_LENGTH(src) >= 1024)
627 			goto err;
628 		if (header == NULL)
629 			return;
630 		r = gemini_parse_reply(req, header, len);
631 		free(header);
632 		if (!r)
633 			goto err;
634 		req->done_header = 1;
635 		return;
636 	}
637 
638 	if ((len = EVBUFFER_LENGTH(src)) == 0)
639 		return;
640 	data = EVBUFFER_DATA(src);
641 
642 	/*
643 	 * Split data into chunks before sending.  imsg can't handle
644 	 * message that are "too big".
645 	 */
646 	while (len != 0) {
647 		chunk = MIN(len, 4096);
648 		net_send_ui(IMSG_BUF, req->id, data, chunk);
649 		data += chunk;
650 		len -= chunk;
651 	}
652 
653 	evbuffer_drain(src, EVBUFFER_LENGTH(src));
654 	return;
655 
656 err:
657 	(*bev->errorcb)(bev, EVBUFFER_READ, bev->cbarg);
658 }
659 
660 /* called after a write has been done */
661 static void
662 net_write(struct bufferevent *bev, void *d)
663 {
664 	struct evbuffer	*dst = EVBUFFER_OUTPUT(bev);
665 
666 	if (EVBUFFER_LENGTH(dst) == 0)
667 		(*bev->errorcb)(bev, EVBUFFER_WRITE, bev->cbarg);
668 }
669 
670 static void
671 net_error(struct bufferevent *bev, short error, void *d)
672 {
673 	struct req	*req = d;
674 	struct evbuffer	*src;
675 
676 	if (error & EVBUFFER_TIMEOUT) {
677 		close_with_err(req, "Timeout loading page");
678 		return;
679 	}
680 
681 	if (error & EVBUFFER_ERROR) {
682 		close_with_err(req, "buffer event error");
683 		return;
684 	}
685 
686 	if (error & EVBUFFER_EOF) {
687 		src = EVBUFFER_INPUT(req->bev);
688 		if (EVBUFFER_LENGTH(src) != 0)
689 			net_send_ui(IMSG_BUF, req->id, EVBUFFER_DATA(src),
690 			    EVBUFFER_LENGTH(src));
691 		net_send_ui(IMSG_EOF, req->id, NULL, 0);
692 		close_conn(0, 0, req);
693 		return;
694 	}
695 
696 	if (error & EVBUFFER_WRITE) {
697 		/* finished sending request */
698 		bufferevent_disable(bev, EV_WRITE);
699 		return;
700 	}
701 
702 	if (error & EVBUFFER_READ) {
703 		close_with_err(req, "protocol error");
704 		return;
705 	}
706 
707 	close_with_errf(req, "unknown event error %x", error);
708 }
709 
710 static void
711 handle_get_raw(struct imsg *imsg, size_t datalen)
712 {
713 	struct req	*req;
714 	struct get_req	*r;
715 
716 	r = imsg->data;
717 
718 	if (datalen != sizeof(*r))
719 		die();
720 
721 	if ((req = calloc(1, sizeof(*req))) == NULL)
722 		die();
723 
724 	req->id = imsg->hdr.peerid;
725 	TAILQ_INSERT_HEAD(&reqhead, req, reqs);
726 
727 	strlcpy(req->url.host, r->host, sizeof(req->url.host));
728 	strlcpy(req->url.port, r->port, sizeof(req->url.port));
729 
730 	strlcpy(req->req, r->req, sizeof(req->req));
731 	req->len = strlen(r->req);
732 
733 	req->proto = r->proto;
734 
735 #if HAVE_ASR_RUN
736 	async_conn_towards(req);
737 #else
738 	blocking_conn_towards(req);
739 #endif
740 }
741 
742 static void
743 handle_cert_status(struct imsg *imsg, size_t datalen)
744 {
745 	struct req	*req;
746 	int		 is_ok;
747 
748 	req = req_by_id(imsg->hdr.peerid);
749 
750 	if (datalen < sizeof(is_ok))
751 		die();
752 	memcpy(&is_ok, imsg->data, sizeof(is_ok));
753 
754 	if (is_ok)
755 		net_ready(req);
756 	else
757 		close_conn(0, 0, req);
758 }
759 
760 static void
761 handle_proceed(struct imsg *imsg, size_t datalen)
762 {
763 	struct req *req;
764 
765 	if ((req = req_by_id(imsg->hdr.peerid)) == NULL)
766 		return;
767 
768 	bufferevent_enable(req->bev, EV_READ);
769 }
770 
771 static void
772 handle_stop(struct imsg *imsg, size_t datalen)
773 {
774 	struct req	*req;
775 
776 	if ((req = req_by_id(imsg->hdr.peerid)) == NULL)
777 		return;
778 	close_conn(0, 0, req);
779 }
780 
781 static void
782 handle_quit(struct imsg *imsg, size_t datalen)
783 {
784 	event_loopbreak();
785 }
786 
787 static void
788 handle_dispatch_imsg(int fd, short ev, void *d)
789 {
790 	struct imsgev	*iev = d;
791 
792 	if (dispatch_imsg(iev, ev, handlers, sizeof(handlers)) == -1)
793 		err(1, "connection closed");
794 }
795 
796 static int
797 net_send_ui(int type, uint32_t peerid, const void *data,
798     uint16_t datalen)
799 {
800 	return imsg_compose_event(iev_ui, type, peerid, 0, -1,
801 	    data, datalen);
802 }
803 
804 int
805 net_main(void)
806 {
807 	setproctitle("net");
808 
809 	TAILQ_INIT(&reqhead);
810 
811 	if ((tlsconf = tls_config_new()) == NULL)
812 		die();
813 	tls_config_insecure_noverifycert(tlsconf);
814 	tls_config_insecure_noverifyname(tlsconf);
815 
816 	event_init();
817 
818 	/* Setup pipe and event handler to the main process */
819 	if ((iev_ui = malloc(sizeof(*iev_ui))) == NULL)
820 		die();
821 	imsg_init(&iev_ui->ibuf, 3);
822 	iev_ui->handler = handle_dispatch_imsg;
823 	iev_ui->events = EV_READ;
824 	event_set(&iev_ui->ev, iev_ui->ibuf.fd, iev_ui->events,
825 	    iev_ui->handler, iev_ui);
826 	event_add(&iev_ui->ev, NULL);
827 
828 	sandbox_net_process();
829 
830 	event_dispatch();
831 
832 	tls_config_free(tlsconf);
833 	msgbuf_clear(&iev_ui->ibuf.w);
834 	close(iev_ui->ibuf.fd);
835 	free(iev_ui);
836 
837 	return 0;
838 }