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