int main (int argc, char* argv[]) { const char *uri; WebKitWebView* web_view; GMainLoop* loop; SoupSession *session; gtk_init(&argc, &argv); if (argc == 1) { printf("Usage: URI\n"); return 1; } uri = argv[1]; if (!g_thread_supported()) {g_thread_init(NULL);} loop = g_main_loop_new(NULL, TRUE); session = webkit_get_default_session(); g_signal_connect(session, "request-started", G_CALLBACK(request_started_cb), NULL); web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(G_OBJECT(web_view)); g_signal_connect(web_view, "notify::load-status", G_CALLBACK(load_status_cb), loop); webkit_web_view_load_uri(web_view, uri); g_main_loop_run(loop); g_object_unref(web_view); return 0; }
void ripcurl_init(void) { /* webkit settings */ ripcurl->Global.webkit_settings = webkit_web_settings_new(); /* libsoup session */ ripcurl->Global.soup_session = webkit_get_default_session(); /* browser list */ ripcurl->Global.browsers = NULL; /* bookmarks list */ ripcurl->Global.bookmarks = NULL; /* history list */ ripcurl->Global.history = NULL; /* command history list */ ripcurl->Global.command_history = NULL; /* GDK keymap */ ripcurl->Global.keymap = gdk_keymap_get_default(); /* create config dir */ ripcurl->Files.config_dir = g_build_filename(g_get_user_config_dir(), "ripcurl", NULL); g_mkdir_with_parents(ripcurl->Files.config_dir, 0771); }
void LayoutTestController::setAlwaysAcceptCookies(bool alwaysAcceptCookies) { #ifdef HAVE_LIBSOUP_2_29_90 SoupSession* session = webkit_get_default_session(); SoupCookieJar* jar = reinterpret_cast<SoupCookieJar*>(soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR)); /* If the jar was not created - we create it on demand, i.e, just in case we have HTTP requests - then we must create it here in order to set the proper accept policy */ if (!jar) { jar = soup_cookie_jar_new(); soup_session_add_feature(session, SOUP_SESSION_FEATURE(jar)); g_object_unref(jar); } SoupCookieJarAcceptPolicy policy; if (alwaysAcceptCookies) policy = SOUP_COOKIE_JAR_ACCEPT_ALWAYS; else policy = SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY; g_object_set(G_OBJECT(jar), SOUP_COOKIE_JAR_ACCEPT_POLICY, policy, NULL); #endif }
OssiferSession * ossifer_session_initialize (const gchar *cookie_db_path, OssiferSessionCookieJarChanged cookie_jar_changed_callback) { static OssiferSession *session_instance = NULL; SoupSession *session; SoupCookieJar *cookie_jar; gchar *path; if (session_instance != NULL) { return session_instance; } session_instance = g_new0 (OssiferSession, 1); session_instance->cookie_jar_changed = cookie_jar_changed_callback; session = webkit_get_default_session (); g_object_set (session, SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE, NULL); path = g_strdup_printf ("%s.sqlite", cookie_db_path); cookie_jar = soup_cookie_jar_db_new (path, FALSE); soup_session_add_feature (session, SOUP_SESSION_FEATURE (cookie_jar)); g_object_unref (cookie_jar); g_free (path); g_signal_connect (cookie_jar, "changed", G_CALLBACK (ossifer_session_cookie_jar_changed), session_instance); return session_instance; }
/* ghtml_set_proxy */ int ghtml_set_proxy(GtkWidget * widget, SurferProxyType type, char const * http, unsigned int http_port) { #if WEBKIT_CHECK_VERSION(1, 1, 0) SoupSession * session; char buf[32]; struct hostent * he; struct in_addr addr; SoupURI * uri = NULL; session = webkit_get_default_session(); if(type == SPT_HTTP && http != NULL && strlen(http) > 0) { if((he = gethostbyname(http)) == NULL) return -error_set_code(1, "%s: %s", http, hstrerror( h_errno)); memcpy(&addr.s_addr, he->h_addr, sizeof(addr.s_addr)); snprintf(buf, sizeof(buf), "http://%s:%u/", inet_ntoa(addr), http_port); uri = soup_uri_new(buf); } g_object_set(session, "proxy-uri", uri, NULL); return 0; #else /* FIXME really implement */ return -error_set_code(1, "%s", strerror(ENOSYS)); #endif }
int main(int argc, char *argv[]) { gchar *uri = NULL, *file = NULL; SoupSession *s; Client *c; int o; const gchar *home, *filename; gtk_init(NULL, NULL); if (!g_thread_supported()) g_thread_init(NULL); setup(); while((o = getopt(argc, argv, "vhxeu:f:")) != -1) switch(o) { case 'x': showxid = TRUE; break; case 'e': showxid = TRUE; embed = TRUE; break; case 'u': if(!(uri = optarg)) goto argerr; c = newclient(); loaduri(c, uri); updatetitle(c); break; case 'f': if(!(file = optarg)) goto argerr; c = newclient(); loadfile(c, file); updatetitle(c); break; case 'v': die("surf-"VERSION", © 2009 surf engineers, see LICENSE for details\n"); break; argerr: default: puts("surf - simple browser"); die("usage: surf [-e] [-x] [-u uri] [-f file]\n"); return EXIT_FAILURE; } if(optind != argc) goto argerr; if(!clients) newclient(); /* cookie persistance */ s = webkit_get_default_session(); home = g_get_home_dir(); filename = g_build_filename(home, ".surf-cookies", NULL); cookiejar = soup_cookie_jar_text_new(filename, FALSE); soup_session_add_feature(s, SOUP_SESSION_FEATURE(cookiejar)); gtk_main(); cleanup(); return EXIT_SUCCESS; }
void setup(void) { char *proxy; char *new_proxy; SoupURI *puri; SoupSession *s; /* clean up any zombies immediately */ sigchld(0); gtk_init(NULL, NULL); if (!g_thread_supported()) g_thread_init(NULL); dpy = GDK_DISPLAY(); s = webkit_get_default_session(); /* atoms */ atoms[AtomFind] = XInternAtom(dpy, "_SURF_FIND", False); atoms[AtomGo] = XInternAtom(dpy, "_SURF_GO", False); atoms[AtomUri] = XInternAtom(dpy, "_SURF_URI", False); /* dirs and files */ cookiefile = buildpath(cookiefile); scriptfile = buildpath(scriptfile); stylefile = buildpath(stylefile); /* request handler */ s = webkit_get_default_session(); soup_session_remove_feature_by_type(s, soup_cookie_get_type()); soup_session_remove_feature_by_type(s, soup_cookie_jar_get_type()); g_signal_connect_after(G_OBJECT(s), "request-started", G_CALLBACK(newrequest), NULL); /* proxy */ if((proxy = getenv("http_proxy")) && strcmp(proxy, "")) { new_proxy = g_strrstr(proxy, "http://") ? g_strdup(proxy) : g_strdup_printf("http://%s", proxy); puri = soup_uri_new(new_proxy); g_object_set(G_OBJECT(s), "proxy-uri", puri, NULL); soup_uri_free(puri); g_free(new_proxy); } XSetErrorHandler(&xerrorhandler); }
JNIEXPORT jintLong JNICALL WebKitGTK_NATIVE(_1webkit_1get_1default_1session) (JNIEnv *env, jclass that) { jintLong rc = 0; WebKitGTK_NATIVE_ENTER(env, that, _1webkit_1get_1default_1session_FUNC); rc = (jintLong)webkit_get_default_session(); WebKitGTK_NATIVE_EXIT(env, that, _1webkit_1get_1default_1session_FUNC); return rc; }
static SoupCookieJar *get_current_cookie_jar () { SoupSession *session = webkit_get_default_session (); SoupCookieJar *jar; jar = (SoupCookieJar*)soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR); /* WebKit might not have a cookie jar yet, if it has not needed one * and none has been set by Epiphany. */ return jar ? g_object_ref (jar) : NULL; }
void spike_setup_webkit_globals(char * web_database_path, char * cookie_jar_path) { //eg. /tmp/spike.webkit.db webkit_set_web_database_directory_path(web_database_path); SoupSession * ses = webkit_get_default_session(); //eg. /tmp/spike.webkit.cookie.db SoupCookieJar * jar = soup_cookie_jar_sqlite_new(cookie_jar_path, 0); soup_session_add_feature( ses, SOUP_SESSION_FEATURE (jar)); }
void setup(void) { SoupSession *s; char *proxy; char *new_proxy; SoupURI *puri; /* clean up any zombies immediately */ sigchld(0); gtk_init(NULL, NULL); if (!g_thread_supported()) g_thread_init(NULL); dpy = GDK_DISPLAY(); session = webkit_get_default_session(); uriprop = XInternAtom(dpy, "_SURF_URI", False); findprop = XInternAtom(dpy, "_SURF_FIND", False); /* create dirs and files */ cookiefile = buildpath(cookiefile); dldir = buildpath(dldir); scriptfile = buildpath(scriptfile); stylefile = buildpath(stylefile); /* cookie persistance */ s = webkit_get_default_session(); cookies = soup_cookie_jar_new(); soup_session_add_feature(s, SOUP_SESSION_FEATURE(cookies)); g_signal_connect(cookies, "changed", G_CALLBACK(changecookie), NULL); if((proxy = getenv("http_proxy")) && strcmp(proxy, "")) { new_proxy = g_strrstr(proxy, "http://") ? g_strdup(proxy) : g_strdup_printf("http://%s", proxy); puri = soup_uri_new(new_proxy); g_object_set(G_OBJECT(s), "proxy-uri", puri, NULL); soup_uri_free(puri); g_free(new_proxy); } reloadcookies(); }
OssiferSession * ossifer_session_initialize (const gchar *cookie_db_path, OssiferSessionCookieJarChanged cookie_jar_changed_callback) { static OssiferSession *session_instance = NULL; SoupSession *session; SoupCookieJar *cookie_jar; gchar *path; if (session_instance != NULL) { return session_instance; } session_instance = g_new0 (OssiferSession, 1); session_instance->cookie_jar_changed = cookie_jar_changed_callback; session = webkit_get_default_session (); #ifdef HAVE_LIBSOUP_2_38 g_object_set (session, SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE, NULL); #endif #ifdef HAVE_LIBSOUP_2_38 g_object_set (session, SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE, NULL); #endif #ifdef HAVE_LIBSOUP_GNOME path = g_strdup_printf ("%s.sqlite", cookie_db_path); cookie_jar = soup_cookie_jar_sqlite_new (path, FALSE); #else path = g_strdup_printf ("%s.txt", cookie_db_path); cookie_jar = soup_cookie_jar_text_new (path, FALSE); #endif soup_session_add_feature (session, SOUP_SESSION_FEATURE (cookie_jar)); g_object_unref (cookie_jar); g_free (path); g_signal_connect (cookie_jar, "changed", G_CALLBACK (ossifer_session_cookie_jar_changed), session_instance); #ifdef HAVE_LIBSOUP_GNOME soup_session_add_feature_by_type (session, SOUP_TYPE_PROXY_RESOLVER_GNOME); #endif return session_instance; }
/* ghtml_set_user_agent */ int ghtml_set_user_agent(GtkWidget * ghtml, char const * user_agent) { #if WEBKIT_CHECK_VERSION(1, 1, 0) SoupSession * session; session = webkit_get_default_session(); g_object_set(session, "user-agent", user_agent, NULL); return 0; #else if(user_agent == NULL) return 0; return -error_set_code(1, "%s", strerror(ENOSYS)); #endif }
widget_t * widget_webview(widget_t *w) { w->index = luaH_webview_index; w->newindex = luaH_webview_newindex; w->destructor = webview_destructor; /* init soup session & cookies handling */ if (!Soup.session) { Soup.session = webkit_get_default_session(); gchar *cookie_file = g_build_filename(globalconf.base_data_directory, "cookies.txt", NULL); Soup.cookiejar = soup_cookie_jar_text_new(cookie_file, FALSE); soup_session_add_feature(Soup.session, (SoupSessionFeature*) Soup.cookiejar); g_free(cookie_file); } GtkWidget *view = webkit_web_view_new(); w->widget = gtk_scrolled_window_new(NULL, NULL); g_object_set_data(G_OBJECT(w->widget), "widget", w); g_object_set_data(G_OBJECT(w->widget), "webview", view); gtk_container_add(GTK_CONTAINER(w->widget), view); show_scrollbars(w, TRUE); /* connect webview signals */ g_object_connect((GObject*)view, "signal::button-press-event", (GCallback)wv_button_press_cb, w, "signal::expose-event", (GCallback)expose_cb, w, "signal::focus-in-event", (GCallback)focus_cb, w, "signal::focus-out-event", (GCallback)focus_cb, w, "signal::hovering-over-link", (GCallback)link_hover_cb, w, "signal::key-press-event", (GCallback)key_press_cb, w, "signal::load-committed", (GCallback)load_commit_cb, w, "signal::load-finished", (GCallback)load_finish_cb, w, "signal::load-progress-changed", (GCallback)progress_cb, w, "signal::load-started", (GCallback)load_start_cb, w, "signal::navigation-policy-decision-requested", (GCallback)navigation_decision_cb, w, "signal::parent-set", (GCallback)parent_set_cb, w, "signal::title-changed", (GCallback)title_changed_cb, w, "signal::download-requested", (GCallback)download_request_cb, w, "signal::mime-type-policy-decision-requested", (GCallback)mime_type_decision_cb, w, NULL); /* setup */ gtk_widget_show(view); gtk_widget_show(w->widget); return w; }
int main (int argc, char** argv) { midori_app_setup (argv); g_object_set_data (G_OBJECT (webkit_get_default_session ()), "midori-session-initialized", (void*)1); g_test_init (&argc, &argv, NULL); gtk_init_check (&argc, &argv); g_test_add_func ("/browser/create", browser_create); g_test_add_func ("/browser/tooltips", browser_tooltips); return g_test_run (); }
int main(int argc, char* argv[]) { WebKitWebView *webView; GtkWidget *main_window; gtk_init(&argc, &argv); if (!g_thread_supported()) g_thread_init(NULL); #ifndef WEBKIT2 #ifdef SOUP_TYPE_PROXY_RESOLVER_DEFAULT soup_session_add_feature_by_type(webkit_get_default_session(), SOUP_TYPE_PROXY_RESOLVER_DEFAULT); #else const char *httpProxy = g_getenv("http_proxy"); if (httpProxy) { SoupURI *proxyUri = soup_uri_new(httpProxy); g_object_set(webkit_get_default_session(), SOUP_SESSION_PROXY_URI, proxyUri, NULL); soup_uri_free(proxyUri); } #endif #endif main_window = createWindow(&webView); gchar *uri =(gchar*)(argc > 1 ? argv[1] : "http://www.google.com/"); gchar *fileURL = filenameToURL(uri); webkit_web_view_load_uri(webView, fileURL ? fileURL : uri); g_free(fileURL); gtk_widget_grab_focus(GTK_WIDGET(webView)); gtk_widget_show_all(main_window); gtk_main(); return 0; }
GtkWidget * html_create_widget (GtkWidget * dlg) { GtkWidget *sw; WebKitWebSettings *settings; SoupSession *sess; const gchar *enc; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); view = WEBKIT_WEB_VIEW (webkit_web_view_new ()); gtk_container_add (GTK_CONTAINER (sw), GTK_WIDGET (view)); settings = webkit_web_view_get_settings (view); g_get_charset (&enc); g_object_set (G_OBJECT (settings), "default-encoding", enc); g_signal_connect (view, "hovering-over-link", G_CALLBACK (link_hover_cb), NULL); g_signal_connect (view, "navigation-policy-decision-requested", G_CALLBACK (link_cb), NULL); if (options.html_data.browser) g_signal_connect (view, "context-menu", G_CALLBACK (menu_cb), NULL); else g_signal_connect (view, "document-load-finished", G_CALLBACK (loaded_cb), NULL); sess = webkit_get_default_session (); soup_session_add_feature_by_type (sess, SOUP_TYPE_PROXY_RESOLVER_DEFAULT); g_object_set (G_OBJECT (sess), SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE, NULL); gtk_widget_show_all (sw); gtk_widget_grab_focus (GTK_WIDGET (view)); if (options.html_data.uri) load_uri (options.html_data.uri); else if (!options.html_data.browser) { GIOChannel *ch; inbuf = g_string_new (NULL); ch = g_io_channel_unix_new (0); g_io_channel_set_encoding (ch, NULL, NULL); g_io_channel_set_flags (ch, G_IO_FLAG_NONBLOCK, NULL); g_io_add_watch (ch, G_IO_IN | G_IO_HUP, handle_stdin, NULL); } return sw; }
/* Hide the authentication browser */ void auth_browser_hide (AuthBrowser *browser) { AuthBrowserPrivate *priv = GET_PRIVATE (browser); SoupSession *session = webkit_get_default_session (); SoupCookieJar* jar = (SoupCookieJar*)soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR); GSList *l, *p; gtk_widget_hide (priv->window); /* clear cookies */ l = soup_cookie_jar_all_cookies (jar); for (p = l; p; p = p->next) soup_cookie_jar_delete_cookie (jar, (SoupCookie*)p->data); soup_cookies_free (l); }
static void liferea_webkit_set_proxy (const gchar *host, guint port, const gchar *user, const gchar *pwd) { SoupURI *proxy = NULL; if (host) { proxy = soup_uri_new (NULL); soup_uri_set_scheme (proxy, SOUP_URI_SCHEME_HTTP); soup_uri_set_host (proxy, host); soup_uri_set_port (proxy, port); soup_uri_set_user (proxy, user); soup_uri_set_password (proxy, pwd); } g_object_set (webkit_get_default_session (), SOUP_SESSION_PROXY_URI, proxy, NULL); }
static int _download_set_proxy(Download * download, char const * http, uint16_t http_port) { #ifdef WITH_WEBKIT # if WEBKIT_CHECK_VERSION(1, 1, 0) SoupSession * session; struct addrinfo hints; struct addrinfo * ai; struct addrinfo * aip; char buf[6]; int res; SoupURI * uri = NULL; session = webkit_get_default_session(); if(http != NULL && strlen(http) > 0) { snprintf(buf, sizeof(buf), "%hu", http_port); memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_NUMERICSERV; if((res = getaddrinfo(http, buf, &hints, &ai)) != 0) return -error_set_code(1, "%s: %s", http, gai_strerror( res)); for(aip = ai; aip != NULL; aip = aip->ai_next) if((uri = _set_proxy_address(aip)) != NULL) break; freeaddrinfo(ai); if(uri == NULL) return -error_set_code(1, "%s: %s", http, "No suitable address found for proxy"); } g_object_set(session, "proxy-uri", uri, NULL); return 0; # else /* FIXME really implement */ return -error_set_code(1, "%s", strerror(ENOSYS)); # endif #else /* FIXME really implement */ return -error_set_code(1, "%s", strerror(ENOSYS)); #endif }
static void _new_init(GHtml * ghtml) { static int initialized = 0; #if WEBKIT_CHECK_VERSION(1, 1, 0) SoupSession * session; # if WEBKIT_CHECK_VERSION(1, 3, 5) && defined(EMBEDDED) WebKitWebSettings * settings; # endif char const * cacerts[] = { "/etc/pki/tls/certs/ca-bundle.crt", "/etc/ssl/certs/ca-certificates.crt", "/etc/openssl/certs/ca-certificates.crt", PREFIX "/etc/ssl/certs/ca-certificates.crt", PREFIX "/etc/openssl/certs/ca-certificates.crt" }; size_t i; #endif if(initialized++ != 0) { initialized = 1; return; } #if WEBKIT_CHECK_VERSION(1, 1, 0) session = webkit_get_default_session(); # if WEBKIT_CHECK_VERSION(1, 3, 5) && defined(EMBEDDED) settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(ghtml->view)); g_object_set(settings, "enable-frame-flattening", TRUE, NULL); # endif for(i = 0; i < sizeof(cacerts) / sizeof(*cacerts); i++) if(access(cacerts[i], R_OK) == 0) { g_object_set(session, "ssl-ca-file", cacerts[i], "ssl-strict", FALSE, NULL); ghtml->ssl = TRUE; return; } #endif surfer_warning(ghtml->surfer, _("Could not load certificate bundle:\n" "SSL certificates will not be verified.")); }
/* Object initialization * Create private structure and set up default values */ static void cookie_permission_manager_init(CookiePermissionManager *self) { CookiePermissionManagerPrivate *priv; priv=self->priv=COOKIE_PERMISSION_MANAGER_GET_PRIVATE(self); /* Set up default values */ priv->database=NULL; priv->databaseFilename=NULL; priv->unknownPolicy=COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED; /* Hijack session's cookie jar to handle cookies requests on our own in HTTP streams * but remember old handlers to restore them on deactivation */ priv->session=webkit_get_default_session(); priv->cookieJar=SOUP_COOKIE_JAR(soup_session_get_feature(priv->session, SOUP_TYPE_COOKIE_JAR)); priv->featureIface=SOUP_SESSION_FEATURE_GET_CLASS(priv->cookieJar); g_object_set_data(G_OBJECT(priv->cookieJar), "cookie-permission-manager", self); /* Listen to changed cookies set or changed by other sources like javascript */ priv->cookieJarChangedID=g_signal_connect_swapped(priv->cookieJar, "changed", G_CALLBACK(_cookie_permission_manager_on_cookie_changed), self); }
GtkUIBinding::GtkUIBinding(Host *host) : UIBinding(host), menu(0), contextMenu(0), iconPath("") { // Prepare the custom URL handlers webkit_titanium_set_normalize_url_cb(NormalizeURLCallback); webkit_titanium_set_url_to_file_url_cb(URLToFileURLCallback); webkit_titanium_set_can_preprocess_cb(CanPreprocessURLCallback); webkit_titanium_set_preprocess_cb(PreprocessURLCallback); // Setup libsoup proxy support SoupSession* session = webkit_get_default_session(); soup_session_add_feature_by_type(session, SOUP_TYPE_PROXY_RESOLVER_GNOME); std::string webInspectorPath(host->GetApplication()->runtime->path); webInspectorPath = FileUtils::Join(webInspectorPath.c_str(), "webinspector", NULL); webkit_titanium_set_inspector_url(webInspectorPath.c_str()); //webkit_set_cache_model(WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER); }
/** * Sends a http-request synchronously * @name sendRequestSync * @memberOf net * @function * * @param {String} uri The uri the request will be sent to. * @param {String} [method] The http request method, default GET * * @returns {Object} * Object that contains the response body, the response headers and the * http status code of the request. * */ static JSValueRef net_send_request_sync(JSContextRef ctx, JSObjectRef f, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exc) { char *method = NULL, *uri = NULL; SoupMessage *msg; guint status; JSValueRef val; JSObjectRef o; JSStringRef js_key; JSValueRef js_value; if (argc < 1) return NIL; uri = js_value_to_char(ctx, argv[0], -1, exc); if (uri == NULL) return NIL; if (argc > 1) method = js_value_to_char(ctx, argv[1], -1, exc); msg = soup_message_new(method == NULL ? "GET" : method, uri); if (argc > 2) set_request(ctx, msg, argv[2], exc); status = soup_session_send_message(webkit_get_default_session(), msg); val = get_message_data(msg); js_key = JSStringCreateWithUTF8CString("status"); js_value = JSValueMakeNumber(ctx, status); o = JSValueToObject(ctx, val, exc); JSObjectSetProperty(ctx, o, js_key, js_value, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly, exc); JSStringRelease(js_key); return o; }
/** * Sends a http-request * @name sendRequest * @memberOf net * @function * * @param {String} uri * The uri the request will be sent to. * @param {net~onResponse} callback * A callback that will be called when the request is finished * @param {String} [method] The http request method, default GET * @param {Object} [data] An object if method is POST * @param {String} data.contentType The content type * @param {String} data.data The data that will be sent with the request * * @returns {Boolean} * true if the request was sent * */ static JSValueRef net_send_request(JSContextRef ctx, JSObjectRef f, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exc) { gboolean ret = -1; char *method = NULL, *uri = NULL; SoupMessage *msg; JSObjectRef function; if (argc < 2) return JSValueMakeNumber(ctx, -1); uri = js_value_to_char(ctx, argv[0], -1, exc); if (uri == NULL) return JSValueMakeNumber(ctx, -1); function = js_value_to_function(ctx, argv[1], exc); if (function == NULL) goto error_out; if (argc > 2) method = js_value_to_char(ctx, argv[2], -1, exc); msg = soup_message_new(method == NULL ? "GET" : method, uri); if (msg == NULL) goto error_out; if (argc > 3 && method != NULL && !g_ascii_strcasecmp("POST", method)) set_request(ctx, msg, argv[3], exc); JSValueProtect(ctx, function); soup_session_queue_message(webkit_get_default_session(), msg, (SoupSessionCallback)request_callback, function); ret = 0; error_out: g_free(uri); g_free(method); return JSValueMakeNumber(ctx, ret); }/*}}}*/
int main(int argc, char* argv[]) { WebKitWebSettings *webkitSettings = 0; const gchar **uriArguments = 0; const GOptionEntry commandLineOptions[] = { { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &uriArguments, 0, "[URL]" }, { 0, 0, 0, 0, 0, 0, 0 } }; gtk_init(&argc, &argv); GOptionContext *context = g_option_context_new(0); g_option_context_add_main_entries(context, commandLineOptions, 0); g_option_context_add_group(context, gtk_get_option_group(TRUE)); webkitSettings = webkit_web_settings_new(); if (!addWebSettingsGroupToContext(context, webkitSettings)) { g_object_unref(webkitSettings); webkitSettings = 0; } GError *error = 0; if (!g_option_context_parse(context, &argc, &argv, &error)) { g_printerr("Cannot parse arguments: %s\n", error->message); g_error_free(error); g_option_context_free(context); return 1; } g_option_context_free(context); #ifdef SOUP_TYPE_PROXY_RESOLVER_DEFAULT soup_session_add_feature_by_type(webkit_get_default_session(), SOUP_TYPE_PROXY_RESOLVER_DEFAULT); #else const char *httpProxy = g_getenv("http_proxy"); if (httpProxy) { SoupURI *proxyUri = soup_uri_new(httpProxy); g_object_set(webkit_get_default_session(), SOUP_SESSION_PROXY_URI, proxyUri, NULL); soup_uri_free(proxyUri); } #endif WebKitWebView *webView; GtkWidget *main_window = createWindow(&webView); if (webkitSettings) { webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings); g_object_unref(webkitSettings); } const gchar *uri = (uriArguments ? uriArguments[0] : "http://www.google.com/"); gchar *fileURL = filenameToURL(uri); webkit_web_view_load_uri(webView, fileURL ? fileURL : uri); g_free(fileURL); gtk_widget_grab_focus(GTK_WIDGET(webView)); gtk_widget_show_all(main_window); gtk_main(); return 0; }
static void add_cookie(char *cookie_file) { SoupSession *session = webkit_get_default_session(); SoupCookieJar *jar = soup_cookie_jar_text_new(cookie_file, false); soup_session_add_feature(session, SOUP_SESSION_FEATURE(jar)); }
static SoupCookieJar * ossifer_session_get_cookie_jar () { return (SoupCookieJar *)soup_session_get_feature (webkit_get_default_session (), SOUP_TYPE_COOKIE_JAR); }
MidoriBrowser* midori_private_app_new (const gchar* config, const gchar* webapp, gchar** open_uris, gchar** execute_commands, gint inactivity_reset, const gchar* block_uris) { guint i; midori_paths_init (MIDORI_RUNTIME_MODE_PRIVATE, config); #ifndef HAVE_WEBKIT2 g_object_set_data (G_OBJECT (webkit_get_default_session ()), "pass-through-console", (void*)1); #endif /* Mask the timezone, which can be read by Javascript */ g_setenv ("TZ", "UTC", TRUE); MidoriBrowser* browser = midori_browser_new (); g_signal_connect (browser, "new-window", G_CALLBACK (midori_frontend_browser_new_window_cb), NULL); MidoriWebSettings* settings = midori_settings_new_full (NULL); g_object_set (settings, "preferred-languages", "en", "enable-private-browsing", TRUE, #ifdef HAVE_LIBSOUP_2_29_91 "first-party-cookies-only", TRUE, #endif "enable-html5-database", FALSE, "enable-html5-local-storage", FALSE, "enable-offline-web-application-cache", FALSE, /* Arguably DNS prefetching is or isn't a privacy concern. For the * lack of more fine-grained control we'll go the safe route. */ "enable-dns-prefetching", FALSE, "strip-referer", TRUE, "show-panel", FALSE, "last-window-state", MIDORI_WINDOW_NORMAL, "inactivity-reset", inactivity_reset, "block-uris", block_uris, NULL); midori_load_soup_session (settings); /* In-memory trash for re-opening closed tabs */ KatzeArray* trash = katze_array_new (KATZE_TYPE_ITEM); g_signal_connect_after (trash, "add-item", G_CALLBACK (midori_trash_add_item_no_save_cb), NULL); KatzeArray* search_engines = midori_search_engines_new_from_folder (NULL); g_object_set (browser, "settings", settings, "trash", trash, "search-engines", search_engines, NULL); g_object_unref (settings); g_object_unref (trash); g_object_unref (search_engines); midori_browser_set_action_visible (browser, "Tools", FALSE); midori_browser_set_action_visible (browser, "ClearPrivateData", FALSE); #if ENABLE_ADDSPEEDDIAL midori_browser_set_action_visible (browser, "AddSpeedDial", FALSE); #endif #if GTK_CHECK_VERSION (3, 0, 0) g_object_set (gtk_widget_get_settings (GTK_WIDGET (browser)), "gtk-application-prefer-dark-theme", TRUE, NULL); #endif if (webapp != NULL) { gchar* tmp_uri = sokoke_magic_uri (webapp, FALSE, TRUE); g_object_set (settings, "homepage", tmp_uri, NULL); midori_browser_add_uri (browser, tmp_uri); g_free (tmp_uri); } for (i = 0; open_uris && open_uris[i]; i++) { gchar* new_uri = sokoke_magic_uri (open_uris[i], FALSE, TRUE); midori_browser_add_uri (browser, new_uri); g_free (new_uri); } if (midori_browser_get_n_pages (browser) == 0) midori_browser_add_uri (browser, "about:private"); gtk_widget_show (GTK_WIDGET (browser)); for (i = 0; execute_commands && execute_commands[i]; i++) { midori_browser_assert_action (browser, execute_commands[i]); midori_browser_activate_action (browser, execute_commands[i]); } /* FIXME need proper stock extension mechanism */ //由于整合了若干预置扩展,此处相应修改 #if 0 midori_browser_activate_action (browser, "libtransfers." G_MODULE_SUFFIX "=true"); midori_browser_activate_action (browser, "libabout." G_MODULE_SUFFIX "=true"); midori_browser_activate_action (browser, "libopen-with." G_MODULE_SUFFIX "=true"); #else midori_browser_activate_action (browser, "libtransfers." G_MODULE_SUFFIX "=true"); midori_browser_activate_action (browser, "libbuiltinextension." G_MODULE_SUFFIX "=true"); #endif g_assert (g_module_error () == NULL); return browser; }
int main (int argc, char* argv[]) { gtk_init (&argc, &argv); if (!g_thread_supported ()) g_thread_init (NULL); printf("Uzbl start location: %s\n", argv[0]); strcpy(executable_path,argv[0]); strcat ((char *) XDG_CONFIG_HOME_default, getenv ("HOME")); strcat ((char *) XDG_CONFIG_HOME_default, "/.config"); GError *error = NULL; GOptionContext* context = g_option_context_new ("- some stuff here maybe someday"); g_option_context_add_main_entries (context, entries, NULL); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, &error); /* initialize hash table */ bindings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, free_action); soup_session = webkit_get_default_session(); keycmd = g_string_new(""); settings_init (); commands_hash (); if (always_insert_mode) insert_mode = TRUE; GtkWidget* vbox = gtk_vbox_new (FALSE, 0); if (status_top) gtk_box_pack_start (GTK_BOX (vbox), create_mainbar (), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), create_browser (), TRUE, TRUE, 0); if (!status_top) gtk_box_pack_start (GTK_BOX (vbox), create_mainbar (), FALSE, TRUE, 0); main_window = create_window (); gtk_container_add (GTK_CONTAINER (main_window), vbox); load_uri (web_view, uri); gtk_widget_grab_focus (GTK_WIDGET (web_view)); gtk_widget_show_all (main_window); xwin = GDK_WINDOW_XID (GTK_WIDGET (main_window)->window); printf("window_id %i\n",(int) xwin); printf("pid %i\n", getpid ()); printf("name: %s\n", instance_name); scbar_v = (GtkScrollbar*) gtk_vscrollbar_new (NULL); bar_v = gtk_range_get_adjustment((GtkRange*) scbar_v); scbar_h = (GtkScrollbar*) gtk_hscrollbar_new (NULL); bar_h = gtk_range_get_adjustment((GtkRange*) scbar_h); gtk_widget_set_scroll_adjustments ((GtkWidget*) web_view, bar_h, bar_v); if (!show_status) gtk_widget_hide(mainbar); if (fifo_dir) create_fifo (); if (socket_dir) create_socket(); gtk_main (); g_string_free(keycmd, TRUE); if (fifo_dir) unlink (fifo_path); if (socket_dir) unlink (socket_path); g_hash_table_destroy(bindings); g_hash_table_destroy(commands); return 0; }