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