?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "Do a show_oops when a download is finished"
[xxxterm.git] / xxxterm.c
blobe3e1542420dca1ae58e77b9a06a6c4a0c07ffea6
1 /*
2 * Copyright (c) 2010, 2011 Marco Peereboom <marco@peereboom.us>
3 * Copyright (c) 2011 Stevan Andjelkovic <stevan@student.chalmers.se>
4 * Copyright (c) 2010, 2011, 2012 Edd Barrett <vext01@gmail.com>
5 * Copyright (c) 2011 Todd T. Fries <todd@fries.net>
6 * Copyright (c) 2011 Raphael Graf <r@undefined.ch>
7 * Copyright (c) 2011 Michal Mazurek <akfaew@jasminek.net>
8 *
9 * Permission to use, copy, modify, and distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 */
21
22 #include <xxxterm.h>
23 #include "version.h"
24
25 char *version = XXXTERM_VERSION;
26
27 #ifdef XT_DEBUG
28 uint32_t swm_debug = 0
29 | XT_D_MOVE
30 | XT_D_KEY
31 | XT_D_TAB
32 | XT_D_URL
33 | XT_D_CMD
34 | XT_D_NAV
35 | XT_D_DOWNLOAD
36 | XT_D_CONFIG
37 | XT_D_JS
38 | XT_D_FAVORITE
39 | XT_D_PRINTING
40 | XT_D_COOKIE
41 | XT_D_KEYBINDING
42 | XT_D_CLIP
43 | XT_D_BUFFERCMD
44 | XT_D_INSPECTOR
45 | XT_D_VISITED
46 | XT_D_HISTORY
47 ;
48 #endif
49
50 #ifdef USE_THREADS
51 GCRY_THREAD_OPTION_PTHREAD_IMPL;
52 #endif
53
54 char *icons[] = {
55 "xxxtermicon16.png",
56 "xxxtermicon32.png",
57 "xxxtermicon48.png",
58 "xxxtermicon64.png",
59 "xxxtermicon128.png"
60 };
61
62 struct session {
63 TAILQ_ENTRY(session) entry;
64 const gchar *name;
65 };
66 TAILQ_HEAD(session_list, session);
67
68 struct undo {
69 TAILQ_ENTRY(undo) entry;
70 gchar *uri;
71 GList *history;
72 int back; /* Keeps track of how many back
73 * history items there are. */
74 };
75 TAILQ_HEAD(undo_tailq, undo);
76
77 struct command_entry {
78 char *line;
79 TAILQ_ENTRY(command_entry) entry;
80 };
81 TAILQ_HEAD(command_list, command_entry);
82
83 /* defines */
84 #define XT_DIR (".xxxterm")
85 #define XT_CACHE_DIR ("cache")
86 #define XT_CERT_DIR ("certs")
87 #define XT_JS_DIR ("js")
88 #define XT_SESSIONS_DIR ("sessions")
89 #define XT_TEMP_DIR ("tmp")
90 #define XT_CONF_FILE ("xxxterm.conf")
91 #define XT_QMARKS_FILE ("quickmarks")
92 #define XT_SAVED_TABS_FILE ("main_session")
93 #define XT_RESTART_TABS_FILE ("restart_tabs")
94 #define XT_SOCKET_FILE ("socket")
95 #define XT_SAVE_SESSION_ID ("SESSION_NAME=")
96 #define XT_SEARCH_FILE ("search_history")
97 #define XT_COMMAND_FILE ("command_history")
98 #define XT_DLMAN_REFRESH "10"
99 #define XT_MAX_URL_LENGTH (4096) /* 1 page is atomic, don't make bigger */
100 #define XT_MAX_UNDO_CLOSE_TAB (32)
101 #define XT_RESERVED_CHARS "$&+,/:;=?@ \"<>#%%{}|^~[]`"
102 #define XT_PRINT_EXTRA_MARGIN 10
103 #define XT_URL_REGEX ("^[[:blank:]]*[^[:blank:]]*([[:alnum:]-]+\\.)+[[:alnum:]-][^[:blank:]]*[[:blank:]]*$")
104 #define XT_INVALID_MARK (-1) /* XXX this is a double, maybe use something else, like a nan */
105
106 /* colors */
107 #define XT_COLOR_RED "#cc0000"
108 #define XT_COLOR_YELLOW "#ffff66"
109 #define XT_COLOR_BLUE "lightblue"
110 #define XT_COLOR_GREEN "#99ff66"
111 #define XT_COLOR_WHITE "white"
112 #define XT_COLOR_BLACK "black"
113
114 #define XT_COLOR_CT_BACKGROUND "#000000"
115 #define XT_COLOR_CT_INACTIVE "#dddddd"
116 #define XT_COLOR_CT_ACTIVE "#bbbb00"
117 #define XT_COLOR_CT_SEPARATOR "#555555"
118
119 #define XT_COLOR_SB_SEPARATOR "#555555"
120
121 #define XT_PROTO_DELIM "://"
122
123 /* actions */
124 #define XT_MOVE_INVALID (0)
125 #define XT_MOVE_DOWN (1)
126 #define XT_MOVE_UP (2)
127 #define XT_MOVE_BOTTOM (3)
128 #define XT_MOVE_TOP (4)
129 #define XT_MOVE_PAGEDOWN (5)
130 #define XT_MOVE_PAGEUP (6)
131 #define XT_MOVE_HALFDOWN (7)
132 #define XT_MOVE_HALFUP (8)
133 #define XT_MOVE_LEFT (9)
134 #define XT_MOVE_FARLEFT (10)
135 #define XT_MOVE_RIGHT (11)
136 #define XT_MOVE_FARRIGHT (12)
137 #define XT_MOVE_PERCENT (13)
138 #define XT_MOVE_CENTER (14)
139
140 #define XT_QMARK_SET (0)
141 #define XT_QMARK_OPEN (1)
142 #define XT_QMARK_TAB (2)
143
144 #define XT_MARK_SET (0)
145 #define XT_MARK_GOTO (1)
146
147 #define XT_GO_UP_ROOT (999)
148
149 #define XT_NAV_INVALID (0)
150 #define XT_NAV_BACK (1)
151 #define XT_NAV_FORWARD (2)
152 #define XT_NAV_RELOAD (3)
153 #define XT_NAV_STOP (4)
154
155 #define XT_FOCUS_INVALID (0)
156 #define XT_FOCUS_URI (1)
157 #define XT_FOCUS_SEARCH (2)
158
159 #define XT_SEARCH_INVALID (0)
160 #define XT_SEARCH_NEXT (1)
161 #define XT_SEARCH_PREV (2)
162
163 #define XT_PASTE_CURRENT_TAB (0)
164 #define XT_PASTE_NEW_TAB (1)
165
166 #define XT_ZOOM_IN (-1)
167 #define XT_ZOOM_OUT (-2)
168 #define XT_ZOOM_NORMAL (100)
169
170 #define XT_CMD_OPEN (0)
171 #define XT_CMD_OPEN_CURRENT (1)
172 #define XT_CMD_TABNEW (2)
173 #define XT_CMD_TABNEW_CURRENT (3)
174
175 #define XT_STATUS_NOTHING (0)
176 #define XT_STATUS_LINK (1)
177 #define XT_STATUS_URI (2)
178 #define XT_STATUS_LOADING (3)
179
180 #define XT_SES_DONOTHING (0)
181 #define XT_SES_CLOSETABS (1)
182
183 #define XT_PREFIX (1<<0)
184 #define XT_USERARG (1<<1)
185 #define XT_URLARG (1<<2)
186 #define XT_INTARG (1<<3)
187 #define XT_SESSARG (1<<4)
188 #define XT_SETARG (1<<5)
189
190 #define XT_HINT_NEWTAB (1<<0)
191
192 #define XT_BUFCMD_SZ (8)
193
194 #define XT_EJS_SHOW (1<<0)
195
196 GtkWidget * create_button(char *, char *, int);
197
198 void recalc_tabs(void);
199 void recolor_compact_tabs(void);
200 void set_current_tab(int page_num);
201 gboolean update_statusbar_position(GtkAdjustment*, gpointer);
202 void marks_clear(struct tab *t);
203
204 /* globals */
205 extern char *__progname;
206 char * const *start_argv;
207 struct passwd *pwd;
208 GtkWidget *main_window;
209 GtkNotebook *notebook;
210 GtkWidget *tab_bar;
211 GtkWidget *arrow, *abtn;
212 struct tab_list tabs;
213 struct history_list hl;
214 int hl_purge_count = 0;
215 struct session_list sessions;
216 struct domain_list c_wl;
217 struct domain_list js_wl;
218 struct domain_list pl_wl;
219 struct strict_transport_tree st_tree;
220 struct undo_tailq undos;
221 struct keybinding_list kbl;
222 struct sp_list spl;
223 struct user_agent_list ua_list;
224 int user_agent_count = 0;
225 struct command_list chl;
226 struct command_list shl;
227 struct command_entry *history_at;
228 struct command_entry *search_at;
229 int undo_count;
230 int cmd_history_count = 0;
231 int search_history_count = 0;
232 char *global_search;
233 uint64_t blocked_cookies = 0;
234 char named_session[PATH_MAX];
235 GtkListStore *completion_model;
236 GtkListStore *buffers_store;
237
238 char *qmarks[XT_NOQMARKS];
239 int btn_down; /* M1 down in any wv */
240 regex_t url_re; /* guess_search regex */
241
242 /* starts from 1 to catch atoi() failures when calling xtp_handle_dl() */
243 int next_download_id = 1;
244
245 void xxx_dir(char *);
246 int icon_size_map(int);
247 void activate_uri_entry_cb(GtkWidget*, struct tab *);
248
249 void
250 history_delete(struct command_list *l, int *counter)
251 {
252 struct command_entry *c;
253
254 if (l == NULL || counter == NULL)
255 return;
256
257 c = TAILQ_LAST(l, command_list);
258 if (c == NULL)
259 return;
260
261 TAILQ_REMOVE(l, c, entry);
262 *counter -= 1;
263 g_free(c->line);
264 g_free(c);
265 }
266
267 void
268 history_add(struct command_list *list, char *file, char *l, int *counter)
269 {
270 struct command_entry *c;
271 FILE *f;
272
273 if (list == NULL || l == NULL || counter == NULL)
274 return;
275
276 /* don't add the same line */
277 c = TAILQ_FIRST(list);
278 if (c)
279 if (!strcmp(c->line + 1 /* skip space */, l))
280 return;
281
282 c = g_malloc0(sizeof *c);
283 c->line = g_strdup_printf(" %s", l);
284
285 *counter += 1;
286 TAILQ_INSERT_HEAD(list, c, entry);
287
288 if (*counter > 1000)
289 history_delete(list, counter);
290
291 if (history_autosave && file) {
292 f = fopen(file, "w");
293 if (f == NULL) {
294 show_oops(NULL, "couldn't write history %s", file);
295 return;
296 }
297
298 TAILQ_FOREACH_REVERSE(c, list, command_list, entry) {
299 c->line[0] = ' ';
300 fprintf(f, "%s\n", c->line);
301 }
302
303 fclose(f);
304 }
305 }
306
307 int
308 history_read(struct command_list *list, char *file, int *counter)
309 {
310 FILE *f;
311 char *s, line[65536];
312
313 if (list == NULL || file == NULL)
314 return (1);
315
316 f = fopen(file, "r");
317 if (f == NULL) {
318 startpage_add("couldn't open history file %s", file);
319 return (1);
320 }
321
322 for (;;) {
323 s = fgets(line, sizeof line, f);
324 if (s == NULL || feof(f) || ferror(f))
325 break;
326 if ((s = strchr(line, '\n')) == NULL) {
327 startpage_add("invalid history file %s", file);
328 fclose(f);
329 return (1);
330 }
331 *s = '\0';
332
333 history_add(list, NULL, line + 1, counter);
334 }
335
336 fclose(f);
337
338 return (0);
339 }
340
341 /* marks array storage. */
342 char
343 indextomark(int i)
344 {
345 if (i < 0 || i >= XT_NOMARKS)
346 return (0);
347
348 return XT_MARKS[i];
349 }
350
351 int
352 marktoindex(char m)
353 {
354 char *ret;
355
356 if ((ret = strchr(XT_MARKS, m)) != NULL)
357 return ret - XT_MARKS;
358
359 return (-1);
360 }
361
362 /* quickmarks array storage. */
363 char
364 indextoqmark(int i)
365 {
366 if (i < 0 || i >= XT_NOQMARKS)
367 return (0);
368
369 return XT_QMARKS[i];
370 }
371
372 int
373 qmarktoindex(char m)
374 {
375 char *ret;
376
377 if ((ret = strchr(XT_QMARKS, m)) != NULL)
378 return ret - XT_QMARKS;
379
380 return (-1);
381 }
382
383 #ifndef XT_SIGNALS_DISABLE
384 void
385 sigchild(int sig)
386 {
387 int saved_errno, status;
388 pid_t pid;
389
390 saved_errno = errno;
391
392 while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) != 0) {
393 if (pid == -1) {
394 if (errno == EINTR)
395 continue;
396 if (errno != ECHILD) {
397 /*
398 clog_warn("sigchild: waitpid:");
399 */
400 }
401 break;
402 }
403
404 if (WIFEXITED(status)) {
405 if (WEXITSTATUS(status) != 0) {
406 /*
407 clog_warnx("sigchild: child exit status: %d",
408 WEXITSTATUS(status));
409 */
410 }
411 } else {
412 /*
413 clog_warnx("sigchild: child is terminated abnormally");
414 */
415 }
416 }
417
418 errno = saved_errno;
419 }
420 #endif
421
422 int
423 is_g_object_setting(GObject *o, char *str)
424 {
425 guint n_props = 0, i;
426 GParamSpec **proplist;
427 int rv = 0;
428
429 if (!G_IS_OBJECT(o))
430 return (0);
431
432 proplist = g_object_class_list_properties(G_OBJECT_GET_CLASS(o),
433 &n_props);
434
435 for (i = 0; i < n_props; i++) {
436 if (! strcmp(proplist[i]->name, str)) {
437 rv = 1;
438 break;
439 }
440 }
441
442 g_free(proplist);
443 return (rv);
444 }
445
446 struct tab *
447 get_current_tab(void)
448 {
449 struct tab *t;
450
451 TAILQ_FOREACH(t, &tabs, entry) {
452 if (t->tab_id == gtk_notebook_get_current_page(notebook))
453 return (t);
454 }
455
456 warnx("%s: no current tab", __func__);
457
458 return (NULL);
459 }
460
461 int
462 set_ssl_ca_file(char *file)
463 {
464 struct stat sb;
465
466 if (file == NULL || strlen(file) == 0)
467 return (-1);
468 if (stat(file, &sb)) {
469 warnx("no CA file: %s", file);
470 if (ssl_ca_file == file) { /* check and fix */
471 g_free(ssl_ca_file);
472 ssl_ca_file = NULL;
473 }
474 return (-1);
475 }
476 if (ssl_ca_file != file) { /* set dynamically */
477 if (ssl_ca_file)
478 g_free(ssl_ca_file);
479 ssl_ca_file = g_strdup(file);
480 }
481 g_object_set(session,
482 SOUP_SESSION_SSL_CA_FILE, ssl_ca_file,
483 SOUP_SESSION_SSL_STRICT, ssl_strict_certs,
484 (void *)NULL);
485 return (0);
486 }
487
488 void
489 set_status(struct tab *t, gchar *s, int status)
490 {
491 gchar *type = NULL;
492
493 if (s == NULL)
494 return;
495
496 switch (status) {
497 case XT_STATUS_LOADING:
498 type = g_strdup_printf("Loading: %s", s);
499 s = type;
500 break;
501 case XT_STATUS_LINK:
502 type = g_strdup_printf("Link: %s", s);
503 if (!t->status)
504 t->status = g_strdup(gtk_entry_get_text(
505 GTK_ENTRY(t->sbe.statusbar)));
506 s = type;
507 break;
508 case XT_STATUS_URI:
509 type = g_strdup_printf("%s", s);
510 if (!t->status) {
511 t->status = g_strdup(type);
512 }
513 s = type;
514 if (!t->status)
515 t->status = g_strdup(s);
516 break;
517 case XT_STATUS_NOTHING:
518 /* FALL THROUGH */
519 default:
520 break;
521 }
522 gtk_entry_set_text(GTK_ENTRY(t->sbe.statusbar), s);
523 if (type)
524 g_free(type);
525 }
526
527 void
528 hide_cmd(struct tab *t)
529 {
530 DNPRINTF(XT_D_CMD, "%s: tab %d\n", __func__, t->tab_id);
531
532 history_at = NULL; /* just in case */
533 search_at = NULL; /* just in case */
534 gtk_widget_hide(t->cmd);
535 }
536
537 void
538 show_cmd(struct tab *t)
539 {
540 DNPRINTF(XT_D_CMD, "%s: tab %d\n", __func__, t->tab_id);
541
542 history_at = NULL;
543 search_at = NULL;
544 gtk_widget_hide(t->oops);
545 gtk_widget_show(t->cmd);
546 }
547
548 void
549 hide_buffers(struct tab *t)
550 {
551 gtk_widget_hide(t->buffers);
552 gtk_list_store_clear(buffers_store);
553 }
554
555 enum {
556 COL_ID = 0,
557 COL_FAVICON,
558 COL_TITLE,
559 NUM_COLS
560 };
561
562 int
563 sort_tabs_by_page_num(struct tab ***stabs)
564 {
565 int num_tabs = 0;
566 struct tab *t;
567
568 num_tabs = gtk_notebook_get_n_pages(notebook);
569
570 *stabs = g_malloc0(num_tabs * sizeof(struct tab *));
571
572 TAILQ_FOREACH(t, &tabs, entry)
573 (*stabs)[gtk_notebook_page_num(notebook, t->vbox)] = t;
574
575 return (num_tabs);
576 }
577
578 void
579 buffers_make_list(void)
580 {
581 int i, num_tabs;
582 const gchar *title = NULL;
583 GtkTreeIter iter;
584 struct tab **stabs = NULL;
585
586 num_tabs = sort_tabs_by_page_num(&stabs);
587
588 for (i = 0; i < num_tabs; i++)
589 if (stabs[i]) {
590 gtk_list_store_append(buffers_store, &iter);
591 title = get_title(stabs[i], FALSE);
592 gtk_list_store_set(buffers_store, &iter,
593 COL_ID, i + 1, /* Enumerate the tabs starting from 1
594 * rather than 0. */
595 COL_FAVICON, gtk_image_get_pixbuf
596 (GTK_IMAGE(stabs[i]->tab_elems.favicon)),
597 COL_TITLE, title,
598 -1);
599 }
600
601 g_free(stabs);
602 }
603
604 void
605 show_buffers(struct tab *t)
606 {
607 if (gtk_widget_get_visible(GTK_WIDGET(t->buffers)))
608 return;
609
610 buffers_make_list();
611 gtk_widget_show(t->buffers);
612 gtk_widget_grab_focus(GTK_WIDGET(t->buffers));
613 }
614
615 void
616 toggle_buffers(struct tab *t)
617 {
618 if (gtk_widget_get_visible(t->buffers))
619 hide_buffers(t);
620 else
621 show_buffers(t);
622 }
623
624 int
625 buffers(struct tab *t, struct karg *args)
626 {
627 show_buffers(t);
628
629 return (0);
630 }
631
632 void
633 hide_oops(struct tab *t)
634 {
635 gtk_widget_hide(t->oops);
636 }
637
638 void
639 show_oops(struct tab *at, const char *fmt, ...)
640 {
641 va_list ap;
642 char *msg = NULL;
643 struct tab *t = NULL;
644
645 if (fmt == NULL)
646 return;
647
648 if (at == NULL) {
649 if ((t = get_current_tab()) == NULL)
650 return;
651 } else
652 t = at;
653
654 va_start(ap, fmt);
655 if (vasprintf(&msg, fmt, ap) == -1)
656 errx(1, "show_oops failed");
657 va_end(ap);
658
659 gtk_entry_set_text(GTK_ENTRY(t->oops), msg);
660 gtk_widget_hide(t->cmd);
661 gtk_widget_show(t->oops);
662
663 if (msg)
664 free(msg);
665 }
666
667 char work_dir[PATH_MAX];
668 char certs_dir[PATH_MAX];
669 char js_dir[PATH_MAX];
670 char cache_dir[PATH_MAX];
671 char sessions_dir[PATH_MAX];
672 char temp_dir[PATH_MAX];
673 char cookie_file[PATH_MAX];
674 char *strict_transport_file = NULL;
675 SoupSession *session;
676 SoupCookieJar *s_cookiejar;
677 SoupCookieJar *p_cookiejar;
678 char rc_fname[PATH_MAX];
679
680 struct mime_type_list mtl;
681 struct alias_list aliases;
682
683 /* protos */
684 struct tab *create_new_tab(char *, struct undo *, int, int);
685 void delete_tab(struct tab *);
686 void setzoom_webkit(struct tab *, int);
687 int download_rb_cmp(struct download *, struct download *);
688 gboolean cmd_execute(struct tab *t, char *str);
689
690 int
691 history_rb_cmp(struct history *h1, struct history *h2)
692 {
693 return (strcmp(h1->uri, h2->uri));
694 }
695 RB_GENERATE(history_list, history, entry, history_rb_cmp);
696
697 int
698 domain_rb_cmp(struct domain *d1, struct domain *d2)
699 {
700 return (strcmp(d1->d, d2->d));
701 }
702 RB_GENERATE(domain_list, domain, entry, domain_rb_cmp);
703
704 int
705 download_rb_cmp(struct download *e1, struct download *e2)
706 {
707 return (e1->id < e2->id ? -1 : e1->id > e2->id);
708 }
709 RB_GENERATE(download_list, download, entry, download_rb_cmp);
710
711 struct valid_url_types {
712 char *type;
713 } vut[] = {
714 { "http://" },
715 { "https://" },
716 { "ftp://" },
717 { "file://" },
718 { XT_XTP_STR },
719 };
720
721 int
722 valid_url_type(char *url)
723 {
724 int i;
725
726 for (i = 0; i < LENGTH(vut); i++)
727 if (!strncasecmp(vut[i].type, url, strlen(vut[i].type)))
728 return (0);
729
730 return (1);
731 }
732
733 char *
734 match_alias(char *url_in)
735 {
736 struct alias *a;
737 char *arg;
738 char *url_out = NULL, *search, *enc_arg;
739
740 search = g_strdup(url_in);
741 arg = search;
742 if (strsep(&arg, " \t") == NULL) {
743 show_oops(NULL, "match_alias: NULL URL");
744 goto done;
745 }
746
747 TAILQ_FOREACH(a, &aliases, entry) {
748 if (!strcmp(search, a->a_name))
749 break;
750 }
751
752 if (a != NULL) {
753 DNPRINTF(XT_D_URL, "match_alias: matched alias %s\n",
754 a->a_name);
755 if (arg != NULL) {
756 enc_arg = soup_uri_encode(arg, XT_RESERVED_CHARS);
757 url_out = g_strdup_printf(a->a_uri, enc_arg);
758 g_free(enc_arg);
759 } else
760 url_out = g_strdup_printf(a->a_uri, "");
761 }
762 done:
763 g_free(search);
764 return (url_out);
765 }
766
767 char *
768 guess_url_type(char *url_in)
769 {
770 struct stat sb;
771 char *url_out = NULL, *enc_search = NULL;
772 int i;
773 char *cwd;
774
775
776 /* substitute aliases */
777 url_out = match_alias(url_in);
778 if (url_out != NULL)
779 return (url_out);
780
781 /* see if we are an about page */
782 if (!strncmp(url_in, XT_URI_ABOUT, XT_URI_ABOUT_LEN))
783 for (i = 0; i < about_list_size(); i++)
784 if (!strcmp(&url_in[XT_URI_ABOUT_LEN],
785 about_list[i].name)) {
786 url_out = g_strdup(url_in);
787 goto done;
788 }
789
790 if (guess_search && url_regex &&
791 !(g_str_has_prefix(url_in, "http://") ||
792 g_str_has_prefix(url_in, "https://"))) {
793 if (regexec(&url_re, url_in, 0, NULL, 0)) {
794 /* invalid URI so search instead */
795 enc_search = soup_uri_encode(url_in, XT_RESERVED_CHARS);
796 url_out = g_strdup_printf(search_string, enc_search);
797 g_free(enc_search);
798 goto done;
799 }
800 }
801
802 /* XXX not sure about this heuristic */
803 if (stat(url_in, &sb) == 0) {
804 if (url_in[0] == '/')
805 url_out = g_strdup_printf("file://%s", url_in);
806 else {
807 cwd = malloc(PATH_MAX);
808 if (getcwd(cwd, PATH_MAX) != NULL) {
809 url_out = g_strdup_printf("file://%s/%s",cwd, url_in);
810 }
811 free(cwd);
812 }
813 } else
814 url_out = g_strdup_printf("http://%s", url_in); /* guess http */
815 done:
816 DNPRINTF(XT_D_URL, "guess_url_type: guessed %s\n", url_out);
817
818 return (url_out);
819 }
820
821 void
822 load_uri(struct tab *t, gchar *uri)
823 {
824 struct karg args;
825 gchar *newuri = NULL;
826 int i;
827
828 if (uri == NULL)
829 return;
830
831 /* Strip leading spaces. */
832 while (*uri && isspace(*uri))
833 uri++;
834
835 if (strlen(uri) == 0) {
836 blank(t, NULL);
837 return;
838 }
839
840 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
841
842 if (valid_url_type(uri)) {
843 newuri = guess_url_type(uri);
844 uri = newuri;
845 }
846
847 if (!strncmp(uri, XT_URI_ABOUT, XT_URI_ABOUT_LEN)) {
848 for (i = 0; i < about_list_size(); i++)
849 if (!strcmp(&uri[XT_URI_ABOUT_LEN], about_list[i].name)) {
850 bzero(&args, sizeof args);
851 about_list[i].func(t, &args);
852 gtk_widget_set_sensitive(GTK_WIDGET(t->stop),
853 FALSE);
854 goto done;
855 }
856 show_oops(t, "invalid about page");
857 goto done;
858 }
859
860 set_status(t, (char *)uri, XT_STATUS_LOADING);
861 marks_clear(t);
862 webkit_web_view_load_uri(t->wv, uri);
863 done:
864 if (newuri)
865 g_free(newuri);
866 }
867
868 const gchar *
869 get_uri(struct tab *t)
870 {
871 const gchar *uri = NULL;
872
873 if (webkit_web_view_get_load_status(t->wv) == WEBKIT_LOAD_FAILED)
874 return (NULL);
875 if (t->xtp_meaning == XT_XTP_TAB_MEANING_NORMAL) {
876 uri = webkit_web_view_get_uri(t->wv);
877 } else {
878 /* use tmp_uri to make sure it is g_freed */
879 if (t->tmp_uri)
880 g_free(t->tmp_uri);
881 t->tmp_uri =g_strdup_printf("%s%s", XT_URI_ABOUT,
882 about_list[t->xtp_meaning].name);
883 uri = t->tmp_uri;
884 }
885 return uri;
886 }
887
888 const gchar *
889 get_title(struct tab *t, bool window)
890 {
891 const gchar *set = NULL, *title = NULL;
892 WebKitLoadStatus status = webkit_web_view_get_load_status(t->wv);
893
894 if (status == WEBKIT_LOAD_PROVISIONAL || status == WEBKIT_LOAD_FAILED ||
895 t->xtp_meaning == XT_XTP_TAB_MEANING_BL)
896 goto notitle;
897
898 title = webkit_web_view_get_title(t->wv);
899 if ((set = title ? title : get_uri(t)))
900 return set;
901
902 notitle:
903 set = window ? XT_NAME : "(untitled)";
904
905 return set;
906 }
907
908 struct mime_type *
909 find_mime_type(char *mime_type)
910 {
911 struct mime_type *m, *def = NULL, *rv = NULL;
912
913 TAILQ_FOREACH(m, &mtl, entry) {
914 if (m->mt_default &&
915 !strncmp(mime_type, m->mt_type, strlen(m->mt_type)))
916 def = m;
917
918 if (m->mt_default == 0 && !strcmp(mime_type, m->mt_type)) {
919 rv = m;
920 break;
921 }
922 }
923
924 if (rv == NULL)
925 rv = def;
926
927 return (rv);
928 }
929
930 struct domain *
931 wl_find_uri(const gchar *s, struct domain_list *wl)
932 {
933 int i;
934 char *ss;
935 struct domain *r;
936
937 if (s == NULL || wl == NULL)
938 return (NULL);
939
940 if (!strncmp(s, "http://", strlen("http://")))
941 s = &s[strlen("http://")];
942 else if (!strncmp(s, "https://", strlen("https://")))
943 s = &s[strlen("https://")];
944
945 if (strlen(s) < 2)
946 return (NULL);
947
948 for (i = 0; i < strlen(s) + 1 /* yes er need this */; i++)
949 /* chop string at first slash */
950 if (s[i] == '/' || s[i] == ':' || s[i] == '\0') {
951 ss = g_strdup(s);
952 ss[i] = '\0';
953 r = wl_find(ss, wl);
954 g_free(ss);
955 return (r);
956 }
957
958 return (NULL);
959 }
960
961 char *
962 js_ref_to_string(JSContextRef context, JSValueRef ref)
963 {
964 char *s = NULL;
965 size_t l;
966 JSStringRef jsref;
967
968 jsref = JSValueToStringCopy(context, ref, NULL);
969 if (jsref == NULL)
970 return (NULL);
971
972 l = JSStringGetMaximumUTF8CStringSize(jsref);
973 s = g_malloc(l);
974 if (s)
975 JSStringGetUTF8CString(jsref, s, l);
976 JSStringRelease(jsref);
977
978 return (s);
979 }
980
981 #define XT_JS_DONE ("done;")
982 #define XT_JS_DONE_LEN (strlen(XT_JS_DONE))
983 #define XT_JS_INSERT ("insert;")
984 #define XT_JS_INSERT_LEN (strlen(XT_JS_INSERT))
985
986 int
987 run_script(struct tab *t, char *s)
988 {
989 JSGlobalContextRef ctx;
990 WebKitWebFrame *frame;
991 JSStringRef str;
992 JSValueRef val, exception;
993 char *es;
994
995 DNPRINTF(XT_D_JS, "%s: tab %d %s\n", __func__,
996 t->tab_id, s == (char *)JS_HINTING ? "JS_HINTING" : s);
997
998 frame = webkit_web_view_get_main_frame(t->wv);
999 ctx = webkit_web_frame_get_global_context(frame);
1000
1001 str = JSStringCreateWithUTF8CString(s);
1002 val = JSEvaluateScript(ctx, str, JSContextGetGlobalObject(ctx),
1003 NULL, 0, &exception);
1004 JSStringRelease(str);
1005
1006 DNPRINTF(XT_D_JS, "%s: val %p\n", __func__, val);
1007 if (val == NULL) {
1008 es = js_ref_to_string(ctx, exception);
1009 if (es) {
1010 DNPRINTF(XT_D_JS, "%s: exception %s\n", __func__, es);
1011 g_free(es);
1012 }
1013 return (1);
1014 } else {
1015 es = js_ref_to_string(ctx, val);
1016 #if 0
1017 /* return values */
1018 if (!strncmp(es, XT_JS_DONE, XT_JS_DONE_LEN))
1019 ; /* do nothing */
1020 if (!strncmp(es, XT_JS_INSERT, XT_JS_INSERT_LEN))
1021 ; /* do nothing */
1022 #endif
1023 if (es) {
1024 DNPRINTF(XT_D_JS, "%s: val %s\n", __func__, es);
1025 g_free(es);
1026 }
1027 }
1028
1029 return (0);
1030 }
1031
1032 void
1033 enable_hints(struct tab *t)
1034 {
1035 DNPRINTF(XT_D_JS, "%s: tab %d\n", __func__, t->tab_id);
1036
1037 if (t->new_tab)
1038 run_script(t, "hints.createHints('', 'F');");
1039 else
1040 run_script(t, "hints.createHints('', 'f');");
1041 t->mode = XT_MODE_HINT;
1042 }
1043
1044 void
1045 disable_hints(struct tab *t)
1046 {
1047 DNPRINTF(XT_D_JS, "%s: tab %d\n", __func__, t->tab_id);
1048
1049 run_script(t, "hints.clearHints();");
1050 t->mode = XT_MODE_COMMAND;
1051 t->new_tab = 0;
1052 }
1053
1054 int
1055 passthrough(struct tab *t, struct karg *args)
1056 {
1057 t->mode = XT_MODE_PASSTHROUGH;
1058 return (0);
1059 }
1060
1061 int
1062 modurl(struct tab *t, struct karg *args)
1063 {
1064 const gchar *uri = NULL;
1065 char *u = NULL;
1066
1067 /* XXX kind of a bad hack, but oh well */
1068 if (GTK_WIDGET_HAS_FOCUS(t->uri_entry)) {
1069 if ((uri = gtk_entry_get_text(GTK_ENTRY(t->uri_entry))) &&
1070 (strlen(uri))) {
1071 u = g_strdup_printf("www.%s.com", uri);
1072 gtk_entry_set_text(GTK_ENTRY(t->uri_entry), u);
1073 g_free(u);
1074 activate_uri_entry_cb(t->uri_entry, t);
1075 }
1076 }
1077 return (0);
1078 }
1079
1080 int
1081 hint(struct tab *t, struct karg *args)
1082 {
1083
1084 DNPRINTF(XT_D_JS, "hint: tab %d args %d\n", t->tab_id, args->i);
1085
1086 if (t->mode == XT_MODE_HINT) {
1087 if (args->i == XT_HINT_NEWTAB)
1088 t->new_tab = 1;
1089 enable_hints(t);
1090 } else
1091 disable_hints(t);
1092
1093 return (0);
1094 }
1095
1096 void
1097 apply_style(struct tab *t)
1098 {
1099 t->styled = 1;
1100 g_object_set(G_OBJECT(t->settings),
1101 "user-stylesheet-uri", t->stylesheet, (char *)NULL);
1102 }
1103
1104 void
1105 remove_style(struct tab *t)
1106 {
1107 t->styled = 0;
1108 g_object_set(G_OBJECT(t->settings),
1109 "user-stylesheet-uri", NULL, (char *)NULL);
1110 }
1111
1112 int
1113 userstyle(struct tab *t, struct karg *args)
1114 {
1115 struct tab *tt;
1116
1117 DNPRINTF(XT_D_JS, "userstyle: tab %d\n", t->tab_id);
1118
1119 switch (args->i) {
1120 case XT_STYLE_CURRENT_TAB:
1121 if (t->styled)
1122 remove_style(t);
1123 else
1124 apply_style(t);
1125 break;
1126 case XT_STYLE_GLOBAL:
1127 if (userstyle_global) {
1128 userstyle_global = 0;
1129 TAILQ_FOREACH(tt, &tabs, entry)
1130 remove_style(tt);
1131 } else {
1132 userstyle_global = 1;
1133 TAILQ_FOREACH(tt, &tabs, entry)
1134 apply_style(tt);
1135 }
1136 break;
1137 }
1138
1139 return (0);
1140 }
1141
1142 int
1143 quit(struct tab *t, struct karg *args)
1144 {
1145 if (save_global_history)
1146 save_global_history_to_disk(t);
1147
1148 gtk_main_quit();
1149
1150 return (1);
1151 }
1152
1153 void
1154 restore_sessions_list(void)
1155 {
1156 DIR *sdir = NULL;
1157 struct dirent *dp = NULL;
1158 struct session *s;
1159 int reg;
1160
1161 sdir = opendir(sessions_dir);
1162 if (sdir) {
1163 while ((dp = readdir(sdir)) != NULL) {
1164 #if defined __MINGW32__
1165 reg = 1; /* windows only has regular files */
1166 #else
1167 reg = dp->d_type == DT_REG;
1168 #endif
1169 if (dp && reg) {
1170 s = g_malloc(sizeof(struct session));
1171 s->name = g_strdup(dp->d_name);
1172 TAILQ_INSERT_TAIL(&sessions, s, entry);
1173 }
1174 }
1175 closedir(sdir);
1176 }
1177 }
1178
1179 int
1180 open_tabs(struct tab *t, struct karg *a)
1181 {
1182 char file[PATH_MAX];
1183 FILE *f = NULL;
1184 char *uri = NULL;
1185 int rv = 1;
1186 struct tab *ti, *tt;
1187
1188 if (a == NULL)
1189 goto done;
1190
1191 ti = TAILQ_LAST(&tabs, tab_list);
1192
1193 snprintf(file, sizeof file, "%s" PS "%s", sessions_dir, a->s);
1194 if ((f = fopen(file, "r")) == NULL)
1195 goto done;
1196
1197 for (;;) {
1198 if ((uri = fparseln(f, NULL, NULL, "\0\0\0", 0)) == NULL)
1199 if (feof(f) || ferror(f))
1200 break;
1201
1202 /* retrieve session name */
1203 if (uri && g_str_has_prefix(uri, XT_SAVE_SESSION_ID)) {
1204 strlcpy(named_session,
1205 &uri[strlen(XT_SAVE_SESSION_ID)],
1206 sizeof named_session);
1207 continue;
1208 }
1209
1210 if (uri && strlen(uri))
1211 create_new_tab(uri, NULL, 1, -1);
1212
1213 free(uri);
1214 uri = NULL;
1215 }
1216
1217 /* close open tabs */
1218 if (a->i == XT_SES_CLOSETABS && ti != NULL) {
1219 for (;;) {
1220 tt = TAILQ_FIRST(&tabs);
1221 if (tt == NULL)
1222 break;
1223 if (tt != ti) {
1224 delete_tab(tt);
1225 continue;
1226 }
1227 delete_tab(tt);
1228 break;
1229 }
1230 }
1231
1232 rv = 0;
1233 done:
1234 if (f)
1235 fclose(f);
1236
1237 return (rv);
1238 }
1239
1240 int
1241 restore_saved_tabs(void)
1242 {
1243 char file[PATH_MAX];
1244 int unlink_file = 0;
1245 struct stat sb;
1246 struct karg a;
1247 int rv = 0;
1248
1249 snprintf(file, sizeof file, "%s" PS "%s",
1250 sessions_dir, XT_RESTART_TABS_FILE);
1251 if (stat(file, &sb) == -1)
1252 a.s = XT_SAVED_TABS_FILE;
1253 else {
1254 unlink_file = 1;
1255 a.s = XT_RESTART_TABS_FILE;
1256 }
1257
1258 a.i = XT_SES_DONOTHING;
1259 rv = open_tabs(NULL, &a);
1260
1261 if (unlink_file)
1262 unlink(file);
1263
1264 return (rv);
1265 }
1266
1267 int
1268 save_tabs(struct tab *t, struct karg *a)
1269 {
1270 char file[PATH_MAX];
1271 FILE *f;
1272 int num_tabs = 0, i;
1273 struct tab **stabs = NULL;
1274
1275 /* tab may be null here */
1276
1277 if (a == NULL)
1278 return (1);
1279 if (a->s == NULL)
1280 snprintf(file, sizeof file, "%s" PS "%s",
1281 sessions_dir, named_session);
1282 else
1283 snprintf(file, sizeof file, "%s" PS "%s", sessions_dir, a->s);
1284
1285 if ((f = fopen(file, "w")) == NULL) {
1286 show_oops(t, "Can't open save_tabs file: %s", strerror(errno));
1287 return (1);
1288 }
1289
1290 /* save session name */
1291 fprintf(f, "%s%s\n", XT_SAVE_SESSION_ID, named_session);
1292
1293 /* Save tabs, in the order they are arranged in the notebook. */
1294 num_tabs = sort_tabs_by_page_num(&stabs);
1295
1296 for (i = 0; i < num_tabs; i++)
1297 if (stabs[i]) {
1298 if (get_uri(stabs[i]) != NULL)
1299 fprintf(f, "%s\n", get_uri(stabs[i]));
1300 else if (gtk_entry_get_text(GTK_ENTRY(
1301 stabs[i]->uri_entry)))
1302 fprintf(f, "%s\n", gtk_entry_get_text(GTK_ENTRY(
1303 stabs[i]->uri_entry)));
1304 }
1305
1306 g_free(stabs);
1307
1308 /* try and make sure this gets to disk NOW. XXX Backup first? */
1309 if (fflush(f) != 0 || fsync(fileno(f)) != 0) {
1310 show_oops(t, "May not have managed to save session: %s",
1311 strerror(errno));
1312 }
1313
1314 fclose(f);
1315
1316 return (0);
1317 }
1318
1319 int
1320 save_tabs_and_quit(struct tab *t, struct karg *args)
1321 {
1322 struct karg a;
1323
1324 a.s = NULL;
1325 save_tabs(t, &a);
1326 quit(t, NULL);
1327
1328 return (1);
1329 }
1330
1331 int
1332 run_page_script(struct tab *t, struct karg *args)
1333 {
1334 const gchar *uri;
1335 char *tmp, script[PATH_MAX];
1336
1337 tmp = args->s != NULL && strlen(args->s) > 0 ? args->s : default_script;
1338 if (tmp[0] == '\0') {
1339 show_oops(t, "no script specified");
1340 return (1);
1341 }
1342
1343 if ((uri = get_uri(t)) == NULL) {
1344 show_oops(t, "tab is empty, not running script");
1345 return (1);
1346 }
1347
1348 if (tmp[0] == '~')
1349 snprintf(script, sizeof script, "%s" PS "%s",
1350 pwd->pw_dir, &tmp[1]);
1351 else
1352 strlcpy(script, tmp, sizeof script);
1353
1354 return (fork_exec(t, script, uri, "can't launch external script", 1));
1355 }
1356
1357 int
1358 yank_uri(struct tab *t, struct karg *args)
1359 {
1360 const gchar *uri;
1361 GtkClipboard *clipboard;
1362
1363 if ((uri = get_uri(t)) == NULL)
1364 return (1);
1365
1366 clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1367 gtk_clipboard_set_text(clipboard, uri, -1);
1368
1369 return (0);
1370 }
1371
1372 int
1373 paste_uri(struct tab *t, struct karg *args)
1374 {
1375 GtkClipboard *clipboard;
1376 GdkAtom atom = gdk_atom_intern("CUT_BUFFER0", FALSE);
1377 gint len;
1378 gchar *p = NULL, *uri;
1379
1380 /* try primary clipboard first */
1381 clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1382 p = gtk_clipboard_wait_for_text(clipboard);
1383
1384 /* if it failed get whatever text is in cut_buffer0 */
1385 if (p == NULL && xterm_workaround)
1386 if (gdk_property_get(gdk_get_default_root_window(),
1387 atom,
1388 gdk_atom_intern("STRING", FALSE),
1389 0,
1390 1024 * 1024 /* picked out of my butt */,
1391 FALSE,
1392 NULL,
1393 NULL,
1394 &len,
1395 (guchar **)&p)) {
1396 if (p == NULL)
1397 goto done;
1398 /* yes sir, we need to NUL the string */
1399 p[len] = '\0';
1400 }
1401
1402 if (p) {
1403 uri = p;
1404 while (*uri && isspace(*uri))
1405 uri++;
1406 if (strlen(uri) == 0) {
1407 show_oops(t, "empty paste buffer");
1408 goto done;
1409 }
1410 if (guess_search == 0 && valid_url_type(uri)) {
1411 /* we can be clever and paste this in search box */
1412 show_oops(t, "not a valid URL");
1413 goto done;
1414 }
1415
1416 if (args->i == XT_PASTE_CURRENT_TAB)
1417 load_uri(t, uri);
1418 else if (args->i == XT_PASTE_NEW_TAB)
1419 create_new_tab(uri, NULL, 1, -1);
1420 }
1421
1422 done:
1423 if (p)
1424 g_free(p);
1425
1426 return (0);
1427 }
1428
1429 void
1430 js_toggle_cb(GtkWidget *w, struct tab *t)
1431 {
1432 struct karg a;
1433 int es, set;
1434
1435 g_object_get(G_OBJECT(t->settings),
1436 "enable-scripts", &es, (char *)NULL);
1437 es = !es;
1438 if (es)
1439 set = XT_WL_ENABLE;
1440 else
1441 set = XT_WL_DISABLE;
1442
1443 a.i = set | XT_WL_TOPLEVEL;
1444 toggle_pl(t, &a);
1445
1446 a.i = set | XT_WL_TOPLEVEL;
1447 toggle_cwl(t, &a);
1448
1449 a.i = XT_WL_TOGGLE | XT_WL_TOPLEVEL | XT_WL_RELOAD;
1450 toggle_js(t, &a);
1451 }
1452
1453 int
1454 toggle_src(struct tab *t, struct karg *args)
1455 {
1456 gboolean mode;
1457
1458 if (t == NULL)
1459 return (0);
1460
1461 mode = webkit_web_view_get_view_source_mode(t->wv);
1462 webkit_web_view_set_view_source_mode(t->wv, !mode);
1463 webkit_web_view_reload(t->wv);
1464
1465 return (0);
1466 }
1467
1468 void
1469 focus_webview(struct tab *t)
1470 {
1471 if (t == NULL)
1472 return;
1473
1474 /* only grab focus if we are visible */
1475 if (gtk_notebook_get_current_page(notebook) == t->tab_id)
1476 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
1477 }
1478
1479 int
1480 focus(struct tab *t, struct karg *args)
1481 {
1482 if (t == NULL || args == NULL)
1483 return (1);
1484
1485 if (show_url == 0)
1486 return (0);
1487
1488 if (args->i == XT_FOCUS_URI)
1489 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
1490 else if (args->i == XT_FOCUS_SEARCH)
1491 gtk_widget_grab_focus(GTK_WIDGET(t->search_entry));
1492
1493 return (0);
1494 }
1495
1496 int
1497 connect_socket_from_uri(const gchar *uri, const gchar **error_str, char *domain,
1498 size_t domain_sz)
1499 {
1500 SoupURI *su = NULL;
1501 struct addrinfo hints, *res = NULL, *ai;
1502 int rv = -1, s = -1, on, error;
1503 char port[8];
1504 static gchar myerror[256]; /* this is not thread safe */
1505
1506 myerror[0] = '\0';
1507 *error_str = myerror;
1508 if (uri && !g_str_has_prefix(uri, "https://")) {
1509 *error_str = "invalid URI";
1510 goto done;
1511 }
1512
1513 su = soup_uri_new(uri);
1514 if (su == NULL) {
1515 *error_str = "invalid soup URI";
1516 goto done;
1517 }
1518 if (!SOUP_URI_VALID_FOR_HTTP(su)) {
1519 *error_str = "invalid HTTPS URI";
1520 goto done;
1521 }
1522
1523 snprintf(port, sizeof port, "%d", su->port);
1524 bzero(&hints, sizeof(struct addrinfo));
1525 hints.ai_flags = AI_CANONNAME;
1526 hints.ai_family = AF_UNSPEC;
1527 hints.ai_socktype = SOCK_STREAM;
1528
1529 if ((error = getaddrinfo(su->host, port, &hints, &res))) {
1530 snprintf(myerror, sizeof myerror, "getaddrinfo failed: %s",
1531 gai_strerror(errno));
1532 goto done;
1533 }
1534
1535 for (ai = res; ai; ai = ai->ai_next) {
1536 if (s != -1) {
1537 close(s);
1538 s = -1;
1539 }
1540
1541 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
1542 continue;
1543 s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
1544 if (s == -1)
1545 continue;
1546 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on,
1547 sizeof(on)) == -1)
1548 continue;
1549 if (connect(s, ai->ai_addr, ai->ai_addrlen) == 0)
1550 break;
1551 }
1552 if (s == -1) {
1553 snprintf(myerror, sizeof myerror,
1554 "could not obtain certificates from: %s",
1555 su->host);
1556 goto done;
1557 }
1558
1559 if (domain)
1560 strlcpy(domain, su->host, domain_sz);
1561 rv = s;
1562 done:
1563 if (su)
1564 soup_uri_free(su);
1565 if (res)
1566 freeaddrinfo(res);
1567 if (rv == -1 && s != -1)
1568 close(s);
1569
1570 return (rv);
1571 }
1572
1573 #ifdef __MINGW32__
1574 static ssize_t
1575 custom_gnutls_push(void *s, const void *buf, size_t len)
1576 {
1577 return send((size_t)s, buf, len, 0);
1578 }
1579
1580 static ssize_t
1581 custom_gnutls_pull(void *s, void *buf, size_t len)
1582 {
1583 return recv((size_t)s, buf, len, 0);
1584 }
1585 #endif
1586
1587 int
1588 stop_tls(gnutls_session_t gsession, gnutls_certificate_credentials_t xcred)
1589 {
1590 if (gsession)
1591 gnutls_deinit(gsession);
1592 if (xcred)
1593 gnutls_certificate_free_credentials(xcred);
1594
1595 return (0);
1596 }
1597
1598 int
1599 start_tls(const gchar **error_str, int s, gnutls_session_t *gs,
1600 gnutls_certificate_credentials_t *xc)
1601 {
1602 gnutls_certificate_credentials_t xcred;
1603 gnutls_session_t gsession;
1604 int rv = 1;
1605 static gchar myerror[1024]; /* this is not thread safe */
1606
1607 if (gs == NULL || xc == NULL)
1608 goto done;
1609
1610 myerror[0] = '\0';
1611 *gs = NULL;
1612 *xc = NULL;
1613
1614 gnutls_certificate_allocate_credentials(&xcred);
1615 gnutls_certificate_set_x509_trust_file(xcred, ssl_ca_file,
1616 GNUTLS_X509_FMT_PEM);
1617
1618 gnutls_init(&gsession, GNUTLS_CLIENT);
1619 gnutls_priority_set_direct(gsession, "PERFORMANCE", NULL);
1620 gnutls_credentials_set(gsession, GNUTLS_CRD_CERTIFICATE, xcred);
1621 gnutls_transport_set_ptr(gsession, (gnutls_transport_ptr_t)(long)s);
1622 #ifdef __MINGW32__
1623 /* sockets on windows don't use file descriptors */
1624 gnutls_transport_set_push_function(gsession, custom_gnutls_push);
1625 gnutls_transport_set_pull_function(gsession, custom_gnutls_pull);
1626 #endif
1627 if ((rv = gnutls_handshake(gsession)) < 0) {
1628 snprintf(myerror, sizeof myerror,
1629 "gnutls_handshake failed %d fatal %d %s",
1630 rv,
1631 gnutls_error_is_fatal(rv),
1632 #if LIBGNUTLS_VERSION_MAJOR >= 2 && LIBGNUTLS_VERSION_MINOR >= 6
1633 gnutls_strerror_name(rv));
1634 #else
1635 "GNUTLS version is too old to provide human readable error");
1636 #endif
1637 stop_tls(gsession, xcred);
1638 goto done;
1639 }
1640
1641 gnutls_credentials_type_t cred;
1642 cred = gnutls_auth_get_type(gsession);
1643 if (cred != GNUTLS_CRD_CERTIFICATE) {
1644 snprintf(myerror, sizeof myerror,
1645 "gnutls_auth_get_type failed %d",
1646 (int)cred);
1647 stop_tls(gsession, xcred);
1648 goto done;
1649 }
1650
1651 *gs = gsession;
1652 *xc = xcred;
1653 rv = 0;
1654 done:
1655 *error_str = myerror;
1656 return (rv);
1657 }
1658
1659 int
1660 get_connection_certs(gnutls_session_t gsession, gnutls_x509_crt_t **certs,
1661 size_t *cert_count)
1662 {
1663 unsigned int len;
1664 const gnutls_datum_t *cl;
1665 gnutls_x509_crt_t *all_certs;
1666 int i, rv = 1;
1667
1668 if (certs == NULL || cert_count == NULL)
1669 goto done;
1670 if (gnutls_certificate_type_get(gsession) != GNUTLS_CRT_X509)
1671 goto done;
1672 cl = gnutls_certificate_get_peers(gsession, &len);
1673 if (len == 0)
1674 goto done;
1675
1676 all_certs = g_malloc(sizeof(gnutls_x509_crt_t) * len);
1677 for (i = 0; i < len; i++) {
1678 gnutls_x509_crt_init(&all_certs[i]);
1679 if (gnutls_x509_crt_import(all_certs[i], &cl[i],
1680 GNUTLS_X509_FMT_PEM < 0)) {
1681 g_free(all_certs);
1682 goto done;
1683 }
1684 }
1685
1686 *certs = all_certs;
1687 *cert_count = len;
1688 rv = 0;
1689 done:
1690 return (rv);
1691 }
1692
1693 void
1694 free_connection_certs(gnutls_x509_crt_t *certs, size_t cert_count)
1695 {
1696 int i;
1697
1698 for (i = 0; i < cert_count; i++)
1699 gnutls_x509_crt_deinit(certs[i]);
1700 g_free(certs);
1701 }
1702
1703 void
1704 statusbar_modify_attr(struct tab *t, const char *text, const char *base)
1705 {
1706 GdkColor c_text, c_base;
1707
1708 gdk_color_parse(text, &c_text);
1709 gdk_color_parse(base, &c_base);
1710
1711 gtk_widget_modify_text(t->sbe.statusbar, GTK_STATE_NORMAL, &c_text);
1712 gtk_widget_modify_text(t->sbe.buffercmd, GTK_STATE_NORMAL, &c_text);
1713 gtk_widget_modify_text(t->sbe.zoom, GTK_STATE_NORMAL, &c_text);
1714 gtk_widget_modify_text(t->sbe.position, GTK_STATE_NORMAL, &c_text);
1715
1716 gtk_widget_modify_base(t->sbe.statusbar, GTK_STATE_NORMAL, &c_base);
1717 gtk_widget_modify_base(t->sbe.buffercmd, GTK_STATE_NORMAL, &c_base);
1718 gtk_widget_modify_base(t->sbe.zoom, GTK_STATE_NORMAL, &c_base);
1719 gtk_widget_modify_base(t->sbe.position, GTK_STATE_NORMAL, &c_base);
1720 }
1721
1722 void
1723 save_certs(struct tab *t, gnutls_x509_crt_t *certs,
1724 size_t cert_count, char *domain)
1725 {
1726 size_t cert_buf_sz;
1727 char cert_buf[64 * 1024], file[PATH_MAX];
1728 int i;
1729 FILE *f;
1730 GdkColor color;
1731
1732 if (t == NULL || certs == NULL || cert_count <= 0 || domain == NULL)
1733 return;
1734
1735 snprintf(file, sizeof file, "%s" PS "%s", certs_dir, domain);
1736 if ((f = fopen(file, "w")) == NULL) {
1737 show_oops(t, "Can't create cert file %s %s",
1738 file, strerror(errno));
1739 return;
1740 }
1741
1742 for (i = 0; i < cert_count; i++) {
1743 cert_buf_sz = sizeof cert_buf;
1744 if (gnutls_x509_crt_export(certs[i], GNUTLS_X509_FMT_PEM,
1745 cert_buf, &cert_buf_sz)) {
1746 show_oops(t, "gnutls_x509_crt_export failed");
1747 goto done;
1748 }
1749 if (fwrite(cert_buf, cert_buf_sz, 1, f) != 1) {
1750 show_oops(t, "Can't write certs: %s", strerror(errno));
1751 goto done;
1752 }
1753 }
1754
1755 /* not the best spot but oh well */
1756 gdk_color_parse(XT_COLOR_BLUE, &color);
1757 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL, &color);
1758 statusbar_modify_attr(t, XT_COLOR_BLACK, XT_COLOR_BLUE);
1759 done:
1760 fclose(f);
1761 }
1762
1763 enum cert_trust {
1764 CERT_LOCAL,
1765 CERT_TRUSTED,
1766 CERT_UNTRUSTED,
1767 CERT_BAD
1768 };
1769
1770 enum cert_trust
1771 load_compare_cert(const gchar *uri, const gchar **error_str)
1772 {
1773 char domain[8182], file[PATH_MAX];
1774 char cert_buf[64 * 1024], r_cert_buf[64 * 1024];
1775 int s = -1, i;
1776 unsigned int error = 0;
1777 FILE *f = NULL;
1778 size_t cert_buf_sz, cert_count;
1779 enum cert_trust rv = CERT_UNTRUSTED;
1780 static gchar serr[80]; /* this isn't thread safe */
1781 gnutls_session_t gsession;
1782 gnutls_x509_crt_t *certs;
1783 gnutls_certificate_credentials_t xcred;
1784
1785 DNPRINTF(XT_D_URL, "%s: %s\n", __func__, uri);
1786
1787 serr[0] = '\0';
1788 *error_str = serr;
1789 if ((s = connect_socket_from_uri(uri, error_str, domain,
1790 sizeof domain)) == -1)
1791 return (rv);
1792
1793 DNPRINTF(XT_D_URL, "%s: fd %d\n", __func__, s);
1794
1795 /* go ssl/tls */
1796 if (start_tls(error_str, s, &gsession, &xcred))
1797 goto done;
1798 DNPRINTF(XT_D_URL, "%s: got tls\n", __func__);
1799
1800 /* verify certs in case cert file doesn't exist */
1801 if (gnutls_certificate_verify_peers2(gsession, &error) !=
1802 GNUTLS_E_SUCCESS) {
1803 *error_str = "Invalid certificates";
1804 goto done;
1805 }
1806
1807 /* get certs */
1808 if (get_connection_certs(gsession, &certs, &cert_count)) {
1809 *error_str = "Can't get connection certificates";
1810 goto done;
1811 }
1812
1813 snprintf(file, sizeof file, "%s" PS "%s", certs_dir, domain);
1814 if ((f = fopen(file, "r")) == NULL) {
1815 if (!error)
1816 rv = CERT_TRUSTED;
1817 goto freeit;
1818 }
1819
1820 for (i = 0; i < cert_count; i++) {
1821 cert_buf_sz = sizeof cert_buf;
1822 if (gnutls_x509_crt_export(certs[i], GNUTLS_X509_FMT_PEM,
1823 cert_buf, &cert_buf_sz)) {
1824 goto freeit;
1825 }
1826 if (fread(r_cert_buf, cert_buf_sz, 1, f) != 1) {
1827 rv = CERT_BAD; /* critical */
1828 goto freeit;
1829 }
1830 if (bcmp(r_cert_buf, cert_buf, sizeof cert_buf_sz)) {
1831 rv = CERT_BAD; /* critical */
1832 goto freeit;
1833 }
1834 rv = CERT_LOCAL;
1835 }
1836
1837 freeit:
1838 if (f)
1839 fclose(f);
1840 free_connection_certs(certs, cert_count);
1841 done:
1842 /* we close the socket first for speed */
1843 if (s != -1)
1844 close(s);
1845
1846 /* only complain if we didn't save it locally */
1847 if (error && rv != CERT_LOCAL) {
1848 strlcpy(serr, "Certificate exception(s): ", sizeof serr);
1849 if (error & GNUTLS_CERT_INVALID)
1850 strlcat(serr, "invalid, ", sizeof serr);
1851 if (error & GNUTLS_CERT_REVOKED)
1852 strlcat(serr, "revoked, ", sizeof serr);
1853 if (error & GNUTLS_CERT_SIGNER_NOT_FOUND)
1854 strlcat(serr, "signer not found, ", sizeof serr);
1855 if (error & GNUTLS_CERT_SIGNER_NOT_CA)
1856 strlcat(serr, "not signed by CA, ", sizeof serr);
1857 if (error & GNUTLS_CERT_INSECURE_ALGORITHM)
1858 strlcat(serr, "insecure algorithm, ", sizeof serr);
1859 #if LIBGNUTLS_VERSION_MAJOR >= 2 && LIBGNUTLS_VERSION_MINOR >= 6
1860 if (error & GNUTLS_CERT_NOT_ACTIVATED)
1861 strlcat(serr, "not activated, ", sizeof serr);
1862 if (error & GNUTLS_CERT_EXPIRED)
1863 strlcat(serr, "expired, ", sizeof serr);
1864 #endif
1865 for (i = strlen(serr) - 1; i > 0; i--)
1866 if (serr[i] == ',') {
1867 serr[i] = '\0';
1868 break;
1869 }
1870 *error_str = serr;
1871 }
1872
1873 stop_tls(gsession, xcred);
1874
1875 return (rv);
1876 }
1877
1878 int
1879 cert_cmd(struct tab *t, struct karg *args)
1880 {
1881 const gchar *uri, *error_str = NULL;
1882 char domain[8182];
1883 int s = -1;
1884 size_t cert_count;
1885 gnutls_session_t gsession;
1886 gnutls_x509_crt_t *certs;
1887 gnutls_certificate_credentials_t xcred;
1888
1889 if (t == NULL)
1890 return (1);
1891
1892 if (ssl_ca_file == NULL) {
1893 show_oops(t, "Can't open CA file: %s", ssl_ca_file);
1894 return (1);
1895 }
1896
1897 if ((uri = get_uri(t)) == NULL) {
1898 show_oops(t, "Invalid URI");
1899 return (1);
1900 }
1901
1902 if ((s = connect_socket_from_uri(uri, &error_str, domain,
1903 sizeof domain)) == -1) {
1904 show_oops(t, "%s", error_str);
1905 return (1);
1906 }
1907
1908 /* go ssl/tls */
1909 if (start_tls(&error_str, s, &gsession, &xcred))
1910 goto done;
1911
1912 /* get certs */
1913 if (get_connection_certs(gsession, &certs, &cert_count)) {
1914 show_oops(t, "get_connection_certs failed");
1915 goto done;
1916 }
1917
1918 if (args->i & XT_SHOW)
1919 show_certs(t, certs, cert_count, "Certificate Chain");
1920 else if (args->i & XT_SAVE)
1921 save_certs(t, certs, cert_count, domain);
1922
1923 free_connection_certs(certs, cert_count);
1924 done:
1925 /* we close the socket first for speed */
1926 if (s != -1)
1927 close(s);
1928 stop_tls(gsession, xcred);
1929 if (error_str && strlen(error_str))
1930 show_oops(t, "%s", error_str);
1931 return (0);
1932 }
1933
1934 int
1935 remove_cookie(int index)
1936 {
1937 int i, rv = 1;
1938 GSList *cf;
1939 SoupCookie *c;
1940
1941 DNPRINTF(XT_D_COOKIE, "remove_cookie: %d\n", index);
1942
1943 cf = soup_cookie_jar_all_cookies(s_cookiejar);
1944
1945 for (i = 1; cf; cf = cf->next, i++) {
1946 if (i != index)
1947 continue;
1948 c = cf->data;
1949 print_cookie("remove cookie", c);
1950 soup_cookie_jar_delete_cookie(s_cookiejar, c);
1951 rv = 0;
1952 break;
1953 }
1954
1955 soup_cookies_free(cf);
1956
1957 return (rv);
1958 }
1959
1960 int
1961 remove_cookie_domain(int domain_id)
1962 {
1963 int domain_count, rv = 1;
1964 GSList *cf;
1965 SoupCookie *c;
1966 char *last_domain;
1967
1968 DNPRINTF(XT_D_COOKIE, "remove_cookie_domain: %d\n", domain_id);
1969
1970 last_domain = "";
1971 cf = soup_cookie_jar_all_cookies(s_cookiejar);
1972
1973 for (domain_count = 0; cf; cf = cf->next) {
1974 c = cf->data;
1975
1976 if (strcmp(last_domain, c->domain) != 0) {
1977 domain_count++;
1978 last_domain = c->domain;
1979 }
1980
1981 if (domain_count < domain_id)
1982 continue;
1983 else if (domain_count > domain_id)
1984 break;
1985
1986 print_cookie("remove cookie", c);
1987 soup_cookie_jar_delete_cookie(s_cookiejar, c);
1988 rv = 0;
1989 }
1990
1991 soup_cookies_free(cf);
1992
1993 return (rv);
1994 }
1995
1996 int
1997 remove_cookie_all()
1998 {
1999 int rv = 1;
2000 GSList *cf;
2001 SoupCookie *c;
2002
2003 DNPRINTF(XT_D_COOKIE, "remove_cookie_all\n");
2004
2005 cf = soup_cookie_jar_all_cookies(s_cookiejar);
2006
2007 for (; cf; cf = cf->next) {
2008 c = cf->data;
2009
2010 print_cookie("remove cookie", c);
2011 soup_cookie_jar_delete_cookie(s_cookiejar, c);
2012 rv = 0;
2013 }
2014
2015 soup_cookies_free(cf);
2016
2017 return (rv);
2018 }
2019
2020 int
2021 toplevel_cmd(struct tab *t, struct karg *args)
2022 {
2023 js_toggle_cb(t->js_toggle, t);
2024
2025 return (0);
2026 }
2027
2028 int
2029 can_go_back_for_real(struct tab *t)
2030 {
2031 int i;
2032 WebKitWebHistoryItem *item;
2033 const gchar *uri;
2034
2035 if (t == NULL)
2036 return (FALSE);
2037
2038 /* rely on webkit to make sure we can go backward when on an about page */
2039 uri = get_uri(t);
2040 if (uri == NULL || g_str_has_prefix(uri, "about:"))
2041 return (webkit_web_view_can_go_back(t->wv));
2042
2043 /* the back/forwars list is stupid so help determine if we can go back */
2044 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2045 item != NULL;
2046 i--, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2047 if (strcmp(webkit_web_history_item_get_uri(item), uri))
2048 return (TRUE);
2049 }
2050
2051 return (FALSE);
2052 }
2053
2054 int
2055 can_go_forward_for_real(struct tab *t)
2056 {
2057 int i;
2058 WebKitWebHistoryItem *item;
2059 const gchar *uri;
2060
2061 if (t == NULL)
2062 return (FALSE);
2063
2064 /* rely on webkit to make sure we can go forward when on an about page */
2065 uri = get_uri(t);
2066 if (uri == NULL || g_str_has_prefix(uri, "about:"))
2067 return (webkit_web_view_can_go_forward(t->wv));
2068
2069 /* the back/forwars list is stupid so help selecting a different item */
2070 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2071 item != NULL;
2072 i++, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2073 if (strcmp(webkit_web_history_item_get_uri(item), uri))
2074 return (TRUE);
2075 }
2076
2077 return (FALSE);
2078 }
2079
2080 void
2081 go_back_for_real(struct tab *t)
2082 {
2083 int i;
2084 WebKitWebHistoryItem *item;
2085 const gchar *uri;
2086
2087 if (t == NULL)
2088 return;
2089
2090 uri = get_uri(t);
2091 if (uri == NULL) {
2092 webkit_web_view_go_back(t->wv);
2093 return;
2094 }
2095 /* the back/forwars list is stupid so help selecting a different item */
2096 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2097 item != NULL;
2098 i--, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2099 if (strcmp(webkit_web_history_item_get_uri(item), uri)) {
2100 webkit_web_view_go_to_back_forward_item(t->wv, item);
2101 break;
2102 }
2103 }
2104 }
2105
2106 void
2107 go_forward_for_real(struct tab *t)
2108 {
2109 int i;
2110 WebKitWebHistoryItem *item;
2111 const gchar *uri;
2112
2113 if (t == NULL)
2114 return;
2115
2116 uri = get_uri(t);
2117 if (uri == NULL) {
2118 webkit_web_view_go_forward(t->wv);
2119 return;
2120 }
2121 /* the back/forwars list is stupid so help selecting a different item */
2122 for (i = 0, item = webkit_web_back_forward_list_get_current_item(t->bfl);
2123 item != NULL;
2124 i++, item = webkit_web_back_forward_list_get_nth_item(t->bfl, i)) {
2125 if (strcmp(webkit_web_history_item_get_uri(item), uri)) {
2126 webkit_web_view_go_to_back_forward_item(t->wv, item);
2127 break;
2128 }
2129 }
2130 }
2131
2132 int
2133 navaction(struct tab *t, struct karg *args)
2134 {
2135 WebKitWebHistoryItem *item;
2136 WebKitWebFrame *frame;
2137
2138 DNPRINTF(XT_D_NAV, "navaction: tab %d opcode %d\n",
2139 t->tab_id, args->i);
2140
2141 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
2142 if (t->item) {
2143 if (args->i == XT_NAV_BACK)
2144 item = webkit_web_back_forward_list_get_current_item(t->bfl);
2145 else
2146 item = webkit_web_back_forward_list_get_forward_item(t->bfl);
2147 if (item == NULL)
2148 return (XT_CB_PASSTHROUGH);
2149 webkit_web_view_go_to_back_forward_item(t->wv, item);
2150 t->item = NULL;
2151 return (XT_CB_PASSTHROUGH);
2152 }
2153
2154 switch (args->i) {
2155 case XT_NAV_BACK:
2156 marks_clear(t);
2157 go_back_for_real(t);
2158 break;
2159 case XT_NAV_FORWARD:
2160 marks_clear(t);
2161 go_forward_for_real(t);
2162 break;
2163 case XT_NAV_RELOAD:
2164 frame = webkit_web_view_get_main_frame(t->wv);
2165 webkit_web_frame_reload(frame);
2166 break;
2167 case XT_NAV_STOP:
2168 frame = webkit_web_view_get_main_frame(t->wv);
2169 webkit_web_frame_stop_loading(frame);
2170 break;
2171 }
2172 return (XT_CB_PASSTHROUGH);
2173 }
2174
2175 int
2176 move(struct tab *t, struct karg *args)
2177 {
2178 GtkAdjustment *adjust;
2179 double pi, si, pos, ps, upper, lower, max;
2180 double percent;
2181
2182 switch (args->i) {
2183 case XT_MOVE_DOWN:
2184 case XT_MOVE_UP:
2185 case XT_MOVE_BOTTOM:
2186 case XT_MOVE_TOP:
2187 case XT_MOVE_PAGEDOWN:
2188 case XT_MOVE_PAGEUP:
2189 case XT_MOVE_HALFDOWN:
2190 case XT_MOVE_HALFUP:
2191 case XT_MOVE_PERCENT:
2192 case XT_MOVE_CENTER:
2193 adjust = t->adjust_v;
2194 break;
2195 default:
2196 adjust = t->adjust_h;
2197 break;
2198 }
2199
2200 pos = gtk_adjustment_get_value(adjust);
2201 ps = gtk_adjustment_get_page_size(adjust);
2202 upper = gtk_adjustment_get_upper(adjust);
2203 lower = gtk_adjustment_get_lower(adjust);
2204 si = gtk_adjustment_get_step_increment(adjust);
2205 pi = gtk_adjustment_get_page_increment(adjust);
2206 max = upper - ps;
2207
2208 DNPRINTF(XT_D_MOVE, "move: opcode %d %s pos %f ps %f upper %f lower %f "
2209 "max %f si %f pi %f\n",
2210 args->i, adjust == t->adjust_h ? "horizontal" : "vertical",
2211 pos, ps, upper, lower, max, si, pi);
2212
2213 switch (args->i) {
2214 case XT_MOVE_DOWN:
2215 case XT_MOVE_RIGHT:
2216 pos += si;
2217 gtk_adjustment_set_value(adjust, MIN(pos, max));
2218 break;
2219 case XT_MOVE_UP:
2220 case XT_MOVE_LEFT:
2221 pos -= si;
2222 gtk_adjustment_set_value(adjust, MAX(pos, lower));
2223 break;
2224 case XT_MOVE_BOTTOM:
2225 case XT_MOVE_FARRIGHT:
2226 t->mark[marktoindex('\'')] = gtk_adjustment_get_value(t->adjust_v);
2227 gtk_adjustment_set_value(adjust, max);
2228 break;
2229 case XT_MOVE_TOP:
2230 case XT_MOVE_FARLEFT:
2231 t->mark[marktoindex('\'')] = gtk_adjustment_get_value(t->adjust_v);
2232 gtk_adjustment_set_value(adjust, lower);
2233 break;
2234 case XT_MOVE_PAGEDOWN:
2235 pos += pi;
2236 gtk_adjustment_set_value(adjust, MIN(pos, max));
2237 break;
2238 case XT_MOVE_PAGEUP:
2239 pos -= pi;
2240 gtk_adjustment_set_value(adjust, MAX(pos, lower));
2241 break;
2242 case XT_MOVE_HALFDOWN:
2243 pos += pi / 2;
2244 gtk_adjustment_set_value(adjust, MIN(pos, max));
2245 break;
2246 case XT_MOVE_HALFUP:
2247 pos -= pi / 2;
2248 gtk_adjustment_set_value(adjust, MAX(pos, lower));
2249 break;
2250 case XT_MOVE_CENTER:
2251 t->mark[marktoindex('\'')] = gtk_adjustment_get_value(t->adjust_v);
2252 args->s = g_strdup("50.0");
2253 /* FALLTHROUGH */
2254 case XT_MOVE_PERCENT:
2255 t->mark[marktoindex('\'')] = gtk_adjustment_get_value(t->adjust_v);
2256 percent = atoi(args->s) / 100.0;
2257 pos = max * percent;
2258 if (pos < 0.0 || pos > max)
2259 break;
2260 gtk_adjustment_set_value(adjust, pos);
2261 break;
2262 default:
2263 return (XT_CB_PASSTHROUGH);
2264 }
2265
2266 DNPRINTF(XT_D_MOVE, "move: new pos %f %f\n", pos, MIN(pos, max));
2267
2268 return (XT_CB_HANDLED);
2269 }
2270
2271 void
2272 url_set_visibility(void)
2273 {
2274 struct tab *t;
2275
2276 TAILQ_FOREACH(t, &tabs, entry)
2277 if (show_url == 0) {
2278 gtk_widget_hide(t->toolbar);
2279 focus_webview(t);
2280 } else
2281 gtk_widget_show(t->toolbar);
2282 }
2283
2284 void
2285 notebook_tab_set_visibility(void)
2286 {
2287 if (show_tabs == 0) {
2288 gtk_widget_hide(tab_bar);
2289 gtk_notebook_set_show_tabs(notebook, FALSE);
2290 } else {
2291 if (tab_style == XT_TABS_NORMAL) {
2292 gtk_widget_hide(tab_bar);
2293 gtk_notebook_set_show_tabs(notebook, TRUE);
2294 } else if (tab_style == XT_TABS_COMPACT) {
2295 gtk_widget_show(tab_bar);
2296 gtk_notebook_set_show_tabs(notebook, FALSE);
2297 }
2298 }
2299 }
2300
2301 void
2302 statusbar_set_visibility(void)
2303 {
2304 struct tab *t;
2305
2306 TAILQ_FOREACH(t, &tabs, entry){
2307 if (show_statusbar == 0)
2308 gtk_widget_hide(t->statusbar_box);
2309 else
2310 gtk_widget_show(t->statusbar_box);
2311
2312 focus_webview(t);
2313 }
2314 }
2315
2316 void
2317 url_set(struct tab *t, int enable_url_entry)
2318 {
2319 GdkPixbuf *pixbuf;
2320 int progress;
2321
2322 show_url = enable_url_entry;
2323
2324 if (enable_url_entry) {
2325 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
2326 GTK_ENTRY_ICON_PRIMARY, NULL);
2327 gtk_entry_set_progress_fraction(GTK_ENTRY(t->sbe.statusbar), 0);
2328 } else {
2329 pixbuf = gtk_entry_get_icon_pixbuf(GTK_ENTRY(t->uri_entry),
2330 GTK_ENTRY_ICON_PRIMARY);
2331 progress =
2332 gtk_entry_get_progress_fraction(GTK_ENTRY(t->uri_entry));
2333 gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(t->sbe.statusbar),
2334 GTK_ENTRY_ICON_PRIMARY, pixbuf);
2335 gtk_entry_set_progress_fraction(GTK_ENTRY(t->sbe.statusbar),
2336 progress);
2337 }
2338 }
2339
2340 int
2341 fullscreen(struct tab *t, struct karg *args)
2342 {
2343 DNPRINTF(XT_D_TAB, "%s: %p %d\n", __func__, t, args->i);
2344
2345 if (t == NULL)
2346 return (XT_CB_PASSTHROUGH);
2347
2348 if (show_url == 0) {
2349 url_set(t, 1);
2350 show_tabs = 1;
2351 } else {
2352 url_set(t, 0);
2353 show_tabs = 0;
2354 }
2355
2356 url_set_visibility();
2357 notebook_tab_set_visibility();
2358
2359 return (XT_CB_HANDLED);
2360 }
2361
2362 int
2363 statustoggle(struct tab *t, struct karg *args)
2364 {
2365 DNPRINTF(XT_D_TAB, "%s: %p %d\n", __func__, t, args->i);
2366
2367 if (show_statusbar == 1) {
2368 show_statusbar = 0;
2369 statusbar_set_visibility();
2370 } else if (show_statusbar == 0) {
2371 show_statusbar = 1;
2372 statusbar_set_visibility();
2373 }
2374 return (XT_CB_HANDLED);
2375 }
2376
2377 int
2378 urlaction(struct tab *t, struct karg *args)
2379 {
2380 int rv = XT_CB_HANDLED;
2381
2382 DNPRINTF(XT_D_TAB, "%s: %p %d\n", __func__, t, args->i);
2383
2384 if (t == NULL)
2385 return (XT_CB_PASSTHROUGH);
2386
2387 switch (args->i) {
2388 case XT_URL_SHOW:
2389 if (show_url == 0) {
2390 url_set(t, 1);
2391 url_set_visibility();
2392 }
2393 break;
2394 case XT_URL_HIDE:
2395 if (show_url == 1) {
2396 url_set(t, 0);
2397 url_set_visibility();
2398 }
2399 break;
2400 }
2401 return (rv);
2402 }
2403
2404 int
2405 tabaction(struct tab *t, struct karg *args)
2406 {
2407 int rv = XT_CB_HANDLED;
2408 char *url = args->s;
2409 struct undo *u;
2410 struct tab *tt;
2411
2412 DNPRINTF(XT_D_TAB, "tabaction: %p %d\n", t, args->i);
2413
2414 if (t == NULL)
2415 return (XT_CB_PASSTHROUGH);
2416
2417 switch (args->i) {
2418 case XT_TAB_NEW:
2419 if (strlen(url) > 0)
2420 create_new_tab(url, NULL, 1, args->precount);
2421 else
2422 create_new_tab(NULL, NULL, 1, args->precount);
2423 break;
2424 case XT_TAB_DELETE:
2425 if (args->precount < 0)
2426 delete_tab(t);
2427 else
2428 TAILQ_FOREACH(tt, &tabs, entry)
2429 if (tt->tab_id == args->precount - 1) {
2430 delete_tab(tt);
2431 break;
2432 }
2433 break;
2434 case XT_TAB_DELQUIT:
2435 if (gtk_notebook_get_n_pages(notebook) > 1)
2436 delete_tab(t);
2437 else
2438 quit(t, args);
2439 break;
2440 case XT_TAB_OPEN:
2441 if (strlen(url) > 0)
2442 ;
2443 else {
2444 rv = XT_CB_PASSTHROUGH;
2445 goto done;
2446 }
2447 load_uri(t, url);
2448 break;
2449 case XT_TAB_SHOW:
2450 if (show_tabs == 0) {
2451 show_tabs = 1;
2452 notebook_tab_set_visibility();
2453 }
2454 break;
2455 case XT_TAB_HIDE:
2456 if (show_tabs == 1) {
2457 show_tabs = 0;
2458 notebook_tab_set_visibility();
2459 }
2460 break;
2461 case XT_TAB_NEXTSTYLE:
2462 if (tab_style == XT_TABS_NORMAL) {
2463 tab_style = XT_TABS_COMPACT;
2464 recolor_compact_tabs();
2465 }
2466 else
2467 tab_style = XT_TABS_NORMAL;
2468 notebook_tab_set_visibility();
2469 break;
2470 case XT_TAB_UNDO_CLOSE:
2471 if (undo_count == 0) {
2472 DNPRINTF(XT_D_TAB, "%s: no tabs to undo close",
2473 __func__);
2474 goto done;
2475 } else {
2476 undo_count--;
2477 u = TAILQ_FIRST(&undos);
2478 create_new_tab(u->uri, u, 1, -1);
2479
2480 TAILQ_REMOVE(&undos, u, entry);
2481 g_free(u->uri);
2482 /* u->history is freed in create_new_tab() */
2483 g_free(u);
2484 }
2485 break;
2486 case XT_TAB_LOAD_IMAGES:
2487
2488 if (!auto_load_images) {
2489
2490 /* Enable auto-load images (this will load all
2491 * previously unloaded images). */
2492 g_object_set(G_OBJECT(t->settings),
2493 "auto-load-images", TRUE, (char *)NULL);
2494 webkit_web_view_set_settings(t->wv, t->settings);
2495
2496 webkit_web_view_reload(t->wv);
2497
2498 /* Webkit triggers an event when we change the setting,
2499 * so we can't disable the auto-loading at once.
2500 *
2501 * Unfortunately, webkit does not tell us when it's done.
2502 * Instead, we wait until the next request, and then
2503 * disable autoloading again.
2504 */
2505 t->load_images = TRUE;
2506 }
2507 break;
2508 default:
2509 rv = XT_CB_PASSTHROUGH;
2510 goto done;
2511 }
2512
2513 done:
2514 if (args->s) {
2515 g_free(args->s);
2516 args->s = NULL;
2517 }
2518
2519 return (rv);
2520 }
2521
2522 int
2523 resizetab(struct tab *t, struct karg *args)
2524 {
2525 if (t == NULL || args == NULL) {
2526 show_oops(NULL, "resizetab invalid parameters");
2527 return (XT_CB_PASSTHROUGH);
2528 }
2529
2530 DNPRINTF(XT_D_TAB, "resizetab: tab %d %d\n",
2531 t->tab_id, args->i);
2532
2533 setzoom_webkit(t, args->i);
2534
2535 return (XT_CB_HANDLED);
2536 }
2537
2538 int
2539 movetab(struct tab *t, struct karg *args)
2540 {
2541 int n, dest;
2542
2543 if (t == NULL || args == NULL) {
2544 show_oops(NULL, "movetab invalid parameters");
2545 return (XT_CB_PASSTHROUGH);
2546 }
2547
2548 DNPRINTF(XT_D_TAB, "movetab: tab %d opcode %d\n",
2549 t->tab_id, args->i);
2550
2551 if (args->i >= XT_TAB_INVALID)
2552 return (XT_CB_PASSTHROUGH);
2553
2554 if (TAILQ_EMPTY(&tabs))
2555 return (XT_CB_PASSTHROUGH);
2556
2557 n = gtk_notebook_get_n_pages(notebook);
2558 dest = gtk_notebook_get_current_page(notebook);
2559
2560 switch (args->i) {
2561 case XT_TAB_NEXT:
2562 if (args->precount < 0)
2563 dest = dest == n - 1 ? 0 : dest + 1;
2564 else
2565 dest = args->precount - 1;
2566
2567 break;
2568 case XT_TAB_PREV:
2569 if (args->precount < 0)
2570 dest -= 1;
2571 else
2572 dest -= args->precount % n;
2573
2574 if (dest < 0)
2575 dest += n;
2576
2577 break;
2578 case XT_TAB_FIRST:
2579 dest = 0;
2580 break;
2581 case XT_TAB_LAST:
2582 dest = n - 1;
2583 break;
2584 default:
2585 return (XT_CB_PASSTHROUGH);
2586 }
2587
2588 if (dest < 0 || dest >= n)
2589 return (XT_CB_PASSTHROUGH);
2590 if (t->tab_id == dest) {
2591 DNPRINTF(XT_D_TAB, "movetab: do nothing\n");
2592 return (XT_CB_HANDLED);
2593 }
2594
2595 set_current_tab(dest);
2596
2597 return (XT_CB_HANDLED);
2598 }
2599
2600 int cmd_prefix = 0;
2601
2602
2603 int
2604 command(struct tab *t, struct karg *args)
2605 {
2606 char *s = NULL, *ss = NULL;
2607 gchar *text, *base;
2608 const gchar *uri;
2609 struct karg a;
2610
2611 if (t == NULL || args == NULL) {
2612 show_oops(NULL, "command invalid parameters");
2613 return (XT_CB_PASSTHROUGH);
2614 }
2615
2616 switch (args->i) {
2617 case '/':
2618 s = "/";
2619 break;
2620 case '?':
2621 s = "?";
2622 break;
2623 case ':':
2624 if (cmd_prefix == 0)
2625 s = ":";
2626 else {
2627 ss = g_strdup_printf(":%d", cmd_prefix);
2628 s = ss;
2629 cmd_prefix = 0;
2630 }
2631 break;
2632 case '.':
2633 t->mode = XT_MODE_HINT;
2634 bzero(&a, sizeof a);
2635 a.i = 0;
2636 hint(t, &a);
2637 s = ".";
2638 break;
2639 case ',':
2640 t->mode = XT_MODE_HINT;
2641 bzero(&a, sizeof a);
2642 a.i = XT_HINT_NEWTAB;
2643 hint(t, &a);
2644 s = ",";
2645 break;
2646 case XT_CMD_OPEN:
2647 s = ":open ";
2648 break;
2649 case XT_CMD_TABNEW:
2650 s = ":tabnew ";
2651 break;
2652 case XT_CMD_OPEN_CURRENT:
2653 s = ":open ";
2654 /* FALL THROUGH */
2655 case XT_CMD_TABNEW_CURRENT:
2656 if (!s) /* FALL THROUGH? */
2657 s = ":tabnew ";
2658 if ((uri = get_uri(t)) != NULL) {
2659 ss = g_strdup_printf("%s%s", s, uri);
2660 s = ss;
2661 }
2662 break;
2663 default:
2664 show_oops(t, "command: invalid opcode %d", args->i);
2665 return (XT_CB_PASSTHROUGH);
2666 }
2667
2668 DNPRINTF(XT_D_CMD, "%s: tab %d type %s\n", __func__, t->tab_id, s);
2669
2670 gtk_entry_set_text(GTK_ENTRY(t->cmd), s);
2671 text = gdk_color_to_string(&t->default_style->text[GTK_STATE_NORMAL]);
2672 base = gdk_color_to_string(&t->default_style->base[GTK_STATE_NORMAL]);
2673 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL,
2674 &t->default_style->base[GTK_STATE_NORMAL]);
2675 statusbar_modify_attr(t, text, base);
2676 g_free(text);
2677 g_free(base);
2678 show_cmd(t);
2679 gtk_widget_grab_focus(GTK_WIDGET(t->cmd));
2680 gtk_editable_set_position(GTK_EDITABLE(t->cmd), -1);
2681
2682 if (ss)
2683 g_free(ss);
2684
2685 return (XT_CB_HANDLED);
2686 }
2687
2688 int
2689 search(struct tab *t, struct karg *args)
2690 {
2691 gboolean d;
2692
2693 if (t == NULL || args == NULL) {
2694 show_oops(NULL, "search invalid parameters");
2695 return (1);
2696 }
2697
2698 switch (args->i) {
2699 case XT_SEARCH_NEXT:
2700 d = t->search_forward;
2701 break;
2702 case XT_SEARCH_PREV:
2703 d = !t->search_forward;
2704 break;
2705 default:
2706 return (XT_CB_PASSTHROUGH);
2707 }
2708
2709 if (t->search_text == NULL) {
2710 if (global_search == NULL)
2711 return (XT_CB_PASSTHROUGH);
2712 else {
2713 d = t->search_forward = TRUE;
2714 t->search_text = g_strdup(global_search);
2715 webkit_web_view_mark_text_matches(t->wv, global_search, FALSE, 0);
2716 webkit_web_view_set_highlight_text_matches(t->wv, TRUE);
2717 }
2718 }
2719
2720 DNPRINTF(XT_D_CMD, "search: tab %d opc %d forw %d text %s\n",
2721 t->tab_id, args->i, t->search_forward, t->search_text);
2722
2723 webkit_web_view_search_text(t->wv, t->search_text, FALSE, d, TRUE);
2724
2725 return (XT_CB_HANDLED);
2726 }
2727
2728 int
2729 session_save(struct tab *t, char *filename)
2730 {
2731 struct karg a;
2732 int rv = 1;
2733 struct session *s;
2734
2735 if (strlen(filename) == 0)
2736 goto done;
2737
2738 if (filename[0] == '.' || filename[0] == '/')
2739 goto done;
2740
2741 a.s = filename;
2742 if (save_tabs(t, &a))
2743 goto done;
2744 strlcpy(named_session, filename, sizeof named_session);
2745
2746 /* add the new session to the list of sessions */
2747 s = g_malloc(sizeof(struct session));
2748 s->name = g_strdup(filename);
2749 TAILQ_INSERT_TAIL(&sessions, s, entry);
2750
2751 rv = 0;
2752 done:
2753 return (rv);
2754 }
2755
2756 int
2757 session_open(struct tab *t, char *filename)
2758 {
2759 struct karg a;
2760 int rv = 1;
2761
2762 if (strlen(filename) == 0)
2763 goto done;
2764
2765 if (filename[0] == '.' || filename[0] == '/')
2766 goto done;
2767
2768 a.s = filename;
2769 a.i = XT_SES_CLOSETABS;
2770 if (open_tabs(t, &a))
2771 goto done;
2772
2773 strlcpy(named_session, filename, sizeof named_session);
2774
2775 rv = 0;
2776 done:
2777 return (rv);
2778 }
2779
2780 int
2781 session_delete(struct tab *t, char *filename)
2782 {
2783 char file[PATH_MAX];
2784 int rv = 1;
2785 struct session *s;
2786
2787 if (strlen(filename) == 0)
2788 goto done;
2789
2790 if (filename[0] == '.' || filename[0] == '/')
2791 goto done;
2792
2793 snprintf(file, sizeof file, "%s" PS "%s", sessions_dir, filename);
2794 if (unlink(file))
2795 goto done;
2796
2797 if (!strcmp(filename, named_session))
2798 strlcpy(named_session, XT_SAVED_TABS_FILE,
2799 sizeof named_session);
2800
2801 /* remove session from sessions list */
2802 TAILQ_FOREACH(s, &sessions, entry) {
2803 if (!strcmp(s->name, filename))
2804 break;
2805 }
2806 if (s == NULL)
2807 goto done;
2808 TAILQ_REMOVE(&sessions, s, entry);
2809 g_free((gpointer) s->name);
2810 g_free(s);
2811
2812 rv = 0;
2813 done:
2814 return (rv);
2815 }
2816
2817 int
2818 session_cmd(struct tab *t, struct karg *args)
2819 {
2820 char *filename = args->s;
2821
2822 if (t == NULL)
2823 return (1);
2824
2825 if (args->i & XT_SHOW)
2826 show_oops(t, "Current session: %s", named_session[0] == '\0' ?
2827 XT_SAVED_TABS_FILE : named_session);
2828 else if (args->i & XT_SAVE) {
2829 if (session_save(t, filename)) {
2830 show_oops(t, "Can't save session: %s",
2831 filename ? filename : "INVALID");
2832 goto done;
2833 }
2834 } else if (args->i & XT_OPEN) {
2835 if (session_open(t, filename)) {
2836 show_oops(t, "Can't open session: %s",
2837 filename ? filename : "INVALID");
2838 goto done;
2839 }
2840 } else if (args->i & XT_DELETE) {
2841 if (session_delete(t, filename)) {
2842 show_oops(t, "Can't delete session: %s",
2843 filename ? filename : "INVALID");
2844 goto done;
2845 }
2846 }
2847 done:
2848 return (XT_CB_PASSTHROUGH);
2849 }
2850
2851 int
2852 script_cmd(struct tab *t, struct karg *args)
2853 {
2854 struct stat sb;
2855 FILE *f = NULL;
2856 char *buf = NULL;
2857
2858 if (t == NULL)
2859 goto done;
2860
2861 if ((f = fopen(args->s, "r")) == NULL) {
2862 show_oops(t, "Can't open script file: %s", args->s);
2863 goto done;
2864 }
2865
2866 if (fstat(fileno(f), &sb) == -1) {
2867 show_oops(t, "Can't stat script file: %s", args->s);
2868 goto done;
2869 }
2870
2871 buf = g_malloc0(sb.st_size + 1);
2872 if (fread(buf, 1, sb.st_size, f) != sb.st_size) {
2873 show_oops(t, "Can't read script file: %s", args->s);
2874 goto done;
2875 }
2876
2877 DNPRINTF(XT_D_JS, "%s: about to run script\n", __func__);
2878 run_script(t, buf);
2879
2880 done:
2881 if (f)
2882 fclose(f);
2883 if (buf)
2884 g_free(buf);
2885
2886 return (XT_CB_PASSTHROUGH);
2887 }
2888
2889 /*
2890 * Make a hardcopy of the page
2891 */
2892 int
2893 print_page(struct tab *t, struct karg *args)
2894 {
2895 WebKitWebFrame *frame;
2896 GtkPageSetup *ps;
2897 GtkPrintOperation *op;
2898 GtkPrintOperationAction action;
2899 GtkPrintOperationResult print_res;
2900 GError *g_err = NULL;
2901 int marg_l, marg_r, marg_t, marg_b;
2902
2903 DNPRINTF(XT_D_PRINTING, "%s:", __func__);
2904
2905 ps = gtk_page_setup_new();
2906 op = gtk_print_operation_new();
2907 action = GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG;
2908 frame = webkit_web_view_get_main_frame(t->wv);
2909
2910 /* the default margins are too small, so we will bump them */
2911 marg_l = gtk_page_setup_get_left_margin(ps, GTK_UNIT_MM) +
2912 XT_PRINT_EXTRA_MARGIN;
2913 marg_r = gtk_page_setup_get_right_margin(ps, GTK_UNIT_MM) +
2914 XT_PRINT_EXTRA_MARGIN;
2915 marg_t = gtk_page_setup_get_top_margin(ps, GTK_UNIT_MM) +
2916 XT_PRINT_EXTRA_MARGIN;
2917 marg_b = gtk_page_setup_get_bottom_margin(ps, GTK_UNIT_MM) +
2918 XT_PRINT_EXTRA_MARGIN;
2919
2920 /* set margins */
2921 gtk_page_setup_set_left_margin(ps, marg_l, GTK_UNIT_MM);
2922 gtk_page_setup_set_right_margin(ps, marg_r, GTK_UNIT_MM);
2923 gtk_page_setup_set_top_margin(ps, marg_t, GTK_UNIT_MM);
2924 gtk_page_setup_set_bottom_margin(ps, marg_b, GTK_UNIT_MM);
2925
2926 gtk_print_operation_set_default_page_setup(op, ps);
2927
2928 /* this appears to free 'op' and 'ps' */
2929 print_res = webkit_web_frame_print_full(frame, op, action, &g_err);
2930
2931 /* check it worked */
2932 if (print_res == GTK_PRINT_OPERATION_RESULT_ERROR) {
2933 show_oops(NULL, "can't print: %s", g_err->message);
2934 g_error_free (g_err);
2935 return (1);
2936 }
2937
2938 return (0);
2939 }
2940
2941 int
2942 go_home(struct tab *t, struct karg *args)
2943 {
2944 load_uri(t, home);
2945 return (0);
2946 }
2947
2948 int
2949 set_encoding(struct tab *t, struct karg *args)
2950 {
2951 const gchar *e;
2952
2953 if (args->s && strlen(g_strstrip(args->s)) == 0) {
2954 e = webkit_web_view_get_custom_encoding(t->wv);
2955 if (e == NULL)
2956 e = webkit_web_view_get_encoding(t->wv);
2957 show_oops(t, "encoding: %s", e ? e : "N/A");
2958 } else
2959 webkit_web_view_set_custom_encoding(t->wv, args->s);
2960
2961 return (0);
2962 }
2963
2964 int
2965 restart(struct tab *t, struct karg *args)
2966 {
2967 struct karg a;
2968
2969 a.s = XT_RESTART_TABS_FILE;
2970 save_tabs(t, &a);
2971 execvp(start_argv[0], start_argv);
2972 /* NOTREACHED */
2973
2974 return (0);
2975 }
2976
2977 char *http_proxy_save; /* not a setting, used to toggle */
2978
2979 int
2980 proxy_cmd(struct tab *t, struct karg *args)
2981 {
2982 DNPRINTF(XT_D_CMD, "%s: tab %d\n", __func__, t->tab_id);
2983
2984 if (t == NULL)
2985 return (1);
2986
2987 /* setup */
2988 if (http_proxy) {
2989 if (http_proxy_save)
2990 g_free(http_proxy_save);
2991 http_proxy_save = g_strdup(http_proxy);
2992 }
2993
2994 if (args->i & XT_PRXY_SHOW) {
2995 if (http_proxy)
2996 show_oops(t, "http_proxy = %s", http_proxy);
2997 else
2998 show_oops(t, "proxy is currently disabled");
2999 } else if (args->i & XT_PRXY_TOGGLE) {
3000 if (http_proxy_save == NULL && http_proxy == NULL) {
3001 show_oops(t, "can't toggle proxy");
3002 goto done;
3003 }
3004 if (http_proxy)
3005 setup_proxy(NULL);
3006 else
3007 setup_proxy(http_proxy_save);
3008 }
3009 done:
3010 return (XT_CB_PASSTHROUGH);
3011 }
3012 struct cmd {
3013 char *cmd;
3014 int level;
3015 int (*func)(struct tab *, struct karg *);
3016 int arg;
3017 int type;
3018 } cmds[] = {
3019 { "command_mode", 0, command_mode, XT_MODE_COMMAND, 0 },
3020 { "insert_mode", 0, command_mode, XT_MODE_INSERT, 0 },
3021 { "command", 0, command, ':', 0 },
3022 { "search", 0, command, '/', 0 },
3023 { "searchb", 0, command, '?', 0 },
3024 { "hinting", 0, command, '.', 0 },
3025 { "hinting_newtab", 0, command, ',', 0 },
3026 { "togglesrc", 0, toggle_src, 0, 0 },
3027 { "editsrc", 0, edit_src, 0, 0 },
3028 { "editelement", 0, edit_element, 0, 0 },
3029 { "passthrough", 0, passthrough, 0, 0 },
3030 { "modurl", 0, modurl, 0, 0 },
3031
3032 /* yanking and pasting */
3033 { "yankuri", 0, yank_uri, 0, 0 },
3034 /* XXX: pasteuri{cur,new} do not work from the cmd_entry? */
3035 { "pasteuricur", 0, paste_uri, XT_PASTE_CURRENT_TAB, 0 },
3036 { "pasteurinew", 0, paste_uri, XT_PASTE_NEW_TAB, 0 },
3037
3038 /* search */
3039 { "searchnext", 0, search, XT_SEARCH_NEXT, 0 },
3040 { "searchprevious", 0, search, XT_SEARCH_PREV, 0 },
3041
3042 /* focus */
3043 { "focusaddress", 0, focus, XT_FOCUS_URI, 0 },
3044 { "focussearch", 0, focus, XT_FOCUS_SEARCH, 0 },
3045
3046 /* hinting */
3047 { "hinting", 0, hint, 0, 0 },
3048 { "hinting_newtab", 0, hint, XT_HINT_NEWTAB, 0 },
3049
3050 /* custom stylesheet */
3051 { "userstyle", 0, userstyle, XT_STYLE_CURRENT_TAB, 0 },
3052 { "userstyle_global", 0, userstyle, XT_STYLE_GLOBAL, 0 },
3053
3054 /* navigation */
3055 { "goback", 0, navaction, XT_NAV_BACK, 0 },
3056 { "goforward", 0, navaction, XT_NAV_FORWARD, 0 },
3057 { "reload", 0, navaction, XT_NAV_RELOAD, 0 },
3058 { "stop", 0, navaction, XT_NAV_STOP, 0 },
3059
3060 /* vertical movement */
3061 { "scrolldown", 0, move, XT_MOVE_DOWN, 0 },
3062 { "scrollup", 0, move, XT_MOVE_UP, 0 },
3063 { "scrollbottom", 0, move, XT_MOVE_BOTTOM, 0 },
3064 { "scrolltop", 0, move, XT_MOVE_TOP, 0 },
3065 { "1", 0, move, XT_MOVE_TOP, 0 },
3066 { "scrollhalfdown", 0, move, XT_MOVE_HALFDOWN, 0 },
3067 { "scrollhalfup", 0, move, XT_MOVE_HALFUP, 0 },
3068 { "scrollpagedown", 0, move, XT_MOVE_PAGEDOWN, 0 },
3069 { "scrollpageup", 0, move, XT_MOVE_PAGEUP, 0 },
3070 /* horizontal movement */
3071 { "scrollright", 0, move, XT_MOVE_RIGHT, 0 },
3072 { "scrollleft", 0, move, XT_MOVE_LEFT, 0 },
3073 { "scrollfarright", 0, move, XT_MOVE_FARRIGHT, 0 },
3074 { "scrollfarleft", 0, move, XT_MOVE_FARLEFT, 0 },
3075
3076 { "favorites", 0, xtp_page_fl, 0, 0 },
3077 { "fav", 0, xtp_page_fl, 0, 0 },
3078 { "favadd", 0, add_favorite, 0, 0 },
3079
3080 { "qall", 0, quit, 0, 0 },
3081 { "quitall", 0, quit, 0, 0 },
3082 { "w", 0, save_tabs, 0, 0 },
3083 { "wq", 0, save_tabs_and_quit, 0, 0 },
3084 { "help", 0, help, 0, 0 },
3085 { "about", 0, about, 0, 0 },
3086 { "stats", 0, stats, 0, 0 },
3087 { "version", 0, about, 0, 0 },
3088
3089 /* js command */
3090 { "js", 0, js_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3091 { "save", 1, js_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3092 { "domain", 2, js_cmd, XT_SAVE | XT_WL_TOPLEVEL, 0 },
3093 { "fqdn", 2, js_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3094 { "show", 1, js_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3095 { "all", 2, js_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3096 { "persistent", 2, js_cmd, XT_SHOW | XT_WL_PERSISTENT, 0 },
3097 { "session", 2, js_cmd, XT_SHOW | XT_WL_SESSION, 0 },
3098 { "toggle", 1, js_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3099 { "domain", 2, js_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL, 0 },
3100 { "fqdn", 2, js_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3101
3102 /* cookie command */
3103 { "cookie", 0, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3104 { "save", 1, cookie_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3105 { "domain", 2, cookie_cmd, XT_SAVE | XT_WL_TOPLEVEL, 0 },
3106 { "fqdn", 2, cookie_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3107 { "show", 1, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3108 { "all", 2, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3109 { "persistent", 2, cookie_cmd, XT_SHOW | XT_WL_PERSISTENT, 0 },
3110 { "session", 2, cookie_cmd, XT_SHOW | XT_WL_SESSION, 0 },
3111 { "toggle", 1, cookie_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3112 { "domain", 2, cookie_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL, 0 },
3113 { "fqdn", 2, cookie_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3114 { "purge", 1, cookie_cmd, XT_DELETE, 0 },
3115
3116 /* plugin command */
3117 { "plugin", 0, pl_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3118 { "save", 1, pl_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3119 { "domain", 2, pl_cmd, XT_SAVE | XT_WL_TOPLEVEL, 0 },
3120 { "fqdn", 2, pl_cmd, XT_SAVE | XT_WL_FQDN, 0 },
3121 { "show", 1, pl_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3122 { "all", 2, pl_cmd, XT_SHOW | XT_WL_PERSISTENT | XT_WL_SESSION, 0 },
3123 { "persistent", 2, pl_cmd, XT_SHOW | XT_WL_PERSISTENT, 0 },
3124 { "session", 2, pl_cmd, XT_SHOW | XT_WL_SESSION, 0 },
3125 { "toggle", 1, pl_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3126 { "domain", 2, pl_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL, 0 },
3127 { "fqdn", 2, pl_cmd, XT_WL_TOGGLE | XT_WL_FQDN, 0 },
3128
3129 /* toplevel (domain) command */
3130 { "toplevel", 0, toplevel_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL | XT_WL_RELOAD, 0 },
3131 { "toggle", 1, toplevel_cmd, XT_WL_TOGGLE | XT_WL_TOPLEVEL | XT_WL_RELOAD, 0 },
3132
3133 /* cookie jar */
3134 { "cookiejar", 0, xtp_page_cl, 0, 0 },
3135
3136 /* cert command */
3137 { "cert", 0, cert_cmd, XT_SHOW, 0 },
3138 { "save", 1, cert_cmd, XT_SAVE, 0 },
3139 { "show", 1, cert_cmd, XT_SHOW, 0 },
3140
3141 { "ca", 0, ca_cmd, 0, 0 },
3142 { "downloadmgr", 0, xtp_page_dl, 0, 0 },
3143 { "dl", 0, xtp_page_dl, 0, 0 },
3144 { "h", 0, xtp_page_hl, 0, 0 },
3145 { "history", 0, xtp_page_hl, 0, 0 },
3146 { "home", 0, go_home, 0, 0 },
3147 { "restart", 0, restart, 0, 0 },
3148 { "urlhide", 0, urlaction, XT_URL_HIDE, 0 },
3149 { "urlshow", 0, urlaction, XT_URL_SHOW, 0 },
3150 { "statustoggle", 0, statustoggle, 0, 0 },
3151 { "run_script", 0, run_page_script, 0, XT_USERARG },
3152
3153 { "print", 0, print_page, 0, 0 },
3154
3155 /* tabs */
3156 { "focusin", 0, resizetab, XT_ZOOM_IN, 0 },
3157 { "focusout", 0, resizetab, XT_ZOOM_OUT, 0 },
3158 { "focusreset", 0, resizetab, XT_ZOOM_NORMAL, 0 },
3159 { "q", 0, tabaction, XT_TAB_DELQUIT, 0 },
3160 { "quit", 0, tabaction, XT_TAB_DELQUIT, 0 },
3161 { "open", 0, tabaction, XT_TAB_OPEN, XT_URLARG },
3162 { "tabclose", 0, tabaction, XT_TAB_DELETE, XT_PREFIX | XT_INTARG},
3163 { "tabedit", 0, tabaction, XT_TAB_NEW, XT_PREFIX | XT_URLARG },
3164 { "tabfirst", 0, movetab, XT_TAB_FIRST, 0 },
3165 { "tabhide", 0, tabaction, XT_TAB_HIDE, 0 },
3166 { "tablast", 0, movetab, XT_TAB_LAST, 0 },
3167 { "tabnew", 0, tabaction, XT_TAB_NEW, XT_PREFIX | XT_URLARG },
3168 { "tabnext", 0, movetab, XT_TAB_NEXT, XT_PREFIX | XT_INTARG},
3169 { "tabnextstyle", 0, tabaction, XT_TAB_NEXTSTYLE, 0 },
3170 { "tabprevious", 0, movetab, XT_TAB_PREV, XT_PREFIX | XT_INTARG},
3171 { "tabrewind", 0, movetab, XT_TAB_FIRST, 0 },
3172 { "tabshow", 0, tabaction, XT_TAB_SHOW, 0 },
3173 { "tabs", 0, buffers, 0, 0 },
3174 { "tabundoclose", 0, tabaction, XT_TAB_UNDO_CLOSE, 0 },
3175 { "buffers", 0, buffers, 0, 0 },
3176 { "ls", 0, buffers, 0, 0 },
3177 { "encoding", 0, set_encoding, 0, XT_USERARG },
3178 { "loadimages", 0, tabaction, XT_TAB_LOAD_IMAGES, 0 },
3179
3180 /* command aliases (handy when -S flag is used) */
3181 { "promptopen", 0, command, XT_CMD_OPEN, 0 },
3182 { "promptopencurrent", 0, command, XT_CMD_OPEN_CURRENT, 0 },
3183 { "prompttabnew", 0, command, XT_CMD_TABNEW, 0 },
3184 { "prompttabnewcurrent",0, command, XT_CMD_TABNEW_CURRENT, 0 },
3185
3186 /* settings */
3187 { "set", 0, set, 0, XT_SETARG },
3188
3189 { "fullscreen", 0, fullscreen, 0, 0 },
3190 { "f", 0, fullscreen, 0, 0 },
3191
3192 /* sessions */
3193 { "session", 0, session_cmd, XT_SHOW, 0 },
3194 { "delete", 1, session_cmd, XT_DELETE, XT_SESSARG },
3195 { "open", 1, session_cmd, XT_OPEN, XT_SESSARG },
3196 { "save", 1, session_cmd, XT_SAVE, XT_USERARG },
3197 { "show", 1, session_cmd, XT_SHOW, 0 },
3198
3199 /* external javascript */
3200 { "script", 0, script_cmd, XT_EJS_SHOW, XT_USERARG },
3201
3202 /* inspector */
3203 { "inspector", 0, inspector_cmd, XT_INS_SHOW, 0 },
3204 { "show", 1, inspector_cmd, XT_INS_SHOW, 0 },
3205 { "hide", 1, inspector_cmd, XT_INS_HIDE, 0 },
3206
3207 /* proxy */
3208 { "proxy", 0, proxy_cmd, XT_PRXY_SHOW, 0 },
3209 { "show", 1, proxy_cmd, XT_PRXY_SHOW, 0 },
3210 { "toggle", 1, proxy_cmd, XT_PRXY_TOGGLE, 0 },
3211 };
3212
3213 struct {
3214 int index;
3215 int len;
3216 gchar *list[256];
3217 } cmd_status = {-1, 0};
3218
3219 gboolean
3220 wv_release_button_cb(GtkWidget *btn, GdkEventButton *e, struct tab *t)
3221 {
3222
3223 if (e->type == GDK_BUTTON_RELEASE && e->button == 1)
3224 btn_down = 0;
3225
3226 return (FALSE);
3227 }
3228
3229 gboolean
3230 wv_button_cb(GtkWidget *btn, GdkEventButton *e, struct tab *t)
3231 {
3232 struct karg a;
3233 WebKitHitTestResult *hit_test_result;
3234 guint context;
3235
3236 hit_test_result = webkit_web_view_get_hit_test_result(t->wv, e);
3237 g_object_get(hit_test_result, "context", &context, NULL);
3238
3239 hide_oops(t);
3240 hide_buffers(t);
3241
3242 if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE)
3243 t->mode = XT_MODE_INSERT;
3244 else
3245 t->mode = XT_MODE_COMMAND;
3246
3247 if (e->type == GDK_BUTTON_PRESS && e->button == 1)
3248 btn_down = 1;
3249 else if (e->type == GDK_BUTTON_PRESS && e->button == 8 /* btn 4 */) {
3250 /* go backward */
3251 a.i = XT_NAV_BACK;
3252 navaction(t, &a);
3253
3254 return (TRUE);
3255 } else if (e->type == GDK_BUTTON_PRESS && e->button == 9 /* btn 5 */) {
3256 /* go forward */
3257 a.i = XT_NAV_FORWARD;
3258 navaction(t, &a);
3259
3260 return (TRUE);
3261 }
3262
3263 return (FALSE);
3264 }
3265
3266 gboolean
3267 tab_close_cb(GtkWidget *btn, GdkEventButton *e, struct tab *t)
3268 {
3269 DNPRINTF(XT_D_TAB, "tab_close_cb: tab %d\n", t->tab_id);
3270
3271 if (e->type == GDK_BUTTON_PRESS && e->button == 1)
3272 delete_tab(t);
3273
3274 return (FALSE);
3275 }
3276
3277
3278
3279 void
3280 activate_uri_entry_cb(GtkWidget* entry, struct tab *t)
3281 {
3282 const gchar *uri = gtk_entry_get_text(GTK_ENTRY(entry));
3283
3284 DNPRINTF(XT_D_URL, "activate_uri_entry_cb: %s\n", uri);
3285
3286 if (t == NULL) {
3287 show_oops(NULL, "activate_uri_entry_cb invalid parameters");
3288 return;
3289 }
3290
3291 if (uri == NULL) {
3292 show_oops(t, "activate_uri_entry_cb no uri");
3293 return;
3294 }
3295
3296 uri += strspn(uri, "\t ");
3297
3298 /* if xxxt:// treat specially */
3299 if (parse_xtp_url(t, uri))
3300 return;
3301
3302 /* otherwise continue to load page normally */
3303 load_uri(t, (gchar *)uri);
3304 focus_webview(t);
3305 }
3306
3307 void
3308 activate_search_entry_cb(GtkWidget* entry, struct tab *t)
3309 {
3310 const gchar *search = gtk_entry_get_text(GTK_ENTRY(entry));
3311 char *newuri = NULL;
3312 gchar *enc_search;
3313
3314 DNPRINTF(XT_D_URL, "activate_search_entry_cb: %s\n", search);
3315
3316 if (t == NULL) {
3317 show_oops(NULL, "activate_search_entry_cb invalid parameters");
3318 return;
3319 }
3320
3321 if (search_string == NULL || strlen(search_string) == 0) {
3322 show_oops(t, "no search_string");
3323 return;
3324 }
3325
3326 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
3327
3328 enc_search = soup_uri_encode(search, XT_RESERVED_CHARS);
3329 newuri = g_strdup_printf(search_string, enc_search);
3330 g_free(enc_search);
3331
3332 marks_clear(t);
3333 webkit_web_view_load_uri(t->wv, newuri);
3334 focus_webview(t);
3335
3336 if (newuri)
3337 g_free(newuri);
3338 }
3339
3340 void
3341 check_and_set_cookie(const gchar *uri, struct tab *t)
3342 {
3343 struct domain *d = NULL;
3344 int es = 0;
3345
3346 if (uri == NULL || t == NULL)
3347 return;
3348
3349 if ((d = wl_find_uri(uri, &c_wl)) == NULL)
3350 es = 0;
3351 else
3352 es = 1;
3353
3354 DNPRINTF(XT_D_COOKIE, "check_and_set_cookie: %s %s\n",
3355 es ? "enable" : "disable", uri);
3356
3357 g_object_set(G_OBJECT(t->settings),
3358 "enable-html5-local-storage", es, (char *)NULL);
3359 webkit_web_view_set_settings(t->wv, t->settings);
3360 }
3361
3362 void
3363 check_and_set_js(const gchar *uri, struct tab *t)
3364 {
3365 struct domain *d = NULL;
3366 int es = 0;
3367
3368 if (uri == NULL || t == NULL)
3369 return;
3370
3371 if ((d = wl_find_uri(uri, &js_wl)) == NULL)
3372 es = 0;
3373 else
3374 es = 1;
3375
3376 DNPRINTF(XT_D_JS, "check_and_set_js: %s %s\n",
3377 es ? "enable" : "disable", uri);
3378
3379 g_object_set(G_OBJECT(t->settings),
3380 "enable-scripts", es, (char *)NULL);
3381 g_object_set(G_OBJECT(t->settings),
3382 "javascript-can-open-windows-automatically", es, (char *)NULL);
3383 webkit_web_view_set_settings(t->wv, t->settings);
3384
3385 button_set_stockid(t->js_toggle,
3386 es ? GTK_STOCK_MEDIA_PLAY : GTK_STOCK_MEDIA_PAUSE);
3387 }
3388
3389 void
3390 check_and_set_pl(const gchar *uri, struct tab *t)
3391 {
3392 struct domain *d = NULL;
3393 int es = 0;
3394
3395 if (uri == NULL || t == NULL)
3396 return;
3397
3398 if ((d = wl_find_uri(uri, &pl_wl)) == NULL)
3399 es = 0;
3400 else
3401 es = 1;
3402
3403 DNPRINTF(XT_D_JS, "check_and_set_pl: %s %s\n",
3404 es ? "enable" : "disable", uri);
3405
3406 g_object_set(G_OBJECT(t->settings),
3407 "enable-plugins", es, (char *)NULL);
3408 webkit_web_view_set_settings(t->wv, t->settings);
3409 }
3410
3411 void
3412 color_address_bar(gpointer p)
3413 {
3414 GdkColor color;
3415 struct tab *tt, *t = p;
3416 gchar *col_str = XT_COLOR_WHITE, *text, *base;
3417 const gchar *uri, *u = NULL, *error_str = NULL;
3418
3419 #ifdef USE_THREADS
3420 gdk_threads_enter();
3421 #endif
3422 DNPRINTF(XT_D_URL, "%s:\n", __func__);
3423
3424 /* make sure t still exists */
3425 if (t == NULL)
3426 goto done;
3427 TAILQ_FOREACH(tt, &tabs, entry)
3428 if (t == tt)
3429 break;
3430 if (t != tt)
3431 goto done;
3432
3433 if ((uri = get_uri(t)) == NULL)
3434 goto white;
3435 u = g_strdup(uri);
3436
3437 #ifdef USE_THREADS
3438 gdk_flush();
3439 gdk_threads_leave();
3440 #endif
3441
3442 col_str = XT_COLOR_YELLOW;
3443 switch (load_compare_cert(u, &error_str)) {
3444 case CERT_LOCAL:
3445 col_str = XT_COLOR_BLUE;
3446 break;
3447 case CERT_TRUSTED:
3448 col_str = XT_COLOR_GREEN;
3449 break;
3450 case CERT_UNTRUSTED:
3451 col_str = XT_COLOR_YELLOW;
3452 break;
3453 case CERT_BAD:
3454 col_str = XT_COLOR_RED;
3455 break;
3456 }
3457
3458 #ifdef USE_THREADS
3459 gdk_threads_enter();
3460 #endif
3461 /* make sure t isn't deleted */
3462 TAILQ_FOREACH(tt, &tabs, entry)
3463 if (t == tt)
3464 break;
3465 if (t != tt)
3466 goto done;
3467
3468 #ifdef USE_THREADS
3469 /* test to see if the user navigated away and canceled the thread */
3470 if (t->thread != g_thread_self())
3471 goto done;
3472 if ((uri = get_uri(t)) == NULL) {
3473 t->thread = NULL;
3474 goto done;
3475 }
3476 if (strcmp(uri, u)) {
3477 /* make sure we are still the same url */
3478 t->thread = NULL;
3479 goto done;
3480 }
3481 #endif
3482 white:
3483
3484 if (!strcmp(col_str, XT_COLOR_WHITE)) {
3485 text = gdk_color_to_string(
3486 &t->default_style->text[GTK_STATE_NORMAL]);
3487 base = gdk_color_to_string(
3488 &t->default_style->base[GTK_STATE_NORMAL]);
3489 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL,
3490 &t->default_style->base[GTK_STATE_NORMAL]);
3491 statusbar_modify_attr(t, text, base);
3492 g_free(text);
3493 g_free(base);
3494 } else {
3495 gdk_color_parse(col_str, &color);
3496 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL, &color);
3497 statusbar_modify_attr(t, XT_COLOR_BLACK, col_str);
3498 }
3499
3500 if (error_str && error_str[0] != '\0')
3501 show_oops(t, "%s", error_str);
3502 #ifdef USE_THREADS
3503 t->thread = NULL;
3504 #endif
3505 done:
3506 /* t is invalid at this point */
3507 if (u)
3508 g_free((gpointer)u);
3509 #ifdef USE_THREADS
3510 gdk_flush();
3511 gdk_threads_leave();
3512 #endif
3513 }
3514
3515 void
3516 show_ca_status(struct tab *t, const char *uri)
3517 {
3518 GdkColor color;
3519 gchar *col_str = XT_COLOR_WHITE, *text, *base;
3520
3521 DNPRINTF(XT_D_URL, "show_ca_status: %d %s %s\n",
3522 ssl_strict_certs, ssl_ca_file, uri);
3523
3524 if (t == NULL)
3525 return;
3526
3527 if (uri == NULL)
3528 goto done;
3529 if (ssl_ca_file == NULL) {
3530 if (g_str_has_prefix(uri, "http://"))
3531 goto done;
3532 if (g_str_has_prefix(uri, "https://")) {
3533 col_str = XT_COLOR_RED;
3534 goto done;
3535 }
3536 return;
3537 }
3538 if (g_str_has_prefix(uri, "http://") ||
3539 !g_str_has_prefix(uri, "https://"))
3540 goto done;
3541 #ifdef USE_THREADS
3542 /*
3543 * It is not necessary to see if the thread is already running.
3544 * If the thread is in progress setting it to something else aborts it
3545 * on the way out.
3546 */
3547
3548 /* thread the coloring of the address bar */
3549 t->thread = g_thread_create((GThreadFunc)color_address_bar, t, TRUE, NULL);
3550 #else
3551 color_address_bar(t);
3552 #endif
3553 return;
3554
3555 done:
3556 if (col_str) {
3557
3558 if (!strcmp(col_str, XT_COLOR_WHITE)) {
3559 text = gdk_color_to_string(
3560 &t->default_style->text[GTK_STATE_NORMAL]);
3561 base = gdk_color_to_string(
3562 &t->default_style->base[GTK_STATE_NORMAL]);
3563 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL,
3564 &t->default_style->base[GTK_STATE_NORMAL]);
3565 statusbar_modify_attr(t, text, base);
3566 g_free(text);
3567 g_free(base);
3568 } else {
3569 gdk_color_parse(col_str, &color);
3570 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL, &color);
3571 statusbar_modify_attr(t, XT_COLOR_BLACK, col_str);
3572 }
3573 }
3574 }
3575
3576 void
3577 free_favicon(struct tab *t)
3578 {
3579 DNPRINTF(XT_D_DOWNLOAD, "%s: down %p req %p\n",
3580 __func__, t->icon_download, t->icon_request);
3581
3582 if (t->icon_request)
3583 g_object_unref(t->icon_request);
3584 if (t->icon_dest_uri)
3585 g_free(t->icon_dest_uri);
3586
3587 t->icon_request = NULL;
3588 t->icon_dest_uri = NULL;
3589 }
3590
3591 void
3592 xt_icon_from_name(struct tab *t, gchar *name)
3593 {
3594 if (!enable_favicon_entry)
3595 return;
3596
3597 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->uri_entry),
3598 GTK_ENTRY_ICON_PRIMARY, "text-html");
3599 if (show_url == 0)
3600 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
3601 GTK_ENTRY_ICON_PRIMARY, "text-html");
3602 else
3603 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
3604 GTK_ENTRY_ICON_PRIMARY, NULL);
3605 }
3606
3607 void
3608 xt_icon_from_pixbuf(struct tab *t, GdkPixbuf *pb)
3609 {
3610 GdkPixbuf *pb_scaled;
3611
3612 if (gdk_pixbuf_get_width(pb) > 16 || gdk_pixbuf_get_height(pb) > 16)
3613 pb_scaled = gdk_pixbuf_scale_simple(pb, 16, 16,
3614 GDK_INTERP_BILINEAR);
3615 else
3616 pb_scaled = pb;
3617
3618 if (enable_favicon_entry) {
3619
3620 /* Classic tabs. */
3621 gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(t->uri_entry),
3622 GTK_ENTRY_ICON_PRIMARY, pb_scaled);
3623
3624 /* Minimal tabs. */
3625 if (show_url == 0) {
3626 gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(t->sbe.statusbar),
3627 GTK_ENTRY_ICON_PRIMARY, pb_scaled);
3628 } else
3629 gtk_entry_set_icon_from_icon_name(GTK_ENTRY(t->sbe.statusbar),
3630 GTK_ENTRY_ICON_PRIMARY, NULL);
3631 }
3632
3633 /* XXX: Only supports the minimal tabs atm. */
3634 if (enable_favicon_tabs)
3635 gtk_image_set_from_pixbuf(GTK_IMAGE(t->tab_elems.favicon),
3636 pb_scaled);
3637
3638 if (pb_scaled != pb)
3639 g_object_unref(pb_scaled);
3640 }
3641
3642 void
3643 xt_icon_from_file(struct tab *t, char *file)
3644 {
3645 GdkPixbuf *pb;
3646
3647 if (g_str_has_prefix(file, "file://"))
3648 file += strlen("file://");
3649
3650 pb = gdk_pixbuf_new_from_file(file, NULL);
3651 if (pb) {
3652 xt_icon_from_pixbuf(t, pb);
3653 g_object_unref(pb);
3654 } else
3655 xt_icon_from_name(t, "text-html");
3656 }
3657
3658 gboolean
3659 is_valid_icon(char *file)
3660 {
3661 gboolean valid = 0;
3662 const char *mime_type;
3663 GFileInfo *fi;
3664 GFile *gf;
3665
3666 gf = g_file_new_for_path(file);
3667 fi = g_file_query_info(gf, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, 0,
3668 NULL, NULL);
3669 mime_type = g_file_info_get_content_type(fi);
3670 valid = g_strcmp0(mime_type, "image/x-ico") == 0 ||
3671 g_strcmp0(mime_type, "image/vnd.microsoft.icon") == 0 ||
3672 g_strcmp0(mime_type, "image/png") == 0 ||
3673 g_strcmp0(mime_type, "image/gif") == 0 ||
3674 g_strcmp0(mime_type, "application/octet-stream") == 0;
3675 g_object_unref(fi);
3676 g_object_unref(gf);
3677
3678 return (valid);
3679 }
3680
3681 void
3682 set_favicon_from_file(struct tab *t, char *file)
3683 {
3684 struct stat sb;
3685
3686 if (t == NULL || file == NULL)
3687 return;
3688
3689 if (g_str_has_prefix(file, "file://"))
3690 file += strlen("file://");
3691 DNPRINTF(XT_D_DOWNLOAD, "%s: loading %s\n", __func__, file);
3692
3693 if (!stat(file, &sb)) {
3694 if (sb.st_size == 0 || !is_valid_icon(file)) {
3695 /* corrupt icon so trash it */
3696 DNPRINTF(XT_D_DOWNLOAD, "%s: corrupt icon %s\n",
3697 __func__, file);
3698 unlink(file);
3699 /* no need to set icon to default here */
3700 return;
3701 }
3702 }
3703 xt_icon_from_file(t, file);
3704 }
3705
3706 void
3707 favicon_download_status_changed_cb(WebKitDownload *download, GParamSpec *spec,
3708 WebKitWebView *wv)
3709 {
3710 WebKitDownloadStatus status = webkit_download_get_status(download);
3711 struct tab *tt = NULL, *t = NULL;
3712
3713 /*
3714 * find the webview instead of passing in the tab as it could have been
3715 * deleted from underneath us.
3716 */
3717 TAILQ_FOREACH(tt, &tabs, entry) {
3718 if (tt->wv == wv) {
3719 t = tt;
3720 break;
3721 }
3722 }
3723 if (t == NULL)
3724 return;
3725
3726 DNPRINTF(XT_D_DOWNLOAD, "%s: tab %d status %d\n",
3727 __func__, t->tab_id, status);
3728
3729 switch (status) {
3730 case WEBKIT_DOWNLOAD_STATUS_ERROR:
3731 /* -1 */
3732 t->icon_download = NULL;
3733 free_favicon(t);
3734 break;
3735 case WEBKIT_DOWNLOAD_STATUS_CREATED:
3736 /* 0 */
3737 break;
3738 case WEBKIT_DOWNLOAD_STATUS_STARTED:
3739 /* 1 */
3740 break;
3741 case WEBKIT_DOWNLOAD_STATUS_CANCELLED:
3742 /* 2 */
3743 DNPRINTF(XT_D_DOWNLOAD, "%s: freeing favicon %d\n",
3744 __func__, t->tab_id);
3745 t->icon_download = NULL;
3746 free_favicon(t);
3747 break;
3748 case WEBKIT_DOWNLOAD_STATUS_FINISHED:
3749 /* 3 */
3750
3751 DNPRINTF(XT_D_DOWNLOAD, "%s: setting icon to %s\n",
3752 __func__, t->icon_dest_uri);
3753 set_favicon_from_file(t, t->icon_dest_uri);
3754 /* these will be freed post callback */
3755 t->icon_request = NULL;
3756 t->icon_download = NULL;
3757 break;
3758 default:
3759 break;
3760 }
3761 }
3762
3763 void
3764 abort_favicon_download(struct tab *t)
3765 {
3766 DNPRINTF(XT_D_DOWNLOAD, "%s: down %p\n", __func__, t->icon_download);
3767
3768 #if !WEBKIT_CHECK_VERSION(1, 4, 0)
3769 if (t->icon_download) {
3770 g_signal_handlers_disconnect_by_func(G_OBJECT(t->icon_download),
3771 G_CALLBACK(favicon_download_status_changed_cb), t->wv);
3772 webkit_download_cancel(t->icon_download);
3773 t->icon_download = NULL;
3774 } else
3775 free_favicon(t);
3776 #endif
3777
3778 xt_icon_from_name(t, "text-html");
3779 }
3780
3781 void
3782 notify_icon_loaded_cb(WebKitWebView *wv, gchar *uri, struct tab *t)
3783 {
3784 DNPRINTF(XT_D_DOWNLOAD, "%s %s\n", __func__, uri);
3785
3786 if (uri == NULL || t == NULL)
3787 return;
3788
3789 #if WEBKIT_CHECK_VERSION(1, 4, 0)
3790 /* take icon from WebKitIconDatabase */
3791 GdkPixbuf *pb;
3792
3793 pb = webkit_web_view_get_icon_pixbuf(wv);
3794 if (pb) {
3795 xt_icon_from_pixbuf(t, pb);
3796 g_object_unref(pb);
3797 } else
3798 xt_icon_from_name(t, "text-html");
3799 #elif WEBKIT_CHECK_VERSION(1, 1, 18)
3800 /* download icon to cache dir */
3801 gchar *name_hash, file[PATH_MAX];
3802 struct stat sb;
3803
3804 if (t->icon_request) {
3805 DNPRINTF(XT_D_DOWNLOAD, "%s: download in progress\n", __func__);
3806 return;
3807 }
3808
3809 /* check to see if we got the icon in cache */
3810 name_hash = g_compute_checksum_for_string(G_CHECKSUM_SHA256, uri, -1);
3811 snprintf(file, sizeof file, "%s" PS "%s.ico", cache_dir, name_hash);
3812 g_free(name_hash);
3813
3814 if (!stat(file, &sb)) {
3815 if (sb.st_size > 0) {
3816 DNPRINTF(XT_D_DOWNLOAD, "%s: loading from cache %s\n",
3817 __func__, file);
3818 set_favicon_from_file(t, file);
3819 return;
3820 }
3821
3822 /* corrupt icon so trash it */
3823 DNPRINTF(XT_D_DOWNLOAD, "%s: corrupt icon %s\n",
3824 __func__, file);
3825 unlink(file);
3826 }
3827
3828 /* create download for icon */
3829 t->icon_request = webkit_network_request_new(uri);
3830 if (t->icon_request == NULL) {
3831 DNPRINTF(XT_D_DOWNLOAD, "%s: invalid uri %s\n",
3832 __func__, uri);
3833 return;
3834 }
3835
3836 t->icon_download = webkit_download_new(t->icon_request);
3837 if (t->icon_download == NULL)
3838 return;
3839
3840 /* we have to free icon_dest_uri later */
3841 t->icon_dest_uri = g_strdup_printf("file://%s", file);
3842 webkit_download_set_destination_uri(t->icon_download,
3843 t->icon_dest_uri);
3844
3845 if (webkit_download_get_status(t->icon_download) ==
3846 WEBKIT_DOWNLOAD_STATUS_ERROR) {
3847 g_object_unref(t->icon_request);
3848 g_free(t->icon_dest_uri);
3849 t->icon_request = NULL;
3850 t->icon_dest_uri = NULL;
3851 return;
3852 }
3853
3854 g_signal_connect(G_OBJECT(t->icon_download), "notify::status",
3855 G_CALLBACK(favicon_download_status_changed_cb), t->wv);
3856
3857 webkit_download_start(t->icon_download);
3858 #endif
3859 }
3860
3861 void
3862 notify_load_status_cb(WebKitWebView* wview, GParamSpec* pspec, struct tab *t)
3863 {
3864 const gchar *uri = NULL;
3865 struct history *h, find;
3866 struct karg a;
3867 gchar *text, *base;
3868
3869 DNPRINTF(XT_D_URL, "notify_load_status_cb: %d %s\n",
3870 webkit_web_view_get_load_status(wview),
3871 get_uri(t) ? get_uri(t) : "NOTHING");
3872
3873 if (t == NULL) {
3874 show_oops(NULL, "notify_load_status_cb invalid parameters");
3875 return;
3876 }
3877
3878 switch (webkit_web_view_get_load_status(wview)) {
3879 case WEBKIT_LOAD_PROVISIONAL:
3880 /* 0 */
3881 abort_favicon_download(t);
3882 #if GTK_CHECK_VERSION(2, 20, 0)
3883 gtk_widget_show(t->spinner);
3884 gtk_spinner_start(GTK_SPINNER(t->spinner));
3885 #endif
3886 gtk_label_set_text(GTK_LABEL(t->label), "Loading");
3887
3888 gtk_widget_set_sensitive(GTK_WIDGET(t->stop), TRUE);
3889
3890 /* assume we are a new address */
3891 gtk_widget_modify_base(t->uri_entry, GTK_STATE_NORMAL,
3892 &t->default_style->base[GTK_STATE_NORMAL]);
3893 text = gdk_color_to_string(
3894 &t->default_style->text[GTK_STATE_NORMAL]);
3895 base = gdk_color_to_string(
3896 &t->default_style->base[GTK_STATE_NORMAL]);
3897 statusbar_modify_attr(t, text, base);
3898 g_free(text);
3899 g_free(base);
3900
3901 /* take focus if we are visible */
3902 focus_webview(t);
3903 t->focus_wv = 1;
3904
3905 marks_clear(t);
3906 #ifdef USE_THREAD
3907 /* kill color thread */
3908 t->thread = NULL;
3909 #endif
3910 break;
3911
3912 case WEBKIT_LOAD_COMMITTED:
3913 /* 1 */
3914 uri = get_uri(t);
3915 if (uri == NULL)
3916 return;
3917 gtk_entry_set_text(GTK_ENTRY(t->uri_entry), uri);
3918
3919 if (t->status) {
3920 g_free(t->status);
3921 t->status = NULL;
3922 }
3923 set_status(t, (char *)uri, XT_STATUS_LOADING);
3924
3925 /* check if js white listing is enabled */
3926 if (enable_plugin_whitelist)
3927 check_and_set_pl(uri, t);
3928 if (enable_cookie_whitelist)
3929 check_and_set_cookie(uri, t);
3930 if (enable_js_whitelist)
3931 check_and_set_js(uri, t);
3932
3933 if (t->styled)
3934 apply_style(t);
3935
3936
3937 /* we know enough to autosave the session */
3938 if (session_autosave) {
3939 a.s = NULL;
3940 save_tabs(t, &a);
3941 }
3942
3943 show_ca_status(t, uri);
3944 run_script(t, JS_HINTING);
3945 if (enable_autoscroll)
3946 run_script(t, JS_AUTOSCROLL);
3947 break;
3948
3949 case WEBKIT_LOAD_FIRST_VISUALLY_NON_EMPTY_LAYOUT:
3950 /* 3 */
3951 if (color_visited_uris) {
3952 color_visited(t, color_visited_helper());
3953
3954 /* This colors the links you middle-click (open in new
3955 * tab) in the current tab. */
3956 if (t->tab_id != gtk_notebook_get_current_page(notebook) &&
3957 (uri = get_uri(t)) != NULL)
3958 color_visited(get_current_tab(),
3959 g_strdup_printf("{'%s' : 'dummy'}", uri));
3960 }
3961 break;
3962
3963 case WEBKIT_LOAD_FINISHED:
3964 /* 2 */
3965 if ((uri = get_uri(t)) == NULL)
3966 return;
3967
3968 if (!strncmp(uri, "http://", strlen("http://")) ||
3969 !strncmp(uri, "https://", strlen("https://")) ||
3970 !strncmp(uri, "file://", strlen("file://"))) {
3971 find.uri = (gchar *)uri;
3972 h = RB_FIND(history_list, &hl, &find);
3973 if (!h)
3974 insert_history_item(uri,
3975 get_title(t, FALSE), time(NULL));
3976 else
3977 h->time = time(NULL);
3978 }
3979
3980 set_status(t, (char *)uri, XT_STATUS_URI);
3981 #if WEBKIT_CHECK_VERSION(1, 1, 18)
3982 case WEBKIT_LOAD_FAILED:
3983 /* 4 */
3984 #endif
3985 #if GTK_CHECK_VERSION(2, 20, 0)
3986 gtk_spinner_stop(GTK_SPINNER(t->spinner));
3987 gtk_widget_hide(t->spinner);
3988 #endif
3989 default:
3990 gtk_widget_set_sensitive(GTK_WIDGET(t->stop), FALSE);
3991 break;
3992 }
3993
3994 if (t->item)
3995 gtk_widget_set_sensitive(GTK_WIDGET(t->backward), TRUE);
3996 else
3997 gtk_widget_set_sensitive(GTK_WIDGET(t->backward),
3998 can_go_back_for_real(t));
3999
4000 gtk_widget_set_sensitive(GTK_WIDGET(t->forward),
4001 can_go_forward_for_real(t));
4002 }
4003
4004 void
4005 notify_title_cb(WebKitWebView* wview, GParamSpec* pspec, struct tab *t)
4006 {
4007 const gchar *title = NULL, *win_title = NULL;
4008
4009 title = get_title(t, FALSE);
4010 win_title = get_title(t, TRUE);
4011 if (title) {
4012 gtk_label_set_text(GTK_LABEL(t->label), title);
4013 gtk_label_set_text(GTK_LABEL(t->tab_elems.label), title);
4014 }
4015
4016 if (win_title && t->tab_id == gtk_notebook_get_current_page(notebook))
4017 gtk_window_set_title(GTK_WINDOW(main_window), win_title);
4018 }
4019
4020 char *
4021 get_domain(const gchar *host)
4022 {
4023 size_t x;
4024 char *p;
4025
4026 /* handle silly domains like .co.uk */
4027
4028 if ((x = strlen(host)) <= 6)
4029 return (g_strdup(host));
4030
4031 if (host[x - 3] == '.' && host[x - 6] == '.') {
4032 x = x - 7;
4033 while (x > 0)
4034 if (host[x] != '.')
4035 x--;
4036 else
4037 return (g_strdup(&host[x + 1]));
4038 }
4039
4040 /* find first . */
4041 p = g_strrstr(host, ".");
4042 if (p == NULL)
4043 return (g_strdup(""));
4044 p--;
4045 while (p > host)
4046 if (*p != '.')
4047 p--;
4048 else
4049 return (g_strdup(p + 1));
4050
4051 return (g_strdup(host));
4052 }
4053
4054 void
4055 js_autorun(struct tab *t)
4056 {
4057 SoupURI *su = NULL;
4058 const gchar *uri;
4059 size_t got_default = 0, got_host = 0;
4060 struct stat sb;
4061 char deff[PATH_MAX], hostf[PATH_MAX];
4062 char *js = NULL, *jsat, *domain = NULL;
4063 FILE *deffile = NULL, *hostfile = NULL;
4064
4065 if (enable_js_autorun == 0)
4066 return;
4067
4068 uri = get_uri(t);
4069 if (uri &&
4070 !(g_str_has_prefix(uri, "http://") ||
4071 g_str_has_prefix(uri, "https://")))
4072 goto done;
4073
4074 su = soup_uri_new(uri);
4075 if (su == NULL)
4076 goto done;
4077 if (!SOUP_URI_VALID_FOR_HTTP(su))
4078 goto done;
4079
4080 DNPRINTF(XT_D_JS, "%s: host: %s domain: %s\n", __func__,
4081 su->host, domain);
4082 domain = get_domain(su->host);
4083
4084 snprintf(deff, sizeof deff, "%s" PS "default.js", js_dir);
4085 if ((deffile = fopen(deff, "r")) != NULL) {
4086 if (fstat(fileno(deffile), &sb) == -1) {
4087 show_oops(t, "can't stat default JS file");
4088 goto done;
4089 }
4090 got_default = sb.st_size;
4091 }
4092
4093 /* try host first followed by domain */
4094 snprintf(hostf, sizeof hostf, "%s" PS "%s.js", js_dir, su->host);
4095 DNPRINTF(XT_D_JS, "trying file: %s\n", hostf);
4096 if ((hostfile = fopen(hostf, "r")) == NULL) {
4097 snprintf(hostf, sizeof hostf, "%s" PS "%s.js", js_dir, domain);
4098 DNPRINTF(XT_D_JS, "trying file: %s\n", hostf);
4099 if ((hostfile = fopen(hostf, "r")) == NULL)
4100 goto nofile;
4101 }
4102 DNPRINTF(XT_D_JS, "file: %s\n", hostf);
4103 if (fstat(fileno(hostfile), &sb) == -1) {
4104 show_oops(t, "can't stat %s JS file", hostf);
4105 goto done;
4106 }
4107 got_host = sb.st_size;
4108
4109 nofile:
4110 if (got_default + got_host == 0)
4111 goto done;
4112
4113 js = g_malloc0(got_default + got_host + 1);
4114 jsat = js;
4115
4116 if (got_default) {
4117 if (fread(js, got_default, 1, deffile) != 1) {
4118 show_oops(t, "default file read error");
4119 goto done;
4120 }
4121 jsat = js + got_default;
4122 }
4123
4124 if (got_host) {
4125 if (fread(jsat, got_host, 1, hostfile) != 1) {
4126 show_oops(t, "host file read error");
4127 goto done;
4128 }
4129 }
4130
4131 DNPRINTF(XT_D_JS, "%s: about to run script\n", __func__);
4132 run_script(t, js);
4133
4134 done:
4135 if (su)
4136 soup_uri_free(su);
4137 if (js)
4138 g_free(js);
4139 if (deffile)
4140 fclose(deffile);
4141 if (hostfile)
4142 fclose(hostfile);
4143 if (domain)
4144 g_free(domain);
4145 }
4146
4147 void
4148 webview_load_finished_cb(WebKitWebView *wv, WebKitWebFrame *wf, struct tab *t)
4149 {
4150 /* autorun some js if enabled */
4151 js_autorun(t);
4152
4153 input_autofocus(t);
4154
4155 }
4156
4157 void
4158 webview_progress_changed_cb(WebKitWebView *wv, int progress, struct tab *t)
4159 {
4160 gtk_entry_set_progress_fraction(GTK_ENTRY(t->uri_entry),
4161 progress == 100 ? 0 : (double)progress / 100);
4162 if (show_url == 0) {
4163 gtk_entry_set_progress_fraction(GTK_ENTRY(t->sbe.statusbar),
4164 progress == 100 ? 0 : (double)progress / 100);
4165 }
4166
4167 update_statusbar_position(NULL, NULL);
4168 }
4169
4170 int
4171 strict_transport_rb_cmp(struct strict_transport *a, struct strict_transport *b)
4172 {
4173 char *p1, *p2;
4174 int l1, l2;
4175
4176 /* compare strings from the end */
4177 l1 = strlen(a->host);
4178 l2 = strlen(b->host);
4179
4180 p1 = a->host + l1;
4181 p2 = b->host + l2;
4182 for (; *p1 == *p2 && p1 > a->host && p2 > b->host;
4183 p1--, p2--)
4184 ;
4185
4186 /*
4187 * Check if we need to do pattern expansion,
4188 * or if we're just keeping the tree in order
4189 */
4190 if (a->flags & XT_STS_FLAGS_EXPAND &&
4191 b->flags & XT_STS_FLAGS_INCLUDE_SUBDOMAINS) {
4192 /* Check if we're matching the
4193 * 'host.xyz' part in '*.host.xyz'
4194 */
4195 if (p2 == b->host && (p1 == a->host || *(p1-1) == '.')) {
4196 return (0);
4197 }
4198 }
4199
4200 if (p1 == a->host && p2 == b->host)
4201 return (0);
4202 if (p1 == a->host)
4203 return (1);
4204 if (p2 == b->host)
4205 return (-1);
4206
4207 if (*p1 < *p2)
4208 return (-1);
4209 if (*p1 > *p2)
4210 return (1);
4211
4212 return (0);
4213 }
4214 RB_GENERATE(strict_transport_tree, strict_transport, entry,
4215 strict_transport_rb_cmp);
4216
4217 int
4218 strict_transport_add(const char *domain, time_t timeout, int subdomains)
4219 {
4220 struct strict_transport *d, find;
4221 time_t now;
4222 FILE *f;
4223
4224 if (enable_strict_transport == FALSE)
4225 return (0);
4226
4227 DPRINTF("strict_transport_add(%s,%lld,%d)\n", domain,
4228 (long long)timeout, subdomains);
4229
4230 now = time(NULL);
4231 if (timeout < now)
4232 return (0);
4233
4234 find.host = (char *)domain;
4235 find.flags = 0;
4236 d = RB_FIND(strict_transport_tree, &st_tree, &find);
4237
4238 /* update flags */
4239 if (d) {
4240 /* check if update is needed */
4241 if (d->timeout == timeout &&
4242 (d->flags & XT_STS_FLAGS_INCLUDE_SUBDOMAINS) == subdomains)
4243 return (0);
4244
4245 d->timeout = timeout;
4246 if (subdomains)
4247 d->flags |= XT_STS_FLAGS_INCLUDE_SUBDOMAINS;
4248
4249 /* We're still initializing */
4250 if (strict_transport_file == NULL)
4251 return (0);
4252
4253 if ((f = fopen(strict_transport_file, "w")) == NULL) {
4254 show_oops(NULL,
4255 "can't open strict-transport rules file");
4256 return (1);
4257 }
4258
4259 fprintf(f, "# Generated file - do not update unless you know "
4260 "what you're doing\n");
4261 RB_FOREACH(d, strict_transport_tree, &st_tree) {
4262 if (d->timeout < now)
4263 continue;
4264 fprintf(f, "%s\t%lld\t%d\n", d->host, (long long)d->timeout,
4265 d->flags & XT_STS_FLAGS_INCLUDE_SUBDOMAINS);
4266 }
4267 fclose(f);
4268 } else {
4269 d = g_malloc(sizeof *d);
4270 d->host= g_strdup(domain);
4271 d->timeout = timeout;
4272 if (subdomains)
4273 d->flags = XT_STS_FLAGS_INCLUDE_SUBDOMAINS;
4274 else
4275 d->flags = 0;
4276 RB_INSERT(strict_transport_tree, &st_tree, d);
4277
4278 /* We're still initializing */
4279 if (strict_transport_file == NULL)
4280 return (0);
4281
4282 if ((f = fopen(strict_transport_file, "a+")) == NULL) {
4283 show_oops(NULL,
4284 "can't open strict-transport rules file");
4285 return (1);
4286 }
4287
4288 fseek(f, 0, SEEK_END);
4289 fprintf(f,"%s\t%lld\t%d\n", d->host, (long long)timeout, subdomains);
4290 fclose(f);
4291 }
4292 return (0);
4293 }
4294
4295 int
4296 strict_transport_check(const char *host)
4297 {
4298 static struct strict_transport *d = NULL;
4299 struct strict_transport find;
4300
4301 if (enable_strict_transport == FALSE)
4302 return (0);
4303
4304 find.host = (char *)host;
4305
4306 /* match for domains that include subdomains */
4307 find.flags = XT_STS_FLAGS_EXPAND;
4308
4309 /* First, check if we're already at the right node */
4310 if (d != NULL && strict_transport_rb_cmp(&find, d) == 0) {
4311 return (1);
4312 }
4313
4314 d = RB_FIND(strict_transport_tree, &st_tree, &find);
4315 if (d != NULL)
4316 return (1);
4317
4318 return (0);
4319 }
4320
4321 int
4322 strict_transport_init()
4323 {
4324 char file[PATH_MAX];
4325 char delim[3];
4326 char *rule;
4327 char *ptr;
4328 FILE *f;
4329 size_t len;
4330 time_t timeout, now;
4331 int subdomains;
4332
4333 snprintf(file, sizeof file, "%s" PS "%s", work_dir, XT_STS_FILE);
4334 if ((f = fopen(file, "r")) == NULL) {
4335 strict_transport_file = g_strdup(file);
4336 return (0);
4337 }
4338
4339 delim[0] = '\\';
4340 delim[1] = '\\';
4341 delim[2] = '#';
4342 rule = NULL;
4343 now = time(NULL);
4344
4345 for (;;) {
4346 if ((rule = fparseln(f, &len, NULL, delim, 0)) == NULL) {
4347 if (!feof(f) || ferror(f))
4348 goto corrupt_file;
4349 else
4350 break;
4351 }
4352
4353 /* get second entry */
4354 if ((ptr = strpbrk(rule, " \t")) == NULL)
4355 goto corrupt_file;
4356
4357 *ptr++ = '\0';
4358 timeout = atoi(ptr);
4359
4360 /* get third entry */
4361 if ((ptr = strpbrk(ptr, " \t")) == NULL)
4362 goto corrupt_file;
4363
4364 ptr ++;
4365 subdomains = atoi(ptr);
4366
4367 if (timeout > now)
4368 strict_transport_add(rule, timeout, subdomains);
4369 free(rule);
4370 }
4371
4372 fclose(f);
4373 strict_transport_file = g_strdup(file);
4374 return (0);
4375
4376 corrupt_file:
4377 startpage_add("strict-transport rules file ('%s') is corrupt", file);
4378 if (rule)
4379 free(rule);
4380 fclose(f);
4381 return (1);
4382 }
4383
4384 void
4385 strict_transport_security_cb(SoupMessage *msg, gpointer data)
4386 {
4387 SoupURI *uri;
4388 const char *sts;
4389 char *ptr;
4390 time_t timeout = 0;
4391 int subdomains = FALSE;
4392
4393 if (msg == NULL)
4394 return;
4395
4396 sts = soup_message_headers_get_one(msg->response_headers,
4397 "Strict-Transport-Security");
4398 uri = soup_message_get_uri(msg);
4399
4400 if (sts == NULL || uri == NULL)
4401 return;
4402
4403 if ((ptr = strcasestr(sts, "max-age="))) {
4404 ptr += strlen("max-age=");
4405 timeout = atoll(ptr);
4406 } else
4407 return; /* malformed header - max-age must be included */
4408
4409 if ((ptr = strcasestr(sts, "includeSubDomains")))
4410 subdomains = TRUE;
4411
4412 strict_transport_add(uri->host, timeout + time(NULL), subdomains);
4413 }
4414
4415 void
4416 session_rq_cb(SoupSession *s, SoupMessage *msg, SoupSocket *socket,
4417 gpointer data)
4418 {
4419 SoupURI *dest;
4420 SoupURI *ref_uri;
4421 const char *ref;
4422
4423 char *ref_suffix;
4424 char *dest_suffix;
4425
4426 if (s == NULL || msg == NULL)
4427 return;
4428
4429 if (referer_mode == XT_REFERER_ALWAYS)
4430 return;
4431
4432 /* Check if referer is set - and what the user requested for referers */
4433 ref = soup_message_headers_get_one(msg->request_headers, "Referer");
4434 if (ref) {
4435 DNPRINTF(XT_D_NAV, "session_rq_cb: Referer: %s\n", ref);
4436 switch (referer_mode) {
4437 case XT_REFERER_NEVER:
4438 DNPRINTF(XT_D_NAV, "session_rq_cb: removing referer\n");
4439 soup_message_headers_remove(msg->request_headers,
4440 "Referer");
4441 break;
4442 case XT_REFERER_SAME_DOMAIN:
4443 ref_uri = soup_uri_new(ref);
4444 dest = soup_message_get_uri(msg);
4445
4446 ref_suffix = tld_get_suffix(ref_uri->host);
4447 dest_suffix = tld_get_suffix(dest->host);
4448
4449 if (dest && ref_suffix && dest_suffix &&
4450 strcmp(ref_suffix, dest_suffix) != 0) {
4451 soup_message_headers_remove(msg->request_headers,
4452 "Referer");
4453 DNPRINTF(XT_D_NAV, "session_rq_cb: removing "
4454 "referer (not same domain) (suffixes: %s - %s)\n",
4455 ref_suffix, dest_suffix);
4456 }
4457 soup_uri_free(ref_uri);
4458 break;
4459 case XT_REFERER_SAME_FQDN:
4460 ref_uri = soup_uri_new(ref);
4461 dest = soup_message_get_uri(msg);
4462 if (dest && strcmp(ref_uri->host, dest->host) != 0) {
4463 soup_message_headers_remove(msg->request_headers,
4464 "Referer");
4465 DNPRINTF(XT_D_NAV, "session_rq_cb: removing "
4466 "referer (not same fqdn) (should be %s)\n",
4467 dest->host);
4468 }
4469 soup_uri_free(ref_uri);
4470 break;
4471 case XT_REFERER_CUSTOM:
4472 DNPRINTF(XT_D_NAV, "session_rq_cb: setting referer "
4473 "to %s\n", referer_custom);
4474 soup_message_headers_replace(msg->request_headers,
4475 "Referer", referer_custom);
4476 break;
4477 }
4478 }
4479
4480 if (enable_strict_transport) {
4481 soup_message_add_header_handler(msg, "finished",
4482 "Strict-Transport-Security",
4483 G_CALLBACK(strict_transport_security_cb), NULL);
4484 }
4485 }
4486
4487 int
4488 webview_npd_cb(WebKitWebView *wv, WebKitWebFrame *wf,
4489 WebKitNetworkRequest *request, WebKitWebNavigationAction *na,
4490 WebKitWebPolicyDecision *pd, struct tab *t)
4491 {
4492 char *uri;
4493 WebKitWebNavigationReason reason;
4494 struct domain *d = NULL;
4495
4496 if (t == NULL) {
4497 show_oops(NULL, "webview_npd_cb invalid parameters");
4498 return (FALSE);
4499 }
4500
4501 DNPRINTF(XT_D_NAV, "webview_npd_cb: ctrl_click %d %s\n",
4502 t->ctrl_click,
4503 webkit_network_request_get_uri(request));
4504
4505 uri = (char *)webkit_network_request_get_uri(request);
4506
4507 if (!auto_load_images && t->load_images) {
4508
4509 /* Disable autoloading of images, now that we're done loading
4510 * them. */
4511 g_object_set(G_OBJECT(t->settings),
4512 "auto-load-images", FALSE, (char *)NULL);
4513 webkit_web_view_set_settings(t->wv, t->settings);
4514
4515 t->load_images = FALSE;
4516 }
4517
4518 /* If this is an xtp url, we don't load anything else. */
4519 if (parse_xtp_url(t, uri))
4520 return (TRUE);
4521
4522 if ((t->mode == XT_MODE_HINT && t->new_tab) || t->ctrl_click) {
4523 t->ctrl_click = 0;
4524 create_new_tab(uri, NULL, ctrl_click_focus, -1);
4525 webkit_web_policy_decision_ignore(pd);
4526 return (TRUE); /* we made the decission */
4527 }
4528
4529 /* Change user agent if more than one has been given. */
4530 if (user_agent_count > 1) {
4531 struct user_agent *ua;
4532
4533 if ((ua = TAILQ_NEXT(user_agent, entry)) == NULL)
4534 user_agent = TAILQ_FIRST(&ua_list);
4535 else
4536 user_agent = ua;
4537
4538 free(t->user_agent);
4539 t->user_agent = g_strdup(user_agent->value);
4540
4541 DNPRINTF(XT_D_NAV, "user-agent: %s\n", t->user_agent);
4542
4543 g_object_set(G_OBJECT(t->settings),
4544 "user-agent", t->user_agent, (char *)NULL);
4545
4546 webkit_web_view_set_settings(wv, t->settings);
4547 }
4548
4549 /*
4550 * This is a little hairy but it comes down to this:
4551 * when we run in whitelist mode we have to assist the browser in
4552 * opening the URL that it would have opened in a new tab.
4553 */
4554 reason = webkit_web_navigation_action_get_reason(na);
4555 if (reason == WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED) {
4556 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
4557 if (enable_scripts == 0 && enable_cookie_whitelist == 1)
4558 if (uri && (d = wl_find_uri(uri, &js_wl)) == NULL)
4559 load_uri(t, uri);
4560 webkit_web_policy_decision_use(pd);
4561 return (TRUE); /* we made the decision */
4562 }
4563
4564 return (FALSE);
4565 }
4566
4567 void
4568 webview_rrs_cb(WebKitWebView *wv, WebKitWebFrame *wf, WebKitWebResource *res,
4569 WebKitNetworkRequest *request, WebKitNetworkResponse *response,
4570 struct tab *t)
4571 {
4572 SoupMessage *msg;
4573 SoupURI *uri;
4574
4575 msg = webkit_network_request_get_message(request);
4576 if (!msg) return;
4577
4578 uri = soup_message_get_uri(msg);
4579 if (!uri) return;
4580
4581 if (strcmp(soup_uri_get_scheme(uri), SOUP_URI_SCHEME_HTTP) == 0) {
4582 if (strict_transport_check(uri->host)) {
4583 DNPRINTF(XT_D_NAV, "webview_rrs_cb: force https for %s\n",
4584 uri->host);
4585 soup_uri_set_scheme(uri, SOUP_URI_SCHEME_HTTPS);
4586 }
4587 }
4588 }
4589
4590 WebKitWebView *
4591 webview_cwv_cb(WebKitWebView *wv, WebKitWebFrame *wf, struct tab *t)
4592 {
4593 struct tab *tt;
4594 struct domain *d = NULL;
4595 const gchar *uri;
4596 WebKitWebView *webview = NULL;
4597 int x = 1;
4598
4599 DNPRINTF(XT_D_NAV, "webview_cwv_cb: %s\n",
4600 webkit_web_view_get_uri(wv));
4601
4602 if (tabless) {
4603 /* open in current tab */
4604 webview = t->wv;
4605 } else if (enable_scripts == 0 && enable_js_whitelist == 1) {
4606 uri = webkit_web_view_get_uri(wv);
4607 if (uri && (d = wl_find_uri(uri, &js_wl)) == NULL)
4608 return (NULL);
4609
4610 if (t->ctrl_click) {
4611 x = ctrl_click_focus;
4612 t->ctrl_click = 0;
4613 }
4614 tt = create_new_tab(NULL, NULL, x, -1);
4615 webview = tt->wv;
4616 } else if (enable_scripts == 1) {
4617 if (t->ctrl_click) {
4618 x = ctrl_click_focus;
4619 t->ctrl_click = 0;
4620 }
4621 tt = create_new_tab(NULL, NULL, x, -1);
4622 webview = tt->wv;
4623 }
4624
4625 return (webview);
4626 }
4627
4628 gboolean
4629 webview_closewv_cb(WebKitWebView *wv, struct tab *t)
4630 {
4631 const gchar *uri;
4632 struct domain *d = NULL;
4633
4634 DNPRINTF(XT_D_NAV, "webview_close_cb: %d\n", t->tab_id);
4635
4636 if (enable_scripts == 0 && enable_cookie_whitelist == 1) {
4637 uri = webkit_web_view_get_uri(wv);
4638 if (uri && (d = wl_find_uri(uri, &js_wl)) == NULL)
4639 return (FALSE);
4640
4641 delete_tab(t);
4642 } else if (enable_scripts == 1)
4643 delete_tab(t);
4644
4645 return (TRUE);
4646 }
4647
4648 int
4649 webview_event_cb(GtkWidget *w, GdkEventButton *e, struct tab *t)
4650 {
4651 /* we can not eat the event without throwing gtk off so defer it */
4652
4653 /* catch middle click */
4654 if (e->type == GDK_BUTTON_RELEASE && e->button == 2) {
4655 t->ctrl_click = 1;
4656 goto done;
4657 }
4658
4659 /* catch ctrl click */
4660 if (e->type == GDK_BUTTON_RELEASE &&
4661 CLEAN(e->state) == GDK_CONTROL_MASK)
4662 t->ctrl_click = 1;
4663 else
4664 t->ctrl_click = 0;
4665 done:
4666 return (XT_CB_PASSTHROUGH);
4667 }
4668
4669 int
4670 run_mimehandler(struct tab *t, char *mime_type, WebKitNetworkRequest *request)
4671 {
4672 struct mime_type *m;
4673
4674 m = find_mime_type(mime_type);
4675 if (m == NULL)
4676 return (1);
4677 if (m->mt_download)
4678 return (1);
4679
4680 return (fork_exec(t, m->mt_action,
4681 webkit_network_request_get_uri(request),
4682 "can't launch MIME handler", 0));
4683 }
4684
4685 char *
4686 get_mime_type(const char *file)
4687 {
4688 const gchar *m;
4689 char *mime_type = NULL;
4690 GFileInfo *fi;
4691 GFile *gf;
4692
4693 if (g_str_has_prefix(file, "file://"))
4694 file += strlen("file://");
4695
4696 gf = g_file_new_for_path(file);
4697 fi = g_file_query_info(gf, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, 0,
4698 NULL, NULL);
4699 if ((m = g_file_info_get_content_type(fi)) != NULL)
4700 mime_type = g_strdup(m);
4701 g_object_unref(fi);
4702 g_object_unref(gf);
4703
4704 return (mime_type);
4705 }
4706
4707 int
4708 run_download_mimehandler(char *mime_type, char *file)
4709 {
4710 struct mime_type *m;
4711
4712 m = find_mime_type(mime_type);
4713 if (m == NULL)
4714 return (1);
4715
4716 return (fork_exec(NULL, m->mt_action, file,
4717 "can't launch download MIME handler", 0));
4718 }
4719
4720 void
4721 download_status_changed_cb(WebKitDownload *download, GParamSpec *spec,
4722 WebKitWebView *wv)
4723 {
4724 WebKitDownloadStatus status;
4725 const char *file = NULL;
4726 char *mime = NULL;
4727
4728 if (download == NULL)
4729 return;
4730 status = webkit_download_get_status(download);
4731 if (status != WEBKIT_DOWNLOAD_STATUS_FINISHED)
4732 return;
4733
4734 file = webkit_download_get_destination_uri(download);
4735 if (file == NULL)
4736 return;
4737 mime = get_mime_type(file);
4738 if (mime == NULL)
4739 return;
4740
4741 if (g_str_has_prefix(file, "file://"))
4742 file += strlen("file://");
4743 run_download_mimehandler((char *)mime, (char *)file);
4744 g_free(mime);
4745 }
4746
4747 int
4748 webview_mimetype_cb(WebKitWebView *wv, WebKitWebFrame *frame,
4749 WebKitNetworkRequest *request, char *mime_type,
4750 WebKitWebPolicyDecision *decision, struct tab *t)
4751 {
4752 if (t == NULL) {
4753 show_oops(NULL, "webview_mimetype_cb invalid parameters");
4754 return (FALSE);
4755 }
4756
4757 DNPRINTF(XT_D_DOWNLOAD, "webview_mimetype_cb: tab %d mime %s\n",
4758 t->tab_id, mime_type);
4759
4760 if (run_mimehandler(t, mime_type, request) == 0) {
4761 webkit_web_policy_decision_ignore(decision);
4762 focus_webview(t);
4763 return (TRUE);
4764 }
4765
4766 if (webkit_web_view_can_show_mime_type(wv, mime_type) == FALSE) {
4767 webkit_web_policy_decision_download(decision);
4768 return (TRUE);
4769 }
4770
4771 return (FALSE);
4772 }
4773
4774 int
4775 download_start(struct tab *t, struct download *d, int flag)
4776 {
4777 WebKitNetworkRequest *req;
4778 struct stat sb;
4779 const gchar *suggested_name;
4780 gchar *filename = NULL;
4781 char *uri = NULL;
4782 int ret = TRUE;
4783 int i;
4784
4785 if (d == NULL || t == NULL) {
4786 show_oops(NULL, "%s invalid parameters", __func__);
4787 return (FALSE);
4788 }
4789
4790 suggested_name = webkit_download_get_suggested_filename(d->download);
4791 if (suggested_name == NULL)
4792 return (FALSE); /* abort download */
4793
4794 i = 0;
4795 do {
4796 if (filename) {
4797 g_free(filename);
4798 filename = NULL;
4799 }
4800 if (i) {
4801 g_free(uri);
4802 uri = NULL;
4803 filename = g_strdup_printf("%d%s", i, suggested_name);
4804 }
4805 #ifdef __MINGW32__
4806 uri = g_strdup_printf("%s\\%s", download_dir, i ?
4807 filename : suggested_name);
4808 #else
4809 uri = g_strdup_printf("file://%s/%s", download_dir, i ?
4810 filename : suggested_name);
4811 #endif
4812 i++;
4813 #ifdef __MINGW32__
4814 } while (!stat(uri, &sb));
4815 #else
4816 } while (!stat(uri + strlen("file://"), &sb)); /* XXX is the + strlen right? */
4817 #endif
4818
4819 DNPRINTF(XT_D_DOWNLOAD, "%s: tab %d filename %s "
4820 "local %s\n", __func__, t->tab_id, filename, uri);
4821
4822 /* if we're restarting the download, or starting
4823 * it after doing something else, we need to recreate
4824 * the download request.
4825 */
4826 if (flag == XT_DL_RESTART) {
4827 req = webkit_network_request_new(webkit_download_get_uri(d->download));
4828 webkit_download_cancel(d->download);
4829 g_object_unref(d->download);
4830 d->download = webkit_download_new(req);
4831 }
4832
4833 webkit_download_set_destination_uri(d->download, uri);
4834
4835 if (webkit_download_get_status(d->download) ==
4836 WEBKIT_DOWNLOAD_STATUS_ERROR) {
4837 show_oops(t, "%s: download failed to start", __func__);
4838 ret = FALSE;
4839 gtk_label_set_text(GTK_LABEL(t->label), "Download Failed");
4840 } else {
4841 /* connect "download first" mime handler */
4842 g_signal_connect(G_OBJECT(d->download), "notify::status",
4843 G_CALLBACK(download_status_changed_cb), NULL);
4844
4845 /* get from history */
4846 g_object_ref(d->download);
4847 gtk_label_set_text(GTK_LABEL(t->label), "Downloading");
4848 show_oops(t, "Download of '%s' started...",
4849 basename((char *)webkit_download_get_destination_uri(d->download)));
4850 }
4851
4852 if (flag != XT_DL_START)
4853 webkit_download_start(d->download);
4854
4855 DNPRINTF(XT_D_DOWNLOAD, "download status : %d",
4856 webkit_download_get_status(d->download));
4857
4858 /* sync other download manager tabs */
4859 update_download_tabs(NULL);
4860
4861 if (uri)
4862 g_free(uri);
4863
4864 if (filename)
4865 g_free(filename);
4866
4867 return (ret);
4868 }
4869
4870 int
4871 download_ask_cb(struct tab *t, GdkEventKey *e, gpointer data)
4872 {
4873 struct download *d = data;
4874
4875 /* unset mode */
4876 t->mode_cb = NULL;
4877 t->mode_cb_data = NULL;
4878
4879 if (!e || !d) {
4880 e->keyval = GDK_Escape;
4881 return (XT_CB_PASSTHROUGH);
4882 }
4883
4884 DPRINTF("download_ask_cb: User pressed %c\n", e->keyval);
4885 if (e->keyval == 'y' || e->keyval == 'Y' || e->keyval == GDK_Return)
4886 /* We need to do a RESTART, because we're not calling from
4887 * webview_download_cb
4888 */
4889 download_start(t, d, XT_DL_RESTART);
4890
4891 /* for all other keyvals, we just let the download be */
4892 e->keyval = GDK_Escape;
4893 return (XT_CB_HANDLED);
4894 }
4895
4896 int
4897 download_ask(struct tab *t, struct download *d)
4898 {
4899 const gchar *suggested_name;
4900
4901 suggested_name = webkit_download_get_suggested_filename(d->download);
4902 if (suggested_name == NULL)
4903 return (FALSE); /* abort download */
4904
4905 show_oops(t, "download file %s [y/n] ?", suggested_name);
4906 t->mode_cb = download_ask_cb;
4907 t->mode_cb_data = d;
4908
4909 return (TRUE);
4910 }
4911
4912 int
4913 webview_download_cb(WebKitWebView *wv, WebKitDownload *wk_download,
4914 struct tab *t)
4915 {
4916 const gchar *suggested_name;
4917 struct download *download_entry;
4918 int ret = TRUE;
4919
4920 if (wk_download == NULL || t == NULL) {
4921 show_oops(NULL, "%s invalid parameters", __func__);
4922 return (FALSE);
4923 }
4924
4925 suggested_name = webkit_download_get_suggested_filename(wk_download);
4926 if (suggested_name == NULL)
4927 return (FALSE); /* abort download */
4928
4929 download_entry = g_malloc(sizeof(struct download));
4930 download_entry->download = wk_download;
4931 download_entry->tab = t;
4932 download_entry->id = next_download_id++;
4933 RB_INSERT(download_list, &downloads, download_entry);
4934
4935 if (download_mode == XT_DM_START)
4936 ret = download_start(t, download_entry, XT_DL_START);
4937 else if (download_mode == XT_DM_ASK)
4938 ret = download_ask(t, download_entry);
4939 else if (download_mode == XT_DM_ADD)
4940 show_oops(t, "added %s to download manager",
4941 suggested_name);
4942
4943 /* sync other download manager tabs */
4944 update_download_tabs(NULL);
4945
4946 /*
4947 * NOTE: never redirect/render the current tab before this
4948 * function returns. This will cause the download to never start.
4949 */
4950 return (ret); /* start download */
4951 }
4952
4953 void
4954 webview_hover_cb(WebKitWebView *wv, gchar *title, gchar *uri, struct tab *t)
4955 {
4956 DNPRINTF(XT_D_KEY, "webview_hover_cb: %s %s\n", title, uri);
4957
4958 if (t == NULL) {
4959 show_oops(NULL, "webview_hover_cb");
4960 return;
4961 }
4962
4963 if (uri)
4964 set_status(t, uri, XT_STATUS_LINK);
4965 else {
4966 if (t->status)
4967 set_status(t, t->status, XT_STATUS_NOTHING);
4968 }
4969 }
4970
4971 int
4972 mark(struct tab *t, struct karg *arg)
4973 {
4974 char mark;
4975 int index;
4976 double pos;
4977
4978 mark = arg->s[1];
4979 if ((index = marktoindex(mark)) == -1)
4980 return (-1);
4981
4982 if (arg->i == XT_MARK_SET)
4983 t->mark[index] = gtk_adjustment_get_value(t->adjust_v);
4984 else if (arg->i == XT_MARK_GOTO) {
4985 if (t->mark[index] == XT_INVALID_MARK) {
4986 show_oops(t, "mark '%c' does not exist", mark);
4987 return (-1);
4988 }
4989 /* XXX t->mark[index] can be bigger than the maximum if ajax or
4990 something changes the document size */
4991 pos = gtk_adjustment_get_value(t->adjust_v);
4992 gtk_adjustment_set_value(t->adjust_v, t->mark[index]);
4993 t->mark[marktoindex('\'')] = pos;
4994 }
4995
4996 return (0);
4997 }
4998
4999 void
5000 marks_clear(struct tab *t)
5001 {
5002 int i;
5003
5004 for (i = 0; i < LENGTH(t->mark); i++)
5005 t->mark[i] = XT_INVALID_MARK;
5006 }
5007
5008 int
5009 qmarks_load(void)
5010 {
5011 char file[PATH_MAX];
5012 char *line = NULL, *p;
5013 int index, i;
5014 FILE *f;
5015 size_t linelen;
5016
5017 snprintf(file, sizeof file, "%s" PS "%s", work_dir, XT_QMARKS_FILE);
5018 if ((f = fopen(file, "r+")) == NULL) {
5019 show_oops(NULL, "Can't open quickmarks file: %s", strerror(errno));
5020 return (1);
5021 }
5022
5023 for (i = 1; ; i++) {
5024 if ((line = fparseln(f, &linelen, NULL, NULL, 0)) == NULL)
5025 break;
5026 if (strlen(line) == 0 || line[0] == '#') {
5027 free(line);
5028 line = NULL;
5029 continue;
5030 }
5031
5032 p = strtok(line, " \t");
5033
5034 if (p == NULL || strlen(p) != 1 ||
5035 (index = qmarktoindex(*p)) == -1) {
5036 warnx("corrupt quickmarks file, line %d", i);
5037 break;
5038 }
5039
5040 p = strtok(NULL, " \t");
5041 if (qmarks[index] != NULL)
5042 g_free(qmarks[index]);
5043 qmarks[index] = g_strdup(p);
5044 }
5045
5046 fclose(f);
5047
5048 return (0);
5049 }
5050
5051 int
5052 qmarks_save(void)
5053 {
5054 char file[PATH_MAX];
5055 int i;
5056 FILE *f;
5057
5058 snprintf(file, sizeof file, "%s" PS "%s", work_dir, XT_QMARKS_FILE);
5059 if ((f = fopen(file, "r+")) == NULL) {
5060 show_oops(NULL, "Can't open quickmarks file: %s", strerror(errno));
5061 return (1);
5062 }
5063
5064 for (i = 0; i < XT_NOQMARKS; i++)
5065 if (qmarks[i] != NULL)
5066 fprintf(f, "%c %s\n", indextoqmark(i), qmarks[i]);
5067
5068 fclose(f);
5069
5070 return (0);
5071 }
5072
5073 int
5074 qmark(struct tab *t, struct karg *arg)
5075 {
5076 char mark;
5077 int index;
5078
5079 mark = arg->s[strlen(arg->s)-1];
5080 index = qmarktoindex(mark);
5081 if (index == -1)
5082 return (-1);
5083
5084 switch (arg->i) {
5085 case XT_QMARK_SET:
5086 if (qmarks[index] != NULL) {
5087 g_free(qmarks[index]);
5088 qmarks[index] = NULL;
5089 }
5090
5091 qmarks_load(); /* sync if multiple instances */
5092 qmarks[index] = g_strdup(get_uri(t));
5093 qmarks_save();
5094 break;
5095 case XT_QMARK_OPEN:
5096 if (qmarks[index] != NULL)
5097 load_uri(t, qmarks[index]);
5098 else {
5099 show_oops(t, "quickmark \"%c\" does not exist",
5100 mark);
5101 return (-1);
5102 }
5103 break;
5104 case XT_QMARK_TAB:
5105 if (qmarks[index] != NULL)
5106 create_new_tab(qmarks[index], NULL, 1, -1);
5107 else {
5108 show_oops(t, "quickmark \"%c\" does not exist",
5109 mark);
5110 return (-1);
5111 }
5112 break;
5113 }
5114
5115 return (0);
5116 }
5117
5118 int
5119 go_up(struct tab *t, struct karg *args)
5120 {
5121 int levels;
5122 int lastidx;
5123 char *uri;
5124 char *tmp;
5125 char *p;
5126
5127 if (args->i == XT_GO_UP_ROOT)
5128 levels = XT_GO_UP_ROOT;
5129 else if ((levels = atoi(args->s)) == 0)
5130 levels = 1;
5131
5132 uri = g_strdup(get_uri(t));
5133 if (uri == NULL)
5134 return (1);
5135
5136 if ((tmp = strstr(uri, XT_PROTO_DELIM)) == NULL)
5137 return (1);
5138
5139 tmp += strlen(XT_PROTO_DELIM);
5140
5141 /* it makes no sense to strip the last slash from ".../dir/", skip it */
5142 lastidx = strlen(tmp) - 1;
5143 if (lastidx > 0) {
5144 if (tmp[lastidx] == '/')
5145 tmp[lastidx] = '\0';
5146 }
5147
5148 while (levels--) {
5149 p = strrchr(tmp, '/');
5150 if (p == tmp) { /* Are we at the root of a file://-path? */
5151 p[1] = '\0';
5152 break;
5153 } else if (p != NULL)
5154 *p = '\0';
5155 else
5156 break;
5157 }
5158
5159 load_uri(t, uri);
5160 g_free(uri);
5161
5162 return (0);
5163 }
5164
5165 int
5166 gototab(struct tab *t, struct karg *args)
5167 {
5168 int tab;
5169 struct karg arg = {0, NULL, -1};
5170
5171 tab = atoi(args->s);
5172
5173 if (args->i == 0)
5174 arg.i = XT_TAB_NEXT;
5175 else
5176 arg.i = args->i;
5177
5178 arg.precount = tab;
5179
5180 movetab(t, &arg);
5181
5182 return (0);
5183 }
5184
5185 int
5186 zoom_amount(struct tab *t, struct karg *arg)
5187 {
5188 struct karg narg = {0, NULL, -1};
5189
5190 narg.i = atoi(arg->s);
5191 resizetab(t, &narg);
5192
5193 return (0);
5194 }
5195
5196 int
5197 flip_colon(struct tab *t, struct karg *arg)
5198 {
5199 struct karg narg = {0, NULL, -1};
5200 char *p;
5201
5202 if (t == NULL || arg == NULL)
5203 return (1);
5204
5205 p = strstr(arg->s, ":");
5206 if (p == NULL)
5207 return (1);
5208 *p = '\0';
5209
5210 narg.i = ':';
5211 narg.s = arg->s;
5212 command(t, &narg);
5213
5214 return (0);
5215 }
5216
5217 /* buffer commands receive the regex that triggered them in arg.s */
5218 char bcmd[XT_BUFCMD_SZ];
5219 struct buffercmd {
5220 char *regex;
5221 int precount;
5222 #define XT_PRE_NO (0)
5223 #define XT_PRE_YES (1)
5224 #define XT_PRE_MAYBE (2)
5225 char *cmd;
5226 int (*func)(struct tab *, struct karg *);
5227 int arg;
5228 regex_t cregex;
5229 } buffercmds[] = {
5230 { "^[0-9]*gu$", XT_PRE_MAYBE, "gu", go_up, 0 },
5231 { "^gU$", XT_PRE_NO, "gU", go_up, XT_GO_UP_ROOT },
5232 { "^gg$", XT_PRE_NO, "gg", move, XT_MOVE_TOP },
5233 { "^gG$", XT_PRE_NO, "gG", move, XT_MOVE_BOTTOM },
5234 { "^[0-9]+%$", XT_PRE_YES, "%", move, XT_MOVE_PERCENT },
5235 { "^zz$", XT_PRE_NO, "zz", move, XT_MOVE_CENTER },
5236 { "^gh$", XT_PRE_NO, "gh", go_home, 0 },
5237 { "^m[a-zA-Z0-9]$", XT_PRE_NO, "m", mark, XT_MARK_SET },
5238 { "^['][a-zA-Z0-9']$", XT_PRE_NO, "'", mark, XT_MARK_GOTO },
5239 { "^[0-9]+t$", XT_PRE_YES, "t", gototab, 0 },
5240 { "^g0$", XT_PRE_YES, "g0", movetab, XT_TAB_FIRST },
5241 { "^g[$]$", XT_PRE_YES, "g$", movetab, XT_TAB_LAST },
5242 { "^[0-9]*gt$", XT_PRE_YES, "t", movetab, XT_TAB_NEXT },
5243 { "^[0-9]*gT$", XT_PRE_YES, "T", movetab, XT_TAB_PREV },
5244 { "^M[a-zA-Z0-9]$", XT_PRE_NO, "M", qmark, XT_QMARK_SET },
5245 { "^go[a-zA-Z0-9]$", XT_PRE_NO, "go", qmark, XT_QMARK_OPEN },
5246 { "^gn[a-zA-Z0-9]$", XT_PRE_NO, "gn", qmark, XT_QMARK_TAB },
5247 { "^ZR$", XT_PRE_NO, "ZR", restart, 0 },
5248 { "^ZZ$", XT_PRE_NO, "ZZ", quit, 0 },
5249 { "^zi$", XT_PRE_NO, "zi", resizetab, XT_ZOOM_IN },
5250 { "^zo$", XT_PRE_NO, "zo", resizetab, XT_ZOOM_OUT },
5251 { "^z0$", XT_PRE_NO, "z0", resizetab, XT_ZOOM_NORMAL },
5252 { "^[0-9]+Z$", XT_PRE_YES, "Z", zoom_amount, 0 },
5253 { "^[0-9]+:$", XT_PRE_YES, ":", flip_colon, 0 },
5254 };
5255
5256 void
5257 buffercmd_init(void)
5258 {
5259 int i;
5260
5261 for (i = 0; i < LENGTH(buffercmds); i++)
5262 if (regcomp(&buffercmds[i].cregex, buffercmds[i].regex,
5263 REG_EXTENDED | REG_NOSUB))
5264 startpage_add("invalid buffercmd regex %s",
5265 buffercmds[i].regex);
5266 }
5267
5268 void
5269 buffercmd_abort(struct tab *t)
5270 {
5271 int i;
5272
5273 if (t == NULL)
5274 return;
5275
5276 DNPRINTF(XT_D_BUFFERCMD, "%s: clearing buffer\n", __func__);
5277
5278 for (i = 0; i < LENGTH(bcmd); i++)
5279 bcmd[i] = '\0';
5280
5281 cmd_prefix = 0; /* clear prefix for non-buffer commands */
5282 gtk_entry_set_text(GTK_ENTRY(t->sbe.buffercmd), bcmd);
5283 }
5284
5285 void
5286 buffercmd_execute(struct tab *t, struct buffercmd *cmd)
5287 {
5288 struct karg arg = {0, NULL, -1};
5289
5290 arg.i = cmd->arg;
5291 arg.s = g_strdup(bcmd);
5292
5293 DNPRINTF(XT_D_BUFFERCMD, "buffercmd_execute: buffer \"%s\" "
5294 "matches regex \"%s\", executing\n", bcmd, cmd->regex);
5295 cmd->func(t, &arg);
5296
5297 if (arg.s)
5298 g_free(arg.s);
5299
5300 buffercmd_abort(t);
5301 }
5302
5303 gboolean
5304 buffercmd_addkey(struct tab *t, guint keyval)
5305 {
5306 int i, c, match ;
5307 char s[XT_BUFCMD_SZ];
5308
5309 if (gtk_widget_get_visible(GTK_WIDGET(t->buffers))) {
5310 buffercmd_abort(t);
5311 return (XT_CB_PASSTHROUGH);
5312 }
5313
5314 if (keyval == GDK_Escape) {
5315 buffercmd_abort(t);
5316 return (XT_CB_HANDLED);
5317 }
5318
5319 /* key with modifier or non-ascii character */
5320 if (!isascii(keyval)) {
5321 /*
5322 * XXX this looks wrong but fixes some sites like
5323 * http://www.seslisozluk.com/
5324 * that eat a shift or ctrl and end putting default focus in js
5325 * instead of ignoring the keystroke
5326 * so instead of return (XT_CB_PASSTHROUGH); eat the key
5327 */
5328 return (XT_CB_HANDLED);
5329 }
5330
5331 DNPRINTF(XT_D_BUFFERCMD, "buffercmd_addkey: adding key \"%c\" "
5332 "to buffer \"%s\"\n", keyval, bcmd);
5333
5334 for (i = 0; i < LENGTH(bcmd); i++)
5335 if (bcmd[i] == '\0') {
5336 bcmd[i] = keyval;
5337 break;
5338 }
5339
5340 /* buffer full, ignore input */
5341 if (i >= LENGTH(bcmd) -1) {
5342 DNPRINTF(XT_D_BUFFERCMD, "buffercmd_addkey: buffer full\n");
5343 buffercmd_abort(t);
5344 return (XT_CB_HANDLED);
5345 }
5346
5347 gtk_entry_set_text(GTK_ENTRY(t->sbe.buffercmd), bcmd);
5348
5349 /* find exact match */
5350 for (i = 0; i < LENGTH(buffercmds); i++)
5351 if (regexec(&buffercmds[i].cregex, bcmd,
5352 (size_t) 0, NULL, 0) == 0) {
5353 buffercmd_execute(t, &buffercmds[i]);
5354 goto done;
5355 }
5356
5357 /* find non exact matches to see if we need to abort ot not */
5358 for (i = 0, match = 0; i < LENGTH(buffercmds); i++) {
5359 DNPRINTF(XT_D_BUFFERCMD, "trying: %s\n", bcmd);
5360 c = -1;
5361 s[0] = '\0';
5362 if (buffercmds[i].precount == XT_PRE_MAYBE) {
5363 if (isdigit(bcmd[0])) {
5364 if (sscanf(bcmd, "%d%s", &c, s) == 0)
5365 continue;
5366 } else {
5367 c = 0;
5368 if (sscanf(bcmd, "%s", s) == 0)
5369 continue;
5370 }
5371 } else if (buffercmds[i].precount == XT_PRE_YES) {
5372 if (sscanf(bcmd, "%d%s", &c, s) == 0)
5373 continue;
5374 } else {
5375 if (sscanf(bcmd, "%s", s) == 0)
5376 continue;
5377 }
5378 if (c == -1 && buffercmds[i].precount)
5379 continue;
5380 if (!strncmp(s, buffercmds[i].cmd, strlen(s)))
5381 match++;
5382
5383 DNPRINTF(XT_D_BUFFERCMD, "got[%d] %d <%s>: %d %s\n",
5384 i, match, buffercmds[i].cmd, c, s);
5385 }
5386 if (match == 0) {
5387 DNPRINTF(XT_D_BUFFERCMD, "aborting: %s\n", bcmd);
5388 buffercmd_abort(t);
5389 }
5390
5391 done:
5392 return (XT_CB_HANDLED);
5393 }
5394
5395 gboolean
5396 handle_keypress(struct tab *t, GdkEventKey *e, int entry)
5397 {
5398 struct key_binding *k;
5399
5400 /* handle keybindings if buffercmd is empty.
5401 if not empty, allow commands like C-n */
5402 if (bcmd[0] == '\0' || ((e->state & (CTRL | MOD1)) != 0))
5403 TAILQ_FOREACH(k, &kbl, entry)
5404 if (e->keyval == k->key
5405 && (entry ? k->use_in_entry : 1)) {
5406 /* when we are edditing eat ctrl/mod keys */
5407 if (edit_mode == XT_EM_VI &&
5408 t->mode == XT_MODE_INSERT &&
5409 (e->state & CTRL || e->state & MOD1))
5410 return (XT_CB_PASSTHROUGH);
5411
5412 if (k->mask == 0) {
5413 if ((e->state & (CTRL | MOD1)) == 0)
5414 return (cmd_execute(t, k->cmd));
5415 } else if ((e->state & k->mask) == k->mask) {
5416 return (cmd_execute(t, k->cmd));
5417 }
5418 }
5419
5420 if (!entry && ((e->state & (CTRL | MOD1)) == 0))
5421 return buffercmd_addkey(t, e->keyval);
5422
5423 return (XT_CB_PASSTHROUGH);
5424 }
5425
5426 int
5427 wv_keypress_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
5428 {
5429 char s[2];
5430
5431 /* don't use w directly; use t->whatever instead */
5432
5433 if (t == NULL) {
5434 show_oops(NULL, "wv_keypress_cb");
5435 return (XT_CB_PASSTHROUGH);
5436 }
5437
5438 hide_oops(t);
5439
5440 if (t->mode_cb)
5441 return t->mode_cb(t, e, t->mode_cb_data);
5442
5443 DNPRINTF(XT_D_KEY, "wv_keypress_cb: mode %d keyval 0x%x mask "
5444 "0x%x tab %d\n", t->mode, e->keyval, e->state, t->tab_id);
5445
5446 /* Hide buffers, if they are visible, with escape. */
5447 if (gtk_widget_get_visible(GTK_WIDGET(t->buffers)) &&
5448 CLEAN(e->state) == 0 && e->keyval == GDK_Escape) {
5449 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
5450 hide_buffers(t);
5451 return (XT_CB_HANDLED);
5452 }
5453
5454 if (t->mode == XT_MODE_HINT)
5455 return (XT_CB_HANDLED);
5456
5457 if ((CLEAN(e->state) == 0 && e->keyval == GDK_Tab) ||
5458 (CLEAN(e->state) == SHFT && e->keyval == GDK_Tab))
5459 /* something focussy is about to happen */
5460 return (XT_CB_PASSTHROUGH);
5461
5462 /* check if we are some sort of text input thing in the dom */
5463 input_check_mode(t);
5464
5465 if (t->mode == XT_MODE_HINT) {
5466 /* XXX make sure cmd entry is enabled */
5467 return (XT_CB_HANDLED);
5468 } else if (t->mode == XT_MODE_PASSTHROUGH) {
5469 if (CLEAN(e->state) == 0 && e->keyval == GDK_Escape)
5470 t->mode = XT_MODE_COMMAND;
5471 return (XT_CB_PASSTHROUGH);
5472 } else if (t->mode == XT_MODE_COMMAND) {
5473 /* prefix input */
5474 snprintf(s, sizeof s, "%c", e->keyval);
5475 if (CLEAN(e->state) == 0 && isdigit(s[0]))
5476 cmd_prefix = 10 * cmd_prefix + atoi(s);
5477 return (handle_keypress(t, e, 0));
5478 } else {
5479 /* insert mode */
5480 return (handle_keypress(t, e, 1));
5481 }
5482
5483 /* NOTREACHED */
5484 return (XT_CB_PASSTHROUGH);
5485 }
5486
5487 gboolean
5488 hint_continue(struct tab *t)
5489 {
5490 const gchar *c = gtk_entry_get_text(GTK_ENTRY(t->cmd));
5491 char *s;
5492 const gchar *errstr = NULL;
5493 gboolean rv = TRUE;
5494 int i;
5495
5496 if (!(c[0] == '.' || c[0] == ','))
5497 goto done;
5498 if (strlen(c) == 1) {
5499 /* XXX should not happen */
5500 rv = TRUE;
5501 goto done;
5502 }
5503
5504 if (isdigit(c[1])) {
5505 /* numeric input */
5506 i = strtonum(&c[1], 1, 4096, &errstr);
5507 if (errstr) {
5508 show_oops(t, "invalid numerical hint %s", &c[1]);
5509 goto done;
5510 }
5511 s = g_strdup_printf("hints.updateHints(%d);", i);
5512 run_script(t, s);
5513 g_free(s);
5514 } else {
5515 /* alphanumeric input */
5516 s = g_strdup_printf("hints.createHints('%s', '%c');",
5517 &c[1], c[0] == '.' ? 'f' : 'F');
5518 run_script(t, s);
5519 g_free(s);
5520 }
5521
5522 rv = FALSE;
5523 done:
5524 return (rv);
5525 }
5526
5527 gboolean
5528 search_continue(struct tab *t)
5529 {
5530 const gchar *c = gtk_entry_get_text(GTK_ENTRY(t->cmd));
5531 gboolean rv = FALSE;
5532
5533 if (c[0] == ':' || c[0] == '.' || c[0] == ',')
5534 goto done;
5535 if (strlen(c) == 1) {
5536 webkit_web_view_unmark_text_matches(t->wv);
5537 goto done;
5538 }
5539
5540 if (c[0] == '/')
5541 t->search_forward = TRUE;
5542 else if (c[0] == '?')
5543 t->search_forward = FALSE;
5544 else
5545 goto done;
5546
5547 rv = TRUE;
5548 done:
5549 return (rv);
5550 }
5551
5552 gboolean
5553 search_cb(struct tab *t)
5554 {
5555 const gchar *c = gtk_entry_get_text(GTK_ENTRY(t->cmd));
5556 GdkColor color;
5557
5558 if (search_continue(t) == FALSE)
5559 goto done;
5560
5561 /* search */
5562 if (webkit_web_view_search_text(t->wv, &c[1], FALSE, t->search_forward,
5563 TRUE) == FALSE) {
5564 /* not found, mark red */
5565 gdk_color_parse(XT_COLOR_RED, &color);
5566 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL, &color);
5567 /* unmark and remove selection */
5568 webkit_web_view_unmark_text_matches(t->wv);
5569 /* my kingdom for a way to unselect text in webview */
5570 } else {
5571 /* found, highlight all */
5572 webkit_web_view_unmark_text_matches(t->wv);
5573 webkit_web_view_mark_text_matches(t->wv, &c[1], FALSE, 0);
5574 webkit_web_view_set_highlight_text_matches(t->wv, TRUE);
5575 gtk_widget_modify_base(t->cmd, GTK_STATE_NORMAL,
5576 &t->default_style->base[GTK_STATE_NORMAL]);
5577 }
5578 done:
5579 t->search_id = 0;
5580 return (FALSE);
5581 }
5582
5583 int
5584 cmd_keyrelease_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
5585 {
5586 const gchar *c = gtk_entry_get_text(w);
5587
5588 if (t == NULL) {
5589 show_oops(NULL, "cmd_keyrelease_cb invalid parameters");
5590 return (XT_CB_PASSTHROUGH);
5591 }
5592
5593 DNPRINTF(XT_D_CMD, "cmd_keyrelease_cb: keyval 0x%x mask 0x%x tab %d\n",
5594 e->keyval, e->state, t->tab_id);
5595
5596 /* hinting */
5597 if (!(e->keyval == GDK_Tab || e->keyval == GDK_ISO_Left_Tab)) {
5598 if (hint_continue(t) == FALSE)
5599 goto done;
5600 }
5601
5602 /* search */
5603 if (search_continue(t) == FALSE)
5604 goto done;
5605
5606 /* if search length is > 4 then no longer play timeout games */
5607 if (strlen(c) > 4) {
5608 if (t->search_id) {
5609 g_source_remove(t->search_id);
5610 t->search_id = 0;
5611 }
5612 search_cb(t);
5613 goto done;
5614 }
5615
5616 /* reestablish a new timer if the user types fast */
5617 if (t->search_id)
5618 g_source_remove(t->search_id);
5619 t->search_id = g_timeout_add(250, (GSourceFunc)search_cb, (gpointer)t);
5620
5621 done:
5622 return (XT_CB_PASSTHROUGH);
5623 }
5624
5625 gboolean
5626 match_uri(const gchar *uri, const gchar *key) {
5627 gchar *voffset;
5628 size_t len;
5629 gboolean match = FALSE;
5630
5631 len = strlen(key);
5632
5633 if (!strncmp(key, uri, len))
5634 match = TRUE;
5635 else {
5636 voffset = strstr(uri, "/") + 2;
5637 if (!strncmp(key, voffset, len))
5638 match = TRUE;
5639 else if (g_str_has_prefix(voffset, "www.")) {
5640 voffset = voffset + strlen("www.");
5641 if (!strncmp(key, voffset, len))
5642 match = TRUE;
5643 }
5644 }
5645
5646 return (match);
5647 }
5648
5649 gboolean
5650 match_session(const gchar *name, const gchar *key) {
5651 char *sub;
5652
5653 sub = strcasestr(name, key);
5654
5655 return sub == name;
5656 }
5657
5658 void
5659 cmd_getlist(int id, char *key)
5660 {
5661 int i, dep, c = 0;
5662 struct history *h;
5663 struct session *s;
5664
5665 if (id >= 0) {
5666 if (cmds[id].type & XT_URLARG) {
5667 RB_FOREACH_REVERSE(h, history_list, &hl)
5668 if (match_uri(h->uri, key)) {
5669 cmd_status.list[c] = (char *)h->uri;
5670 if (++c > 255)
5671 break;
5672 }
5673 cmd_status.len = c;
5674 return;
5675 } else if (cmds[id].type & XT_SESSARG) {
5676 TAILQ_FOREACH(s, &sessions, entry)
5677 if (match_session(s->name, key)) {
5678 cmd_status.list[c] = (char *)s->name;
5679 if (++c > 255)
5680 break;
5681 }
5682 cmd_status.len = c;
5683 return;
5684 } else if (cmds[id].type & XT_SETARG) {
5685 for (i = 0; i < get_settings_size(); i++)
5686 if (!strncmp(key, get_setting_name(i),
5687 strlen(key)))
5688 cmd_status.list[c++] =
5689 get_setting_name(i);
5690 cmd_status.len = c;
5691 return;
5692 }
5693 }
5694
5695 dep = (id == -1) ? 0 : cmds[id].level + 1;
5696
5697 for (i = id + 1; i < LENGTH(cmds); i++) {
5698 if (cmds[i].level < dep)
5699 break;
5700 if (cmds[i].level == dep && !strncmp(key, cmds[i].cmd,
5701 strlen(key)) && !isdigit(cmds[i].cmd[0]))
5702 cmd_status.list[c++] = cmds[i].cmd;
5703
5704 }
5705
5706 cmd_status.len = c;
5707 }
5708
5709 char *
5710 cmd_getnext(int dir)
5711 {
5712 cmd_status.index += dir;
5713
5714 if (cmd_status.index < 0)
5715 cmd_status.index = cmd_status.len - 1;
5716 else if (cmd_status.index >= cmd_status.len)
5717 cmd_status.index = 0;
5718
5719 return cmd_status.list[cmd_status.index];
5720 }
5721
5722 int
5723 cmd_tokenize(char *s, char *tokens[])
5724 {
5725 int i = 0;
5726 char *tok, *last = NULL;
5727 size_t len = strlen(s);
5728 bool blank;
5729
5730 blank = len == 0 || (len > 0 && s[len - 1] == ' ');
5731 for (tok = strtok_r(s, " ", &last); tok && i < 3;
5732 tok = strtok_r(NULL, " ", &last), i++)
5733 tokens[i] = tok;
5734
5735 if (blank && i < 3)
5736 tokens[i++] = "";
5737
5738 return (i);
5739 }
5740
5741 void
5742 cmd_complete(struct tab *t, char *str, int dir)
5743 {
5744 GtkEntry *w = GTK_ENTRY(t->cmd);
5745 int i, j, levels, c = 0, dep = 0, parent = -1;
5746 int matchcount = 0;
5747 char *tok, *match, *s = g_strdup(str);
5748 char *tokens[3];
5749 char res[XT_MAX_URL_LENGTH + 32] = ":";
5750 char *sc = s;
5751
5752 DNPRINTF(XT_D_CMD, "%s: complete %s\n", __func__, str);
5753
5754 /* copy prefix*/
5755 for (i = 0; isdigit(s[i]); i++)
5756 res[i + 1] = s[i];
5757
5758 for (; isspace(s[i]); i++)
5759 res[i + 1] = s[i];
5760
5761 s += i;
5762
5763 levels = cmd_tokenize(s, tokens);
5764
5765 for (i = 0; i < levels - 1; i++) {
5766 tok = tokens[i];
5767 matchcount = 0;
5768 for (j = c; j < LENGTH(cmds); j++) {
5769 if (cmds[j].level < dep)
5770 break;
5771 if (cmds[j].level == dep && !strncmp(tok, cmds[j].cmd,
5772 strlen(tok))) {
5773 matchcount++;
5774 c = j + 1;
5775 if (strlen(tok) == strlen(cmds[j].cmd)) {
5776 matchcount = 1;
5777 break;
5778 }
5779 }
5780 }
5781
5782 if (matchcount == 1) {
5783 strlcat(res, tok, sizeof res);
5784 strlcat(res, " ", sizeof res);
5785 dep++;
5786 } else {
5787 g_free(sc);
5788 return;
5789 }
5790
5791 parent = c - 1;
5792 }
5793
5794 if (cmd_status.index == -1)
5795 cmd_getlist(parent, tokens[i]);
5796
5797 if (cmd_status.len > 0) {
5798 match = cmd_getnext(dir);
5799 strlcat(res, match, sizeof res);
5800 gtk_entry_set_text(w, res);
5801 gtk_editable_set_position(GTK_EDITABLE(w), -1);
5802 }
5803
5804 g_free(sc);
5805 }
5806
5807 gboolean
5808 cmd_execute(struct tab *t, char *str)
5809 {
5810 struct cmd *cmd = NULL;
5811 char *tok, *last = NULL, *s = g_strdup(str), *sc;
5812 char prefixstr[4];
5813 int j, len, c = 0, dep = 0, matchcount = 0;
5814 int prefix = -1, rv = XT_CB_PASSTHROUGH;
5815 struct karg arg = {0, NULL, -1};
5816
5817 sc = s;
5818
5819 /* copy prefix*/
5820 for (j = 0; j<3 && isdigit(s[j]); j++)
5821 prefixstr[j]=s[j];
5822
5823 prefixstr[j]='\0';
5824
5825 s += j;
5826 while (isspace(s[0]))
5827 s++;
5828
5829 if (strlen(s) > 0 && strlen(prefixstr) > 0)
5830 prefix = atoi(prefixstr);
5831 else
5832 s = sc;
5833
5834 for (tok = strtok_r(s, " ", &last); tok;
5835 tok = strtok_r(NULL, " ", &last)) {
5836 matchcount = 0;
5837 for (j = c; j < LENGTH(cmds); j++) {
5838 if (cmds[j].level < dep)
5839 break;
5840 len = (tok[strlen(tok) - 1] == '!') ? strlen(tok) - 1 :
5841 strlen(tok);
5842 if (cmds[j].level == dep &&
5843 !strncmp(tok, cmds[j].cmd, len)) {
5844 matchcount++;
5845 c = j + 1;
5846 cmd = &cmds[j];
5847 if (len == strlen(cmds[j].cmd)) {
5848 matchcount = 1;
5849 break;
5850 }
5851 }
5852 }
5853 if (matchcount == 1) {
5854 if (cmd->type > 0)
5855 goto execute_cmd;
5856 dep++;
5857 } else {
5858 show_oops(t, "Invalid command: %s", str);
5859 goto done;
5860 }
5861 }
5862 execute_cmd:
5863 if (cmd == NULL) {
5864 show_oops(t, "Empty command");
5865 goto done;
5866 }
5867 arg.i = cmd->arg;
5868
5869 if (prefix != -1)
5870 arg.precount = prefix;
5871 else if (cmd_prefix > 0)
5872 arg.precount = cmd_prefix;
5873
5874 if (j > 0 && !(cmd->type & XT_PREFIX) && arg.precount > -1) {
5875 show_oops(t, "No prefix allowed: %s", str);
5876 goto done;
5877 }
5878 if (cmd->type > 1)
5879 arg.s = last ? g_strdup(last) : g_strdup("");
5880 if (cmd->type & XT_INTARG && last && strlen(last) > 0) {
5881 if (arg.s == NULL) {
5882 show_oops(t, "Invalid command");
5883 goto done;
5884 }
5885 arg.precount = atoi(arg.s);
5886 if (arg.precount <= 0) {
5887 if (arg.s[0] == '0')
5888 show_oops(t, "Zero count");
5889 else
5890 show_oops(t, "Trailing characters");
5891 goto done;
5892 }
5893 }
5894
5895 DNPRINTF(XT_D_CMD, "%s: prefix %d arg %s\n",
5896 __func__, arg.precount, arg.s);
5897
5898 cmd->func(t, &arg);
5899
5900 rv = XT_CB_HANDLED;
5901 done:
5902 if (j > 0)
5903 cmd_prefix = 0;
5904 g_free(sc);
5905 if (arg.s)
5906 g_free(arg.s);
5907
5908 return (rv);
5909 }
5910
5911 int
5912 entry_key_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
5913 {
5914 if (t == NULL) {
5915 show_oops(NULL, "entry_key_cb invalid parameters");
5916 return (XT_CB_PASSTHROUGH);
5917 }
5918
5919 DNPRINTF(XT_D_CMD, "entry_key_cb: keyval 0x%x mask 0x%x tab %d\n",
5920 e->keyval, e->state, t->tab_id);
5921
5922 hide_oops(t);
5923
5924 if (e->keyval == GDK_Escape) {
5925 /* don't use focus_webview(t) because we want to type :cmds */
5926 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
5927 }
5928
5929 return (handle_keypress(t, e, 1));
5930 }
5931
5932 struct command_entry *
5933 history_prev(struct command_list *l, struct command_entry *at)
5934 {
5935 if (at == NULL)
5936 at = TAILQ_LAST(l, command_list);
5937 else {
5938 at = TAILQ_PREV(at, command_list, entry);
5939 if (at == NULL)
5940 at = TAILQ_LAST(l, command_list);
5941 }
5942
5943 return (at);
5944 }
5945
5946 struct command_entry *
5947 history_next(struct command_list *l, struct command_entry *at)
5948 {
5949 if (at == NULL)
5950 at = TAILQ_FIRST(l);
5951 else {
5952 at = TAILQ_NEXT(at, entry);
5953 if (at == NULL)
5954 at = TAILQ_FIRST(l);
5955 }
5956
5957 return (at);
5958 }
5959
5960 int
5961 cmd_keypress_cb(GtkEntry *w, GdkEventKey *e, struct tab *t)
5962 {
5963 int rv = XT_CB_HANDLED;
5964 const gchar *c = gtk_entry_get_text(w);
5965 char *s;
5966
5967 if (t == NULL) {
5968 show_oops(NULL, "cmd_keypress_cb parameters");
5969 return (XT_CB_PASSTHROUGH);
5970 }
5971
5972 DNPRINTF(XT_D_CMD, "cmd_keypress_cb: keyval 0x%x mask 0x%x tab %d\n",
5973 e->keyval, e->state, t->tab_id);
5974
5975 /* sanity */
5976 if (c == NULL)
5977 e->keyval = GDK_Escape;
5978 else if (!(c[0] == ':' || c[0] == '/' || c[0] == '?' ||
5979 c[0] == '.' || c[0] == ','))
5980 e->keyval = GDK_Escape;
5981
5982 if (e->keyval != GDK_Tab && e->keyval != GDK_Shift_L &&
5983 e->keyval != GDK_ISO_Left_Tab)
5984 cmd_status.index = -1;
5985
5986 switch (e->keyval) {
5987 case GDK_Tab:
5988 if (c[0] == ':')
5989 cmd_complete(t, (char *)&c[1], 1);
5990 else if (c[0] == '.' || c[0] == ',')
5991 run_script(t, "hints.focusNextHint();");
5992 goto done;
5993 case GDK_ISO_Left_Tab:
5994 if (c[0] == ':')
5995 cmd_complete(t, (char *)&c[1], -1);
5996 else if (c[0] == '.' || c[0] == ',')
5997 run_script(t, "hints.focusPreviousHint();");
5998 goto done;
5999 case GDK_Down:
6000 if (c[0] == '?') {
6001 if ((search_at = history_next(&shl, search_at))) {
6002 search_at->line[0] = c[0];
6003 gtk_entry_set_text(w, search_at->line);
6004 gtk_editable_set_position(GTK_EDITABLE(w), -1);
6005 }
6006 } else if (c[0] == '/') {
6007 if ((search_at = history_prev(&shl, search_at))) {
6008 search_at->line[0] = c[0];
6009 gtk_entry_set_text(w, search_at->line);
6010 gtk_editable_set_position(GTK_EDITABLE(w), -1);
6011 }
6012 } if (c[0] == ':') {
6013 if ((history_at = history_prev(&chl, history_at))) {
6014 history_at->line[0] = c[0];
6015 gtk_entry_set_text(w, history_at->line);
6016 gtk_editable_set_position(GTK_EDITABLE(w), -1);
6017 }
6018 }
6019 goto done;
6020 case GDK_Up:
6021 if (c[0] == '/') {
6022 if ((search_at = history_next(&shl, search_at))) {
6023 search_at->line[0] = c[0];
6024 gtk_entry_set_text(w, search_at->line);
6025 gtk_editable_set_position(GTK_EDITABLE(w), -1);
6026 }
6027 } else if (c[0] == '?') {
6028 if ((search_at = history_prev(&shl, search_at))) {
6029 search_at->line[0] = c[0];
6030 gtk_entry_set_text(w, search_at->line);
6031 gtk_editable_set_position(GTK_EDITABLE(w), -1);
6032 }
6033 } if (c[0] == ':') {
6034 if ((history_at = history_next(&chl, history_at))) {
6035 history_at->line[0] = c[0];
6036 gtk_entry_set_text(w, history_at->line);
6037 gtk_editable_set_position(GTK_EDITABLE(w), -1);
6038 }
6039 }
6040 goto done;
6041 case GDK_BackSpace:
6042 if (!(!strcmp(c, ":") || !strcmp(c, "/") || !strcmp(c, "?") ||
6043 !strcmp(c, ".") || !strcmp(c, ","))) {
6044 /* see if we are doing hinting and reset it */
6045 if (c[0] == '.' || c[0] == ',') {
6046 /* recreate hints */
6047 s = g_strdup_printf("hints.createHints('', "
6048 "'%c');", c[0] == '.' ? 'f' : 'F');
6049 run_script(t, s);
6050 g_free(s);
6051 }
6052 break;
6053 }
6054
6055 /* FALLTHROUGH */
6056 case GDK_Escape:
6057 hide_cmd(t);
6058 focus_webview(t);
6059
6060 /* cancel search */
6061 if (c != NULL && (c[0] == '/' || c[0] == '?'))
6062 webkit_web_view_unmark_text_matches(t->wv);
6063
6064 /* no need to cancel hints */
6065 goto done;
6066 }
6067
6068 rv = XT_CB_PASSTHROUGH;
6069 done:
6070 return (rv);
6071 }
6072
6073 void
6074 wv_popup_cb(GtkEntry *entry, GtkMenu *menu, struct tab *t)
6075 {
6076 DNPRINTF(XT_D_CMD, "wv_popup_cb: tab %d\n", t->tab_id);
6077 }
6078
6079 void
6080 cmd_popup_cb(GtkEntry *entry, GtkMenu *menu, struct tab *t)
6081 {
6082 /* popup menu enabled */
6083 t->popup = 1;
6084 }
6085
6086 int
6087 cmd_focusout_cb(GtkWidget *w, GdkEventFocus *e, struct tab *t)
6088 {
6089 if (t == NULL) {
6090 show_oops(NULL, "cmd_focusout_cb invalid parameters");
6091 return (XT_CB_PASSTHROUGH);
6092 }
6093
6094 DNPRINTF(XT_D_CMD, "cmd_focusout_cb: tab %d popup %d\n",
6095 t->tab_id, t->popup);
6096
6097 /* if popup is enabled don't lose focus */
6098 if (t->popup) {
6099 t->popup = 0;
6100 return (XT_CB_PASSTHROUGH);
6101 }
6102
6103 hide_cmd(t);
6104 hide_oops(t);
6105 disable_hints(t);
6106
6107 if (show_url == 0 || t->focus_wv)
6108 focus_webview(t);
6109 else
6110 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
6111
6112 return (XT_CB_PASSTHROUGH);
6113 }
6114
6115 void
6116 cmd_activate_cb(GtkEntry *entry, struct tab *t)
6117 {
6118 char *s;
6119 const gchar *c = gtk_entry_get_text(entry);
6120
6121 if (t == NULL) {
6122 show_oops(NULL, "cmd_activate_cb invalid parameters");
6123 return;
6124 }
6125
6126 DNPRINTF(XT_D_CMD, "cmd_activate_cb: tab %d %s\n", t->tab_id, c);
6127
6128 /* sanity */
6129 if (c == NULL)
6130 goto done;
6131 else if (!(c[0] == ':' || c[0] == '/' || c[0] == '?' ||
6132 c[0] == '.' || c[0] == ','))
6133 goto done;
6134 if (strlen(c) < 1)
6135 goto done;
6136 s = (char *)&c[1];
6137
6138 if (c[0] == '/' || c[0] == '?') {
6139 /* see if there is a timer pending */
6140 if (t->search_id) {
6141 g_source_remove(t->search_id);
6142 t->search_id = 0;
6143 search_cb(t);
6144 }
6145
6146 if (t->search_text) {
6147 g_free(t->search_text);
6148 t->search_text = NULL;
6149 }
6150
6151 t->search_text = g_strdup(s);
6152 if (global_search)
6153 g_free(global_search);
6154 global_search = g_strdup(s);
6155 t->search_forward = c[0] == '/';
6156
6157 history_add(&shl, search_file, s, &search_history_count);
6158 } else if (c[0] == '.' || c[0] == ',') {
6159 run_script(t, "hints.fire();");
6160 /* XXX history for link following? */
6161 } else if (c[0] == ':') {
6162 history_add(&chl, command_file, s, &cmd_history_count);
6163 /* can't call hide_cmd after cmd_execute */
6164 hide_cmd(t);
6165 cmd_execute(t, s);
6166 return;
6167 }
6168
6169 done:
6170 hide_cmd(t);
6171 }
6172
6173 void
6174 backward_cb(GtkWidget *w, struct tab *t)
6175 {
6176 struct karg a;
6177
6178 if (t == NULL) {
6179 show_oops(NULL, "backward_cb invalid parameters");
6180 return;
6181 }
6182
6183 DNPRINTF(XT_D_NAV, "backward_cb: tab %d\n", t->tab_id);
6184
6185 a.i = XT_NAV_BACK;
6186 navaction(t, &a);
6187 }
6188
6189 void
6190 forward_cb(GtkWidget *w, struct tab *t)
6191 {
6192 struct karg a;
6193
6194 if (t == NULL) {
6195 show_oops(NULL, "forward_cb invalid parameters");
6196 return;
6197 }
6198
6199 DNPRINTF(XT_D_NAV, "forward_cb: tab %d\n", t->tab_id);
6200
6201 a.i = XT_NAV_FORWARD;
6202 navaction(t, &a);
6203 }
6204
6205 void
6206 home_cb(GtkWidget *w, struct tab *t)
6207 {
6208 if (t == NULL) {
6209 show_oops(NULL, "home_cb invalid parameters");
6210 return;
6211 }
6212
6213 DNPRINTF(XT_D_NAV, "home_cb: tab %d\n", t->tab_id);
6214
6215 load_uri(t, home);
6216 }
6217
6218 void
6219 stop_cb(GtkWidget *w, struct tab *t)
6220 {
6221 WebKitWebFrame *frame;
6222
6223 if (t == NULL) {
6224 show_oops(NULL, "stop_cb invalid parameters");
6225 return;
6226 }
6227
6228 DNPRINTF(XT_D_NAV, "stop_cb: tab %d\n", t->tab_id);
6229
6230 frame = webkit_web_view_get_main_frame(t->wv);
6231 if (frame == NULL) {
6232 show_oops(t, "stop_cb: no frame");
6233 return;
6234 }
6235
6236 webkit_web_frame_stop_loading(frame);
6237 abort_favicon_download(t);
6238 }
6239
6240 void
6241 setup_webkit(struct tab *t)
6242 {
6243 if (is_g_object_setting(G_OBJECT(t->settings), "enable-dns-prefetching"))
6244 g_object_set(G_OBJECT(t->settings), "enable-dns-prefetching",
6245 FALSE, (char *)NULL);
6246 else
6247 warnx("webkit does not have \"enable-dns-prefetching\" property");
6248 g_object_set(G_OBJECT(t->settings),
6249 "user-agent", t->user_agent, (char *)NULL);
6250 g_object_set(G_OBJECT(t->settings),
6251 "enable-scripts", enable_scripts, (char *)NULL);
6252 g_object_set(G_OBJECT(t->settings),
6253 "enable-plugins", enable_plugins, (char *)NULL);
6254 g_object_set(G_OBJECT(t->settings),
6255 "javascript-can-open-windows-automatically", enable_scripts,
6256 (char *)NULL);
6257 g_object_set(G_OBJECT(t->settings),
6258 "enable-html5-database", FALSE, (char *)NULL);
6259 g_object_set(G_OBJECT(t->settings),
6260 "enable-html5-local-storage", enable_localstorage, (char *)NULL);
6261 g_object_set(G_OBJECT(t->settings),
6262 "enable_spell_checking", enable_spell_checking, (char *)NULL);
6263 g_object_set(G_OBJECT(t->settings),
6264 "spell_checking_languages", spell_check_languages, (char *)NULL);
6265 g_object_set(G_OBJECT(t->settings),
6266 "enable-developer-extras", TRUE, (char *)NULL);
6267 g_object_set(G_OBJECT(t->wv),
6268 "full-content-zoom", TRUE, (char *)NULL);
6269 g_object_set(G_OBJECT(t->settings),
6270 "auto-load-images", auto_load_images, (char *)NULL);
6271
6272 webkit_web_view_set_settings(t->wv, t->settings);
6273 }
6274
6275 gboolean
6276 update_statusbar_position(GtkAdjustment* adjustment, gpointer data)
6277 {
6278 struct tab *ti, *t = NULL;
6279 gdouble view_size, value, max;
6280 gchar *position;
6281
6282 TAILQ_FOREACH(ti, &tabs, entry)
6283 if (ti->tab_id == gtk_notebook_get_current_page(notebook)) {
6284 t = ti;
6285 break;
6286 }
6287
6288 if (t == NULL)
6289 return FALSE;
6290
6291 if (adjustment == NULL)
6292 adjustment = gtk_scrolled_window_get_vadjustment(
6293 GTK_SCROLLED_WINDOW(t->browser_win));
6294
6295 view_size = gtk_adjustment_get_page_size(adjustment);
6296 value = gtk_adjustment_get_value(adjustment);
6297 max = gtk_adjustment_get_upper(adjustment) - view_size;
6298
6299 if (max == 0)
6300 position = g_strdup("All");
6301 else if (value == max)
6302 position = g_strdup("Bot");
6303 else if (value == 0)
6304 position = g_strdup("Top");
6305 else
6306 position = g_strdup_printf("%d%%", (int) ((value / max) * 100));
6307
6308 gtk_entry_set_text(GTK_ENTRY(t->sbe.position), position);
6309 g_free(position);
6310
6311 return (TRUE);
6312 }
6313
6314 GtkWidget *
6315 create_window(const gchar *name)
6316 {
6317 GtkWidget *w;
6318
6319 w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
6320 if (window_maximize)
6321 gtk_window_maximize(GTK_WINDOW(w));
6322 else
6323 gtk_window_set_default_size(GTK_WINDOW(w), window_width, window_height);
6324 gtk_widget_set_name(w, name);
6325 gtk_window_set_wmclass(GTK_WINDOW(w), name, "XXXTerm");
6326
6327 return (w);
6328 }
6329
6330 GtkWidget *
6331 create_browser(struct tab *t)
6332 {
6333 GtkWidget *w;
6334 gchar *strval;
6335 GtkAdjustment *adjustment;
6336
6337 if (t == NULL) {
6338 show_oops(NULL, "create_browser invalid parameters");
6339 return (NULL);
6340 }
6341
6342 t->sb_h = GTK_SCROLLBAR(gtk_hscrollbar_new(NULL));
6343 t->sb_v = GTK_SCROLLBAR(gtk_vscrollbar_new(NULL));
6344 t->adjust_h = gtk_range_get_adjustment(GTK_RANGE(t->sb_h));
6345 t->adjust_v = gtk_range_get_adjustment(GTK_RANGE(t->sb_v));
6346
6347 w = gtk_scrolled_window_new(t->adjust_h, t->adjust_v);
6348 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w),
6349 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
6350
6351 t->wv = WEBKIT_WEB_VIEW(webkit_web_view_new());
6352 gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(t->wv));
6353
6354 /* set defaults */
6355 t->settings = webkit_web_settings_new();
6356
6357 g_object_set(t->settings, "default-encoding", encoding, (char *)NULL);
6358
6359 if (user_agent == NULL) {
6360 g_object_get(G_OBJECT(t->settings), "user-agent", &strval,
6361 (char *)NULL);
6362 t->user_agent = g_strdup_printf("%s %s+", strval, version);
6363 g_free(strval);
6364 } else
6365 t->user_agent = g_strdup(user_agent->value);
6366
6367 t->stylesheet = g_strdup_printf("file://%s/style.css", resource_dir);
6368 t->load_images = auto_load_images;
6369
6370 adjustment =
6371 gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(w));
6372 g_signal_connect(G_OBJECT(adjustment), "value-changed",
6373 G_CALLBACK(update_statusbar_position), NULL);
6374
6375 setup_webkit(t);
6376 setup_inspector(t);
6377
6378 return (w);
6379 }
6380
6381 GtkWidget *
6382 create_kiosk_toolbar(struct tab *t)
6383 {
6384 GtkWidget *toolbar = NULL, *b;
6385
6386 b = gtk_hbox_new(FALSE, 0);
6387 toolbar = b;
6388 gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
6389
6390 /* backward button */
6391 t->backward = create_button("Back", GTK_STOCK_GO_BACK, 0);
6392 gtk_widget_set_sensitive(t->backward, FALSE);
6393 g_signal_connect(G_OBJECT(t->backward), "clicked",
6394 G_CALLBACK(backward_cb), t);
6395 gtk_box_pack_start(GTK_BOX(b), t->backward, TRUE, TRUE, 0);
6396
6397 /* forward button */
6398 t->forward = create_button("Forward", GTK_STOCK_GO_FORWARD, 0);
6399 gtk_widget_set_sensitive(t->forward, FALSE);
6400 g_signal_connect(G_OBJECT(t->forward), "clicked",
6401 G_CALLBACK(forward_cb), t);
6402 gtk_box_pack_start(GTK_BOX(b), t->forward, TRUE, TRUE, 0);
6403
6404 /* home button */
6405 t->gohome = create_button("Home", GTK_STOCK_HOME, 0);
6406 gtk_widget_set_sensitive(t->gohome, true);
6407 g_signal_connect(G_OBJECT(t->gohome), "clicked",
6408 G_CALLBACK(home_cb), t);
6409 gtk_box_pack_start(GTK_BOX(b), t->gohome, TRUE, TRUE, 0);
6410
6411 /* create widgets but don't use them */
6412 t->uri_entry = gtk_entry_new();
6413 t->default_style = gtk_rc_get_style(t->uri_entry);
6414 t->stop = create_button("Stop", GTK_STOCK_STOP, 0);
6415 t->js_toggle = create_button("JS-Toggle", enable_scripts ?
6416 GTK_STOCK_MEDIA_PLAY : GTK_STOCK_MEDIA_PAUSE, 0);
6417
6418 return (toolbar);
6419 }
6420
6421 GtkWidget *
6422 create_toolbar(struct tab *t)
6423 {
6424 GtkWidget *toolbar = NULL, *b, *eb1;
6425
6426 b = gtk_hbox_new(FALSE, 0);
6427 toolbar = b;
6428 gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
6429
6430 /* backward button */
6431 t->backward = create_button("Back", GTK_STOCK_GO_BACK, 0);
6432 gtk_widget_set_sensitive(t->backward, FALSE);
6433 g_signal_connect(G_OBJECT(t->backward), "clicked",
6434 G_CALLBACK(backward_cb), t);
6435 gtk_box_pack_start(GTK_BOX(b), t->backward, FALSE, FALSE, 0);
6436
6437 /* forward button */
6438 t->forward = create_button("Forward",GTK_STOCK_GO_FORWARD, 0);
6439 gtk_widget_set_sensitive(t->forward, FALSE);
6440 g_signal_connect(G_OBJECT(t->forward), "clicked",
6441 G_CALLBACK(forward_cb), t);
6442 gtk_box_pack_start(GTK_BOX(b), t->forward, FALSE,
6443 FALSE, 0);
6444
6445 /* stop button */
6446 t->stop = create_button("Stop", GTK_STOCK_STOP, 0);
6447 gtk_widget_set_sensitive(t->stop, FALSE);
6448 g_signal_connect(G_OBJECT(t->stop), "clicked",
6449 G_CALLBACK(stop_cb), t);
6450 gtk_box_pack_start(GTK_BOX(b), t->stop, FALSE,
6451 FALSE, 0);
6452
6453 /* JS button */
6454 t->js_toggle = create_button("JS-Toggle", enable_scripts ?
6455 GTK_STOCK_MEDIA_PLAY : GTK_STOCK_MEDIA_PAUSE, 0);
6456 gtk_widget_set_sensitive(t->js_toggle, TRUE);
6457 g_signal_connect(G_OBJECT(t->js_toggle), "clicked",
6458 G_CALLBACK(js_toggle_cb), t);
6459 gtk_box_pack_start(GTK_BOX(b), t->js_toggle, FALSE, FALSE, 0);
6460
6461 t->uri_entry = gtk_entry_new();
6462 g_signal_connect(G_OBJECT(t->uri_entry), "activate",
6463 G_CALLBACK(activate_uri_entry_cb), t);
6464 g_signal_connect(G_OBJECT(t->uri_entry), "key-press-event",
6465 G_CALLBACK(entry_key_cb), t);
6466 completion_add(t);
6467 eb1 = gtk_hbox_new(FALSE, 0);
6468 gtk_container_set_border_width(GTK_CONTAINER(eb1), 1);
6469 gtk_box_pack_start(GTK_BOX(eb1), t->uri_entry, TRUE, TRUE, 0);
6470 gtk_box_pack_start(GTK_BOX(b), eb1, TRUE, TRUE, 0);
6471
6472 /* search entry */
6473 if (search_string != NULL && strlen(search_string) != 0) {
6474 GtkWidget *eb2;
6475 t->search_entry = gtk_entry_new();
6476 gtk_entry_set_width_chars(GTK_ENTRY(t->search_entry), 30);
6477 g_signal_connect(G_OBJECT(t->search_entry), "activate",
6478 G_CALLBACK(activate_search_entry_cb), t);
6479 g_signal_connect(G_OBJECT(t->search_entry), "key-press-event",
6480 G_CALLBACK(entry_key_cb), t);
6481 gtk_widget_set_size_request(t->search_entry, -1, -1);
6482 eb2 = gtk_hbox_new(FALSE, 0);
6483 gtk_container_set_border_width(GTK_CONTAINER(eb2), 1);
6484 gtk_box_pack_start(GTK_BOX(eb2), t->search_entry, TRUE, TRUE,
6485 0);
6486 gtk_box_pack_start(GTK_BOX(b), eb2, FALSE, FALSE, 0);
6487 }
6488 t->default_style = gtk_rc_get_style(t->uri_entry);
6489
6490 return (toolbar);
6491 }
6492
6493 GtkWidget *
6494 create_buffers(struct tab *t)
6495 {
6496 GtkCellRenderer *renderer;
6497 GtkWidget *view;
6498
6499 view = gtk_tree_view_new();
6500
6501 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
6502
6503 renderer = gtk_cell_renderer_text_new();
6504 gtk_tree_view_insert_column_with_attributes
6505 (GTK_TREE_VIEW(view), -1, "Id", renderer, "text", COL_ID, (char *)NULL);
6506
6507 renderer = gtk_cell_renderer_pixbuf_new();
6508 gtk_tree_view_insert_column_with_attributes
6509 (GTK_TREE_VIEW(view), -1, "Favicon", renderer, "pixbuf", COL_FAVICON,
6510 (char *)NULL);
6511
6512 renderer = gtk_cell_renderer_text_new();
6513 gtk_tree_view_insert_column_with_attributes
6514 (GTK_TREE_VIEW(view), -1, "Title", renderer, "text", COL_TITLE,
6515 (char *)NULL);
6516
6517 gtk_tree_view_set_model
6518 (GTK_TREE_VIEW(view), GTK_TREE_MODEL(buffers_store));
6519
6520 return (view);
6521 }
6522
6523 void
6524 row_activated_cb(GtkTreeView *view, GtkTreePath *path,
6525 GtkTreeViewColumn *col, struct tab *t)
6526 {
6527 GtkTreeIter iter;
6528 guint id;
6529
6530 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
6531
6532 if (gtk_tree_model_get_iter(GTK_TREE_MODEL(buffers_store), &iter,
6533 path)) {
6534 gtk_tree_model_get
6535 (GTK_TREE_MODEL(buffers_store), &iter, COL_ID, &id, -1);
6536 set_current_tab(id - 1);
6537 }
6538
6539 hide_buffers(t);
6540 }
6541
6542 /* after tab reordering/creation/removal */
6543 void
6544 recalc_tabs(void)
6545 {
6546 struct tab *t;
6547 int maxid = 0;
6548
6549 TAILQ_FOREACH(t, &tabs, entry) {
6550 t->tab_id = gtk_notebook_page_num(notebook, t->vbox);
6551 if (t->tab_id > maxid)
6552 maxid = t->tab_id;
6553
6554 gtk_widget_show(t->tab_elems.sep);
6555 }
6556
6557 TAILQ_FOREACH(t, &tabs, entry) {
6558 if (t->tab_id == maxid) {
6559 gtk_widget_hide(t->tab_elems.sep);
6560 break;
6561 }
6562 }
6563 }
6564
6565 /* after active tab change */
6566 void
6567 recolor_compact_tabs(void)
6568 {
6569 struct tab *t;
6570 int curid = 0;
6571 GdkColor color;
6572
6573 gdk_color_parse(XT_COLOR_CT_INACTIVE, &color);
6574 TAILQ_FOREACH(t, &tabs, entry)
6575 gtk_widget_modify_fg(t->tab_elems.label, GTK_STATE_NORMAL,
6576 &color);
6577
6578 curid = gtk_notebook_get_current_page(notebook);
6579 TAILQ_FOREACH(t, &tabs, entry)
6580 if (t->tab_id == curid) {
6581 gdk_color_parse(XT_COLOR_CT_ACTIVE, &color);
6582 gtk_widget_modify_fg(t->tab_elems.label,
6583 GTK_STATE_NORMAL, &color);
6584 break;
6585 }
6586 }
6587
6588 void
6589 set_current_tab(int page_num)
6590 {
6591 buffercmd_abort(get_current_tab());
6592 gtk_notebook_set_current_page(notebook, page_num);
6593 recolor_compact_tabs();
6594 }
6595
6596 int
6597 undo_close_tab_save(struct tab *t)
6598 {
6599 int m, n;
6600 const gchar *uri;
6601 struct undo *u1, *u2;
6602 GList *items;
6603 WebKitWebHistoryItem *item;
6604
6605 if ((uri = get_uri(t)) == NULL)
6606 return (1);
6607
6608 u1 = g_malloc0(sizeof(struct undo));
6609 u1->uri = g_strdup(uri);
6610
6611 t->bfl = webkit_web_view_get_back_forward_list(t->wv);
6612
6613 m = webkit_web_back_forward_list_get_forward_length(t->bfl);
6614 n = webkit_web_back_forward_list_get_back_length(t->bfl);
6615 u1->back = n;
6616
6617 /* forward history */
6618 items = webkit_web_back_forward_list_get_forward_list_with_limit(t->bfl, m);
6619
6620 while (items) {
6621 item = items->data;
6622 u1->history = g_list_prepend(u1->history,
6623 webkit_web_history_item_copy(item));
6624 items = g_list_next(items);
6625 }
6626
6627 /* current item */
6628 if (m) {
6629 item = webkit_web_back_forward_list_get_current_item(t->bfl);
6630 u1->history = g_list_prepend(u1->history,
6631 webkit_web_history_item_copy(item));
6632 }
6633
6634 /* back history */
6635 items = webkit_web_back_forward_list_get_back_list_with_limit(t->bfl, n);
6636
6637 while (items) {
6638 item = items->data;
6639 u1->history = g_list_prepend(u1->history,
6640 webkit_web_history_item_copy(item));
6641 items = g_list_next(items);
6642 }
6643
6644 TAILQ_INSERT_HEAD(&undos, u1, entry);
6645
6646 if (undo_count > XT_MAX_UNDO_CLOSE_TAB) {
6647 u2 = TAILQ_LAST(&undos, undo_tailq);
6648 TAILQ_REMOVE(&undos, u2, entry);
6649 g_free(u2->uri);
6650 g_list_free(u2->history);
6651 g_free(u2);
6652 } else
6653 undo_count++;
6654
6655 return (0);
6656 }
6657
6658 void
6659 delete_tab(struct tab *t)
6660 {
6661 struct karg a;
6662
6663 DNPRINTF(XT_D_TAB, "delete_tab: %p\n", t);
6664
6665 if (t == NULL)
6666 return;
6667
6668 /*
6669 * no need to join thread here because it won't access t on completion
6670 */
6671
6672 TAILQ_REMOVE(&tabs, t, entry);
6673 buffercmd_abort(t);
6674
6675 /* Halt all webkit activity. */
6676 abort_favicon_download(t);
6677 webkit_web_view_stop_loading(t->wv);
6678
6679 /* Save the tab, so we can undo the close. */
6680 undo_close_tab_save(t);
6681
6682 /* just in case */
6683 if (t->search_id)
6684 g_source_remove(t->search_id);
6685
6686 /* inspector */
6687 bzero(&a, sizeof a);
6688 a.i = XT_INS_CLOSE;
6689 inspector_cmd(t, &a);
6690
6691 if (browser_mode == XT_BM_KIOSK) {
6692 gtk_widget_destroy(t->uri_entry);
6693 gtk_widget_destroy(t->stop);
6694 gtk_widget_destroy(t->js_toggle);
6695 }
6696
6697 gtk_widget_destroy(t->tab_elems.eventbox);
6698 gtk_widget_destroy(t->vbox);
6699
6700 g_free(t->user_agent);
6701 g_free(t->stylesheet);
6702 g_free(t->tmp_uri);
6703 g_free(t);
6704 t = NULL;
6705
6706 if (TAILQ_EMPTY(&tabs)) {
6707 if (browser_mode == XT_BM_KIOSK)
6708 create_new_tab(home, NULL, 1, -1);
6709 else
6710 create_new_tab(NULL, NULL, 1, -1);
6711 }
6712
6713 /* recreate session */
6714 if (session_autosave) {
6715 bzero(&a, sizeof a);
6716 a.s = NULL;
6717 save_tabs(NULL, &a);
6718 }
6719
6720 recalc_tabs();
6721 recolor_compact_tabs();
6722 }
6723
6724 void
6725 update_statusbar_zoom(struct tab *t)
6726 {
6727 gfloat zoom;
6728 char s[16] = { '\0' };
6729
6730 g_object_get(G_OBJECT(t->wv), "zoom-level", &zoom, (char *)NULL);
6731 if ((zoom <= 0.99 || zoom >= 1.01))
6732 snprintf(s, sizeof s, "%d%%", (int)(zoom * 100));
6733 gtk_entry_set_text(GTK_ENTRY(t->sbe.zoom), s);
6734 }
6735
6736 void
6737 setzoom_webkit(struct tab *t, int adjust)
6738 {
6739 #define XT_ZOOMPERCENT 0.04
6740
6741 gfloat zoom;
6742
6743 if (t == NULL) {
6744 show_oops(NULL, "setzoom_webkit invalid parameters");
6745 return;
6746 }
6747
6748 g_object_get(G_OBJECT(t->wv), "zoom-level", &zoom, (char *)NULL);
6749 if (adjust == XT_ZOOM_IN)
6750 zoom += XT_ZOOMPERCENT;
6751 else if (adjust == XT_ZOOM_OUT)
6752 zoom -= XT_ZOOMPERCENT;
6753 else if (adjust > 0)
6754 zoom = default_zoom_level + adjust / 100.0 - 1.0;
6755 else {
6756 show_oops(t, "setzoom_webkit invalid zoom value");
6757 return;
6758 }
6759
6760 if (zoom < XT_ZOOMPERCENT)
6761 zoom = XT_ZOOMPERCENT;
6762 g_object_set(G_OBJECT(t->wv), "zoom-level", zoom, (char *)NULL);
6763 update_statusbar_zoom(t);
6764 }
6765
6766 gboolean
6767 tab_clicked_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
6768 {
6769 struct tab *t = (struct tab *) data;
6770
6771 DNPRINTF(XT_D_TAB, "tab_clicked_cb: tab: %d\n", t->tab_id);
6772
6773 switch (event->button) {
6774 case 1:
6775 set_current_tab(t->tab_id);
6776 break;
6777 case 2:
6778 delete_tab(t);
6779 break;
6780 }
6781
6782 return TRUE;
6783 }
6784
6785 void
6786 append_tab(struct tab *t)
6787 {
6788 if (t == NULL)
6789 return;
6790
6791 TAILQ_INSERT_TAIL(&tabs, t, entry);
6792 t->tab_id = gtk_notebook_append_page(notebook, t->vbox, t->tab_content);
6793 }
6794
6795 GtkWidget *
6796 create_sbe(int width)
6797 {
6798 GtkWidget *sbe;
6799
6800 sbe = gtk_entry_new();
6801 gtk_entry_set_inner_border(GTK_ENTRY(sbe), NULL);
6802 gtk_entry_set_has_frame(GTK_ENTRY(sbe), FALSE);
6803 gtk_widget_set_can_focus(GTK_WIDGET(sbe), FALSE);
6804 gtk_widget_modify_font(GTK_WIDGET(sbe), statusbar_font);
6805 gtk_entry_set_alignment(GTK_ENTRY(sbe), 1.0);
6806 gtk_widget_set_size_request(sbe, width, -1);
6807
6808 return sbe;
6809 }
6810
6811 struct tab *
6812 create_new_tab(char *title, struct undo *u, int focus, int position)
6813 {
6814 struct tab *t;
6815 int load = 1, id;
6816 GtkWidget *b, *bb;
6817 WebKitWebHistoryItem *item;
6818 GList *items;
6819 GdkColor color;
6820 char *p;
6821 int sbe_p = 0, sbe_b = 0,
6822 sbe_z = 0;
6823
6824 DNPRINTF(XT_D_TAB, "create_new_tab: title %s focus %d\n", title, focus);
6825
6826 if (tabless && !TAILQ_EMPTY(&tabs)) {
6827 DNPRINTF(XT_D_TAB, "create_new_tab: new tab rejected\n");
6828 return (NULL);
6829 }
6830
6831 t = g_malloc0(sizeof *t);
6832
6833 if (title == NULL) {
6834 title = "(untitled)";
6835 load = 0;
6836 }
6837
6838 t->vbox = gtk_vbox_new(FALSE, 0);
6839
6840 /* label + button for tab */
6841 b = gtk_hbox_new(FALSE, 0);
6842 t->tab_content = b;
6843
6844 #if GTK_CHECK_VERSION(2, 20, 0)
6845 t->spinner = gtk_spinner_new();
6846 #endif
6847 t->label = gtk_label_new(title);
6848 bb = create_button("Close", GTK_STOCK_CLOSE, 1);
6849 gtk_widget_set_size_request(t->label, 100, 0);
6850 gtk_label_set_max_width_chars(GTK_LABEL(t->label), 20);
6851 gtk_label_set_ellipsize(GTK_LABEL(t->label), PANGO_ELLIPSIZE_END);
6852 gtk_widget_set_size_request(b, 130, 0);
6853
6854 gtk_box_pack_start(GTK_BOX(b), bb, FALSE, FALSE, 0);
6855 gtk_box_pack_start(GTK_BOX(b), t->label, FALSE, FALSE, 0);
6856 #if GTK_CHECK_VERSION(2, 20, 0)
6857 gtk_box_pack_start(GTK_BOX(b), t->spinner, FALSE, FALSE, 0);
6858 #endif
6859
6860 /* toolbar */
6861 if (browser_mode == XT_BM_KIOSK) {
6862 t->toolbar = create_kiosk_toolbar(t);
6863 gtk_box_pack_start(GTK_BOX(t->vbox), t->toolbar, FALSE, FALSE,
6864 0);
6865 } else {
6866 t->toolbar = create_toolbar(t);
6867 if (fancy_bar)
6868 gtk_box_pack_start(GTK_BOX(t->vbox), t->toolbar, FALSE,
6869 FALSE, 0);
6870 }
6871
6872 /* marks */
6873 marks_clear(t);
6874
6875 /* browser */
6876 t->browser_win = create_browser(t);
6877 gtk_box_pack_start(GTK_BOX(t->vbox), t->browser_win, TRUE, TRUE, 0);
6878
6879 /* oops message for user feedback */
6880 t->oops = gtk_entry_new();
6881 gtk_entry_set_inner_border(GTK_ENTRY(t->oops), NULL);
6882 gtk_entry_set_has_frame(GTK_ENTRY(t->oops), FALSE);
6883 gtk_widget_set_can_focus(GTK_WIDGET(t->oops), FALSE);
6884 gdk_color_parse(XT_COLOR_RED, &color);
6885 gtk_widget_modify_base(t->oops, GTK_STATE_NORMAL, &color);
6886 gtk_box_pack_end(GTK_BOX(t->vbox), t->oops, FALSE, FALSE, 0);
6887 gtk_widget_modify_font(GTK_WIDGET(t->oops), oops_font);
6888
6889 /* command entry */
6890 t->cmd = gtk_entry_new();
6891 gtk_entry_set_inner_border(GTK_ENTRY(t->cmd), NULL);
6892 gtk_entry_set_has_frame(GTK_ENTRY(t->cmd), FALSE);
6893 gtk_box_pack_end(GTK_BOX(t->vbox), t->cmd, FALSE, FALSE, 0);
6894 gtk_widget_modify_font(GTK_WIDGET(t->cmd), cmd_font);
6895
6896 /* status bar */
6897 t->statusbar_box = gtk_hbox_new(FALSE, 0);
6898
6899 t->sbe.statusbar = gtk_entry_new();
6900 gtk_entry_set_inner_border(GTK_ENTRY(t->sbe.statusbar), NULL);
6901 gtk_entry_set_has_frame(GTK_ENTRY(t->sbe.statusbar), FALSE);
6902 gtk_widget_set_can_focus(GTK_WIDGET(t->sbe.statusbar), FALSE);
6903 gtk_widget_modify_font(GTK_WIDGET(t->sbe.statusbar), statusbar_font);
6904
6905 /* create these widgets only if specified in statusbar_elems */
6906
6907 t->sbe.position = create_sbe(40);
6908 t->sbe.zoom = create_sbe(40);
6909 t->sbe.buffercmd = create_sbe(60);
6910
6911 statusbar_modify_attr(t, XT_COLOR_WHITE, XT_COLOR_BLACK);
6912
6913 gtk_box_pack_start(GTK_BOX(t->statusbar_box), t->sbe.statusbar, TRUE,
6914 TRUE, FALSE);
6915
6916 /* gtk widgets cannot be added to a box twice. sbe_* variables
6917 make sure of this */
6918 for (p = statusbar_elems; *p != '\0'; p++) {
6919 switch (*p) {
6920 case '|':
6921 {
6922 GtkWidget *sep = gtk_vseparator_new();
6923
6924 gdk_color_parse(XT_COLOR_SB_SEPARATOR, &color);
6925 gtk_widget_modify_bg(sep, GTK_STATE_NORMAL, &color);
6926 gtk_box_pack_start(GTK_BOX(t->statusbar_box), sep,
6927 FALSE, FALSE, FALSE);
6928 break;
6929 }
6930 case 'P':
6931 if (sbe_p) {
6932 warnx("flag \"%c\" specified more than "
6933 "once in statusbar_elems\n", *p);
6934 break;
6935 }
6936 sbe_p = 1;
6937 gtk_box_pack_start(GTK_BOX(t->statusbar_box),
6938 t->sbe.position, FALSE, FALSE, FALSE);
6939 break;
6940 case 'B':
6941 if (sbe_b) {
6942 warnx("flag \"%c\" specified more than "
6943 "once in statusbar_elems\n", *p);
6944 break;
6945 }
6946 sbe_b = 1;
6947 gtk_box_pack_start(GTK_BOX(t->statusbar_box),
6948 t->sbe.buffercmd, FALSE, FALSE, FALSE);
6949 break;
6950 case 'Z':
6951 if (sbe_z) {
6952 warnx("flag \"%c\" specified more than "
6953 "once in statusbar_elems\n", *p);
6954 break;
6955 }
6956 sbe_z = 1;
6957 gtk_box_pack_start(GTK_BOX(t->statusbar_box),
6958 t->sbe.zoom, FALSE, FALSE, FALSE);
6959 break;
6960 default:
6961 warnx("illegal flag \"%c\" in statusbar_elems\n", *p);
6962 break;
6963 }
6964 }
6965
6966 gtk_box_pack_end(GTK_BOX(t->vbox), t->statusbar_box, FALSE, FALSE, 0);
6967
6968 /* buffer list */
6969 t->buffers = create_buffers(t);
6970 gtk_box_pack_end(GTK_BOX(t->vbox), t->buffers, FALSE, FALSE, 0);
6971
6972 /* xtp meaning is normal by default */
6973 t->xtp_meaning = XT_XTP_TAB_MEANING_NORMAL;
6974
6975 /* set empty favicon */
6976 xt_icon_from_name(t, "text-html");
6977
6978 /* and show it all */
6979 gtk_widget_show_all(b);
6980 gtk_widget_show_all(t->vbox);
6981
6982 /* compact tab bar */
6983 t->tab_elems.label = gtk_label_new(title);
6984 t->tab_elems.favicon = gtk_image_new();
6985 gtk_label_set_width_chars(GTK_LABEL(t->tab_elems.label), 1.0);
6986 gtk_misc_set_alignment(GTK_MISC(t->tab_elems.label), 0.0, 0.0);
6987 gtk_misc_set_padding(GTK_MISC(t->tab_elems.label), 4.0, 4.0);
6988 gtk_widget_modify_font(GTK_WIDGET(t->tab_elems.label), tabbar_font);
6989
6990 t->tab_elems.eventbox = gtk_event_box_new();
6991 t->tab_elems.box = gtk_hbox_new(FALSE, 0);
6992 t->tab_elems.sep = gtk_vseparator_new();
6993
6994 gdk_color_parse(XT_COLOR_CT_BACKGROUND, &color);
6995 gtk_widget_modify_bg(t->tab_elems.eventbox, GTK_STATE_NORMAL, &color);
6996 gdk_color_parse(XT_COLOR_CT_INACTIVE, &color);
6997 gtk_widget_modify_fg(t->tab_elems.label, GTK_STATE_NORMAL, &color);
6998 gdk_color_parse(XT_COLOR_CT_SEPARATOR, &color);
6999 gtk_widget_modify_bg(t->tab_elems.sep, GTK_STATE_NORMAL, &color);
7000
7001 gtk_box_pack_start(GTK_BOX(t->tab_elems.box), t->tab_elems.favicon, FALSE,
7002 FALSE, 0);
7003 gtk_box_pack_start(GTK_BOX(t->tab_elems.box), t->tab_elems.label, TRUE,
7004 TRUE, 0);
7005 gtk_box_pack_start(GTK_BOX(t->tab_elems.box), t->tab_elems.sep, FALSE,
7006 FALSE, 0);
7007 gtk_container_add(GTK_CONTAINER(t->tab_elems.eventbox),
7008 t->tab_elems.box);
7009
7010 gtk_box_pack_start(GTK_BOX(tab_bar), t->tab_elems.eventbox, TRUE,
7011 TRUE, 0);
7012 gtk_widget_show_all(t->tab_elems.eventbox);
7013
7014 if (append_next == 0 || gtk_notebook_get_n_pages(notebook) == 0)
7015 append_tab(t);
7016 else {
7017 id = position >= 0 ? position :
7018 gtk_notebook_get_current_page(notebook) + 1;
7019 if (id > gtk_notebook_get_n_pages(notebook))
7020 append_tab(t);
7021 else {
7022 TAILQ_INSERT_TAIL(&tabs, t, entry);
7023 gtk_notebook_insert_page(notebook, t->vbox, b, id);
7024 gtk_box_reorder_child(GTK_BOX(tab_bar),
7025 t->tab_elems.eventbox, id);
7026 recalc_tabs();
7027 }
7028 }
7029
7030 #if GTK_CHECK_VERSION(2, 20, 0)
7031 /* turn spinner off if we are a new tab without uri */
7032 if (!load) {
7033 gtk_spinner_stop(GTK_SPINNER(t->spinner));
7034 gtk_widget_hide(t->spinner);
7035 }
7036 #endif
7037 /* make notebook tabs reorderable */
7038 gtk_notebook_set_tab_reorderable(notebook, t->vbox, TRUE);
7039
7040 /* compact tabs clickable */
7041 g_signal_connect(G_OBJECT(t->tab_elems.eventbox),
7042 "button_press_event", G_CALLBACK(tab_clicked_cb), t);
7043
7044 g_object_connect(G_OBJECT(t->cmd),
7045 "signal::key-press-event", G_CALLBACK(cmd_keypress_cb), t,
7046 "signal::key-release-event", G_CALLBACK(cmd_keyrelease_cb), t,
7047 "signal::focus-out-event", G_CALLBACK(cmd_focusout_cb), t,
7048 "signal::activate", G_CALLBACK(cmd_activate_cb), t,
7049 "signal::populate-popup", G_CALLBACK(cmd_popup_cb), t,
7050 (char *)NULL);
7051
7052 /* reuse wv_button_cb to hide oops */
7053 g_object_connect(G_OBJECT(t->oops),
7054 "signal::button_press_event", G_CALLBACK(wv_button_cb), t,
7055 (char *)NULL);
7056
7057 g_signal_connect(t->buffers,
7058 "row-activated", G_CALLBACK(row_activated_cb), t);
7059 g_object_connect(G_OBJECT(t->buffers),
7060 "signal::key-press-event", G_CALLBACK(wv_keypress_cb), t, (char *)NULL);
7061
7062 g_object_connect(G_OBJECT(t->wv),
7063 "signal::key-press-event", G_CALLBACK(wv_keypress_cb), t,
7064 "signal::hovering-over-link", G_CALLBACK(webview_hover_cb), t,
7065 "signal::download-requested", G_CALLBACK(webview_download_cb), t,
7066 "signal::mime-type-policy-decision-requested", G_CALLBACK(webview_mimetype_cb), t,
7067 "signal::navigation-policy-decision-requested", G_CALLBACK(webview_npd_cb), t,
7068 "signal::new-window-policy-decision-requested", G_CALLBACK(webview_npd_cb), t,
7069 "signal::resource-request-starting", G_CALLBACK(webview_rrs_cb), t,
7070 "signal::create-web-view", G_CALLBACK(webview_cwv_cb), t,
7071 "signal::close-web-view", G_CALLBACK(webview_closewv_cb), t,
7072 "signal::event", G_CALLBACK(webview_event_cb), t,
7073 "signal::load-finished", G_CALLBACK(webview_load_finished_cb), t,
7074 "signal::load-progress-changed", G_CALLBACK(webview_progress_changed_cb), t,
7075 "signal::icon-loaded", G_CALLBACK(notify_icon_loaded_cb), t,
7076 "signal::button_press_event", G_CALLBACK(wv_button_cb), t,
7077 "signal::button_release_event", G_CALLBACK(wv_release_button_cb), t,
7078 "signal::populate-popup", G_CALLBACK(wv_popup_cb), t,
7079 (char *)NULL);
7080 g_signal_connect(t->wv,
7081 "notify::load-status", G_CALLBACK(notify_load_status_cb), t);
7082 g_signal_connect(t->wv,
7083 "notify::title", G_CALLBACK(notify_title_cb), t);
7084
7085 /* hijack the unused keys as if we were the browser */
7086 //g_object_connect(G_OBJECT(t->toolbar),
7087 // "signal-after::key-press-event", G_CALLBACK(wv_keypress_after_cb), t,
7088 // (char *)NULL);
7089
7090 g_signal_connect(G_OBJECT(bb), "button_press_event",
7091 G_CALLBACK(tab_close_cb), t);
7092
7093 /* setup history */
7094 t->bfl = webkit_web_view_get_back_forward_list(t->wv);
7095 /* restore the tab's history */
7096 if (u && u->history) {
7097 items = u->history;
7098 while (items) {
7099 item = items->data;
7100 webkit_web_back_forward_list_add_item(t->bfl, item);
7101 items = g_list_next(items);
7102 }
7103
7104 item = g_list_nth_data(u->history, u->back);
7105 if (item)
7106 webkit_web_view_go_to_back_forward_item(t->wv, item);
7107
7108 g_list_free(items);
7109 g_list_free(u->history);
7110 } else
7111 webkit_web_back_forward_list_clear(t->bfl);
7112
7113 /* hide stuff */
7114 hide_cmd(t);
7115 hide_oops(t);
7116 hide_buffers(t);
7117 url_set_visibility();
7118 statusbar_set_visibility();
7119
7120 if (focus) {
7121 set_current_tab(t->tab_id);
7122 DNPRINTF(XT_D_TAB, "create_new_tab: going to tab: %d\n",
7123 t->tab_id);
7124
7125 if (load) {
7126 gtk_entry_set_text(GTK_ENTRY(t->uri_entry), title);
7127 load_uri(t, title);
7128 } else {
7129 if (show_url == 1)
7130 gtk_widget_grab_focus(GTK_WIDGET(t->uri_entry));
7131 else
7132 focus_webview(t);
7133 }
7134 } else if (load)
7135 load_uri(t, title);
7136
7137 if (userstyle_global)
7138 apply_style(t);
7139
7140 recolor_compact_tabs();
7141 setzoom_webkit(t, XT_ZOOM_NORMAL);
7142 return (t);
7143 }
7144
7145 void
7146 notebook_switchpage_cb(GtkNotebook *nb, GtkWidget *nbp, guint pn,
7147 gpointer *udata)
7148 {
7149 struct tab *t;
7150 const gchar *uri;
7151
7152 DNPRINTF(XT_D_TAB, "notebook_switchpage_cb: tab: %d\n", pn);
7153
7154 if (gtk_notebook_get_current_page(notebook) == -1)
7155 recalc_tabs();
7156
7157 TAILQ_FOREACH(t, &tabs, entry) {
7158 if (t->tab_id == pn) {
7159 DNPRINTF(XT_D_TAB, "notebook_switchpage_cb: going to "
7160 "%d\n", pn);
7161
7162 uri = get_title(t, TRUE);
7163 gtk_window_set_title(GTK_WINDOW(main_window), uri);
7164
7165 hide_cmd(t);
7166 hide_oops(t);
7167
7168 if (t->focus_wv) {
7169 /* can't use focus_webview here */
7170 gtk_widget_grab_focus(GTK_WIDGET(t->wv));
7171 }
7172 }
7173 }
7174 }
7175
7176 void
7177 notebook_pagereordered_cb(GtkNotebook *nb, GtkWidget *nbp, guint pn,
7178 gpointer *udata)
7179 {
7180 struct tab *t = NULL, *tt;
7181
7182 recalc_tabs();
7183
7184 TAILQ_FOREACH(tt, &tabs, entry)
7185 if (tt->tab_id == pn) {
7186 t = tt;
7187 break;
7188 }
7189 if (t == NULL)
7190 return;
7191 DNPRINTF(XT_D_TAB, "page_reordered_cb: tab: %d\n", t->tab_id);
7192
7193 gtk_box_reorder_child(GTK_BOX(tab_bar), t->tab_elems.eventbox,
7194 t->tab_id);
7195 }
7196
7197 void
7198 menuitem_response(struct tab *t)
7199 {
7200 gtk_notebook_set_current_page(notebook, t->tab_id);
7201 }
7202
7203 gboolean
7204 arrow_cb(GtkWidget *w, GdkEventButton *event, gpointer user_data)
7205 {
7206 GtkWidget *menu, *menu_items;
7207 GdkEventButton *bevent;
7208 const gchar *uri;
7209 struct tab *ti;
7210
7211 if (event->type == GDK_BUTTON_PRESS) {
7212 bevent = (GdkEventButton *) event;
7213 menu = gtk_menu_new();
7214
7215 TAILQ_FOREACH(ti, &tabs, entry) {
7216 if ((uri = get_uri(ti)) == NULL)
7217 /* XXX make sure there is something to print */
7218 /* XXX add gui pages in here to look purdy */
7219 uri = "(untitled)";
7220 menu_items = gtk_menu_item_new_with_label(uri);
7221 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
7222 gtk_widget_show(menu_items);
7223
7224 g_signal_connect_swapped((menu_items),
7225 "activate", G_CALLBACK(menuitem_response),
7226 (gpointer)ti);
7227 }
7228
7229 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
7230 bevent->button, bevent->time);
7231
7232 /* unref object so it'll free itself when popped down */
7233 #if !GTK_CHECK_VERSION(3, 0, 0)
7234 /* XXX does not need unref with gtk+3? */
7235 g_object_ref_sink(menu);
7236 g_object_unref(menu);
7237 #endif
7238
7239 return (TRUE /* eat event */);
7240 }
7241
7242 return (FALSE /* propagate */);
7243 }
7244
7245 int
7246 icon_size_map(int iconsz)
7247 {
7248 if (iconsz <= GTK_ICON_SIZE_INVALID ||
7249 iconsz > GTK_ICON_SIZE_DIALOG)
7250 return (GTK_ICON_SIZE_SMALL_TOOLBAR);
7251
7252 return (iconsz);
7253 }
7254
7255 GtkWidget *
7256 create_button(char *name, char *stockid, int size)
7257 {
7258 GtkWidget *button, *image;
7259 gchar *rcstring;
7260 int gtk_icon_size;
7261
7262 rcstring = g_strdup_printf(
7263 "style \"%s-style\"\n"
7264 "{\n"
7265 " GtkWidget::focus-padding = 0\n"
7266 " GtkWidget::focus-line-width = 0\n"
7267 " xthickness = 0\n"
7268 " ythickness = 0\n"
7269 "}\n"
7270 "widget \"*.%s\" style \"%s-style\"", name, name, name);
7271 gtk_rc_parse_string(rcstring);
7272 g_free(rcstring);
7273 button = gtk_button_new();
7274 gtk_button_set_focus_on_click(GTK_BUTTON(button), FALSE);
7275 gtk_icon_size = icon_size_map(size ? size : icon_size);
7276
7277 image = gtk_image_new_from_stock(stockid, gtk_icon_size);
7278 gtk_widget_set_size_request(GTK_WIDGET(image), -1, -1);
7279 gtk_container_set_border_width(GTK_CONTAINER(button), 1);
7280 gtk_container_add(GTK_CONTAINER(button), GTK_WIDGET(image));
7281 gtk_widget_set_name(button, name);
7282 gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
7283
7284 return (button);
7285 }
7286
7287 void
7288 button_set_stockid(GtkWidget *button, char *stockid)
7289 {
7290 GtkWidget *image;
7291
7292 image = gtk_image_new_from_stock(stockid, icon_size_map(icon_size));
7293 gtk_widget_set_size_request(GTK_WIDGET(image), -1, -1);
7294 gtk_button_set_image(GTK_BUTTON(button), image);
7295 }
7296
7297 void
7298 clipb_primary_cb(GtkClipboard *primary, GdkEvent *event, gpointer notused)
7299 {
7300 gchar *p = NULL;
7301 GdkAtom atom = gdk_atom_intern("CUT_BUFFER0", FALSE);
7302 gint len;
7303
7304 if (xterm_workaround == 0)
7305 return;
7306
7307 /*
7308 * xterm doesn't play nice with clipboards because it clears the
7309 * primary when clicked. We rely on primary being set to properly
7310 * handle middle mouse button clicks (paste). So when someone clears
7311 * primary copy whatever is in CUT_BUFFER0 into primary to simualte
7312 * other application behavior (as in DON'T clear primary).
7313 */
7314
7315 p = gtk_clipboard_wait_for_text(primary);
7316 if (p == NULL) {
7317 if (gdk_property_get(gdk_get_default_root_window(),
7318 atom,
7319 gdk_atom_intern("STRING", FALSE),
7320 0,
7321 1024 * 1024 /* picked out of my butt */,
7322 FALSE,
7323 NULL,
7324 NULL,
7325 &len,
7326 (guchar **)&p)) {
7327 if (p == NULL)
7328 return;
7329 /* yes sir, we need to NUL the string */
7330 p[len] = '\0';
7331 gtk_clipboard_set_text(primary, p, -1);
7332 }
7333 }
7334
7335 if (p)
7336 g_free(p);
7337 }
7338
7339 void
7340 create_canvas(void)
7341 {
7342 GtkWidget *vbox;
7343 GList *l = NULL;
7344 GdkPixbuf *pb;
7345 char file[PATH_MAX];
7346 int i;
7347
7348 vbox = gtk_vbox_new(FALSE, 0);
7349 gtk_box_set_spacing(GTK_BOX(vbox), 0);
7350 notebook = GTK_NOTEBOOK(gtk_notebook_new());
7351 #if !GTK_CHECK_VERSION(3, 0, 0)
7352 /* XXX seems to be needed with gtk+2 */
7353 gtk_notebook_set_tab_hborder(notebook, 0);
7354 gtk_notebook_set_tab_vborder(notebook, 0);
7355 #endif
7356 gtk_notebook_set_scrollable(notebook, TRUE);
7357 gtk_notebook_set_show_border(notebook, FALSE);
7358 gtk_widget_set_can_focus(GTK_WIDGET(notebook), FALSE);
7359
7360 abtn = gtk_button_new();
7361 arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
7362 gtk_widget_set_size_request(arrow, -1, -1);
7363 gtk_container_add(GTK_CONTAINER(abtn), arrow);
7364 gtk_widget_set_size_request(abtn, -1, 20);
7365
7366 #if GTK_CHECK_VERSION(2, 20, 0)
7367 gtk_notebook_set_action_widget(notebook, abtn, GTK_PACK_END);
7368 #endif
7369 gtk_widget_set_size_request(GTK_WIDGET(notebook), -1, -1);
7370
7371 /* compact tab bar */
7372 tab_bar = gtk_hbox_new(TRUE, 0);
7373
7374 gtk_box_pack_start(GTK_BOX(vbox), tab_bar, FALSE, FALSE, 0);
7375 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(notebook), TRUE, TRUE, 0);
7376 gtk_widget_set_size_request(vbox, -1, -1);
7377
7378 g_object_connect(G_OBJECT(notebook),
7379 "signal::switch-page", G_CALLBACK(notebook_switchpage_cb), NULL,
7380 (char *)NULL);
7381 g_object_connect(G_OBJECT(notebook),
7382 "signal::page-reordered", G_CALLBACK(notebook_pagereordered_cb),
7383 NULL, (char *)NULL);
7384 g_signal_connect(G_OBJECT(abtn), "button_press_event",
7385 G_CALLBACK(arrow_cb), NULL);
7386
7387 main_window = create_window("xxxterm");
7388 gtk_container_add(GTK_CONTAINER(main_window), vbox);
7389 g_signal_connect(G_OBJECT(main_window), "delete_event",
7390 G_CALLBACK(gtk_main_quit), NULL);
7391
7392 /* icons */
7393 for (i = 0; i < LENGTH(icons); i++) {
7394 snprintf(file, sizeof file, "%s" PS "%s", resource_dir, icons[i]);
7395 pb = gdk_pixbuf_new_from_file(file, NULL);
7396 l = g_list_append(l, pb);
7397 }
7398 gtk_window_set_default_icon_list(l);
7399
7400 /* clipboard work around */
7401 if (xterm_workaround)
7402 g_signal_connect(
7403 G_OBJECT(gtk_clipboard_get(GDK_SELECTION_PRIMARY)),
7404 "owner-change", G_CALLBACK(clipb_primary_cb), NULL);
7405
7406 gtk_widget_show_all(abtn);
7407 gtk_widget_show_all(main_window);
7408 notebook_tab_set_visibility();
7409 }
7410
7411 #ifndef XT_SOCKET_DISABLE
7412 int
7413 send_cmd_to_socket(char *cmd)
7414 {
7415 int s, len, rv = 1;
7416 struct sockaddr_un sa;
7417
7418 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
7419 warnx("%s: socket", __func__);
7420 return (rv);
7421 }
7422
7423 sa.sun_family = AF_UNIX;
7424 snprintf(sa.sun_path, sizeof(sa.sun_path), "%s" PS "%s",
7425 work_dir, XT_SOCKET_FILE);
7426 len = SUN_LEN(&sa);
7427
7428 if (connect(s, (struct sockaddr *)&sa, len) == -1) {
7429 warnx("%s: connect", __func__);
7430 goto done;
7431 }
7432
7433 if (send(s, cmd, strlen(cmd) + 1, 0) == -1) {
7434 warnx("%s: send", __func__);
7435 goto done;
7436 }
7437
7438 rv = 0;
7439 done:
7440 close(s);
7441 return (rv);
7442 }
7443
7444 gboolean
7445 socket_watcher(GIOChannel *source, GIOCondition condition, gpointer data)
7446 {
7447 int s, n;
7448 char str[XT_MAX_URL_LENGTH];
7449 socklen_t t = sizeof(struct sockaddr_un);
7450 struct sockaddr_un sa;
7451 struct passwd *p;
7452 uid_t uid;
7453 gid_t gid;
7454 struct tab *tt;
7455 gint fd = g_io_channel_unix_get_fd(source);
7456
7457 if ((s = accept(fd, (struct sockaddr *)&sa, &t)) == -1) {
7458 warn("accept");
7459 return (FALSE);
7460 }
7461
7462 if (getpeereid(s, &uid, &gid) == -1) {
7463 warn("getpeereid");
7464 return (FALSE);
7465 }
7466 if (uid != getuid() || gid != getgid()) {
7467 warnx("unauthorized user");
7468 return (FALSE);
7469 }
7470
7471 p = getpwuid(uid);
7472 if (p == NULL) {
7473 warnx("not a valid user");
7474 return (FALSE);
7475 }
7476
7477 n = recv(s, str, sizeof(str), 0);
7478 if (n <= 0)
7479 return (TRUE);
7480
7481 tt = TAILQ_LAST(&tabs, tab_list);
7482 cmd_execute(tt, str);
7483 return (TRUE);
7484 }
7485
7486 int
7487 is_running(void)
7488 {
7489 int s, len, rv = 1;
7490 struct sockaddr_un sa;
7491
7492 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
7493 warn("is_running: socket");
7494 return (-1);
7495 }
7496
7497 sa.sun_family = AF_UNIX;
7498 snprintf(sa.sun_path, sizeof(sa.sun_path), "%s" PS "%s",
7499 work_dir, XT_SOCKET_FILE);
7500 len = SUN_LEN(&sa);
7501
7502 /* connect to see if there is a listener */
7503 if (connect(s, (struct sockaddr *)&sa, len) == -1)
7504 rv = 0; /* not running */
7505 else
7506 rv = 1; /* already running */
7507
7508 close(s);
7509
7510 return (rv);
7511 }
7512
7513 int
7514 build_socket(void)
7515 {
7516 int s, len;
7517 struct sockaddr_un sa;
7518
7519 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
7520 warn("build_socket: socket");
7521 return (-1);
7522 }
7523
7524 sa.sun_family = AF_UNIX;
7525 snprintf(sa.sun_path, sizeof(sa.sun_path), "%s" PS "%s",
7526 work_dir, XT_SOCKET_FILE);
7527 len = SUN_LEN(&sa);
7528
7529 /* connect to see if there is a listener */
7530 if (connect(s, (struct sockaddr *)&sa, len) == -1) {
7531 /* no listener so we will */
7532 unlink(sa.sun_path);
7533
7534 if (bind(s, (struct sockaddr *)&sa, len) == -1) {
7535 warn("build_socket: bind");
7536 goto done;
7537 }
7538
7539 if (listen(s, 1) == -1) {
7540 warn("build_socket: listen");
7541 goto done;
7542 }
7543
7544 return (s);
7545 }
7546
7547 done:
7548 close(s);
7549 return (-1);
7550 }
7551 #endif
7552
7553 void
7554 xxx_dir(char *dir)
7555 {
7556 struct stat sb;
7557
7558 if (stat(dir, &sb)) {
7559 #if defined __MINGW32__
7560 printf("making: %s\n", dir);
7561 if (mkdir(dir) == -1)
7562 #else
7563 if (mkdir(dir, S_IRWXU) == -1)
7564 #endif
7565 err(1, "mkdir %s", dir);
7566 if (stat(dir, &sb))
7567 err(1, "stat %s", dir);
7568 }
7569 if (S_ISDIR(sb.st_mode) == 0)
7570 errx(1, "%s not a dir", dir);
7571 #if !defined __MINGW32__
7572 if (((sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO))) != S_IRWXU) {
7573 warnx("fixing invalid permissions on %s", dir);
7574 if (chmod(dir, S_IRWXU) == -1)
7575 err(1, "chmod %s", dir);
7576 }
7577 #endif
7578 }
7579
7580 void
7581 usage(void)
7582 {
7583 fprintf(stderr,
7584 "%s [-nSTVt][-f file][-s session] url ...\n", __progname);
7585 exit(0);
7586 }
7587
7588 GStaticRecMutex my_gdk_mtx = G_STATIC_REC_MUTEX_INIT;
7589 volatile int mtx_depth;
7590 int mtx_complain;
7591
7592 /*
7593 * The linux flash plugin violates the gdk locking mechanism.
7594 * Work around the issue by using a recursive mutex with some match applied
7595 * to see if we hit a buggy condition.
7596 *
7597 * The following code is painful so just don't read it. It really doesn't
7598 * make much sense but seems to work.
7599 */
7600 void
7601 mtx_lock(void)
7602 {
7603 g_static_rec_mutex_lock(&my_gdk_mtx);
7604 mtx_depth++;
7605
7606 if (mtx_depth <= 0) {
7607 /* should not happen */
7608 show_oops(NULL, "negative mutex locking bug, trying to "
7609 "correct");
7610 fprintf(stderr, "negative mutex locking bug, trying to "
7611 "correct\n");
7612 g_static_rec_mutex_unlock_full(&my_gdk_mtx);
7613 g_static_rec_mutex_lock(&my_gdk_mtx);
7614 mtx_depth = 1;
7615 return;
7616 }
7617
7618 if (mtx_depth != 1) {
7619 /* decrease mutext depth to 1 */
7620 do {
7621 g_static_rec_mutex_unlock(&my_gdk_mtx);
7622 mtx_depth--;
7623 } while (mtx_depth > 1);
7624 }
7625 }
7626
7627 void
7628 mtx_unlock(void)
7629 {
7630 guint x;
7631
7632 /* if mutex depth isn't 1 then something went bad */
7633 if (mtx_depth != 1) {
7634 x = g_static_rec_mutex_unlock_full(&my_gdk_mtx);
7635 if (x != 1) {
7636 /* should not happen */
7637 show_oops(NULL, "mutex unlocking bug, trying to "
7638 "correct");
7639 fprintf(stderr, "mutex unlocking bug, trying to "
7640 "correct\n");
7641 }
7642 mtx_depth = 0;
7643 if (mtx_complain == 0) {
7644 show_oops(NULL, "buggy mutex implementation detected, "
7645 "work around implemented");
7646 fprintf(stderr, "buggy mutex implementation detected, "
7647 "work around implemented");
7648 mtx_complain = 1;
7649 }
7650 return;
7651 }
7652
7653 mtx_depth--;
7654 g_static_rec_mutex_unlock(&my_gdk_mtx);
7655 }
7656
7657 void
7658 welcome(void)
7659 {
7660 startpage_add("<b>Welcome to xxxterm %s!</b><p>", version);
7661 startpage_add("Beware that this is the final version that will use the"
7662 " xxxterm name.<br>Moving forward the browser will be called "
7663 "xombrero.<p>", version);
7664 startpage_add("Details will soon appear on the "
7665 "<a href=https://opensource.conformal.com/wiki/xombrero>xombrero "
7666 "wiki page</a><p>");
7667 startpage_add("Unfortunately scroogle has shut it's doors and due to "
7668 "that one has to edit search_string in ~/.xxxterm.conf.<br>"
7669 "There are various examples in the configuration file.<br>"
7670 "The authors of xxxterm are not in a position to suggest a search "
7671 "engine.");
7672 }
7673
7674 int
7675 main(int argc, char **argv)
7676 {
7677 struct stat sb;
7678 int c, optn = 0, opte = 0, focus = 1;
7679 char conf[PATH_MAX] = { '\0' };
7680 char file[PATH_MAX];
7681 char sodversion[32];
7682 char *env_proxy = NULL;
7683 FILE *f = NULL;
7684 struct karg a;
7685
7686 start_argv = (char * const *)argv;
7687
7688 /* prepare gtk */
7689 #ifdef USE_THREADS
7690 /* http://web.archiveorange.com/archive/v/UsPjxkX5PsaXBIoOjqxf */
7691 XInitThreads();
7692
7693 /* http://developer.gnome.org/gdk/stable/gdk-Threads.html */
7694 g_thread_init(NULL);
7695 gdk_threads_set_lock_functions(mtx_lock, mtx_unlock);
7696 gdk_threads_init();
7697 gdk_threads_enter();
7698
7699 /* http://www.gnupg.org/documentation/manuals/gcrypt/Multi_002dThreading.html */
7700 gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
7701 #endif
7702 gtk_init(&argc, &argv);
7703
7704 gnutls_global_init();
7705
7706 strlcpy(named_session, XT_SAVED_TABS_FILE, sizeof named_session);
7707
7708 RB_INIT(&hl);
7709 RB_INIT(&js_wl);
7710 RB_INIT(&pl_wl);
7711 RB_INIT(&downloads);
7712 RB_INIT(&st_tree);
7713
7714 TAILQ_INIT(&sessions);
7715 TAILQ_INIT(&tabs);
7716 TAILQ_INIT(&mtl);
7717 TAILQ_INIT(&aliases);
7718 TAILQ_INIT(&undos);
7719 TAILQ_INIT(&kbl);
7720 TAILQ_INIT(&spl);
7721 TAILQ_INIT(&chl);
7722 TAILQ_INIT(&shl);
7723 TAILQ_INIT(&ua_list);
7724
7725 #ifndef XT_RESOURCE_LIMITS_DISABLE
7726 struct rlimit rlp;
7727 char *cmd = NULL;
7728 int s;
7729 GIOChannel *channel;
7730
7731 /* fiddle with ulimits */
7732 if (getrlimit(RLIMIT_NOFILE, &rlp) == -1)
7733 warn("getrlimit");
7734 else {
7735 /* just use them all */
7736 rlp.rlim_cur = rlp.rlim_max;
7737 if (setrlimit(RLIMIT_NOFILE, &rlp) == -1)
7738 warn("setrlimit");
7739 if (getrlimit(RLIMIT_NOFILE, &rlp) == -1)
7740 warn("getrlimit");
7741 else if (rlp.rlim_cur < 1024)
7742 startpage_add("%s requires at least 1024 "
7743 "(2048 recommended) file " "descriptors, "
7744 "currently it has up to %d available",
7745 __progname, rlp.rlim_cur);
7746 }
7747 #endif
7748
7749 while ((c = getopt(argc, argv, "STVf:s:tne")) != -1) {
7750 switch (c) {
7751 case 'S':
7752 show_url = 0;
7753 break;
7754 case 'T':
7755 show_tabs = 0;
7756 break;
7757 case 'V':
7758 #ifdef XXXTERM_BUILDSTR
7759 errx(0 , "Version: %s Build: %s",
7760 version, XXXTERM_BUILDSTR);
7761 #else
7762 errx(0 , "Version: %s", version);
7763 #endif
7764 break;
7765 case 'f':
7766 strlcpy(conf, optarg, sizeof(conf));
7767 break;
7768 case 's':
7769 strlcpy(named_session, optarg, sizeof(named_session));
7770 break;
7771 case 't':
7772 tabless = 1;
7773 break;
7774 case 'n':
7775 optn = 1;
7776 break;
7777 case 'e':
7778 opte = 1;
7779 break;
7780 default:
7781 usage();
7782 /* NOTREACHED */
7783 }
7784 }
7785 argc -= optind;
7786 argv += optind;
7787
7788 init_keybindings();
7789
7790 xtp_generate_keys();
7791
7792 /* XXX this hammer is way too big but treat all signaling the same */
7793 #ifndef XT_SIGNALS_DISABLE
7794 /* signals */
7795 struct sigaction sact;
7796
7797 bzero(&sact, sizeof(sact));
7798 sigemptyset(&sact.sa_mask);
7799 sact.sa_handler = sigchild;
7800 sact.sa_flags = SA_NOCLDSTOP;
7801 sigaction(SIGCHLD, &sact, NULL);
7802 #endif
7803
7804 /* set download dir */
7805 pwd = getpwuid(getuid());
7806 if (pwd == NULL)
7807 errx(1, "invalid user %d", getuid());
7808 strlcpy(download_dir, pwd->pw_dir, sizeof download_dir);
7809
7810 /* compile buffer command regexes */
7811 buffercmd_init();
7812
7813 /* set default string settings */
7814 home = g_strdup("https://www.cyphertite.com");
7815 search_string = g_strdup("https://ssl.scroogle.org/cgi-bin/nbbwssl.cgi?Gw=%s");
7816 resource_dir = g_strdup("/usr/local/share/xxxterm/");
7817 strlcpy(runtime_settings, "runtime", sizeof runtime_settings);
7818 cmd_font_name = g_strdup("monospace normal 9");
7819 oops_font_name = g_strdup("monospace normal 9");
7820 statusbar_font_name = g_strdup("monospace normal 9");
7821 tabbar_font_name = g_strdup("monospace normal 9");
7822 statusbar_elems = g_strdup("BP");
7823 spell_check_languages = g_strdup("en_US");
7824 encoding = g_strdup("UTF-8");
7825
7826 /* read config file */
7827 if (strlen(conf) == 0)
7828 snprintf(conf, sizeof conf, "%s" PS ".%s",
7829 pwd->pw_dir, XT_CONF_FILE);
7830 config_parse(conf, 0);
7831
7832 /* init fonts */
7833 cmd_font = pango_font_description_from_string(cmd_font_name);
7834 oops_font = pango_font_description_from_string(oops_font_name);
7835 statusbar_font = pango_font_description_from_string(statusbar_font_name);
7836 tabbar_font = pango_font_description_from_string(tabbar_font_name);
7837
7838 /* working directory */
7839 if (strlen(work_dir) == 0)
7840 snprintf(work_dir, sizeof work_dir, "%s" PS "%s",
7841 pwd->pw_dir, XT_DIR);
7842 xxx_dir(work_dir);
7843
7844 /* icon cache dir */
7845 snprintf(cache_dir, sizeof cache_dir, "%s" PS "%s", work_dir, XT_CACHE_DIR);
7846 xxx_dir(cache_dir);
7847
7848 /* certs dir */
7849 snprintf(certs_dir, sizeof certs_dir, "%s" PS "%s", work_dir, XT_CERT_DIR);
7850 xxx_dir(certs_dir);
7851
7852 /* sessions dir */
7853 snprintf(sessions_dir, sizeof sessions_dir, "%s" PS "%s",
7854 work_dir, XT_SESSIONS_DIR);
7855 xxx_dir(sessions_dir);
7856
7857 /* js dir */
7858 snprintf(js_dir, sizeof js_dir, "%s" PS "%s", work_dir, XT_JS_DIR);
7859 xxx_dir(js_dir);
7860
7861 /* temp dir */
7862 snprintf(temp_dir, sizeof temp_dir, "%s" PS "%s", work_dir, XT_TEMP_DIR);
7863 xxx_dir(temp_dir);
7864
7865 /* runtime settings that can override config file */
7866 if (runtime_settings[0] != '\0')
7867 config_parse(runtime_settings, 1);
7868
7869 /* download dir */
7870 if (!strcmp(download_dir, pwd->pw_dir))
7871 strlcat(download_dir, PS "downloads", sizeof download_dir);
7872 xxx_dir(download_dir);
7873
7874 /* first start file */
7875 snprintf(file, sizeof file, "%s" PS "%s", work_dir, XT_SOD_FILE);
7876 if (stat(file, &sb)) {
7877 warnx("start of day file doesn't exist, creating it");
7878 if ((f = fopen(file, "w")) == NULL)
7879 err(1, "startofday");
7880 if (fputs(version, f) == EOF)
7881 err(1, "fputs");
7882 fclose(f);
7883
7884 /* welcome user */
7885 welcome();
7886 } else {
7887 if ((f = fopen(file, "r+")) == NULL)
7888 err(1, "startofday");
7889 if (fgets(sodversion, sizeof sodversion, f) == NULL)
7890 err(1, "fgets");
7891 sodversion[strcspn(sodversion, "\n")] = '\0';
7892 if (strcmp(version, sodversion)) {
7893 rewind(f);
7894 if (fputs(version, f) == EOF)
7895 err(1, "fputs");
7896
7897 /* upgrade, say something smart */
7898 welcome();
7899 }
7900 fclose(f);
7901 }
7902
7903 /* favorites file */
7904 snprintf(file, sizeof file, "%s" PS "%s", work_dir, XT_FAVS_FILE);
7905 if (stat(file, &sb)) {
7906 warnx("favorites file doesn't exist, creating it");
7907 if ((f = fopen(file, "w")) == NULL)
7908 err(1, "favorites");
7909 fclose(f);
7910 }
7911
7912 /* quickmarks file */
7913 snprintf(file, sizeof file, "%s" PS "%s", work_dir, XT_QMARKS_FILE);
7914 if (stat(file, &sb)) {
7915 warnx("quickmarks file doesn't exist, creating it");
7916 if ((f = fopen(file, "w")) == NULL)
7917 err(1, "quickmarks");
7918 fclose(f);
7919 }
7920
7921 /* search history */
7922 if (history_autosave) {
7923 snprintf(search_file, sizeof search_file, "%s" PS "%s",
7924 work_dir, XT_SEARCH_FILE);
7925 if (stat(search_file, &sb)) {
7926 warnx("search history file doesn't exist, creating it");
7927 if ((f = fopen(search_file, "w")) == NULL)
7928 err(1, "search_history");
7929 fclose(f);
7930 }
7931 history_read(&shl, search_file, &search_history_count);
7932 }
7933
7934 /* command history */
7935 if (history_autosave) {
7936 snprintf(command_file, sizeof command_file, "%s" PS "%s",
7937 work_dir, XT_COMMAND_FILE);
7938 if (stat(command_file, &sb)) {
7939 warnx("command history file doesn't exist, creating it");
7940 if ((f = fopen(command_file, "w")) == NULL)
7941 err(1, "command_history");
7942 fclose(f);
7943 }
7944 history_read(&chl, command_file, &cmd_history_count);
7945 }
7946
7947 /* cookies */
7948 session = webkit_get_default_session();
7949 setup_cookies();
7950
7951 /* certs */
7952 set_ssl_ca_file(ssl_ca_file);
7953
7954 /* guess_search regex */
7955 if (url_regex == NULL)
7956 url_regex = g_strdup(XT_URL_REGEX);
7957 if (url_regex)
7958 if (regcomp(&url_re, url_regex, REG_EXTENDED | REG_NOSUB))
7959 startpage_add("invalid url regex %s", url_regex);
7960
7961 /* proxy */
7962 env_proxy = getenv("http_proxy");
7963 if (env_proxy)
7964 setup_proxy(env_proxy);
7965 else {
7966 env_proxy = getenv("HTTP_PROXY");
7967 if (env_proxy)
7968 setup_proxy(env_proxy);
7969 else
7970 setup_proxy(http_proxy);
7971 }
7972 #ifndef XT_SOCKET_DISABLE
7973 if (opte) {
7974 send_cmd_to_socket(argv[0]);
7975 exit(0);
7976 }
7977 #else
7978 opte = opte; /* shut mingw up */
7979 #endif
7980 /* set some connection parameters */
7981 g_object_set(session, "max-conns", max_connections, (char *)NULL);
7982 g_object_set(session, "max-conns-per-host", max_host_connections,
7983 (char *)NULL);
7984
7985 g_signal_connect(session, "request-queued", G_CALLBACK(session_rq_cb),
7986 NULL);
7987
7988 #ifndef XT_SOCKET_DISABLE
7989 /* see if there is already an xxxterm running */
7990 if (single_instance && is_running()) {
7991 optn = 1;
7992 warnx("already running");
7993 }
7994
7995 if (optn) {
7996 while (argc) {
7997 cmd = g_strdup_printf("%s %s", "tabnew", argv[0]);
7998 send_cmd_to_socket(cmd);
7999 if (cmd)
8000 g_free(cmd);
8001
8002 argc--;
8003 argv++;
8004 }
8005 exit(0);
8006 }
8007 #else
8008 optn = optn; /* shut mingw up */
8009 #endif
8010 /* tld list */
8011 tld_tree_init();
8012
8013 if (enable_strict_transport)
8014 strict_transport_init();
8015
8016 /* uri completion */
8017 completion_model = gtk_list_store_new(1, G_TYPE_STRING);
8018
8019 /* buffers */
8020 buffers_store = gtk_list_store_new
8021 (NUM_COLS, G_TYPE_UINT, GDK_TYPE_PIXBUF, G_TYPE_STRING);
8022
8023 qmarks_load();
8024
8025 /* go graphical */
8026 create_canvas();
8027 notebook_tab_set_visibility();
8028
8029 if (save_global_history)
8030 restore_global_history();
8031
8032 /* restore session list */
8033 restore_sessions_list();
8034
8035 if (!strcmp(named_session, XT_SAVED_TABS_FILE))
8036 restore_saved_tabs();
8037 else {
8038 a.s = named_session;
8039 a.i = XT_SES_DONOTHING;
8040 open_tabs(NULL, &a);
8041 }
8042
8043 /* see if we have an exception */
8044 if (!TAILQ_EMPTY(&spl)) {
8045 create_new_tab("about:startpage", NULL, focus, -1);
8046 focus = 0;
8047 }
8048
8049 while (argc) {
8050 create_new_tab(argv[0], NULL, focus, -1);
8051 focus = 0;
8052
8053 argc--;
8054 argv++;
8055 }
8056
8057 if (TAILQ_EMPTY(&tabs))
8058 create_new_tab(home, NULL, 1, -1);
8059 #ifndef XT_SOCKET_DISABLE
8060 if (enable_socket)
8061 if ((s = build_socket()) != -1) {
8062 channel = g_io_channel_unix_new(s);
8063 g_io_add_watch(channel, G_IO_IN, socket_watcher, NULL);
8064 }
8065 #endif
8066
8067 gtk_main();
8068
8069 #ifdef USE_THREADS
8070 gdk_flush();
8071 gdk_threads_leave();
8072 g_static_rec_mutex_unlock_full(&my_gdk_mtx); /* just in case */
8073 #endif
8074
8075 gnutls_global_deinit();
8076
8077 if (url_regex)
8078 regfree(&url_re);
8079
8080 return (0);
8081 }
XXXTerm