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