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