1 #include "telescope.h"
2 
3 #include <sys/socket.h>
4 
5 #include <err.h>
6 #include <errno.h>
7 #include <signal.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <unistd.h>
12 
13 struct event		 netev, fsev;
14 struct tabshead		 tabshead;
15 
16 /* the first is also the fallback one */
17 static struct proto protos[] = {
18 	{ "gemini:",	load_gemini_url },
19 	{ "about:",	load_about_url },
20 	{ NULL, NULL },
21 };
22 
23 static struct imsgbuf	*netibuf, *fsibuf;
24 
25 static void		 die(void) __attribute__((__noreturn__));
26 static struct tab	*tab_by_id(uint32_t);
27 static void		 handle_imsg_err(struct imsg*, size_t);
28 static void		 handle_imsg_check_cert(struct imsg*, size_t);
29 static void		 handle_imsg_got_code(struct imsg*, size_t);
30 static void		 handle_imsg_got_meta(struct imsg*, size_t);
31 static void		 handle_imsg_buf(struct imsg*, size_t);
32 static void		 handle_imsg_eof(struct imsg*, size_t);
33 static void		 dispatch_imsg(int, short, void*);
34 static void		 load_page_from_str(struct tab*, const char*);
35 static void		 do_load_url(struct tab*, const char*);
36 
37 static imsg_handlerfn *handlers[] = {
38 	[IMSG_ERR] = handle_imsg_err,
39 	[IMSG_CHECK_CERT] = handle_imsg_check_cert,
40 	[IMSG_GOT_CODE] = handle_imsg_got_code,
41 	[IMSG_GOT_META] = handle_imsg_got_meta,
42 	[IMSG_BUF] = handle_imsg_buf,
43 	[IMSG_EOF] = handle_imsg_eof,
44 };
45 
46 static void __attribute__((__noreturn__))
47 die(void)
48 {
49 	abort(); 		/* TODO */
50 }
51 
52 static struct tab *
53 tab_by_id(uint32_t id)
54 {
55 	struct tab *t;
56 
57 	TAILQ_FOREACH(t, &tabshead, tabs) {
58 		if (t->id == id)
59 			return t;
60 	}
61 
62 	die();
63 }
64 
65 static void
66 handle_imsg_err(struct imsg *imsg, size_t datalen)
67 {
68 	struct tab	*tab;
69 	char		*page;
70 
71 	tab = tab_by_id(imsg->hdr.peerid);
72 
73 	page = imsg->data;
74 	page[datalen-1] = '\0';
75 
76 	if (asprintf(&page, "# Error loading %s\n\n> %s\n",
77 	    tab->hist_cur->h, page) == -1)
78 		die();
79 	load_page_from_str(tab, page);
80 	free(page);
81 }
82 
83 static void
84 handle_imsg_check_cert(struct imsg *imsg, size_t datalen)
85 {
86 	int	tofu_res = 1;
87 
88 	imsg_compose(netibuf, IMSG_CERT_STATUS, imsg->hdr.peerid, 0, -1, &tofu_res, sizeof(tofu_res));
89 	imsg_flush(netibuf);
90 }
91 
92 static inline int
93 normalize_code(int n)
94 {
95 	if (n < 20) {
96 		if (n == 10 || n == 11)
97 			return n;
98 		return 10;
99 	} else if (n < 30) {
100 		return 20;
101 	} else if (n < 40) {
102 		if (n == 30 || n == 31)
103 			return n;
104 		return 30;
105 	} else if (n < 50) {
106 		if (n <= 44)
107 			return n;
108 		return 40;
109 	} else if (n < 60) {
110 		if (n <= 53 || n == 59)
111 			return n;
112 		return 50;
113 	} else if (n < 70) {
114 		if (n <= 62)
115 			return n;
116 		return 60;
117 	} else
118 		return MALFORMED_RESPONSE;
119 }
120 
121 static void
122 handle_imsg_got_code(struct imsg *imsg, size_t datalen)
123 {
124 	struct tab	*tab;
125 
126 	tab = tab_by_id(imsg->hdr.peerid);
127 
128 	if (sizeof(tab->code) != datalen)
129 		die();
130 
131 	memcpy(&tab->code, imsg->data, sizeof(tab->code));
132 	tab->code = normalize_code(tab->code);
133 	if (tab->code != 30 && tab->code != 31)
134 		tab->redirect_count = 0;
135 }
136 
137 static void
138 handle_imsg_got_meta(struct imsg *imsg, size_t datalen)
139 {
140 	struct tab	*tab;
141 
142 	tab = tab_by_id(imsg->hdr.peerid);
143 
144 	if (sizeof(tab->meta) <= datalen)
145 		die();
146 
147 	memcpy(tab->meta, imsg->data, datalen);
148 
149 	if (tab->code < 10) {	/* internal errors */
150 		load_page_from_str(tab, err_pages[tab->code]);
151 	} else if (tab->code < 20) {	/* 1x */
152 		load_page_from_str(tab, err_pages[tab->code]);
153 		ui_require_input(tab, tab->code == 11);
154 	} else if (tab->code == 20) {
155 		if (setup_parser_for(tab)) {
156 			imsg_compose(netibuf, IMSG_PROCEED, tab->id, 0, -1, NULL, 0);
157 			imsg_flush(netibuf);
158 		} else {
159 			load_page_from_str(tab, err_pages[UNKNOWN_TYPE_OR_CSET]);
160 		}
161 	} else if (tab->code < 40) { /* 3x */
162 		tab->redirect_count++;
163 
164 		/* TODO: make customizable? */
165 		if (tab->redirect_count > 5) {
166 			load_page_from_str(tab,
167 			    err_pages[TOO_MUCH_REDIRECTS]);
168 		} else
169 			do_load_url(tab, tab->meta);
170 	} else { /* 4x, 5x & 6x */
171 		load_page_from_str(tab, err_pages[tab->code]);
172 	}
173 }
174 
175 static void
176 handle_imsg_buf(struct imsg *imsg, size_t datalen)
177 {
178 	struct tab	*tab;
179 
180 	tab = tab_by_id(imsg->hdr.peerid);
181 
182 	if (!tab->page.parse(&tab->page, imsg->data, datalen))
183 		die();
184 
185 	ui_on_tab_refresh(tab);
186 }
187 
188 static void
189 handle_imsg_eof(struct imsg *imsg, size_t datalen)
190 {
191 	struct tab	*t;
192 
193 	t = tab_by_id(imsg->hdr.peerid);
194 	if (!t->page.free(&t->page))
195 		die();
196 
197 	ui_on_tab_refresh(t);
198 	ui_on_tab_loaded(t);
199 }
200 
201 static void
202 dispatch_imsg(int fd, short ev, void *d)
203 {
204 	struct imsgbuf	*ibuf = d;
205 	struct imsg	 imsg;
206 	size_t		 datalen;
207 	ssize_t		 n;
208 
209 	if ((n = imsg_read(ibuf)) == -1) {
210 		if (errno == EAGAIN || errno == EWOULDBLOCK)
211 			return;
212 		die();
213 	}
214 
215 	if (n == 0)
216 		_exit(1);
217 
218 	for (;;) {
219 		if ((n = imsg_get(ibuf, &imsg)) == -1)
220 			die();
221 		if (n == 0)
222 			return;
223 		datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
224 		handlers[imsg.hdr.type](&imsg, datalen);
225 		imsg_free(&imsg);
226 	}
227 }
228 
229 static void
230 load_page_from_str(struct tab *tab, const char *page)
231 {
232 	gemtext_initparser(&tab->page);
233 	if (!tab->page.parse(&tab->page, page, strlen(page)))
234 		die();
235 	if (!tab->page.free(&tab->page))
236 		die();
237 	ui_on_tab_refresh(tab);
238 	ui_on_tab_loaded(tab);
239 }
240 
241 void
242 load_about_url(struct tab *tab, const char *url)
243 {
244 	char	*m;
245 	size_t	 len;
246 
247 
248 	memset(&tab->url, 0, sizeof(tab->url));
249 
250 	m = strchr(url, ':');
251 	strlcpy(tab->url.scheme, "about", sizeof(tab->url.scheme));
252 	strlcpy(tab->url.path, m+1, sizeof(tab->url.path));
253 
254 	len = sizeof(tab->hist_cur->h)-1;
255 	strlcpy(tab->hist_cur->h, url, len);
256 
257 	gemtext_initparser(&tab->page);
258 
259 	imsg_compose(fsibuf, IMSG_GET, tab->id, 0, -1,
260 	    tab->hist_cur->h, len+1);
261 	imsg_flush(fsibuf);
262 }
263 
264 void
265 load_gemini_url(struct tab *tab, const char *url)
266 {
267 	const char	*err;
268 	char		*p;
269 	size_t		 len;
270 
271 	if (has_prefix(url, "gemini:")) {
272 		if (!url_parse(url, &tab->url, &err))
273 			goto err;
274 	} else {
275 		if (!url_resolve_from(&tab->url, url, &err))
276 			goto err;
277 	}
278 
279 	len = sizeof(tab->hist_cur->h)-1;
280 	url_unparse(&tab->url, tab->hist_cur->h, len);
281 	imsg_compose(netibuf, IMSG_GET, tab->id, 0, -1,
282 	    tab->hist_cur->h, len+1);
283 	imsg_flush(netibuf);
284 	return;
285 
286 err:
287 	if (asprintf(&p, "#error loading %s\n>%s\n",
288 	    url, err) == -1)
289 		die();
290 	strlcpy(tab->hist_cur->h, url, len);
291 	load_page_from_str(tab, p);
292 	free(p);
293 }
294 
295 static void
296 do_load_url(struct tab *tab, const char *url)
297 {
298 	struct proto *p;
299 
300 	for (p = protos; p->schema != NULL; ++p) {
301 		if (has_prefix(url, p->schema)) {
302 			p->loadfn(tab, url);
303 			return;
304 		}
305 	}
306 
307 	protos[0].loadfn(tab, url);
308 }
309 
310 void
311 load_url(struct tab *tab, const char *url)
312 {
313 	if (tab->hist_cur != NULL)
314 		hist_clear_forward(&tab->hist, TAILQ_NEXT(tab->hist_cur, entries));
315 
316 	if ((tab->hist_cur = calloc(1, sizeof(*tab->hist_cur))) == NULL) {
317 		event_loopbreak();
318 		return;
319 	}
320 	hist_push(&tab->hist, tab->hist_cur);
321 	do_load_url(tab, url);
322 }
323 
324 int
325 load_previous_page(struct tab *tab)
326 {
327 	struct hist	*h;
328 
329 	if ((h = TAILQ_PREV(tab->hist_cur, mhisthead, entries)) == NULL)
330 		return 0;
331 	tab->hist_cur = h;
332 	do_load_url(tab, h->h);
333 	return 1;
334 }
335 
336 int
337 load_next_page(struct tab *tab)
338 {
339 	struct hist	*h;
340 
341 	if ((h = TAILQ_NEXT(tab->hist_cur, entries)) == NULL)
342 		return 0;
343 	tab->hist_cur = h;
344 	do_load_url(tab, h->h);
345 	return 1;
346 }
347 
348 void
349 stop_tab(struct tab *tab)
350 {
351 	imsg_compose(netibuf, IMSG_STOP, tab->id, 0, -1, NULL, 0);
352 	imsg_flush(netibuf);
353 }
354 
355 int
356 main(void)
357 {
358 	struct imsgbuf	network_ibuf, fs_ibuf;
359 	int		net_fds[2], fs_fds[2];
360 	pid_t		pid;
361 
362 	pid = getpid();
363 
364 	signal(SIGCHLD, SIG_IGN);
365 
366 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, fs_fds) == -1)
367 		err(1, "socketpair");
368 
369 	switch (fork()) {
370 	case -1:
371 		err(1, "fork");
372 	case 0:
373 		/* child */
374 		setproctitle("(%d) fs", pid);
375 		close(fs_fds[0]);
376 		imsg_init(&fs_ibuf, fs_fds[1]);
377 		exit(fs_main(&fs_ibuf));
378 	default:
379 		close(fs_fds[1]);
380 		imsg_init(&fs_ibuf, fs_fds[0]);
381 		fsibuf = &fs_ibuf;
382 	}
383 
384 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, net_fds) == -1)
385 		err(1, "socketpair");
386 
387 	switch (fork()) {
388 	case -1:
389 		err(1, "fork");
390 	case 0:
391 		/* child */
392 		setproctitle("(%d) client", pid);
393 		close(net_fds[0]);
394 		close(fs_fds[0]);
395 		imsg_init(&network_ibuf, net_fds[1]);
396 		exit(client_main(&network_ibuf));
397 	default:
398 		close(net_fds[1]);
399 		imsg_init(&network_ibuf, net_fds[0]);
400 		netibuf = &network_ibuf;
401 	}
402 
403 	setproctitle("(%d) ui", pid);
404 
405 	TAILQ_INIT(&tabshead);
406 
407 	event_init();
408 
409 	event_set(&netev, netibuf->fd, EV_READ | EV_PERSIST, dispatch_imsg, netibuf);
410 	event_add(&netev, NULL);
411 
412 	event_set(&fsev, fsibuf->fd, EV_READ | EV_PERSIST, dispatch_imsg, fsibuf);
413 	event_add(&fsev, NULL);
414 
415 	ui_init();
416 
417 	sandbox_ui_process();
418 
419 	event_dispatch();
420 
421 	imsg_compose(netibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
422 	imsg_flush(netibuf);
423 
424 	imsg_compose(fsibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
425 	imsg_flush(fsibuf);
426 
427 	ui_end();
428 
429 	return 0;
430 }