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