logo

badwolf

minimalist and privacy-oriented web browser based on WebKitGTK git clone https://hacktivis.me/git/badwolf.git

badwolf.c (45286B)

    

  1. // BadWolf: Minimalist and privacy-oriented WebKitGTK+ browser
  2. // SPDX-FileCopyrightText: 2019-2024 Badwolf Authors <https://hacktivis.me/projects/badwolf>
  3. // SPDX-License-Identifier: BSD-3-Clause
  5. #include "badwolf.h"
  7. #include "bookmarks.h"
  8. #include "config.h"
  9. #include "downloads.h"
  10. #include "fmt.h"
  11. #include "keybindings.h"
  12. #include "uri.h"
  13. #include "userscripts.h"
  15. #include <assert.h>
  16. #include <glib/gi18n.h>   /* _() and other internationalization/localization helpers */
  17. #include <libsoup/soup.h> /* soup* */
  18. #include <locale.h>       /* LC_* */
  19. #include <stdio.h>        /* perror(), fprintf(), snprintf() */
  20. #include <stdlib.h>       /* malloc() */
  21. #include <unistd.h>       /* access(), getopt() */
  23. const gchar *homepage = "https://hacktivis.me/projects/badwolf";
  24. const gchar *version  = VERSION;
  26. struct Window *window = NULL;
  28. static gchar *web_extensions_directory;
  29. static uint64_t context_id_counter = 0;
  30. GtkTreeModel *bookmarks_completion_model;
  32. bool opt_S = false, opt_i = false;
  34. static gboolean WebViewCb_close(WebKitWebView *webView, gpointer user_data);
  35. static gboolean WebViewCb_web_process_terminated(WebKitWebView *webView,
  36.                                                  WebKitWebProcessTerminationReason reason,
  37.                                                  gpointer user_data);
  38. static gboolean
  39. WebViewCb_notify__uri(WebKitWebView *webView, GParamSpec *pspec, gpointer user_data);
  40. static gboolean
  41. WebViewCb_notify__title(WebKitWebView *webView, GParamSpec *pspec, gpointer user_data);
  42. static gboolean
  43. WebViewCb_notify__is__playing__audio(WebKitWebView *webView, GParamSpec *pspec, gpointer user_data);
  44. static gboolean WebViewCb_notify__estimated_load_progress(WebKitWebView *webView,
  45.                                                           GParamSpec *pspec,
  46.                                                           gpointer user_data);
  47. static gboolean WebViewCb_mouse_target_changed(WebKitWebView *webView,
  48.                                                WebKitHitTestResult *hit,
  49.                                                guint modifiers,
  50.                                                gpointer user_data);
  51. static WebKitWebView *WebViewCb_create(WebKitWebView *related_web_view,
  52.                                        WebKitNavigationAction *navigation_action,
  53.                                        gpointer user_data);
  54. static gboolean WebViewCb_permission_request(WebKitWebView *web_view,
  55.                                              WebKitPermissionRequest *request,
  56.                                              gpointer user_data);
  57. static gboolean WebViewCb_decide_policy(WebKitWebView *web_view,
  58.                                         WebKitPolicyDecision *decision,
  59.                                         WebKitPolicyDecisionType decision_type,
  60.                                         gpointer user_data);
  61. static void
  62. WebViewCb_load_changed(WebKitWebView *webView, WebKitLoadEvent load_event, gpointer user_data);
  63. static void web_contextCb_download_started(WebKitWebContext *web_context,
  64.                                            WebKitDownload *download,
  65.                                            gpointer user_data);
  66. static gboolean locationCb_activate(GtkEntry *location, gpointer user_data);
  67. static gboolean javascriptCb_toggled(GtkButton *javascript, gpointer user_data);
  68. static gboolean auto_load_imagesCb_toggled(GtkButton *auto_load_images, gpointer user_data);
  69. static void backCb_clicked(GtkButton *back, gpointer user_data);
  70. static void forwardCb_clicked(GtkButton *forward, gpointer user_data);
  71. static void printCb_clicked(GtkButton *forward, gpointer user_data);
  72. static gboolean SearchEntryCb_next__match(GtkSearchEntry *search, gpointer user_data);
  73. static gboolean SearchEntryCb_previous__match(GtkSearchEntry *search, gpointer user_data);
  74. static gboolean SearchEntryCb_search__changed(GtkSearchEntry *search, gpointer user_data);
  75. static gboolean SearchEntryCb_stop__search(GtkSearchEntry *search, gpointer user_data);
  76. static void new_tabCb_clicked(GtkButton *new_tab, gpointer user_data);
  77. static void closeCb_clicked(GtkButton *close, gpointer user_data);
  78. static void
  79. notebookCb_switch__page(GtkNotebook *notebook, GtkWidget *page, guint page_num, gpointer user_data);
  80. void content_managerCb_ready(GObject *store, GAsyncResult *result, gpointer user_data);
  82. static gboolean
  83. WebViewCb_close(WebKitWebView *UNUSED(webView), gpointer user_data)
  84. {
  85. 	struct Client *browser = (struct Client *)user_data;
  87. 	gtk_widget_destroy(browser->box);
  89. 	free(browser);
  91. 	return TRUE;
  92. }
  94. static gboolean
  95. WebViewCb_web_process_terminated(WebKitWebView *UNUSED(webView),
  96.                                  WebKitWebProcessTerminationReason reason,
  97.                                  gpointer user_data)
  98. {
  99. 	struct Client *browser = (struct Client *)user_data;
  101. 	switch(reason)
  102. 	{
  103. 	case WEBKIT_WEB_PROCESS_CRASHED:
  104. 		fprintf(stderr, "%s", _("the web process crashed.\n"));
  105. 		webView_tab_label_change(browser, _("Crashed"));
  106. 		break;
  107. 	case WEBKIT_WEB_PROCESS_EXCEEDED_MEMORY_LIMIT:
  108. 		fprintf(stderr, "%s", _("the web process exceeded the memory limit.\n"));
  109. 		webView_tab_label_change(browser, _("Out of Memory"));
  110. 		break;
  111. 	case WEBKIT_WEB_PROCESS_TERMINATED_BY_API:
  112. 		fprintf(stderr, "%s", _("the web process was user terminated.\n"));
  113. 		webView_tab_label_change(browser, _("User terminated"));
  114. 		break;
  115. 	default:
  116. 		fprintf(stderr, "%s", _("the web process terminated for an unknown reason.\n"));
  117. 		webView_tab_label_change(browser, _("Unknown Crash"));
  118. 	}
  120. 	return FALSE;
  121. }
  123. static gboolean
  124. WebViewCb_notify__uri(WebKitWebView *UNUSED(webView), GParamSpec *UNUSED(pspec), gpointer user_data)
  125. {
  126. 	const gchar *location_uri;
  127. 	struct Client *browser = (struct Client *)user_data;
  129. 	location_uri = webkit_web_view_get_uri(browser->webView);
  130. 	printf("location_uri: <%s>\n", location_uri);
  132. 	// Don't set if location_uri is NULL / empty, latter happens on WebProcess termination
  133. 	if(location_uri == NULL || location_uri[0] == '\0')
  134. 	{
  135. 		return TRUE;
  136. 	}
  138. 	gtk_entry_set_text(GTK_ENTRY(browser->location), location_uri);
  140. 	if(webkit_uri_for_display(location_uri) != location_uri)
  141. 		gtk_widget_set_tooltip_text(browser->location, webkit_uri_for_display(location_uri));
  142. 	else
  143. 		gtk_widget_set_has_tooltip(browser->location, false);
  145. 	return TRUE;
  146. }
  148. GtkWidget *
  149. badwolf_new_tab_box(const gchar *title, struct Client *browser)
  150. {
  151. 	/* flawfinder: ignore. bound checks are done */
  152. 	char context_id_str[BADWOLF_CTX_SIZ] = {0, 0, 0, 0, 0, 0, 0};
  154. 	fmt_context_id(browser->context_id, context_id_str);
  156. 	GtkWidget *tab_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  157. 	gtk_widget_set_name(tab_box, "browser__tabbox");
  159. 	GtkWidget *close =
  160. 	    gtk_button_new_from_icon_name("window-close-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
  161. 	gtk_widget_set_name(close, "browser__tabbox__close");
  162. 	GtkWidget *label = gtk_label_new(title);
  163. 	gtk_widget_set_name(label, "browser__tabbox__label");
  164. 	GtkWidget *label_event_box = gtk_event_box_new();
  165. 	gtk_container_add(GTK_CONTAINER(label_event_box), label);
  166. 	GtkWidget *context_label = gtk_label_new(context_id_str);
  167. 	gtk_widget_set_name(context_label, "browser__tabbox__context_label");
  168. 	GtkWidget *context_label_event_box = gtk_event_box_new();
  169. 	gtk_container_add(GTK_CONTAINER(context_label_event_box), context_label);
  170. 	GtkWidget *playing =
  171. 	    gtk_image_new_from_icon_name("audio-volume-high-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
  172. 	gtk_widget_set_name(playing, "browser__tabbox__playing");
  173. 	GtkWidget *playing_event_box = gtk_event_box_new();
  174. 	gtk_container_add(GTK_CONTAINER(playing_event_box), playing);
  176. #ifdef BADWOLF_TAB_BOX_WIDTH
  177. 	gtk_widget_set_size_request(label, BADWOLF_TAB_BOX_WIDTH, -1);
  178. #endif
  179. #ifdef BADWOLF_TAB_LABEL_CHARWIDTH
  180. 	gtk_label_set_width_chars(GTK_LABEL(label), BADWOLF_TAB_LABEL_CHARWIDTH);
  181. #endif
  182. 	gtk_widget_set_hexpand(tab_box, BADWOLF_TAB_HEXPAND);
  184. 	gtk_label_set_ellipsize(GTK_LABEL(label), BADWOLF_TAB_LABEL_ELLIPSIZE);
  185. 	gtk_label_set_single_line_mode(GTK_LABEL(label), TRUE);
  186. 	gtk_label_set_single_line_mode(GTK_LABEL(context_label), TRUE);
  188. 	gtk_box_pack_start(GTK_BOX(tab_box), context_label_event_box, TRUE, TRUE, 0);
  189. 	gtk_box_pack_start(GTK_BOX(tab_box), playing_event_box, FALSE, FALSE, 0);
  190. 	gtk_box_pack_start(GTK_BOX(tab_box), label_event_box, TRUE, TRUE, 0);
  191. 	gtk_box_pack_start(GTK_BOX(tab_box), close, FALSE, FALSE, 0);
  193. 	gtk_button_set_relief(GTK_BUTTON(close), GTK_RELIEF_NONE);
  195. 	g_signal_connect(close, "clicked", G_CALLBACK(closeCb_clicked), browser);
  197. 	gtk_widget_set_tooltip_text(tab_box, title);
  199. 	gtk_widget_show_all(tab_box);
  200. 	gtk_widget_set_visible(playing, webkit_web_view_is_playing_audio(browser->webView));
  201. 	gtk_widget_set_events(label, GDK_BUTTON_RELEASE_MASK);
  202. 	g_signal_connect(
  203. 	    tab_box, "button-release-event", G_CALLBACK(tab_boxCb_button_release_event), browser);
  205. 	return tab_box;
  206. }
  208. static gboolean
  209. WebViewCb_notify__title(WebKitWebView *UNUSED(webView),
  210.                         GParamSpec *UNUSED(pspec),
  211.                         gpointer user_data)
  212. {
  213. 	struct Client *browser = (struct Client *)user_data;
  215. 	// Don't set if title is NULL / empty, latter happens on WebProcess crash
  216. 	const char *title = webkit_web_view_get_title(browser->webView);
  217. 	printf("title: <%s>\n", title);
  218. 	if(title == NULL || title[0] == '\0')
  219. 	{
  220. 		return TRUE;
  221. 	}
  223. 	webView_tab_label_change(browser, NULL);
  225. 	return TRUE;
  226. }
  228. static gboolean
  229. WebViewCb_notify__is__playing__audio(WebKitWebView *UNUSED(webView),
  230.                                      GParamSpec *UNUSED(pspec),
  231.                                      gpointer user_data)
  232. {
  233. 	struct Client *browser = (struct Client *)user_data;
  235. 	webView_tab_label_change(browser, NULL);
  237. 	return TRUE;
  238. }
  240. void
  241. webView_tab_label_change(struct Client *browser, const gchar *title)
  242. {
  243. 	GtkWidget *notebook = window->notebook;
  245. #define title_IS_EMPTY title == NULL || title[0] == '\0'
  247. 	if(title_IS_EMPTY) title = webkit_web_view_get_title(browser->webView);
  248. 	if(title_IS_EMPTY) title = webkit_web_view_get_uri(browser->webView);
  249. 	if(title_IS_EMPTY) title = _("Empty Title");
  251. 	gtk_notebook_set_tab_label(
  252. 	    GTK_NOTEBOOK(notebook), browser->box, badwolf_new_tab_box(title, browser));
  253. 	gtk_notebook_set_menu_label_text(GTK_NOTEBOOK(notebook), browser->box, title);
  255. 	// Set the window title if the title change was on the current tab
  256. 	if(gtk_notebook_page_num(GTK_NOTEBOOK(notebook), browser->box) ==
  257. 	   gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)))
  258. 		gtk_window_set_title(GTK_WINDOW(window->main_window), title);
  259. }
  261. static gboolean
  262. WebViewCb_notify__estimated_load_progress(WebKitWebView *UNUSED(webView),
  263.                                           GParamSpec *UNUSED(pspec),
  264.                                           gpointer user_data)
  265. {
  266. 	struct Client *browser = (struct Client *)user_data;
  267. 	gdouble progress;
  269. 	progress = webkit_web_view_get_estimated_load_progress(browser->webView);
  271. 	if(progress >= 1) progress = 0;
  273. 	gtk_entry_set_progress_fraction(GTK_ENTRY(browser->location), progress);
  275. 	return TRUE;
  276. }
  278. static gboolean
  279. WebViewCb_mouse_target_changed(WebKitWebView *UNUSED(webView),
  280.                                WebKitHitTestResult *hit,
  281.                                guint UNUSED(modifiers),
  282.                                gpointer user_data)
  283. {
  284. 	struct Client *browser = (struct Client *)user_data;
  286. 	if(webkit_hit_test_result_context_is_link(hit))
  287. 	{
  288. 		const gchar *link_uri = webkit_hit_test_result_get_link_uri(hit);
  290. 		gtk_label_set_text(GTK_LABEL(browser->statuslabel), webkit_uri_for_display(link_uri));
  291. 	}
  292. 	else
  293. 		gtk_label_set_text(GTK_LABEL(browser->statuslabel), NULL);
  295. 	return FALSE;
  296. }
  298. static gboolean
  299. WebViewCb_scroll_event(GtkWidget *UNUSED(widget), GdkEvent *event, gpointer data)
  300. {
  301. 	struct Client *browser = (struct Client *)data;
  302. 	gdouble delta_x, delta_y;
  303. 	gdouble zoom;
  305. 	if(((GdkEventScroll *)event)->state & GDK_CONTROL_MASK)
  306. 	{
  307. 		gdk_event_get_scroll_deltas(event, &delta_x, &delta_y);
  308. 		zoom = webkit_web_view_get_zoom_level(WEBKIT_WEB_VIEW(browser->webView));
  309. 		zoom -= delta_y * 0.1;
  310. 		webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(browser->webView), zoom);
  311. 		return TRUE;
  312. 	}
  314. 	return FALSE;
  315. }
  317. static WebKitWebView *
  318. WebViewCb_create(WebKitWebView *related_web_view,
  319.                  WebKitNavigationAction *UNUSED(navigation_action),
  320.                  gpointer user_data)
  321. {
  322. 	struct Client *old_browser = (struct Client *)user_data;
  323. 	struct Client *browser     = NULL;
  325. 	// shouldn't be needed but better be safe
  326. 	old_browser->webView = related_web_view;
  328. 	browser = new_browser(NULL, old_browser);
  330. 	if(badwolf_new_tab(GTK_NOTEBOOK(window->notebook), browser, FALSE) < 0)
  331. 		return NULL;
  332. 	else
  333. 		return browser->webView;
  334. }
  336. static gboolean
  337. WebViewCb_permission_request(WebKitWebView *UNUSED(web_view),
  338.                              WebKitPermissionRequest *request,
  339.                              gpointer UNUSED(user_data))
  340. {
  341. 	webkit_permission_request_deny(request);
  343. 	return TRUE; /* Stop other handlers */
  344. }
  346. static gboolean
  347. WebViewCb_decide_policy(WebKitWebView *UNUSED(web_view),
  348.                         WebKitPolicyDecision *decision,
  349.                         WebKitPolicyDecisionType decision_type,
  350.                         gpointer user_data)
  351. {
  352. 	struct Client *old_browser = (struct Client *)user_data;
  353. 	WebKitResponsePolicyDecision *r;
  354. 	WebKitNavigationPolicyDecision *n;
  355. 	WebKitNavigationAction *navigation_action;
  357. 	switch(decision_type)
  358. 	{
  359. 	case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION:
  360. 		n                 = WEBKIT_NAVIGATION_POLICY_DECISION(decision);
  361. 		navigation_action = webkit_navigation_policy_decision_get_navigation_action(n);
  363. 		if(GDK_CONTROL_MASK == webkit_navigation_action_get_modifiers(navigation_action) ||
  364. 		   2 == webkit_navigation_action_get_mouse_button(navigation_action))
  365. 		{
  366. 			WebKitURIRequest *uri   = webkit_navigation_action_get_request(navigation_action);
  367. 			const gchar *target_url = webkit_uri_request_get_uri(uri);
  368. 			struct Client *browser  = new_browser(target_url, old_browser);
  369. 			int ret                 = badwolf_new_tab(GTK_NOTEBOOK(window->notebook), browser, FALSE);
  371. 			if(ret < 0)
  372. 			{
  373. 				fprintf(stderr,
  374. 				        "badwolf: Error while opening <%s> in a new tab (badwolf_new_tab returned %d)\n",
  375. 				        target_url,
  376. 				        ret);
  377. 				return FALSE;
  378. 			}
  379. 			webkit_web_view_load_uri(browser->webView, target_url);
  380. 			webkit_policy_decision_ignore(decision);
  381. 		}
  382. 		else
  383. 		{
  384. 			/* Use whatever default there is. */
  385. 			return FALSE;
  386. 		}
  387. 		break;
  388. 	case WEBKIT_POLICY_DECISION_TYPE_RESPONSE:
  389. 		r = WEBKIT_RESPONSE_POLICY_DECISION(decision);
  390. 		if(!webkit_response_policy_decision_is_mime_type_supported(r))
  391. 			webkit_policy_decision_download(decision);
  392. 		else
  393. 			webkit_policy_decision_use(decision);
  394. 		break;
  395. 	default:
  396. 		/* Use whatever default there is. */
  397. 		return FALSE;
  398. 	}
  400. 	return TRUE;
  401. }
  403. static void
  404. WebViewCb_load_changed(WebKitWebView *UNUSED(webView),
  405.                        WebKitLoadEvent UNUSED(load_event),
  406.                        gpointer user_data)
  407. {
  408. 	struct Client *browser = (struct Client *)user_data;
  410. 	gtk_widget_set_sensitive(browser->back, webkit_web_view_can_go_back(browser->webView));
  411. 	gtk_widget_set_sensitive(browser->forward, webkit_web_view_can_go_forward(browser->webView));
  412. }
  414. static char *
  415. detail_tls_certificate_flags(GTlsCertificateFlags tls_errors)
  416. {
  417. 	GString *errors = g_string_new(NULL);
  419. 	g_string_append_printf(errors,
  420. 	                       _("Couldn't verify the TLS certificate to ensure a better security of the "
  421. 	                         "connection. You might want to verify your machine and network.\n\n"));
  423. 	if(tls_errors & G_TLS_CERTIFICATE_UNKNOWN_CA)
  424. 		g_string_append_printf(errors, _("Error: The X509 Certificate Authority is unknown.\n"));
  426. 	if(tls_errors & G_TLS_CERTIFICATE_BAD_IDENTITY)
  427. 		g_string_append(errors, _("Error: The given identity doesn't match the expected one.\n"));
  429. 	if(tls_errors & G_TLS_CERTIFICATE_NOT_ACTIVATED)
  430. 		g_string_append(errors,
  431. 		                _("Error: The certificate isn't valid yet. Check your system's clock.\n"));
  433. 	if(tls_errors & G_TLS_CERTIFICATE_EXPIRED)
  434. 		g_string_append(errors, _("Error: The certificate has expired. Check your system's clock.\n"));
  436. 	if(tls_errors & G_TLS_CERTIFICATE_REVOKED)
  437. 		g_string_append(errors, _("Error: The certificate has been revoked.\n"));
  439. 	if(tls_errors & G_TLS_CERTIFICATE_INSECURE)
  440. 		g_string_append(errors, _("Error: The certificate is considered to be insecure.\n"));
  442. 	if(tls_errors & G_TLS_CERTIFICATE_GENERIC_ERROR)
  443. 		g_string_append(errors, _("Error: Some unknown error occurred validating the certificate.\n"));
  445. 	return g_string_free(errors, FALSE);
  446. }
  448. static gboolean
  449. WebViewCb_load_failed_with_tls_errors(WebKitWebView *UNUSED(web_view),
  450.                                       gchar *failing_text,
  451.                                       GTlsCertificate *certificate,
  452.                                       GTlsCertificateFlags errors,
  453.                                       gpointer user_data)
  454. {
  455. 	struct Client *browser = (struct Client *)user_data;
  456. 	gchar *error_details   = detail_tls_certificate_flags(errors);
  457. 	gint dialog_response;
  459. #ifndef USE_LIBSOUP2
  460. 	GUri *failing_uri = g_uri_parse(failing_text, G_URI_FLAGS_NONE, NULL);
  461. #else
  462. 	SoupURI *failing_uri = soup_uri_new(failing_text);
  463. #endif
  465. 	GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window->main_window),
  466. 	                                           GTK_DIALOG_MODAL & GTK_DIALOG_DESTROY_WITH_PARENT,
  467. 	                                           GTK_MESSAGE_ERROR,
  468. 	                                           GTK_BUTTONS_NONE,
  469. 	                                           _("TLS Error for %s."),
  470. 	                                           failing_text);
  471. 	gtk_dialog_add_buttons(
  472. 	    GTK_DIALOG(dialog), _("Temporarily Add Exception"), 1, _("Continue"), 0, NULL);
  473. 	if(!failing_uri)
  474. 	{
  475. 		gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), 1, FALSE);
  476. 	}
  477. 	gtk_dialog_set_default_response(GTK_DIALOG(dialog), 0);
  478. 	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s\n", error_details);
  480. 	dialog_response = gtk_dialog_run(GTK_DIALOG(dialog));
  482. 	if(dialog_response == 1)
  483. 	{
  484. #ifndef USE_LIBSOUP2
  485. 		webkit_web_context_allow_tls_certificate_for_host(
  486. 		    webkit_web_view_get_context(browser->webView), certificate, g_uri_get_host(failing_uri));
  487. #else
  488. 		webkit_web_context_allow_tls_certificate_for_host(
  489. 		    webkit_web_view_get_context(browser->webView), certificate, failing_uri->host);
  490. #endif
  491. 		webkit_web_view_reload(browser->webView);
  492. 	}
  494. #ifndef USE_LIBSOUP2
  495. 	/* Calling g_free(failing_uri) ought to be the correct way but this causes a segfault.
  496. 	 *
  497. 	 * - documentation describes it as something which should be free
  498. 	 * - implementation seems to make it a pointer that should be freed
  499. 	 * - epiphany doesn't seems to free/unref it but gnome code seems to frequently have memleaks
  500. 	 *
  501. 	 * Decided to at least continue to try with using g_uri_unref(failing_uri) instead.
  502. 	 * Related fediverse post: <https://queer.hacktivis.me/objects/cec7c4e8-6a58-4358-85bf-b66f9bb21a98>
  503. 	 */
  504. 	g_uri_unref(failing_uri);
  505. #else
  506. 	soup_uri_free(failing_uri);
  507. #endif
  508. 	g_free(error_details);
  509. 	gtk_widget_destroy(dialog);
  511. 	return FALSE; /* propagate the event further */
  512. }
  514. static void
  515. web_contextCb_download_started(WebKitWebContext *UNUSED(web_context),
  516.                                WebKitDownload *webkit_download,
  517.                                gpointer user_data)
  518. {
  519. 	struct Download *download = malloc(sizeof(struct Download));
  521. 	assert(webkit_download);
  523. 	if(download != NULL)
  524. 	{
  525. 		download_new_entry(webkit_download, download);
  527. 		g_signal_connect(
  528. 		    G_OBJECT(webkit_download), "received-data", G_CALLBACK(downloadCb_received_data), download);
  529. 		g_signal_connect(G_OBJECT(webkit_download),
  530. 		                 "created-destination",
  531. 		                 G_CALLBACK(downloadCb_created_destination),
  532. 		                 download);
  533. 		g_signal_connect(G_OBJECT(webkit_download), "failed", G_CALLBACK(downloadCb_failed), download);
  534. 		g_signal_connect(
  535. 		    G_OBJECT(webkit_download), "finished", G_CALLBACK(downloadCb_finished), download);
  536. 	}
  538. 	g_signal_connect(G_OBJECT(webkit_download),
  539. 	                 "decide-destination",
  540. 	                 G_CALLBACK(downloadCb_decide_destination),
  541. 	                 user_data);
  542. }
  544. static gboolean
  545. locationCb_activate(GtkEntry *location, gpointer user_data)
  546. {
  547. 	struct Client *browser = (struct Client *)user_data;
  549. 	webkit_web_view_load_uri(browser->webView,
  550. 	                         badwolf_ensure_uri_scheme(gtk_entry_get_text(location), TRUE));
  552. 	return TRUE;
  553. }
  555. static gboolean
  556. javascriptCb_toggled(GtkButton *javascript, gpointer user_data)
  557. {
  558. 	struct Client *browser = (struct Client *)user_data;
  560. 	WebKitSettings *settings = webkit_web_view_get_settings(browser->webView);
  562. 	webkit_settings_set_enable_javascript_markup(
  563. 	    settings, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(javascript)));
  565. 	webkit_web_view_set_settings(browser->webView, settings);
  567. 	return TRUE;
  568. }
  570. static gboolean
  571. auto_load_imagesCb_toggled(GtkButton *auto_load_images, gpointer user_data)
  572. {
  573. 	struct Client *browser = (struct Client *)user_data;
  575. 	WebKitSettings *settings = webkit_web_view_get_settings(browser->webView);
  577. 	webkit_settings_set_auto_load_images(
  578. 	    settings, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auto_load_images)));
  580. 	webkit_web_view_set_settings(browser->webView, settings);
  582. 	return TRUE;
  583. }
  585. static void
  586. backCb_clicked(GtkButton *UNUSED(back), gpointer user_data)
  587. {
  588. 	struct Client *browser = (struct Client *)user_data;
  590. 	webkit_web_view_go_back(browser->webView);
  591. }
  593. static void
  594. forwardCb_clicked(GtkButton *UNUSED(forward), gpointer user_data)
  595. {
  596. 	struct Client *browser = (struct Client *)user_data;
  598. 	webkit_web_view_go_forward(browser->webView);
  599. }
  601. static void
  602. printCb_clicked(GtkButton *UNUSED(print), gpointer user_data)
  603. {
  604. 	struct Client *browser = (struct Client *)user_data;
  606. 	WebKitPrintOperation *print_operation = webkit_print_operation_new(browser->webView);
  608. 	webkit_print_operation_run_dialog(print_operation, GTK_WINDOW(window->main_window));
  609. }
  611. static gboolean
  612. SearchEntryCb_next__match(GtkSearchEntry *UNUSED(search), gpointer user_data)
  613. {
  614. 	struct Client *browser               = (struct Client *)user_data;
  615. 	WebKitFindController *findController = webkit_web_view_get_find_controller(browser->webView);
  617. 	webkit_find_controller_search_next(findController);
  619. 	return TRUE;
  620. }
  622. static gboolean
  623. SearchEntryCb_previous__match(GtkSearchEntry *UNUSED(search), gpointer user_data)
  624. {
  625. 	struct Client *browser               = (struct Client *)user_data;
  626. 	WebKitFindController *findController = webkit_web_view_get_find_controller(browser->webView);
  628. 	webkit_find_controller_search_previous(findController);
  630. 	return TRUE;
  631. }
  633. static gboolean
  634. SearchEntryCb_search__changed(GtkSearchEntry *search, gpointer user_data)
  635. {
  636. 	struct Client *browser               = (struct Client *)user_data;
  637. 	WebKitFindController *findController = webkit_web_view_get_find_controller(browser->webView);
  638. 	const gchar *search_text             = gtk_entry_get_text(GTK_ENTRY(search));
  640. 	webkit_find_controller_search(findController, search_text, 0, 0);
  642. 	return TRUE;
  643. }
  645. static gboolean
  646. SearchEntryCb_stop__search(GtkSearchEntry *UNUSED(search), gpointer user_data)
  647. {
  648. 	struct Client *browser               = (struct Client *)user_data;
  649. 	WebKitFindController *findController = webkit_web_view_get_find_controller(browser->webView);
  651. 	webkit_find_controller_search_finish(findController);
  653. 	return TRUE;
  654. }
  656. static gboolean
  657. widgetCb_drop_button3_event(GtkWidget *UNUSED(widget), GdkEvent *event, gpointer UNUSED(user_data))
  658. {
  659. 	// Button3 being right-click on right-handed mode, left-click on left-handed mode
  660. 	return ((GdkEventButton *)event)->button == 3;
  661. }
  663. struct Client *
  664. new_browser(const gchar *target_url, struct Client *old_browser)
  665. {
  666. 	struct Client *browser = malloc(sizeof(struct Client));
  667. 	target_url             = badwolf_ensure_uri_scheme(target_url, (old_browser == NULL));
  668. 	char *badwolf_l10n     = NULL;
  670. 	WebKitWebContext *web_context = NULL;
  672. 	if(browser == NULL) return NULL;
  674. 	assert(window != NULL);
  676. 	browser->context_id = old_browser == NULL ? context_id_counter++ : old_browser->context_id;
  677. 	browser->box        = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  678. 	gtk_widget_set_name(browser->box, "browser__box");
  680. 	browser->toolbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  681. 	gtk_widget_set_name(browser->toolbar, "browser__toolbar");
  683. 	browser->back =
  684. 	    gtk_button_new_from_icon_name("go-previous-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
  685. 	gtk_widget_set_name(browser->back, "browser__back");
  687. 	browser->forward = gtk_button_new_from_icon_name("go-next-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
  688. 	gtk_widget_set_name(browser->forward, "browser__forward");
  690. 	GtkWidget *toolbar_separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
  692. 	browser->javascript = gtk_toggle_button_new_with_mnemonic(_("_JS"));
  693. 	gtk_widget_set_name(browser->javascript, "browser__javascript");
  694. 	gtk_widget_set_tooltip_text(browser->javascript, _("Toggle javascript"));
  695. 	gtk_button_set_relief(GTK_BUTTON(browser->javascript), GTK_RELIEF_NONE);
  697. 	browser->auto_load_images = gtk_toggle_button_new_with_mnemonic(_("_IMG"));
  698. 	gtk_widget_set_name(browser->auto_load_images, "browser__load_images");
  699. 	gtk_widget_set_tooltip_text(browser->auto_load_images, _("Toggle loading images automatically"));
  700. 	gtk_button_set_relief(GTK_BUTTON(browser->auto_load_images), GTK_RELIEF_NONE);
  702. 	browser->location = gtk_entry_new();
  703. 	gtk_widget_set_name(browser->location, "browser__location");
  705. 	GtkWidget *print =
  706. 	    gtk_button_new_from_icon_name("document-print-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
  707. 	gtk_widget_set_name(browser->back, "browser__print");
  709. 	browser->statusbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  710. 	gtk_widget_set_name(browser->statusbar, "browser__statusbar");
  711. 	browser->search = gtk_search_entry_new();
  712. 	gtk_widget_set_name(browser->search, "browser__search");
  713. 	browser->statuslabel = gtk_label_new(NULL);
  714. 	gtk_widget_set_name(browser->statuslabel, "browser__statuslabel");
  716. 	if(old_browser == NULL)
  717. 	{
  718. 		WebKitWebsiteDataManager *website_data_manager = webkit_website_data_manager_new_ephemeral();
  719. 		webkit_website_data_manager_set_itp_enabled(website_data_manager, TRUE);
  721. 		web_context = webkit_web_context_new_with_website_data_manager(website_data_manager);
  722. 		g_object_unref(website_data_manager);
  723. 		webkit_web_context_set_sandbox_enabled(web_context, TRUE);
  724. 		webkit_web_context_set_web_extensions_directory(web_context, web_extensions_directory);
  726. 		g_signal_connect(G_OBJECT(web_context),
  727. 		                 "download-started",
  728. 		                 G_CALLBACK(web_contextCb_download_started),
  729. 		                 browser);
  731. 		/* flawfinder: ignore. Consider that g_strsplit is safe enough */
  732. 		badwolf_l10n = getenv("BADWOLF_L10N");
  734. 		if(badwolf_l10n != NULL)
  735. 		{
  736. 			gchar **languages = g_strsplit(badwolf_l10n, ":", -1);
  737. 			webkit_web_context_set_spell_checking_languages(web_context, (const gchar *const *)languages);
  738. 			g_strfreev(languages);
  740. 			webkit_web_context_set_spell_checking_enabled(web_context, TRUE);
  741. 		}
  743. 		webkit_web_context_register_uri_scheme(
  744. 		    web_context, "man", man_uri_scheme_request_cb, NULL, NULL);
  745. 	}
  747. 	WebKitSettings *settings = webkit_settings_new_with_settings(BADWOLF_WEBKIT_SETTINGS);
  748. 	if(opt_S) webkit_settings_set_enable_javascript_markup(settings, true);
  749. 	if(opt_i) webkit_settings_set_auto_load_images(settings, false);
  751. 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(browser->javascript),
  752. 	                             webkit_settings_get_enable_javascript_markup(settings));
  753. 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(browser->auto_load_images),
  754. 	                             webkit_settings_get_auto_load_images(settings));
  756. 	browser->webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
  757. 	                                                "web-context",
  758. 	                                                web_context,
  759. 	                                                "related-view",
  760. 	                                                old_browser == NULL ? NULL : old_browser->webView,
  761. 	                                                "settings",
  762. 	                                                settings,
  763. 	                                                "user-content-manager",
  764. 	                                                window->content_manager,
  765. 	                                                NULL));
  767. 	gtk_widget_set_name(GTK_WIDGET(browser->webView), "browser__webView");
  768. 	if(old_browser == NULL)
  769. 	{
  770. 		g_object_unref(web_context);
  771. 	}
  772. 	g_object_unref(settings);
  774. 	gtk_box_pack_start(
  775. 	    GTK_BOX(browser->toolbar), GTK_WIDGET(browser->back), FALSE, FALSE, BADWOLF_TOOLBAR_PADDING);
  776. 	gtk_box_pack_start(GTK_BOX(browser->toolbar),
  777. 	                   GTK_WIDGET(browser->forward),
  778. 	                   FALSE,
  779. 	                   FALSE,
  780. 	                   BADWOLF_TOOLBAR_PADDING);
  781. 	gtk_box_pack_start(GTK_BOX(browser->toolbar),
  782. 	                   toolbar_separator,
  783. 	                   FALSE,
  784. 	                   FALSE,
  785. 	                   BADWOLF_TOOLBAR_SEPARATOR_PADDING);
  786. 	gtk_box_pack_start(GTK_BOX(browser->toolbar),
  787. 	                   GTK_WIDGET(browser->javascript),
  788. 	                   FALSE,
  789. 	                   FALSE,
  790. 	                   BADWOLF_TOOLBAR_PADDING);
  791. 	gtk_box_pack_start(GTK_BOX(browser->toolbar),
  792. 	                   GTK_WIDGET(browser->auto_load_images),
  793. 	                   FALSE,
  794. 	                   FALSE,
  795. 	                   BADWOLF_TOOLBAR_PADDING);
  796. 	gtk_box_pack_start(GTK_BOX(browser->toolbar),
  797. 	                   GTK_WIDGET(browser->location),
  798. 	                   TRUE,
  799. 	                   TRUE,
  800. 	                   BADWOLF_TOOLBAR_PADDING);
  801. 	gtk_box_pack_start(GTK_BOX(browser->toolbar), print, FALSE, FALSE, BADWOLF_TOOLBAR_PADDING);
  803. 	gtk_container_set_focus_child(GTK_CONTAINER(browser->box), browser->toolbar);
  804. 	gtk_container_set_focus_child(GTK_CONTAINER(browser->toolbar), browser->location);
  806. 	gtk_box_pack_start(
  807. 	    GTK_BOX(browser->box), GTK_WIDGET(browser->toolbar), FALSE, FALSE, BADWOLF_BOX_PADDING);
  808. 	gtk_box_pack_start(
  809. 	    GTK_BOX(browser->box), GTK_WIDGET(browser->webView), TRUE, TRUE, BADWOLF_BOX_PADDING);
  811. 	gtk_box_pack_start(
  812. 	    GTK_BOX(browser->box), GTK_WIDGET(browser->statusbar), FALSE, FALSE, BADWOLF_BOX_PADDING);
  814. 	gtk_box_pack_start(GTK_BOX(browser->statusbar),
  815. 	                   GTK_WIDGET(browser->search),
  816. 	                   FALSE,
  817. 	                   FALSE,
  818. 	                   BADWOLF_STATUSBAR_PADDING);
  819. 	gtk_box_pack_start(GTK_BOX(browser->statusbar),
  820. 	                   GTK_WIDGET(browser->statuslabel),
  821. 	                   FALSE,
  822. 	                   FALSE,
  823. 	                   BADWOLF_STATUSBAR_PADDING);
  825. 	gtk_widget_set_halign(browser->statusbar, GTK_ALIGN_START);
  827. 	gtk_label_set_single_line_mode(GTK_LABEL(browser->statuslabel), TRUE);
  828. 	gtk_label_set_ellipsize(GTK_LABEL(browser->statuslabel), BADWOLF_STATUSLABEL_ELLIPSIZE);
  830. 	if(bookmarks_completion_model != NULL)
  831. 	{
  832. 		GtkEntryCompletion *location_completion = gtk_entry_completion_new();
  833. 		GtkTreeModel *location_completion_model = bookmarks_completion_model;
  835. 		bookmarks_completion_setup(location_completion, location_completion_model);
  836. 		gtk_entry_set_completion(GTK_ENTRY(browser->location), location_completion);
  837. 	}
  839. 	gtk_entry_set_text(GTK_ENTRY(browser->location), target_url);
  840. 	gtk_entry_set_input_purpose(GTK_ENTRY(browser->location), GTK_INPUT_PURPOSE_URL);
  842. 	gtk_entry_set_placeholder_text(GTK_ENTRY(browser->search), _("search in current page"));
  844. 	/* signals for back/forward buttons */
  845. 	g_signal_connect(browser->back, "clicked", G_CALLBACK(backCb_clicked), browser);
  846. 	g_signal_connect(browser->forward, "clicked", G_CALLBACK(forwardCb_clicked), browser);
  847. 	/* prevents GtkNotebook from spawning it's context-menu */
  848. 	g_signal_connect(
  849. 	    browser->back, "button-press-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  850. 	g_signal_connect(
  851. 	    browser->back, "button-release-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  852. 	g_signal_connect(
  853. 	    browser->forward, "button-press-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  854. 	g_signal_connect(
  855. 	    browser->forward, "button-release-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  857. 	/* signals for javascript toggle widget */
  858. 	g_signal_connect(browser->javascript, "toggled", G_CALLBACK(javascriptCb_toggled), browser);
  859. 	/* prevents GtkNotebook from spawning it's context-menu */
  860. 	g_signal_connect(
  861. 	    browser->javascript, "button-press-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  862. 	g_signal_connect(
  863. 	    browser->javascript, "button-release-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  865. 	/* signals for auto_load_images toggle widget */
  866. 	g_signal_connect(
  867. 	    browser->auto_load_images, "toggled", G_CALLBACK(auto_load_imagesCb_toggled), browser);
  868. 	/* prevents GtkNotebook from spawning it's context-menu */
  869. 	g_signal_connect(browser->auto_load_images,
  870. 	                 "button-press-event",
  871. 	                 G_CALLBACK(widgetCb_drop_button3_event),
  872. 	                 NULL);
  873. 	g_signal_connect(browser->auto_load_images,
  874. 	                 "button-release-event",
  875. 	                 G_CALLBACK(widgetCb_drop_button3_event),
  876. 	                 NULL);
  878. 	/* signals for location entry widget */
  879. 	g_signal_connect(browser->location, "activate", G_CALLBACK(locationCb_activate), browser);
  881. 	/* signals for print button */
  882. 	g_signal_connect(print, "clicked", G_CALLBACK(printCb_clicked), browser);
  883. 	/* prevents GtkNotebook from spawning it's context-menu */
  884. 	g_signal_connect(print, "button-press-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  885. 	g_signal_connect(print, "button-release-event", G_CALLBACK(widgetCb_drop_button3_event), NULL);
  887. 	/* signals for WebView widget */
  888. 	g_signal_connect(browser->webView,
  889. 	                 "web-process-terminated",
  890. 	                 G_CALLBACK(WebViewCb_web_process_terminated),
  891. 	                 browser);
  892. 	g_signal_connect(browser->webView, "notify::uri", G_CALLBACK(WebViewCb_notify__uri), browser);
  893. 	g_signal_connect(browser->webView, "notify::title", G_CALLBACK(WebViewCb_notify__title), browser);
  894. 	g_signal_connect(browser->webView,
  895. 	                 "notify::is-playing-audio",
  896. 	                 G_CALLBACK(WebViewCb_notify__is__playing__audio),
  897. 	                 browser);
  898. 	g_signal_connect(browser->webView,
  899. 	                 "mouse-target-changed",
  900. 	                 G_CALLBACK(WebViewCb_mouse_target_changed),
  901. 	                 browser);
  902. 	g_signal_connect(browser->webView,
  903. 	                 "notify::estimated-load-progress",
  904. 	                 G_CALLBACK(WebViewCb_notify__estimated_load_progress),
  905. 	                 browser);
  906. 	g_signal_connect(browser->webView, "create", G_CALLBACK(WebViewCb_create), browser);
  907. 	g_signal_connect(browser->webView, "close", G_CALLBACK(WebViewCb_close), browser);
  909. 	g_signal_connect(
  910. 	    browser->webView, "key-press-event", G_CALLBACK(WebViewCb_key_press_event), browser);
  911. 	g_signal_connect(browser->webView, "scroll-event", G_CALLBACK(WebViewCb_scroll_event), browser);
  912. 	g_signal_connect(
  913. 	    browser->webView, "permission-request", G_CALLBACK(WebViewCb_permission_request), NULL);
  914. 	g_signal_connect(browser->webView, "decide-policy", G_CALLBACK(WebViewCb_decide_policy), browser);
  915. 	g_signal_connect(browser->webView,
  916. 	                 "load-failed-with-tls-errors",
  917. 	                 G_CALLBACK(WebViewCb_load_failed_with_tls_errors),
  918. 	                 browser);
  919. 	g_signal_connect(browser->webView, "load-changed", G_CALLBACK(WebViewCb_load_changed), browser);
  921. 	/* signals for search widget */
  922. 	g_signal_connect(browser->search, "next-match", G_CALLBACK(SearchEntryCb_next__match), browser);
  923. 	g_signal_connect(
  924. 	    browser->search, "previous-match", G_CALLBACK(SearchEntryCb_previous__match), browser);
  925. 	g_signal_connect(
  926. 	    browser->search, "search-changed", G_CALLBACK(SearchEntryCb_search__changed), browser);
  927. 	g_signal_connect(browser->search, "stop-search", G_CALLBACK(SearchEntryCb_stop__search), browser);
  929. 	/* signals for box container */
  930. 	g_signal_connect(browser->box, "key-press-event", G_CALLBACK(boxCb_key_press_event), browser);
  932. 	if(old_browser == NULL) webkit_web_view_load_uri(browser->webView, target_url);
  934. 	return browser;
  935. }
  937. /* badwolf_new_tab: Inserts struct Client *browser in GtkNotebook *notebook 
  938.  * and optionally switches selected tab to it.
  939.  *
  940.  * returns:
  941.  * 0  : Ran successfully
  942.  * -1 : Failed to insert a page for browser->box
  943.  * -2 : browser is NULL
  944.  */
  945. int
  946. badwolf_new_tab(GtkNotebook *notebook, struct Client *browser, bool auto_switch)
  947. {
  948. 	gint current_page = gtk_notebook_get_current_page(notebook);
  949. 	gchar *title      = _("New tab");
  951. 	if(browser == NULL) return -2;
  953. 	gtk_widget_show_all(browser->box);
  955. 	if(gtk_notebook_insert_page(notebook, browser->box, NULL, (current_page + 1)) == -1) return -1;
  957. 	gtk_notebook_set_tab_reorderable(notebook, browser->box, TRUE);
  958. 	gtk_notebook_set_tab_label(notebook, browser->box, badwolf_new_tab_box(title, browser));
  959. 	gtk_notebook_set_menu_label_text(GTK_NOTEBOOK(notebook), browser->box, title);
  961. 	gtk_widget_queue_draw(GTK_WIDGET(notebook));
  963. 	if(auto_switch)
  964. 	{
  965. 		gtk_notebook_set_current_page(notebook, gtk_notebook_page_num(notebook, browser->box));
  966. 	}
  968. 	return 0;
  969. }
  971. static void
  972. new_tabCb_clicked(GtkButton *UNUSED(new_tab), gpointer UNUSED(user_data))
  973. {
  974. 	struct Client *browser = new_browser(NULL, NULL);
  976. 	badwolf_new_tab(GTK_NOTEBOOK(window->notebook), browser, TRUE);
  977. }
  979. static void
  980. closeCb_clicked(GtkButton *UNUSED(close), gpointer user_data)
  981. {
  982. 	struct Client *browser = (struct Client *)user_data;
  984. 	webkit_web_view_try_close(browser->webView);
  985. }
  987. static void
  988. notebookCb_switch__page(GtkNotebook *notebook,
  989.                         GtkWidget *page,
  990.                         guint UNUSED(page_num),
  991.                         gpointer UNUSED(user_data))
  992. {
  993. 	GtkWidget *label = gtk_notebook_get_tab_label(notebook, page);
  995. 	// TODO: Maybe find a better way to store the title
  996. 	gtk_window_set_title(GTK_WINDOW(window->main_window), gtk_widget_get_tooltip_text(label));
  997. }
  999. void
  1000. content_managerCb_ready(GObject *UNUSED(store), GAsyncResult *result, gpointer UNUSED(user_data))
  1001. {
  1002. 	GError *err = NULL;
  1004. 	WebKitUserContentFilter *filter =
  1005. 	    webkit_user_content_filter_store_load_finish(window->content_store, result, &err);
  1007. 	if(filter == NULL)
  1008. 	{
  1009. 		if(err == NULL)
  1010. 		{
  1011. 			fprintf(stderr, _("badwolf: failed to load content-filter, err: [%d] %s\n"), -1, "unknown");
  1012. 		}
  1013. 		else
  1014. 		{
  1015. 			fprintf(stderr,
  1016. 			        _("badwolf: failed to load content-filter, err: [%d] %s\n"),
  1017. 			        err->code,
  1018. 			        err->message);
  1019. 		}
  1020. 	}
  1021. 	else
  1022. 	{
  1023. 		fprintf(stderr, _("badwolf: content-filter loaded, adding to content-manager…\n"));
  1024. 		webkit_user_content_manager_add_filter(window->content_manager, filter);
  1025. 	}
  1026. }
  1028. static void
  1029. storeCb_finish(WebKitUserContentFilterStore *UNUSED(store),
  1030.                GAsyncResult *result,
  1031.                gpointer UNUSED(user_data))
  1032. {
  1033. 	GError *err = NULL;
  1035. 	WebKitUserContentFilter *filter =
  1036. 	    webkit_user_content_filter_store_save_finish(window->content_store, result, &err);
  1038. 	if(filter == NULL)
  1039. 	{
  1040. 		if(err == NULL)
  1041. 		{
  1042. 			fprintf(stderr,
  1043. 			        _("badwolf: failed to compile content-filters.json, err: [%d] %s\n"),
  1044. 			        -1,
  1045. 			        "unknown");
  1046. 		}
  1047. 		else
  1048. 		{
  1049. 			fprintf(stderr,
  1050. 			        _("badwolf: failed to compile content-filters.json, err: [%d] %s\n"),
  1051. 			        err->code,
  1052. 			        err->message);
  1053. 		}
  1054. 	}
  1055. 	else
  1056. 	{
  1057. 		webkit_user_content_filter_store_load(
  1058. 		    window->content_store, "a", NULL, content_managerCb_ready, window);
  1059. 	}
  1060. }
  1062. int
  1063. main(int argc, char *argv[])
  1064. {
  1065. 	GApplication *application;
  1066. 	errno = 0;
  1067. 	setlocale(LC_ALL, "");
  1068. 	if(errno != 0)
  1069. 	{
  1070. 		fprintf(stderr, "badwolf: Warning: Failed to initialize locales: %s\n", strerror(errno));
  1071. 		errno = 0;
  1072. 	}
  1073. 	bindtextdomain(PACKAGE, DATADIR "/locale");
  1074. 	bind_textdomain_codeset(PACKAGE, "UTF-8");
  1075. 	textdomain(PACKAGE);
  1077. 	application = g_application_new("me.hacktivis.badwolf",
  1078. 	                                G_APPLICATION_HANDLES_COMMAND_LINE |
  1079. 	                                    G_APPLICATION_SEND_ENVIRONMENT | G_APPLICATION_NON_UNIQUE);
  1080. 	g_application_register(application, NULL, NULL);
  1081. 	//g_application_activate(application);
  1083. 	gtk_init(&argc, &argv);
  1085. 	int c = EOF;
  1086. 	while((c = getopt(argc, argv, "iS")) != EOF)
  1087. 	{
  1088. 		switch(c)
  1089. 		{
  1090. 		case 'i':
  1091. 			opt_i = true;
  1092. 			break;
  1093. 		case 'S':
  1094. 			opt_S = true;
  1095. 			break;
  1096. 		case '?':
  1097. 			fprintf(stderr, _("badwolf: Unrecognized option: '-%c'\n"), optopt);
  1098. 			return 1;
  1099. 		}
  1100. 	}
  1102. 	argc -= optind;
  1103. 	argv += optind;
  1105. 	fprintf(stderr, _("Running Badwolf version: %s\n"), version);
  1106. 	fprintf(stderr,
  1107. 	        _("Buildtime WebKit version: %d.%d.%d\n"),
  1108. 	        WEBKIT_MAJOR_VERSION,
  1109. 	        WEBKIT_MINOR_VERSION,
  1110. 	        WEBKIT_MICRO_VERSION);
  1111. 	fprintf(stderr,
  1112. 	        _("Runtime WebKit version: %d.%d.%d\n"),
  1113. 	        webkit_get_major_version(),
  1114. 	        webkit_get_minor_version(),
  1115. 	        webkit_get_micro_version());
  1117. 	web_extensions_directory =
  1118. 	    g_build_filename(g_get_user_data_dir(), "badwolf", "webkit-web-extension", NULL);
  1119. 	fprintf(stderr, _("webkit-web-extension directory set to: %s\n"), web_extensions_directory);
  1121. 	bookmarks_completion_model = bookmarks_completion_init();
  1122. 	g_object_ref(bookmarks_completion_model);
  1124. 	gchar *filtersPath = g_build_filename(g_get_user_cache_dir(), g_get_prgname(), "filters", NULL);
  1126. 	window = &(struct Window){
  1127. 	    .main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL),
  1128. 	    .notebook    = gtk_notebook_new(),
  1129. 	    .new_tab     = gtk_button_new_from_icon_name("tab-new-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR),
  1130. 	    .downloads_tab   = badwolf_downloads_tab_new(),
  1131. 	    .content_manager = webkit_user_content_manager_new(),
  1132. 	    .content_store   = webkit_user_content_filter_store_new(filtersPath),
  1133. 	};
  1135. 	load_userscripts(window->content_manager);
  1137. 	assert(window != NULL);
  1139. 	gchar *contentFilterPath =
  1140. 	    g_build_filename(g_get_user_config_dir(), g_get_prgname(), "content-filters.json", NULL);
  1141. 	GFile *contentFilterFile = g_file_new_for_path(contentFilterPath);
  1142. 	fprintf(stderr, _("content-filters file set to: %s\n"), contentFilterPath);
  1144. 	webkit_user_content_filter_store_save_from_file(window->content_store,
  1145. 	                                                "a",
  1146. 	                                                contentFilterFile,
  1147. 	                                                NULL,
  1148. 	                                                (GAsyncReadyCallback)storeCb_finish,
  1149. 	                                                window);
  1151. 	gtk_window_set_default_size(
  1152. 	    GTK_WINDOW(window->main_window), BADWOLF_DEFAULT_WIDTH, BADWOLF_DEFAULT_HEIGHT);
  1153. 	gtk_window_set_role(GTK_WINDOW(window->main_window), "browser");
  1154. 	gtk_window_set_icon_name(GTK_WINDOW(window->main_window), "badwolf");
  1156. 	gchar *provider_path_app = g_build_filename(DATADIR, "interface.css", NULL);
  1157. 	/* flawfinder: ignore, just a presence check */
  1158. 	if(access(provider_path_app, R_OK) == 0)
  1159. 	{
  1160. 		GtkCssProvider *css_provider_app = gtk_css_provider_new();
  1161. 		gtk_css_provider_load_from_path(css_provider_app, provider_path_app, NULL);
  1162. 		gtk_style_context_add_provider_for_screen(
  1163. 		    gtk_widget_get_screen(GTK_WIDGET(window->main_window)),
  1164. 		    GTK_STYLE_PROVIDER(css_provider_app),
  1165. 		    GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
  1166. 	}
  1167. 	g_free(provider_path_app);
  1169. 	gchar *provider_path_user =
  1170. 	    g_build_filename(g_get_user_data_dir(), "badwolf", "interface.css", NULL);
  1171. 	/* flawfinder: ignore, just a presence check */
  1172. 	if(access(provider_path_user, R_OK) == 0)
  1173. 	{
  1174. 		GtkCssProvider *css_provider_user = gtk_css_provider_new();
  1175. 		gtk_css_provider_load_from_path(css_provider_user, provider_path_user, NULL);
  1176. 		gtk_style_context_add_provider_for_screen(
  1177. 		    gtk_widget_get_screen(GTK_WIDGET(window->main_window)),
  1178. 		    GTK_STYLE_PROVIDER(css_provider_user),
  1179. 		    GTK_STYLE_PROVIDER_PRIORITY_USER);
  1180. 	}
  1181. 	g_free(provider_path_user);
  1183. 	gtk_widget_set_tooltip_text(window->new_tab, _("Open new tab"));
  1185. 	gtk_notebook_set_action_widget(GTK_NOTEBOOK(window->notebook), window->new_tab, GTK_PACK_END);
  1186. 	gtk_notebook_set_scrollable(GTK_NOTEBOOK(window->notebook), TRUE);
  1187. 	gtk_notebook_set_tab_pos(GTK_NOTEBOOK(window->notebook), BADWOLF_TAB_POSITION);
  1188. 	gtk_notebook_popup_enable(GTK_NOTEBOOK(window->notebook));
  1190. 	gtk_container_add(GTK_CONTAINER(window->main_window), window->notebook);
  1191. 	gtk_widget_queue_draw(window->notebook);
  1193. 	badwolf_downloads_tab_attach();
  1195. 	g_signal_connect(
  1196. 	    window->main_window, "key-press-event", G_CALLBACK(main_windowCb_key_press_event), NULL);
  1198. 	g_signal_connect(window->main_window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
  1199. 	g_signal_connect(window->new_tab, "clicked", G_CALLBACK(new_tabCb_clicked), NULL);
  1200. 	g_signal_connect(window->notebook, "switch-page", G_CALLBACK(notebookCb_switch__page), NULL);
  1202. 	gtk_widget_show(window->new_tab);
  1203. 	gtk_widget_show_all(window->main_window);
  1205. 	if(argc == 0)
  1206. 		badwolf_new_tab(GTK_NOTEBOOK(window->notebook), new_browser(NULL, NULL), FALSE);
  1207. 	else
  1208. 		for(int i = 0; i < argc; ++i)
  1209. 			badwolf_new_tab(GTK_NOTEBOOK(window->notebook), new_browser(argv[i], NULL), FALSE);
  1211. 	gtk_notebook_set_current_page(GTK_NOTEBOOK(window->notebook), 1);
  1213. 	gtk_main();
  1215. 	g_object_unref(bookmarks_completion_model);
  1217. #if 0
  1218. 	/* TRANSLATOR Ignore this entry. Done for forcing Unicode in xgettext. */
  1219. 	_("ø");
  1220. #endif
  1222. 	return 0;
  1223. }