surf.c

   1 /* See LICENSE file for copyright and license details.
   2  *
   3  * To understand surf, start reading main().
   4  */
   5
   6 #include <signal.h>
   7 #include <X11/X.h>
   8 #include <X11/Xatom.h>
   9 #include <gtk/gtk.h>
  10 #include <gdk/gdkx.h>
  11 #include <gdk/gdk.h>
  12 #include <gdk/gdkkeysyms.h>
  13 #include <string.h>
  14 #include <sys/types.h>
  15 #include <sys/wait.h>
  16 #include <unistd.h>
  17 #include <limits.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <webkit/webkit.h>
  21 #include <glib/gstdio.h>
  22 #include <JavaScriptCore/JavaScript.h>
  23 #include <sys/file.h>
  24 #include <libgen.h>
  25 #include <stdarg.h>
  26 #include <regex.h>
  27
  28 #include "arg.h"
  29
  30 char *argv0;
  31
  32 #define LENGTH(x)               (sizeof x / sizeof x[0])
  33 #define CLEANMASK(mask)         (mask & (MODKEY|GDK_SHIFT_MASK))
  34 #define COOKIEJAR_TYPE          (cookiejar_get_type ())
  35 #define COOKIEJAR(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), COOKIEJAR_TYPE, CookieJar))
  36
  37 enum { AtomFind, AtomGo, AtomUri, AtomLast };
  38
  39 typedef union Arg Arg;
  40 union Arg {
  41         gboolean b;
  42         gint i;
  43         const void *v;
  44 };
  45
  46 typedef struct Client {
  47         GtkWidget *win, *scroll, *vbox, *pane;
  48         WebKitWebView *view;
  49         WebKitWebInspector *inspector;
  50         char *title, *linkhover;
  51         const char *needle;
  52         gint progress;
  53         struct Client *next;
  54         gboolean zoomed, fullscreen, isinspecting, sslfailed;
  55 } Client;
  56
  57 typedef struct {
  58         guint mod;
  59         guint keyval;
  60         void (*func)(Client *c, const Arg *arg);
  61         const Arg arg;
  62 } Key;
  63
  64 typedef struct {
  65         SoupCookieJarText parent_instance;
  66         int lock;
  67 } CookieJar;
  68
  69 typedef struct {
  70         SoupCookieJarTextClass parent_class;
  71 } CookieJarClass;
  72
  73 G_DEFINE_TYPE(CookieJar, cookiejar, SOUP_TYPE_COOKIE_JAR_TEXT)
  74
  75 typedef struct {
  76         char *regex;
  77         char *style;
  78         regex_t re;
  79 } SiteStyle;
  80
  81 static Display *dpy;
  82 static Atom atoms[AtomLast];
  83 static Client *clients = NULL;
  84 static GdkNativeWindow embed = 0;
  85 static gboolean showxid = FALSE;
  86 static char winid[64];
  87 static gboolean usingproxy = 0;
  88 static char togglestat[8];
  89 static char pagestat[3];
  90 static GTlsDatabase *tlsdb;
  91 static int policysel = 0;
  92 static char *stylefile = NULL;
  93
  94 static void addaccelgroup(Client *c);
  95 static void beforerequest(WebKitWebView *w, WebKitWebFrame *f,
  96                 WebKitWebResource *r, WebKitNetworkRequest *req,
  97                 WebKitNetworkResponse *resp, gpointer d);
  98 static char *buildpath(const char *path);
  99 static gboolean buttonrelease(WebKitWebView *web, GdkEventButton *e,
 100                 GList *gl);
 101 static void cleanup(void);
 102 static void clipboard(Client *c, const Arg *arg);
 103
 104 /* Cookiejar implementation */
 105 static void cookiejar_changed(SoupCookieJar *self, SoupCookie *old_cookie,
 106                 SoupCookie *new_cookie);
 107 static void cookiejar_finalize(GObject *self);
 108 static SoupCookieJarAcceptPolicy cookiepolicy_get(void);
 109 static SoupCookieJar *cookiejar_new(const char *filename, gboolean read_only,
 110                 SoupCookieJarAcceptPolicy policy);
 111 static void cookiejar_set_property(GObject *self, guint prop_id,
 112                 const GValue *value, GParamSpec *pspec);
 113 static char cookiepolicy_set(const SoupCookieJarAcceptPolicy p);
 114
 115 static char *copystr(char **str, const char *src);
 116 static WebKitWebView *createwindow(WebKitWebView *v, WebKitWebFrame *f,
 117                 Client *c);
 118 static gboolean decidedownload(WebKitWebView *v, WebKitWebFrame *f,
 119                 WebKitNetworkRequest *r, gchar *m,  WebKitWebPolicyDecision *p,
 120                 Client *c);
 121 static gboolean decidewindow(WebKitWebView *v, WebKitWebFrame *f,
 122                 WebKitNetworkRequest *r, WebKitWebNavigationAction *n,
 123                 WebKitWebPolicyDecision *p, Client *c);
 124 static gboolean deletion_interface(WebKitWebView *view,
 125                 WebKitDOMHTMLElement *arg1, Client *c);
 126 static void destroyclient(Client *c);
 127 static void destroywin(GtkWidget* w, Client *c);
 128 static void die(const char *errstr, ...);
 129 static void eval(Client *c, const Arg *arg);
 130 static void find(Client *c, const Arg *arg);
 131 static void fullscreen(Client *c, const Arg *arg);
 132 static void geopolicyrequested(WebKitWebView *v, WebKitWebFrame *f,
 133                 WebKitGeolocationPolicyDecision *d, Client *c);
 134 static const char *getatom(Client *c, int a);
 135 static void gettogglestat(Client *c);
 136 static void getpagestat(Client *c);
 137 static char *geturi(Client *c);
 138 static gchar *getstyle(const char *uri);
 139
 140 static gboolean initdownload(WebKitWebView *v, WebKitDownload *o, Client *c);
 141
 142 static void inspector(Client *c, const Arg *arg);
 143 static WebKitWebView *inspector_new(WebKitWebInspector *i, WebKitWebView *v,
 144                 Client *c);
 145 static gboolean inspector_show(WebKitWebInspector *i, Client *c);
 146 static gboolean inspector_close(WebKitWebInspector *i, Client *c);
 147 static void inspector_finished(WebKitWebInspector *i, Client *c);
 148
 149 static gboolean keypress(GtkAccelGroup *group,
 150                 GObject *obj, guint key, GdkModifierType mods,
 151                 Client *c);
 152 static void linkhover(WebKitWebView *v, const char* t, const char* l,
 153                 Client *c);
 154 static void loadstatuschange(WebKitWebView *view, GParamSpec *pspec,
 155                 Client *c);
 156 static void loaduri(Client *c, const Arg *arg);
 157 static void navigate(Client *c, const Arg *arg);
 158 static Client *newclient(void);
 159 static void newwindow(Client *c, const Arg *arg, gboolean noembed);
 160 static void pasteuri(GtkClipboard *clipboard, const char *text, gpointer d);
 161 static gboolean contextmenu(WebKitWebView *view, GtkWidget *menu,
 162                 WebKitHitTestResult *target, gboolean keyboard, Client *c);
 163 static void menuactivate(GtkMenuItem *item, Client *c);
 164 static void print(Client *c, const Arg *arg);
 165 static GdkFilterReturn processx(GdkXEvent *xevent, GdkEvent *event,
 166                 gpointer d);
 167 static void progresschange(WebKitWebView *view, GParamSpec *pspec, Client *c);
 168 static void reload(Client *c, const Arg *arg);
 169 static void scroll_h(Client *c, const Arg *arg);
 170 static void scroll_v(Client *c, const Arg *arg);
 171 static void scroll(GtkAdjustment *a, const Arg *arg);
 172 static void setatom(Client *c, int a, const char *v);
 173 static void setup(void);
 174 static void sigchld(int unused);
 175 static void source(Client *c, const Arg *arg);
 176 static void spawn(Client *c, const Arg *arg);
 177 static void stop(Client *c, const Arg *arg);
 178 static void titlechange(WebKitWebView *view, GParamSpec *pspec, Client *c);
 179 static void toggle(Client *c, const Arg *arg);
 180 static void togglecookiepolicy(Client *c, const Arg *arg);
 181 static void togglegeolocation(Client *c, const Arg *arg);
 182 static void togglescrollbars(Client *c, const Arg *arg);
 183 static void togglestyle(Client *c, const Arg *arg);
 184 static void updatetitle(Client *c);
 185 static void updatewinid(Client *c);
 186 static void usage(void);
 187 static void windowobjectcleared(GtkWidget *w, WebKitWebFrame *frame,
 188                 JSContextRef js, JSObjectRef win, Client *c);
 189 static void zoom(Client *c, const Arg *arg);
 190
 191 /* configuration, allows nested code to access above variables */
 192 #include "config.h"
 193
 194 static void
 195 addaccelgroup(Client *c) {
 196         int i;
 197         GtkAccelGroup *group = gtk_accel_group_new();
 198         GClosure *closure;
 199
 200         for(i = 0; i < LENGTH(keys); i++) {
 201                 closure = g_cclosure_new(G_CALLBACK(keypress), c, NULL);
 202                 gtk_accel_group_connect(group, keys[i].keyval, keys[i].mod,
 203                                 0, closure);
 204         }
 205         gtk_window_add_accel_group(GTK_WINDOW(c->win), group);
 206 }
 207
 208 static void
 209 beforerequest(WebKitWebView *w, WebKitWebFrame *f, WebKitWebResource *r,
 210                 WebKitNetworkRequest *req, WebKitNetworkResponse *resp,
 211                 gpointer d) {
 212         const gchar *uri = webkit_network_request_get_uri(req);
 213
 214         if(g_str_has_suffix(uri, "/favicon.ico"))
 215                 webkit_network_request_set_uri(req, "about:blank");
 216 }
 217
 218 static char *
 219 buildpath(const char *path) {
 220         char *apath, *p;
 221         FILE *f;
 222
 223         /* creating directory */
 224         if(path[0] == '/') {
 225                 apath = g_strdup(path);
 226         } else if(path[0] == '~') {
 227                 if(path[1] == '/') {
 228                         apath = g_strconcat(g_get_home_dir(), &path[1], NULL);
 229                 } else {
 230                         apath = g_strconcat(g_get_home_dir(), "/",
 231                                         &path[1], NULL);
 232                 }
 233         } else {
 234                 apath = g_strconcat(g_get_current_dir(), "/", path, NULL);
 235         }
 236
 237         if((p = strrchr(apath, '/'))) {
 238                 *p = '\0';
 239                 g_mkdir_with_parents(apath, 0700);
 240                 g_chmod(apath, 0700); /* in case it existed */
 241                 *p = '/';
 242         }
 243         /* creating file (gives error when apath ends with "/") */
 244         if((f = fopen(apath, "a"))) {
 245                 g_chmod(apath, 0600); /* always */
 246                 fclose(f);
 247         }
 248
 249         return apath;
 250 }
 251
 252 static gboolean
 253 buttonrelease(WebKitWebView *web, GdkEventButton *e, GList *gl) {
 254         WebKitHitTestResultContext context;
 255         WebKitHitTestResult *result = webkit_web_view_get_hit_test_result(web,
 256                         e);
 257         Arg arg;
 258
 259         g_object_get(result, "context", &context, NULL);
 260         if(context & WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK) {
 261                 if(e->button == 2 ||
 262                                 (e->button == 1 && CLEANMASK(e->state) == CLEANMASK(MODKEY))) {
 263                         g_object_get(result, "link-uri", &arg.v, NULL);
 264                         newwindow(NULL, &arg, e->state & GDK_CONTROL_MASK);
 265                         return true;
 266                 }
 267         }
 268         return false;
 269 }
 270
 271 static void
 272 cleanup(void) {
 273         while(clients)
 274                 destroyclient(clients);
 275         g_free(cookiefile);
 276         g_free(scriptfile);
 277         g_free(stylefile);
 278 }
 279
 280 static void
 281 cookiejar_changed(SoupCookieJar *self, SoupCookie *old_cookie,
 282                 SoupCookie *new_cookie) {
 283         flock(COOKIEJAR(self)->lock, LOCK_EX);
 284         if(new_cookie && !new_cookie->expires && sessiontime) {
 285                 soup_cookie_set_expires(new_cookie,
 286                                 soup_date_new_from_now(sessiontime));
 287         }
 288         SOUP_COOKIE_JAR_CLASS(cookiejar_parent_class)->changed(self,
 289                         old_cookie, new_cookie);
 290         flock(COOKIEJAR(self)->lock, LOCK_UN);
 291 }
 292
 293 static void
 294 cookiejar_class_init(CookieJarClass *klass) {
 295         SOUP_COOKIE_JAR_CLASS(klass)->changed = cookiejar_changed;
 296         G_OBJECT_CLASS(klass)->get_property =
 297                 G_OBJECT_CLASS(cookiejar_parent_class)->get_property;
 298         G_OBJECT_CLASS(klass)->set_property = cookiejar_set_property;
 299         G_OBJECT_CLASS(klass)->finalize = cookiejar_finalize;
 300         g_object_class_override_property(G_OBJECT_CLASS(klass), 1, "filename");
 301 }
 302
 303 static void
 304 cookiejar_finalize(GObject *self) {
 305         close(COOKIEJAR(self)->lock);
 306         G_OBJECT_CLASS(cookiejar_parent_class)->finalize(self);
 307 }
 308
 309 static void
 310 cookiejar_init(CookieJar *self) {
 311         self->lock = open(cookiefile, 0);
 312 }
 313
 314 static SoupCookieJar *
 315 cookiejar_new(const char *filename, gboolean read_only,
 316                 SoupCookieJarAcceptPolicy policy) {
 317         return g_object_new(COOKIEJAR_TYPE,
 318                             SOUP_COOKIE_JAR_TEXT_FILENAME, filename,
 319                             SOUP_COOKIE_JAR_READ_ONLY, read_only,
 320                             SOUP_COOKIE_JAR_ACCEPT_POLICY, policy, NULL);
 321 }
 322
 323 static void
 324 cookiejar_set_property(GObject *self, guint prop_id, const GValue *value,
 325                 GParamSpec *pspec) {
 326         flock(COOKIEJAR(self)->lock, LOCK_SH);
 327         G_OBJECT_CLASS(cookiejar_parent_class)->set_property(self, prop_id,
 328                         value, pspec);
 329         flock(COOKIEJAR(self)->lock, LOCK_UN);
 330 }
 331
 332 static SoupCookieJarAcceptPolicy
 333 cookiepolicy_get(void) {
 334         switch(cookiepolicies[policysel]) {
 335         case 'a':
 336                 return SOUP_COOKIE_JAR_ACCEPT_NEVER;
 337         case '@':
 338                 return SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
 339         case 'A':
 340         default:
 341                 break;
 342         }
 343
 344         return SOUP_COOKIE_JAR_ACCEPT_ALWAYS;
 345 }
 346
 347 static char
 348 cookiepolicy_set(const SoupCookieJarAcceptPolicy ep) {
 349         switch(ep) {
 350         case SOUP_COOKIE_JAR_ACCEPT_NEVER:
 351                 return 'a';
 352         case SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY:
 353                 return '@';
 354         case SOUP_COOKIE_JAR_ACCEPT_ALWAYS:
 355         default:
 356                 break;
 357         }
 358
 359         return 'A';
 360 }
 361
 362 static void
 363 evalscript(JSContextRef js, char *script, char* scriptname) {
 364         JSStringRef jsscript, jsscriptname;
 365         JSValueRef exception = NULL;
 366
 367         jsscript = JSStringCreateWithUTF8CString(script);
 368         jsscriptname = JSStringCreateWithUTF8CString(scriptname);
 369         JSEvaluateScript(js, jsscript, JSContextGetGlobalObject(js),
 370                         jsscriptname, 0, &exception);
 371         JSStringRelease(jsscript);
 372         JSStringRelease(jsscriptname);
 373 }
 374
 375 static void
 376 runscript(WebKitWebFrame *frame) {
 377         char *script;
 378         GError *error;
 379
 380         if(g_file_get_contents(scriptfile, &script, NULL, &error)) {
 381                 evalscript(webkit_web_frame_get_global_context(frame),
 382                                 script, scriptfile);
 383         }
 384 }
 385
 386 static void
 387 clipboard(Client *c, const Arg *arg) {
 388         gboolean paste = *(gboolean *)arg;
 389
 390         if(paste) {
 391                 gtk_clipboard_request_text(
 392                                 gtk_clipboard_get(GDK_SELECTION_PRIMARY),
 393                                 pasteuri, c);
 394         } else {
 395                 gtk_clipboard_set_text(
 396                                 gtk_clipboard_get(GDK_SELECTION_PRIMARY),
 397                                 c->linkhover ? c->linkhover : geturi(c), -1);
 398         }
 399 }
 400
 401 static char *
 402 copystr(char **str, const char *src) {
 403         char *tmp;
 404         tmp = g_strdup(src);
 405
 406         if(str && *str) {
 407                 g_free(*str);
 408                 *str = tmp;
 409         }
 410         return tmp;
 411 }
 412
 413 static WebKitWebView *
 414 createwindow(WebKitWebView  *v, WebKitWebFrame *f, Client *c) {
 415         Client *n = newclient();
 416         return n->view;
 417 }
 418
 419 static gboolean
 420 decidedownload(WebKitWebView *v, WebKitWebFrame *f, WebKitNetworkRequest *r,
 421                 gchar *m,  WebKitWebPolicyDecision *p, Client *c) {
 422         if(!webkit_web_view_can_show_mime_type(v, m)) {
 423                 webkit_web_policy_decision_download(p);
 424                 return TRUE;
 425         }
 426         return FALSE;
 427 }
 428
 429 static gboolean
 430 decidewindow(WebKitWebView *view, WebKitWebFrame *f, WebKitNetworkRequest *r,
 431                 WebKitWebNavigationAction *n, WebKitWebPolicyDecision *p,
 432                 Client *c) {
 433         Arg arg;
 434
 435         if(webkit_web_navigation_action_get_reason(n) ==
 436                         WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED) {
 437                 webkit_web_policy_decision_ignore(p);
 438                 arg.v = (void *)webkit_network_request_get_uri(r);
 439                 newwindow(NULL, &arg, 0);
 440                 return TRUE;
 441         }
 442         return FALSE;
 443 }
 444
 445 static gboolean
 446 deletion_interface(WebKitWebView *view,
 447                 WebKitDOMHTMLElement *arg1, Client *c) {
 448         return FALSE;
 449 }
 450
 451 static void
 452 destroyclient(Client *c) {
 453         Client *p;
 454
 455         webkit_web_view_stop_loading(c->view);
 456         gtk_widget_destroy(GTK_WIDGET(c->view));
 457         gtk_widget_destroy(c->scroll);
 458         gtk_widget_destroy(c->vbox);
 459         gtk_widget_destroy(c->win);
 460
 461         for(p = clients; p && p->next != c; p = p->next);
 462         if(p) {
 463                 p->next = c->next;
 464         } else {
 465                 clients = c->next;
 466         }
 467         free(c);
 468         if(clients == NULL)
 469                 gtk_main_quit();
 470 }
 471
 472 static void
 473 destroywin(GtkWidget* w, Client *c) {
 474         destroyclient(c);
 475 }
 476
 477 static void
 478 die(const char *errstr, ...) {
 479         va_list ap;
 480
 481         va_start(ap, errstr);
 482         vfprintf(stderr, errstr, ap);
 483         va_end(ap);
 484         exit(EXIT_FAILURE);
 485 }
 486
 487 static void
 488 find(Client *c, const Arg *arg) {
 489         const char *s;
 490
 491         s = getatom(c, AtomFind);
 492         gboolean forward = *(gboolean *)arg;
 493         webkit_web_view_search_text(c->view, s, FALSE, forward, TRUE);
 494 }
 495
 496 static void
 497 fullscreen(Client *c, const Arg *arg) {
 498         if(c->fullscreen) {
 499                 gtk_window_unfullscreen(GTK_WINDOW(c->win));
 500         } else {
 501                 gtk_window_fullscreen(GTK_WINDOW(c->win));
 502         }
 503         c->fullscreen = !c->fullscreen;
 504 }
 505
 506 static void
 507 geopolicyrequested(WebKitWebView *v, WebKitWebFrame *f,
 508                 WebKitGeolocationPolicyDecision *d, Client *c) {
 509         if(allowgeolocation) {
 510                 webkit_geolocation_policy_allow(d);
 511         } else {
 512                 webkit_geolocation_policy_deny(d);
 513         }
 514 }
 515
 516 static const char *
 517 getatom(Client *c, int a) {
 518         static char buf[BUFSIZ];
 519         Atom adummy;
 520         int idummy;
 521         unsigned long ldummy;
 522         unsigned char *p = NULL;
 523
 524         XGetWindowProperty(dpy, GDK_WINDOW_XID(GTK_WIDGET(c->win)->window),
 525                         atoms[a], 0L, BUFSIZ, False, XA_STRING,
 526                         &adummy, &idummy, &ldummy, &ldummy, &p);
 527         if(p) {
 528                 strncpy(buf, (char *)p, LENGTH(buf)-1);
 529         } else {
 530                 buf[0] = '\0';
 531         }
 532         XFree(p);
 533
 534         return buf;
 535 }
 536
 537 static char *
 538 geturi(Client *c) {
 539         char *uri;
 540
 541         if(!(uri = (char *)webkit_web_view_get_uri(c->view)))
 542                 uri = "about:blank";
 543         return uri;
 544 }
 545
 546 static gchar *
 547 getstyle(const char *uri) {
 548         int i;
 549
 550         for(i = 0; i < LENGTH(styles); i++) {
 551                 if(styles[i].regex && !regexec(&(styles[i].re), uri, 0,
 552                                         NULL, 0)) {
 553                         return g_strconcat("file://", styles[i].style, NULL);
 554                 }
 555         }
 556         return g_strdup("");
 557 }
 558
 559 static gboolean
 560 initdownload(WebKitWebView *view, WebKitDownload *o, Client *c) {
 561         Arg arg;
 562
 563         updatewinid(c);
 564         arg = (Arg)DOWNLOAD((char *)webkit_download_get_uri(o), geturi(c));
 565         spawn(c, &arg);
 566         return FALSE;
 567 }
 568
 569 static void
 570 inspector(Client *c, const Arg *arg) {
 571         if(c->isinspecting) {
 572                 webkit_web_inspector_close(c->inspector);
 573         } else {
 574                 webkit_web_inspector_show(c->inspector);
 575         }
 576 }
 577
 578 static WebKitWebView *
 579 inspector_new(WebKitWebInspector *i, WebKitWebView *v, Client *c) {
 580         return WEBKIT_WEB_VIEW(webkit_web_view_new());
 581 }
 582
 583 static gboolean
 584 inspector_show(WebKitWebInspector *i, Client *c) {
 585         WebKitWebView *w;
 586
 587         if(c->isinspecting)
 588                 return false;
 589
 590         w = webkit_web_inspector_get_web_view(i);
 591         gtk_paned_pack2(GTK_PANED(c->pane), GTK_WIDGET(w), TRUE, TRUE);
 592         gtk_widget_show(GTK_WIDGET(w));
 593         c->isinspecting = true;
 594
 595         return true;
 596 }
 597
 598 static gboolean
 599 inspector_close(WebKitWebInspector *i, Client *c) {
 600         GtkWidget *w;
 601
 602         if(!c->isinspecting)
 603                 return false;
 604
 605         w = GTK_WIDGET(webkit_web_inspector_get_web_view(i));
 606         gtk_widget_hide(w);
 607         gtk_widget_destroy(w);
 608         c->isinspecting = false;
 609
 610         return true;
 611 }
 612
 613 static void
 614 inspector_finished(WebKitWebInspector *i, Client *c) {
 615         g_free(c->inspector);
 616 }
 617
 618 static gboolean
 619 keypress(GtkAccelGroup *group, GObject *obj,
 620                 guint key, GdkModifierType mods, Client *c) {
 621         guint i;
 622         gboolean processed = FALSE;
 623
 624         mods = CLEANMASK(mods);
 625         key = gdk_keyval_to_lower(key);
 626         updatewinid(c);
 627         for(i = 0; i < LENGTH(keys); i++) {
 628                 if(key == keys[i].keyval
 629                                 && mods == keys[i].mod
 630                                 && keys[i].func) {
 631                         keys[i].func(c, &(keys[i].arg));
 632                         processed = TRUE;
 633                 }
 634         }
 635
 636         return processed;
 637 }
 638
 639 static void
 640 linkhover(WebKitWebView *v, const char* t, const char* l, Client *c) {
 641         if(l) {
 642                 c->linkhover = copystr(&c->linkhover, l);
 643         } else if(c->linkhover) {
 644                 free(c->linkhover);
 645                 c->linkhover = NULL;
 646         }
 647         updatetitle(c);
 648 }
 649
 650 static void
 651 loadstatuschange(WebKitWebView *view, GParamSpec *pspec, Client *c) {
 652         WebKitWebFrame *frame;
 653         WebKitWebDataSource *src;
 654         WebKitNetworkRequest *request;
 655         WebKitWebSettings *set = webkit_web_view_get_settings(c->view);
 656         SoupMessage *msg;
 657         char *uri;
 658
 659         switch(webkit_web_view_get_load_status (c->view)) {
 660         case WEBKIT_LOAD_COMMITTED:
 661                 uri = geturi(c);
 662                 if(strstr(uri, "https://") == uri) {
 663                         frame = webkit_web_view_get_main_frame(c->view);
 664                         src = webkit_web_frame_get_data_source(frame);
 665                         request = webkit_web_data_source_get_request(src);
 666                         msg = webkit_network_request_get_message(request);
 667                         c->sslfailed = !(soup_message_get_flags(msg)
 668                                         & SOUP_MESSAGE_CERTIFICATE_TRUSTED);
 669                 }
 670                 setatom(c, AtomUri, uri);
 671
 672                 if(stylefile == NULL && enablestyles) {
 673                         g_object_set(G_OBJECT(set), "user-stylesheet-uri",
 674                                         getstyle(uri), NULL);
 675                 }
 676                 break;
 677         case WEBKIT_LOAD_FINISHED:
 678                 c->progress = 100;
 679                 updatetitle(c);
 680                 break;
 681         default:
 682                 break;
 683         }
 684 }
 685
 686 static void
 687 loaduri(Client *c, const Arg *arg) {
 688         char *u = NULL, *rp;
 689         const char *uri = (char *)arg->v;
 690         Arg a = { .b = FALSE };
 691         struct stat st;
 692
 693         if(strcmp(uri, "") == 0)
 694                 return;
 695
 696         /* In case it's a file path. */
 697         if(stat(uri, &st) == 0) {
 698                 rp = realpath(uri, NULL);
 699                 u = g_strdup_printf("file://%s", rp);
 700                 free(rp);
 701         } else {
 702                 u = g_strrstr(uri, "://") ? g_strdup(uri)
 703                         : g_strdup_printf("http://%s", uri);
 704         }
 705
 706         setatom(c, AtomUri, uri);
 707
 708         /* prevents endless loop */
 709         if(strcmp(u, geturi(c)) == 0) {
 710                 reload(c, &a);
 711         } else {
 712                 webkit_web_view_load_uri(c->view, u);
 713                 c->progress = 0;
 714                 c->title = copystr(&c->title, u);
 715                 updatetitle(c);
 716         }
 717         g_free(u);
 718 }
 719
 720 static void
 721 navigate(Client *c, const Arg *arg) {
 722         int steps = *(int *)arg;
 723         webkit_web_view_go_back_or_forward(c->view, steps);
 724 }
 725
 726 static Client *
 727 newclient(void) {
 728         Client *c;
 729         WebKitWebSettings *settings;
 730         WebKitWebFrame *frame;
 731         GdkGeometry hints = { 1, 1 };
 732         GdkScreen *screen;
 733         gdouble dpi;
 734         char *uri = NULL, *ua;
 735
 736         if(!(c = calloc(1, sizeof(Client))))
 737                 die("Cannot malloc!\n");
 738
 739         c->title = NULL;
 740         c->progress = 100;
 741
 742         /* Window */
 743         if(embed) {
 744                 c->win = gtk_plug_new(embed);
 745         } else {
 746                 c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 747
 748                 /* TA:  20091214:  Despite what the GNOME docs say, the ICCCM
 749                  * is always correct, so we should still call this function.
 750                  * But when doing so, we *must* differentiate between a
 751                  * WM_CLASS and a resource on the window.  By convention, the
 752                  * window class (WM_CLASS) is capped, while the resource is in
 753                  * lowercase.   Both these values come as a pair.
 754                  */
 755                 gtk_window_set_wmclass(GTK_WINDOW(c->win), "surf", "Surf");
 756
 757                 /* TA:  20091214:  And set the role here as well -- so that
 758                  * sessions can pick this up.
 759                  */
 760                 gtk_window_set_role(GTK_WINDOW(c->win), "Surf");
 761         }
 762         gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600);
 763         g_signal_connect(G_OBJECT(c->win),
 764                         "destroy",
 765                         G_CALLBACK(destroywin), c);
 766
 767         if(!kioskmode)
 768                 addaccelgroup(c);
 769
 770         /* Pane */
 771         c->pane = gtk_vpaned_new();
 772
 773         /* VBox */
 774         c->vbox = gtk_vbox_new(FALSE, 0);
 775         gtk_paned_pack1(GTK_PANED(c->pane), c->vbox, TRUE, TRUE);
 776
 777         /* Webview */
 778         c->view = WEBKIT_WEB_VIEW(webkit_web_view_new());
 779
 780         g_signal_connect(G_OBJECT(c->view),
 781                         "notify::title",
 782                         G_CALLBACK(titlechange), c);
 783         g_signal_connect(G_OBJECT(c->view),
 784                         "hovering-over-link",
 785                         G_CALLBACK(linkhover), c);
 786         g_signal_connect(G_OBJECT(c->view),
 787                         "geolocation-policy-decision-requested",
 788                         G_CALLBACK(geopolicyrequested), c);
 789         g_signal_connect(G_OBJECT(c->view),
 790                         "create-web-view",
 791                         G_CALLBACK(createwindow), c);
 792         g_signal_connect(G_OBJECT(c->view),
 793                         "new-window-policy-decision-requested",
 794                         G_CALLBACK(decidewindow), c);
 795         g_signal_connect(G_OBJECT(c->view),
 796                         "mime-type-policy-decision-requested",
 797                         G_CALLBACK(decidedownload), c);
 798         g_signal_connect(G_OBJECT(c->view),
 799                         "window-object-cleared",
 800                         G_CALLBACK(windowobjectcleared), c);
 801         g_signal_connect(G_OBJECT(c->view),
 802                         "notify::load-status",
 803                         G_CALLBACK(loadstatuschange), c);
 804         g_signal_connect(G_OBJECT(c->view),
 805                         "notify::progress",
 806                         G_CALLBACK(progresschange), c);
 807         g_signal_connect(G_OBJECT(c->view),
 808                         "download-requested",
 809                         G_CALLBACK(initdownload), c);
 810         g_signal_connect(G_OBJECT(c->view),
 811                         "button-release-event",
 812                         G_CALLBACK(buttonrelease), c);
 813         g_signal_connect(G_OBJECT(c->view),
 814                         "context-menu",
 815                         G_CALLBACK(contextmenu), c);
 816         g_signal_connect(G_OBJECT(c->view),
 817                         "resource-request-starting",
 818                         G_CALLBACK(beforerequest), c);
 819         g_signal_connect(G_OBJECT(c->view),
 820                         "should-show-delete-interface-for-element",
 821                         G_CALLBACK(deletion_interface), c);
 822
 823         /* Scrolled Window */
 824         c->scroll = gtk_scrolled_window_new(NULL, NULL);
 825
 826         frame = webkit_web_view_get_main_frame(WEBKIT_WEB_VIEW(c->view));
 827         g_signal_connect(G_OBJECT(frame), "scrollbars-policy-changed",
 828                         G_CALLBACK(gtk_true), NULL);
 829
 830         if(!enablescrollbars) {
 831                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(c->scroll),
 832                                 GTK_POLICY_NEVER, GTK_POLICY_NEVER);
 833         } else {
 834                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(c->scroll),
 835                                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 836         }
 837
 838         /* Arranging */
 839         gtk_container_add(GTK_CONTAINER(c->scroll), GTK_WIDGET(c->view));
 840         gtk_container_add(GTK_CONTAINER(c->win), c->pane);
 841         gtk_container_add(GTK_CONTAINER(c->vbox), c->scroll);
 842
 843         /* Setup */
 844         gtk_box_set_child_packing(GTK_BOX(c->vbox), c->scroll, TRUE,
 845                         TRUE, 0, GTK_PACK_START);
 846         gtk_widget_grab_focus(GTK_WIDGET(c->view));
 847         gtk_widget_show(c->pane);
 848         gtk_widget_show(c->vbox);
 849         gtk_widget_show(c->scroll);
 850         gtk_widget_show(GTK_WIDGET(c->view));
 851         gtk_widget_show(c->win);
 852         gtk_window_set_geometry_hints(GTK_WINDOW(c->win), NULL, &hints,
 853                         GDK_HINT_MIN_SIZE);
 854         gdk_window_set_events(GTK_WIDGET(c->win)->window, GDK_ALL_EVENTS_MASK);
 855         gdk_window_add_filter(GTK_WIDGET(c->win)->window, processx, c);
 856         webkit_web_view_set_full_content_zoom(c->view, TRUE);
 857
 858         runscript(frame);
 859
 860         settings = webkit_web_view_get_settings(c->view);
 861         if(!(ua = getenv("SURF_USERAGENT")))
 862                 ua = useragent;
 863         g_object_set(G_OBJECT(settings), "user-agent", ua, NULL);
 864         if (stylefile != NULL) {
 865                 uri = g_strconcat("file://", stylefile, NULL);
 866                 g_object_set(G_OBJECT(settings), "user-stylesheet-uri", uri, NULL);
 867         }
 868         g_object_set(G_OBJECT(settings), "auto-load-images", loadimages,
 869                         NULL);
 870         g_object_set(G_OBJECT(settings), "enable-plugins", enableplugins,
 871                         NULL);
 872         g_object_set(G_OBJECT(settings), "enable-scripts", enablescripts,
 873                         NULL);
 874         g_object_set(G_OBJECT(settings), "enable-spatial-navigation",
 875                         enablespatialbrowsing, NULL);
 876         g_object_set(G_OBJECT(settings), "enable-developer-extras",
 877                         enableinspector, NULL);
 878         g_object_set(G_OBJECT(settings), "enable-default-context-menu",
 879                         kioskmode ^ 1, NULL);
 880         g_object_set(G_OBJECT(settings), "default-font-size",
 881                         defaultfontsize, NULL);
 882         g_object_set(G_OBJECT(settings), "resizable-text-areas",
 883                         1, NULL);
 884
 885         /*
 886          * While stupid, CSS specifies that a pixel represents 1/96 of an inch.
 887          * This ensures websites are not unusably small with a high DPI screen.
 888          * It is equivalent to firefox's "layout.css.devPixelsPerPx" setting.
 889          */
 890         if(zoomto96dpi) {
 891                 screen = gdk_window_get_screen(GTK_WIDGET(c->win)->window);
 892                 dpi = gdk_screen_get_resolution(screen);
 893                 if(dpi != -1) {
 894                         g_object_set(G_OBJECT(settings), "enforce-96-dpi", true,
 895                                         NULL);
 896                         webkit_web_view_set_zoom_level(c->view, dpi/96);
 897                 }
 898         }
 899         /* This might conflict with _zoomto96dpi_. */
 900         if(zoomlevel != 1.0)
 901                 webkit_web_view_set_zoom_level(c->view, zoomlevel);
 902
 903         if(enableinspector) {
 904                 c->inspector = WEBKIT_WEB_INSPECTOR(
 905                                 webkit_web_view_get_inspector(c->view));
 906                 g_signal_connect(G_OBJECT(c->inspector), "inspect-web-view",
 907                                 G_CALLBACK(inspector_new), c);
 908                 g_signal_connect(G_OBJECT(c->inspector), "show-window",
 909                                 G_CALLBACK(inspector_show), c);
 910                 g_signal_connect(G_OBJECT(c->inspector), "close-window",
 911                                 G_CALLBACK(inspector_close), c);
 912                 g_signal_connect(G_OBJECT(c->inspector), "finished",
 913                                 G_CALLBACK(inspector_finished), c);
 914                 c->isinspecting = false;
 915         }
 916
 917         if(runinfullscreen) {
 918                 c->fullscreen = 0;
 919                 fullscreen(c, NULL);
 920         }
 921
 922         if(stylefile != NULL)
 923                 g_free(uri);
 924
 925         setatom(c, AtomFind, "");
 926         setatom(c, AtomUri, "about:blank");
 927         if(hidebackground)
 928                 webkit_web_view_set_transparent(c->view, TRUE);
 929
 930         c->next = clients;
 931         clients = c;
 932
 933         if(showxid) {
 934                 gdk_display_sync(gtk_widget_get_display(c->win));
 935                 printf("%u\n",
 936                         (guint)GDK_WINDOW_XID(GTK_WIDGET(c->win)->window));
 937                 fflush(NULL);
 938                 if (fclose(stdout) != 0) {
 939                         die("Error closing stdout");
 940                 }
 941         }
 942
 943         return c;
 944 }
 945
 946 static void
 947 newwindow(Client *c, const Arg *arg, gboolean noembed) {
 948         guint i = 0;
 949         const char *cmd[16], *uri;
 950         const Arg a = { .v = (void *)cmd };
 951         char tmp[64];
 952
 953         cmd[i++] = argv0;
 954         cmd[i++] = "-a";
 955         cmd[i++] = cookiepolicies;
 956         if(!enablescrollbars)
 957                 cmd[i++] = "-b";
 958         if(embed && !noembed) {
 959                 cmd[i++] = "-e";
 960                 snprintf(tmp, LENGTH(tmp), "%u\n", (int)embed);
 961                 cmd[i++] = tmp;
 962         }
 963         if(!loadimages)
 964                 cmd[i++] = "-i";
 965         if(kioskmode)
 966                 cmd[i++] = "-k";
 967         if(!enableplugins)
 968                 cmd[i++] = "-p";
 969         if(!enablescripts)
 970                 cmd[i++] = "-s";
 971         if(showxid)
 972                 cmd[i++] = "-x";
 973         cmd[i++] = "-c";
 974         cmd[i++] = cookiefile;
 975         cmd[i++] = "--";
 976         uri = arg->v ? (char *)arg->v : c->linkhover;
 977         if(uri)
 978                 cmd[i++] = uri;
 979         cmd[i++] = NULL;
 980         spawn(NULL, &a);
 981 }
 982
 983 static gboolean
 984 contextmenu(WebKitWebView *view, GtkWidget *menu, WebKitHitTestResult *target,
 985                 gboolean keyboard, Client *c) {
 986         GList *items = gtk_container_get_children(GTK_CONTAINER(GTK_MENU(menu)));
 987
 988         for(GList *l = items; l; l = l->next) {
 989                 g_signal_connect(l->data, "activate", G_CALLBACK(menuactivate), c);
 990         }
 991
 992         g_list_free(items);
 993         return FALSE;
 994 }
 995
 996 static void
 997 menuactivate(GtkMenuItem *item, Client *c) {
 998         /*
 999          * context-menu-action-2000     open link
1000          * context-menu-action-1        open link in window
1001          * context-menu-action-2        download linked file
1002          * context-menu-action-3        copy link location
1003          * context-menu-action-7        copy image address
1004          * context-menu-action-13       reload
1005          * context-menu-action-10       back
1006          * context-menu-action-11       forward
1007          * context-menu-action-12       stop
1008          */
1009
1010         GtkAction *a = NULL;
1011         const char *name, *uri;
1012         GtkClipboard *prisel, *clpbrd;
1013
1014         a = gtk_activatable_get_related_action(GTK_ACTIVATABLE(item));
1015         if(a == NULL)
1016                 return;
1017
1018         name = gtk_action_get_name(a);
1019         if(!g_strcmp0(name, "context-menu-action-3")) {
1020                 prisel = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1021                 gtk_clipboard_set_text(prisel, c->linkhover, -1);
1022         } else if(!g_strcmp0(name, "context-menu-action-7")) {
1023                 prisel = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1024                 clpbrd = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
1025                 uri = gtk_clipboard_wait_for_text(clpbrd);
1026                 if(uri)
1027                         gtk_clipboard_set_text(prisel, uri, -1);
1028         }
1029 }
1030
1031 static void
1032 pasteuri(GtkClipboard *clipboard, const char *text, gpointer d) {
1033         Arg arg = {.v = text };
1034         if(text != NULL)
1035                 loaduri((Client *) d, &arg);
1036 }
1037
1038 static void
1039 print(Client *c, const Arg *arg) {
1040         webkit_web_frame_print(webkit_web_view_get_main_frame(c->view));
1041 }
1042
1043 static GdkFilterReturn
1044 processx(GdkXEvent *e, GdkEvent *event, gpointer d) {
1045         Client *c = (Client *)d;
1046         XPropertyEvent *ev;
1047         Arg arg;
1048
1049         if(((XEvent *)e)->type == PropertyNotify) {
1050                 ev = &((XEvent *)e)->xproperty;
1051                 if(ev->state == PropertyNewValue) {
1052                         if(ev->atom == atoms[AtomFind]) {
1053                                 arg.b = TRUE;
1054                                 find(c, &arg);
1055
1056                                 return GDK_FILTER_REMOVE;
1057                         } else if(ev->atom == atoms[AtomGo]) {
1058                                 arg.v = getatom(c, AtomGo);
1059                                 loaduri(c, &arg);
1060
1061                                 return GDK_FILTER_REMOVE;
1062                         }
1063                 }
1064         }
1065         return GDK_FILTER_CONTINUE;
1066 }
1067
1068 static void
1069 progresschange(WebKitWebView *view, GParamSpec *pspec, Client *c) {
1070         c->progress = webkit_web_view_get_progress(c->view) * 100;
1071         updatetitle(c);
1072 }
1073
1074 static void
1075 reload(Client *c, const Arg *arg) {
1076         gboolean nocache = *(gboolean *)arg;
1077         if(nocache) {
1078                  webkit_web_view_reload_bypass_cache(c->view);
1079         } else {
1080                  webkit_web_view_reload(c->view);
1081         }
1082 }
1083
1084 static void
1085 scroll_h(Client *c, const Arg *arg) {
1086         scroll(gtk_scrolled_window_get_hadjustment(
1087                                 GTK_SCROLLED_WINDOW(c->scroll)), arg);
1088 }
1089
1090 static void
1091 scroll_v(Client *c, const Arg *arg) {
1092         scroll(gtk_scrolled_window_get_vadjustment(
1093                                 GTK_SCROLLED_WINDOW(c->scroll)), arg);
1094 }
1095
1096 static void
1097 scroll(GtkAdjustment *a, const Arg *arg) {
1098         gdouble v;
1099
1100         v = gtk_adjustment_get_value(a);
1101         switch(arg->i) {
1102         case +10000:
1103         case -10000:
1104                 v += gtk_adjustment_get_page_increment(a) *
1105                         (arg->i / 10000);
1106                 break;
1107         case +20000:
1108         case -20000:
1109         default:
1110                 v += gtk_adjustment_get_step_increment(a) * arg->i;
1111         }
1112
1113         v = MAX(v, 0.0);
1114         v = MIN(v, gtk_adjustment_get_upper(a) -
1115                         gtk_adjustment_get_page_size(a));
1116         gtk_adjustment_set_value(a, v);
1117 }
1118
1119 static void
1120 setatom(Client *c, int a, const char *v) {
1121         XSync(dpy, False);
1122         XChangeProperty(dpy, GDK_WINDOW_XID(GTK_WIDGET(c->win)->window),
1123                         atoms[a], XA_STRING, 8, PropModeReplace,
1124                         (unsigned char *)v, strlen(v) + 1);
1125 }
1126
1127 static void
1128 setup(void) {
1129         int i;
1130         char *proxy;
1131         char *new_proxy;
1132         SoupURI *puri;
1133         SoupSession *s;
1134         GError *error = NULL;
1135
1136         /* clean up any zombies immediately */
1137         sigchld(0);
1138         gtk_init(NULL, NULL);
1139
1140         dpy = GDK_DISPLAY();
1141
1142         /* atoms */
1143         atoms[AtomFind] = XInternAtom(dpy, "_SURF_FIND", False);
1144         atoms[AtomGo] = XInternAtom(dpy, "_SURF_GO", False);
1145         atoms[AtomUri] = XInternAtom(dpy, "_SURF_URI", False);
1146
1147         /* dirs and files */
1148         cookiefile = buildpath(cookiefile);
1149         scriptfile = buildpath(scriptfile);
1150         styledir = buildpath(styledir);
1151         if(stylefile == NULL && enablestyles) {
1152                 for(i = 0; i < LENGTH(styles); i++) {
1153                         if(regcomp(&(styles[i].re), styles[i].regex,
1154                                                 REG_EXTENDED)) {
1155                                 fprintf(stderr,
1156                                         "Could not compile regex: %s\n",
1157                                         styles[i].regex);
1158                                 styles[i].regex = NULL;
1159                         }
1160                         styles[i].style = buildpath(
1161                                         g_strconcat(styledir,
1162                                                 styles[i].style, NULL));
1163                 }
1164         } else {
1165                 stylefile = buildpath(stylefile);
1166         }
1167
1168         /* request handler */
1169         s = webkit_get_default_session();
1170
1171         /* cookie jar */
1172         soup_session_add_feature(s,
1173                         SOUP_SESSION_FEATURE(cookiejar_new(cookiefile, FALSE,
1174                                         cookiepolicy_get())));
1175
1176         /* ssl */
1177         tlsdb = g_tls_file_database_new(cafile, &error);
1178
1179         if(error) {
1180                 g_warning("Error loading SSL database %s: %s", cafile, error->message);
1181                 g_error_free(error);
1182         }
1183         g_object_set(G_OBJECT(s), "tls-database", tlsdb, NULL);
1184         g_object_set(G_OBJECT(s), "ssl-strict", strictssl, NULL);
1185
1186         /* proxy */
1187         if((proxy = getenv("http_proxy")) && strcmp(proxy, "")) {
1188                 new_proxy = g_strrstr(proxy, "http://") ? g_strdup(proxy) :
1189                         g_strdup_printf("http://%s", proxy);
1190                 puri = soup_uri_new(new_proxy);
1191                 g_object_set(G_OBJECT(s), "proxy-uri", puri, NULL);
1192                 soup_uri_free(puri);
1193                 g_free(new_proxy);
1194                 usingproxy = 1;
1195         }
1196 }
1197
1198 static void
1199 sigchld(int unused) {
1200         if(signal(SIGCHLD, sigchld) == SIG_ERR)
1201                 die("Can't install SIGCHLD handler");
1202         while(0 < waitpid(-1, NULL, WNOHANG));
1203 }
1204
1205 static void
1206 source(Client *c, const Arg *arg) {
1207         Arg a = { .b = FALSE };
1208         gboolean s;
1209
1210         s = webkit_web_view_get_view_source_mode(c->view);
1211         webkit_web_view_set_view_source_mode(c->view, !s);
1212         reload(c, &a);
1213 }
1214
1215 static void
1216 spawn(Client *c, const Arg *arg) {
1217         if(fork() == 0) {
1218                 if(dpy)
1219                         close(ConnectionNumber(dpy));
1220                 setsid();
1221                 execvp(((char **)arg->v)[0], (char **)arg->v);
1222                 fprintf(stderr, "surf: execvp %s", ((char **)arg->v)[0]);
1223                 perror(" failed");
1224                 exit(0);
1225         }
1226 }
1227
1228 static void
1229 eval(Client *c, const Arg *arg) {
1230         WebKitWebFrame *frame = webkit_web_view_get_main_frame(c->view);
1231         evalscript(webkit_web_frame_get_global_context(frame),
1232                         ((char **)arg->v)[0], "");
1233 }
1234
1235 static void
1236 stop(Client *c, const Arg *arg) {
1237         webkit_web_view_stop_loading(c->view);
1238 }
1239
1240 static void
1241 titlechange(WebKitWebView *view, GParamSpec *pspec, Client *c) {
1242         const gchar *t = webkit_web_view_get_title(view);
1243         if (t) {
1244                 c->title = copystr(&c->title, t);
1245                 updatetitle(c);
1246         }
1247 }
1248
1249 static void
1250 toggle(Client *c, const Arg *arg) {
1251         WebKitWebSettings *settings;
1252         char *name = (char *)arg->v;
1253         gboolean value;
1254         Arg a = { .b = FALSE };
1255
1256         settings = webkit_web_view_get_settings(c->view);
1257         g_object_get(G_OBJECT(settings), name, &value, NULL);
1258         g_object_set(G_OBJECT(settings), name, !value, NULL);
1259
1260         reload(c, &a);
1261 }
1262
1263 static void
1264 togglecookiepolicy(Client *c, const Arg *arg) {
1265         SoupCookieJar *jar;
1266         SoupCookieJarAcceptPolicy policy;
1267
1268         jar = SOUP_COOKIE_JAR(
1269                         soup_session_get_feature(
1270                                 webkit_get_default_session(),
1271                                 SOUP_TYPE_COOKIE_JAR));
1272         g_object_get(G_OBJECT(jar), "accept-policy", &policy, NULL);
1273
1274         policysel++;
1275         if(policysel >= strlen(cookiepolicies))
1276                 policysel = 0;
1277
1278         g_object_set(G_OBJECT(jar), "accept-policy",
1279                         cookiepolicy_get(), NULL);
1280
1281         updatetitle(c);
1282         /* Do not reload. */
1283 }
1284
1285 static void
1286 togglegeolocation(Client *c, const Arg *arg) {
1287         Arg a = { .b = FALSE };
1288
1289         allowgeolocation ^= 1;
1290
1291         reload(c, &a);
1292 }
1293
1294 static void
1295 twitch(Client *c, const Arg *arg) {
1296         GtkAdjustment *a;
1297         gdouble v;
1298
1299         a = gtk_scrolled_window_get_vadjustment(
1300                         GTK_SCROLLED_WINDOW(c->scroll));
1301
1302         v = gtk_adjustment_get_value(a);
1303
1304         v += arg->i;
1305
1306         v = MAX(v, 0.0);
1307         v = MIN(v, gtk_adjustment_get_upper(a) -
1308                         gtk_adjustment_get_page_size(a));
1309         gtk_adjustment_set_value(a, v);
1310 }
1311
1312 static void
1313 togglescrollbars(Client *c, const Arg *arg) {
1314         GtkPolicyType vspolicy;
1315         Arg a;
1316
1317         gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(c->scroll), NULL, &vspolicy);
1318
1319         if(vspolicy == GTK_POLICY_AUTOMATIC) {
1320                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(c->scroll),
1321                                 GTK_POLICY_NEVER, GTK_POLICY_NEVER);
1322         } else {
1323                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(c->scroll),
1324                                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1325                 a.i = +1;
1326                 twitch(c, &a);
1327                 a.i = -1;
1328                 twitch(c, &a);
1329         }
1330 }
1331
1332 static void
1333 togglestyle(Client *c, const Arg *arg) {
1334         WebKitWebSettings *settings = webkit_web_view_get_settings(c->view);
1335         char *uri;
1336
1337         g_object_get(G_OBJECT(settings), "user-stylesheet-uri", &uri, NULL);
1338         if(stylefile == NULL && enablestyles) {
1339                 uri = (uri && uri[0])? g_strdup("") : getstyle(geturi(c));
1340         } else {
1341                 uri = uri[0]? g_strdup("") : g_strconcat("file://",
1342                                 stylefile, NULL);
1343         }
1344         g_object_set(G_OBJECT(settings), "user-stylesheet-uri", uri, NULL);
1345
1346         updatetitle(c);
1347 }
1348
1349 static void
1350 gettogglestat(Client *c){
1351         gboolean value;
1352         char *uri;
1353         int p = 0;
1354         WebKitWebSettings *settings = webkit_web_view_get_settings(c->view);
1355
1356         togglestat[p++] = cookiepolicy_set(cookiepolicy_get());
1357
1358         g_object_get(G_OBJECT(settings), "enable-caret-browsing",
1359                         &value, NULL);
1360         togglestat[p++] = value? 'C': 'c';
1361
1362         togglestat[p++] = allowgeolocation? 'G': 'g';
1363
1364         g_object_get(G_OBJECT(settings), "auto-load-images", &value, NULL);
1365         togglestat[p++] = value? 'I': 'i';
1366
1367         g_object_get(G_OBJECT(settings), "enable-scripts", &value, NULL);
1368         togglestat[p++] = value? 'S': 's';
1369
1370         g_object_get(G_OBJECT(settings), "enable-plugins", &value, NULL);
1371         togglestat[p++] = value? 'V': 'v';
1372
1373         g_object_get(G_OBJECT(settings), "user-stylesheet-uri", &uri, NULL);
1374         togglestat[p++] = (uri && uri[0]) ? 'M': 'm';
1375
1376         togglestat[p] = '\0';
1377 }
1378
1379 static void
1380 getpagestat(Client *c) {
1381         const char *uri = geturi(c);
1382
1383         if(strstr(uri, "https://") == uri) {
1384                 pagestat[0] = c->sslfailed ? 'U' : 'T';
1385         } else {
1386                 pagestat[0] = '-';
1387         }
1388
1389         pagestat[1] = usingproxy ? 'P' : '-';
1390         pagestat[2] = '\0';
1391
1392 }
1393
1394 static void
1395 updatetitle(Client *c) {
1396         char *t;
1397
1398         if(showindicators) {
1399                 gettogglestat(c);
1400                 getpagestat(c);
1401
1402                 if(c->linkhover) {
1403                         t = g_strdup_printf("%s:%s | %s", togglestat,
1404                                         pagestat, c->linkhover);
1405                 } else if(c->progress != 100) {
1406                         t = g_strdup_printf("[%i%%] %s:%s | %s", c->progress,
1407                                         togglestat, pagestat,
1408                                         (c->title == NULL)? "" : c->title);
1409                 } else {
1410                         t = g_strdup_printf("%s:%s | %s", togglestat, pagestat,
1411                                         (c->title == NULL)? "" : c->title);
1412                 }
1413
1414                 gtk_window_set_title(GTK_WINDOW(c->win), t);
1415                 g_free(t);
1416         } else {
1417                 gtk_window_set_title(GTK_WINDOW(c->win),
1418                                 (c->title == NULL)? "" : c->title);
1419         }
1420 }
1421
1422 static void
1423 updatewinid(Client *c) {
1424         snprintf(winid, LENGTH(winid), "%u",
1425                         (int)GDK_WINDOW_XID(GTK_WIDGET(c->win)->window));
1426 }
1427
1428 static void
1429 usage(void) {
1430         die("usage: %s [-bBfFgGiIkKnNpPsSvx]"
1431                 " [-a cookiepolicies ] "
1432                 " [-c cookiefile] [-e xid] [-r scriptfile]"
1433                 " [-t stylefile] [-u useragent] [-z zoomlevel]"
1434                 " [uri]\n", basename(argv0));
1435 }
1436
1437 static void
1438 windowobjectcleared(GtkWidget *w, WebKitWebFrame *frame, JSContextRef js,
1439                 JSObjectRef win, Client *c) {
1440         runscript(frame);
1441 }
1442
1443 static void
1444 zoom(Client *c, const Arg *arg) {
1445         c->zoomed = TRUE;
1446         if(arg->i < 0) {
1447                 /* zoom out */
1448                 webkit_web_view_zoom_out(c->view);
1449         } else if(arg->i > 0) {
1450                 /* zoom in */
1451                 webkit_web_view_zoom_in(c->view);
1452         } else {
1453                 /* reset */
1454                 c->zoomed = FALSE;
1455                 webkit_web_view_set_zoom_level(c->view, 1.0);
1456         }
1457 }
1458
1459 int
1460 main(int argc, char *argv[]) {
1461         Arg arg;
1462         Client *c;
1463
1464         memset(&arg, 0, sizeof(arg));
1465
1466         /* command line args */
1467         ARGBEGIN {
1468         case 'a':
1469                 cookiepolicies = EARGF(usage());
1470                 break;
1471         case 'b':
1472                 enablescrollbars = 0;
1473                 break;
1474         case 'B':
1475                 enablescrollbars = 1;
1476                 break;
1477         case 'c':
1478                 cookiefile = EARGF(usage());
1479                 break;
1480         case 'e':
1481                 embed = strtol(EARGF(usage()), NULL, 0);
1482                 break;
1483         case 'f':
1484                 runinfullscreen = 1;
1485                 break;
1486         case 'F':
1487                 runinfullscreen = 0;
1488                 break;
1489         case 'g':
1490                 allowgeolocation = 0;
1491                 break;
1492         case 'G':
1493                 allowgeolocation = 1;
1494                 break;
1495         case 'i':
1496                 loadimages = 0;
1497                 break;
1498         case 'I':
1499                 loadimages = 1;
1500                 break;
1501         case 'k':
1502                 kioskmode = 0;
1503                 break;
1504         case 'K':
1505                 kioskmode = 1;
1506                 break;
1507         case 'm':
1508                 enablestyles = 0;
1509                 break;
1510         case 'M':
1511                 enablestyles = 1;
1512                 break;
1513         case 'n':
1514                 enableinspector = 0;
1515                 break;
1516         case 'N':
1517                 enableinspector = 1;
1518                 break;
1519         case 'p':
1520                 enableplugins = 0;
1521                 break;
1522         case 'P':
1523                 enableplugins = 1;
1524                 break;
1525         case 'r':
1526                 scriptfile = EARGF(usage());
1527                 break;
1528         case 's':
1529                 enablescripts = 0;
1530                 break;
1531         case 'S':
1532                 enablescripts = 1;
1533                 break;
1534         case 't':
1535                 stylefile = EARGF(usage());
1536                 break;
1537         case 'u':
1538                 useragent = EARGF(usage());
1539                 break;
1540         case 'v':
1541                 die("surf-"VERSION", ©2009-2014 surf engineers, "
1542                                 "see LICENSE for details\n");
1543         case 'x':
1544                 showxid = TRUE;
1545                 break;
1546         case 'z':
1547                 zoomlevel = strtof(EARGF(usage()), NULL);
1548                 break;
1549         default:
1550                 usage();
1551         } ARGEND;
1552         if(argc > 0)
1553                 arg.v = argv[0];
1554
1555         setup();
1556         c = newclient();
1557         if(arg.v) {
1558                 loaduri(clients, &arg);
1559         } else {
1560                 updatetitle(c);
1561         }
1562
1563         gtk_main();
1564         cleanup();
1565
1566         return EXIT_SUCCESS;
1567 }
1568