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