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