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