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		 imsgev;
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;
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 imsg	imsg;
205 	size_t		datalen;
206 	ssize_t		n;
207 
208 	if ((n = imsg_read(netibuf)) == -1) {
209 		if (errno == EAGAIN || errno == EWOULDBLOCK)
210 			return;
211 		die();
212 	}
213 
214 	if (n == 0) {
215 		fprintf(stderr, "other side is dead\n");
216 		exit(0);
217 	}
218 
219 	for (;;) {
220 		if ((n = imsg_get(netibuf, &imsg)) == -1)
221 			die();
222 		if (n == 0)
223 			return;
224 		datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
225 		handlers[imsg.hdr.type](&imsg, datalen);
226 		imsg_free(&imsg);
227 	}
228 }
229 
230 static void
231 load_page_from_str(struct tab *tab, const char *page)
232 {
233 	gemtext_initparser(&tab->page);
234 	if (!tab->page.parse(&tab->page, page, strlen(page)))
235 		die();
236 	if (!tab->page.free(&tab->page))
237 		die();
238 	ui_on_tab_refresh(tab);
239 	ui_on_tab_loaded(tab);
240 }
241 
242 void
243 load_about_url(struct tab *tab, const char *url)
244 {
245 	char	*m;
246 	size_t	 len;
247 
248 
249 	memset(&tab->url, 0, sizeof(tab->url));
250 
251 	m = strchr(url, ':');
252 	strlcpy(tab->url.scheme, "about", sizeof(tab->url.scheme));
253 	strlcpy(tab->url.path, m+1, sizeof(tab->url.path));
254 
255 	len = sizeof(tab->hist_cur->h)-1;
256 	strlcpy(tab->hist_cur->h, url, len);
257 
258 	if (!strcmp(url, "about:new"))
259 		load_page_from_str(tab, about_new);
260 	else
261 		load_page_from_str(tab, "# not found\n");
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	main_ibuf, network_ibuf;
359 	int		imsg_fds[2];
360 
361 	signal(SIGCHLD, SIG_IGN);
362 
363 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
364 		err(1, "socketpair");
365 
366 	switch (fork()) {
367 	case -1:
368 		err(1, "fork");
369 	case 0:
370 		/* child */
371 		setproctitle("client");
372 		close(imsg_fds[0]);
373 		imsg_init(&network_ibuf, imsg_fds[1]);
374 		exit(client_main(&network_ibuf));
375 	}
376 
377 	setproctitle("ui");
378 
379 	close(imsg_fds[1]);
380 	imsg_init(&main_ibuf, imsg_fds[0]);
381 	netibuf = &main_ibuf;
382 
383 	TAILQ_INIT(&tabshead);
384 
385 	event_init();
386 
387 	event_set(&imsgev, netibuf->fd, EV_READ | EV_PERSIST, dispatch_imsg, netibuf);
388 	event_add(&imsgev, NULL);
389 
390 	ui_init();
391 
392 	sandbox_ui_process();
393 
394 	event_dispatch();
395 
396 	imsg_compose(netibuf, IMSG_QUIT, 0, 0, -1, NULL, 0);
397 	imsg_flush(netibuf);
398 
399 	ui_end();
400 
401 	return 0;
402 }