static void
cache_up (GrlNetWc *self)
{
SoupCache *cache;
GrlNetWcPrivate *priv = self->priv;
gchar *dir;
GRL_DEBUG ("cache up");
dir = g_dir_make_tmp ("grilo-plugin-cache-XXXXXX", NULL);
if (!dir)
return;
cache = soup_cache_new (dir, SOUP_CACHE_SINGLE_USER);
g_free (dir);
soup_session_add_feature (priv->session,
SOUP_SESSION_FEATURE (cache));
if (priv->cache_size) {
soup_cache_set_max_size (cache, priv->cache_size * 1024 * 1024);
}
g_object_unref (cache);
}
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;
}
void WebProcess::platformInitializeWebProcess(const WebProcessCreationParameters& parameters, IPC::MessageDecoder&)
{
#if ENABLE(SECCOMP_FILTERS)
{
#if PLATFORM(EFL)
SeccompFiltersWebProcessEfl seccompFilters(parameters);
#endif
seccompFilters.initialize();
}
#endif
if (usesNetworkProcess())
return;
ASSERT(!parameters.diskCacheDirectory.isEmpty());
GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(parameters.diskCacheDirectory.utf8().data(), SOUP_CACHE_SINGLE_USER));
soup_session_add_feature(WebCore::ResourceHandle::defaultSession(), SOUP_SESSION_FEATURE(soupCache.get()));
soup_cache_load(soupCache.get());
if (!parameters.cookiePersistentStoragePath.isEmpty()) {
supplement<WebCookieManager>()->setCookiePersistentStorage(parameters.cookiePersistentStoragePath,
parameters.cookiePersistentStorageType);
}
supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy);
if (!parameters.languages.isEmpty())
setSoupSessionAcceptLanguage(parameters.languages);
for (size_t i = 0; i < parameters.urlSchemesRegistered.size(); i++)
supplement<WebSoupRequestManager>()->registerURIScheme(parameters.urlSchemesRegistered[i]);
setIgnoreTLSErrors(parameters.ignoreTLSErrors);
WebCore::addLanguageChangeObserver(this, languageChanged);
}
static void
soup_session_init (SoupSession *session)
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
priv->queue = soup_message_queue_new (session);
priv->host_lock = g_mutex_new ();
priv->hosts = g_hash_table_new_full (soup_uri_host_hash,
soup_uri_host_equal,
NULL, (GDestroyNotify)free_host);
priv->conns = g_hash_table_new (NULL, NULL);
priv->max_conns = SOUP_SESSION_MAX_CONNS_DEFAULT;
priv->max_conns_per_host = SOUP_SESSION_MAX_CONNS_PER_HOST_DEFAULT;
priv->auth_manager = g_object_new (SOUP_TYPE_AUTH_MANAGER_NTLM,
SOUP_AUTH_MANAGER_NTLM_USE_NTLM, FALSE,
NULL);
g_signal_connect (priv->auth_manager, "authenticate",
G_CALLBACK (auth_manager_authenticate), session);
soup_auth_manager_add_type (priv->auth_manager, SOUP_TYPE_AUTH_BASIC);
soup_auth_manager_add_type (priv->auth_manager, SOUP_TYPE_AUTH_DIGEST);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (priv->auth_manager));
}
/**
* Sets the path where the cookies are going to be stored. Use @c NULL for keep
* them just in memory.
*
* @param filename path to the cookies.txt file.
*
* @return @c EINA_FALSE if it wasn't possible to create the cookie jar,
* @c EINA_FALSE otherwise.
*/
Eina_Bool ewk_cookies_file_set(const char *filename)
{
#if USE(SOUP)
SoupCookieJar* cookieJar = 0;
if (filename)
cookieJar = soup_cookie_jar_text_new(filename, FALSE);
else
cookieJar = soup_cookie_jar_new();
if (!cookieJar)
return EINA_FALSE;
soup_cookie_jar_set_accept_policy(cookieJar, SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY);
SoupSession* session = WebCore::ResourceHandle::defaultSession();
SoupSessionFeature* oldjar = soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR);
if (oldjar)
soup_session_remove_feature(session, oldjar);
WebCore::setDefaultCookieJar(cookieJar);
soup_session_add_feature(session, SOUP_SESSION_FEATURE(cookieJar));
return EINA_TRUE;
#else
return EINA_FALSE;
#endif
}
static SoupSession *
create_hkp_soup_session (void)
{
SoupSession *session;
#if WITH_DEBUG
SoupLogger *logger;
const gchar *env;
#endif
session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
#if WITH_DEBUG
env = g_getenv ("G_MESSAGES_DEBUG");
if (env && strstr (env, "seahorse")) {
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
#endif
return session;
}
WK_EXPORT int WebProcessMainGtk(int argc, char* argv[])
{
ASSERT(argc == 2);
#ifndef NDEBUG
if (g_getenv("WEBKIT2_PAUSE_WEB_PROCESS_ON_LAUNCH"))
sleep(30);
#endif
gtk_init(&argc, &argv);
g_type_init();
JSC::initializeThreading();
WTF::initializeMainThread();
RunLoop::initializeMainRunLoop();
SoupSession* session = WebCore::ResourceHandle::defaultSession();
SoupSessionFeature* sniffer = static_cast<SoupSessionFeature*>(g_object_new(SOUP_TYPE_CONTENT_SNIFFER, NULL));
soup_session_add_feature(session, sniffer);
g_object_unref(sniffer);
soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER);
int socket = atoi(argv[1]);
WebProcess::shared().initialize(socket, RunLoop::main());
RunLoop::run();
return 0;
}
SoupSession *
soup_test_session_new (GType type, ...)
{
va_list args;
const char *propname;
SoupSession *session;
va_start (args, type);
propname = va_arg (args, const char *);
session = (SoupSession *)g_object_new_valist (type, propname, args);
va_end (args);
g_object_set (G_OBJECT (session),
SOUP_SESSION_SSL_CA_FILE, SRCDIR "/test-cert.pem",
SOUP_SESSION_SSL_STRICT, FALSE,
NULL);
if (http_debug_level && !logger) {
SoupLoggerLogLevel level = MIN ((SoupLoggerLogLevel)http_debug_level, SOUP_LOGGER_LOG_BODY);
logger = soup_logger_new (level, -1);
}
if (logger)
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
return session;
}
static void
aur_client_constructed (GObject * object)
{
AurClient *client = (AurClient *) (object);
gint max_con = 1;
if (G_OBJECT_CLASS (aur_client_parent_class)->constructed != NULL)
G_OBJECT_CLASS (aur_client_parent_class)->constructed (object);
client->soup =
soup_session_async_new_with_options (SOUP_SESSION_ASYNC_CONTEXT,
client->context, NULL);
g_assert (client->soup);
if (!g_strcmp0 ("1", g_getenv ("AURENA_DEBUG")))
soup_session_add_feature (client->soup,
SOUP_SESSION_FEATURE (soup_logger_new (SOUP_LOGGER_LOG_BODY, -1)));
/* Set a 20 second timeout on pings from the server */
g_object_set (G_OBJECT (client->soup), "idle-timeout", 20, NULL);
/* 5 second timeout before retrying with new connections */
g_object_set (G_OBJECT (client->soup), "timeout", 5, NULL);
if (client->flags & AUR_CLIENT_PLAYER)
max_con++;
if (client->flags & AUR_CLIENT_CONTROLLER)
max_con++;
g_object_set (client->soup, "max-conns-per-host", max_con, NULL);
try_reconnect (client);
}
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
goa_http_client_check (GoaHttpClient *self,
const gchar *uri,
const gchar *username,
const gchar *password,
gboolean accept_ssl_errors,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CheckData *data;
CheckAuthData *auth;
SoupLogger *logger;
g_return_if_fail (GOA_IS_HTTP_CLIENT (self));
g_return_if_fail (uri != NULL && uri[0] != '\0');
g_return_if_fail (username != NULL && username[0] != '\0');
g_return_if_fail (password != NULL && password[0] != '\0');
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
data = g_slice_new0 (CheckData);
data->res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, goa_http_client_check);
data->session = soup_session_new_with_options (SOUP_SESSION_SSL_STRICT, FALSE,
NULL);
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_logger_set_printer (logger, http_client_log_printer, NULL, NULL);
soup_session_add_feature (data->session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
data->accept_ssl_errors = accept_ssl_errors;
data->msg = soup_message_new (SOUP_METHOD_GET, uri);
soup_message_headers_append (data->msg->request_headers, "Connection", "close");
if (cancellable != NULL)
{
data->cancellable = g_object_ref (cancellable);
data->cancellable_id = g_cancellable_connect (data->cancellable,
G_CALLBACK (http_client_check_cancelled_cb),
data,
NULL);
g_simple_async_result_set_check_cancellable (data->res, data->cancellable);
}
auth = g_slice_new0 (CheckAuthData);
auth->username = g_strdup (username);
auth->password = g_strdup (password);
g_signal_connect_data (data->session,
"authenticate",
G_CALLBACK (http_client_authenticate),
auth,
http_client_check_auth_data_free,
0);
g_signal_connect (data->session, "request-started", G_CALLBACK (http_client_request_started), data);
soup_session_queue_message (data->session, data->msg, http_client_check_response_cb, data);
}
void
network_init (void)
{
gchar *useragent;
SoupCookieJar *cookies;
gchar *filename;
SoupLogger *logger;
/* Set an appropriate user agent */
if (g_getenv ("LANG")) {
/* e.g. "Liferea/1.10.0 (Linux; de_DE; https://lzone.de/liferea/) AppleWebKit (KHTML, like Gecko)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s; %s) AppleWebKit (KHTML, like Gecko)", VERSION, OSNAME, g_getenv ("LANG"), HOMEPAGE);
} else {
/* e.g. "Liferea/1.10.0 (Linux; https://lzone.de/liferea/) AppleWebKit (KHTML, like Gecko)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s) AppleWebKit (KHTML, like Gecko)", VERSION, OSNAME, HOMEPAGE);
}
/* Cookies */
filename = common_create_config_filename ("cookies.txt");
cookies = soup_cookie_jar_text_new (filename, FALSE);
g_free (filename);
/* Initialize libsoup */
session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
SOUP_SESSION_TIMEOUT, 120,
SOUP_SESSION_IDLE_TIMEOUT, 30,
SOUP_SESSION_ADD_FEATURE, cookies,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
NULL);
session2 = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
SOUP_SESSION_TIMEOUT, 120,
SOUP_SESSION_IDLE_TIMEOUT, 30,
SOUP_SESSION_ADD_FEATURE, cookies,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_PROXY_URI, NULL,
SOUP_SESSION_PROXY_RESOLVER, NULL,
NULL);
/* Only 'session' gets proxy, 'session2' is for non-proxy requests */
network_set_soup_session_proxy (session, network_get_proxy_detect_mode(),
network_get_proxy_host (),
network_get_proxy_port (),
network_get_proxy_username (),
network_get_proxy_password ());
g_signal_connect (session, "authenticate", G_CALLBACK (network_authenticate), NULL);
/* Soup debugging */
if (debug_level & DEBUG_NET) {
logger = soup_logger_new (SOUP_LOGGER_LOG_HEADERS, -1);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
}
g_free (useragent);
}
static void
snra_client_init (SnraClient * client)
{
client->soup = soup_session_async_new ();
client->server_port = 5457;
client->paused = TRUE;
if (!g_strcmp0 ("1", g_getenv ("AURENA_DEBUG")))
soup_session_add_feature (client->soup,
SOUP_SESSION_FEATURE (soup_logger_new (SOUP_LOGGER_LOG_BODY, -1)));
}
void
cmd_http_debug() {
soup_session_remove_feature
(uzbl.net.soup_session, SOUP_SESSION_FEATURE(uzbl.net.soup_logger));
/* do we leak if this doesn't get freed? why does it occasionally crash if freed? */
/*g_free(uzbl.net.soup_logger);*/
uzbl.net.soup_logger = soup_logger_new(uzbl.behave.http_debug, -1);
soup_session_add_feature(uzbl.net.soup_session,
SOUP_SESSION_FEATURE(uzbl.net.soup_logger));
}
WK_EXPORT int NetworkProcessMain(int argc, char* argv[])
{
if (argc != 2)
return 1;
#if PLATFORM(EFL)
if (!ecore_init())
return 1;
if (!ecore_main_loop_glib_integrate())
return 1;
#endif
InitializeWebKit2();
#if USE(SOUP)
SoupSession* session = ResourceHandle::defaultSession();
#if PLATFORM(EFL)
// Only for EFL because GTK port uses the default resolver, which uses GIO's proxy resolver.
const char* httpProxy = getenv("http_proxy");
if (httpProxy) {
const char* noProxy = getenv("no_proxy");
GRefPtr<SoupProxyURIResolver> resolver = adoptGRef(soupProxyResolverWkNew(httpProxy, noProxy));
soup_session_add_feature(session, SOUP_SESSION_FEATURE(resolver.get()));
}
#endif
#endif
int socket = atoi(argv[1]);
WebKit::ChildProcessInitializationParameters parameters;
parameters.connectionIdentifier = int(socket);
NetworkProcess::shared().initialize(parameters);
#if USE(SOUP)
// Despite using system CAs to validate certificates we're
// accepting invalid certificates by default. New API will be
// added later to let client accept/discard invalid certificates.
g_object_set(session, SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
SOUP_SESSION_SSL_STRICT, FALSE, NULL);
#endif
RunLoop::run();
#if USE(SOUP)
if (SoupSessionFeature* soupCache = soup_session_get_feature(session, SOUP_TYPE_CACHE)) {
soup_cache_flush(SOUP_CACHE(soupCache));
soup_cache_dump(SOUP_CACHE(soupCache));
}
#endif
return 0;
}
void SoupNetworkSession::setupLogger()
{
#if !LOG_DISABLED
if (LogNetwork.state != WTFLogChannelOn || soup_session_get_feature(m_soupSession.get(), SOUP_TYPE_LOGGER))
return;
GRefPtr<SoupLogger> logger = adoptGRef(soup_logger_new(SOUP_LOGGER_LOG_BODY, -1));
soup_session_add_feature(m_soupSession.get(), SOUP_SESSION_FEATURE(logger.get()));
soup_logger_set_printer(logger.get(), soupLogPrinter, nullptr, nullptr);
#endif
}
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));
}
/**
* soup_session_add_feature_by_type:
* @session: a #SoupSession
* @feature_type: the #GType of a class that implements #SoupSessionFeature
*
* Creates a new feature of type @feature_type and adds it to
* @session. You can use this instead of soup_session_add_feature() in
* the case wher you don't need to customize the new feature in any
* way. You can also add a feature to the session at construct time by
* using the %SOUP_SESSION_ADD_FEATURE_BY_TYPE property.
*
* Since: 2.24
**/
void
soup_session_add_feature_by_type (SoupSession *session, GType feature_type)
{
SoupSessionFeature *feature;
g_return_if_fail (SOUP_IS_SESSION (session));
g_return_if_fail (g_type_is_a (feature_type, SOUP_TYPE_SESSION_FEATURE));
feature = g_object_new (feature_type, NULL);
soup_session_add_feature (session, feature);
g_object_unref (feature);
}
static void
init_requester (GrlNetWc *self)
{
#ifndef LIBSOUP_REQUESTER_DEPRECATED
GrlNetWcPrivate *priv = self->priv;
priv->requester = soup_requester_new ();
soup_session_add_feature (priv->session,
SOUP_SESSION_FEATURE (priv->requester));
#endif
init_dump_directory ();
}
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;
}
bool ResourceHandle::startHttp(String urlString)
{
if (!session) {
session = soup_session_async_new();
soup_session_add_feature(session, SOUP_SESSION_FEATURE(getCookieJar()));
const char* soup_debug = g_getenv("WEBKIT_SOUP_LOGGING");
if (soup_debug) {
int soup_debug_level = atoi(soup_debug);
SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(soup_debug_level), -1);
soup_logger_attach(logger, session);
g_object_unref(logger);
}
}
SoupMessage* msg;
msg = soup_message_new(request().httpMethod().utf8().data(), urlString.utf8().data());
g_signal_connect(msg, "restarted", G_CALLBACK(restartedCallback), this);
g_signal_connect(msg, "got-headers", G_CALLBACK(gotHeadersCallback), this);
g_signal_connect(msg, "got-chunk", G_CALLBACK(gotChunkCallback), this);
HTTPHeaderMap customHeaders = d->m_request.httpHeaderFields();
if (!customHeaders.isEmpty()) {
HTTPHeaderMap::const_iterator end = customHeaders.end();
for (HTTPHeaderMap::const_iterator it = customHeaders.begin(); it != end; ++it)
soup_message_headers_append(msg->request_headers, it->first.utf8().data(), it->second.utf8().data());
}
FormData* httpBody = d->m_request.httpBody();
if (httpBody && !httpBody->isEmpty()) {
// Making a copy of the request body isn't the most efficient way to
// serialize it, but by far the most simple. Dealing with individual
// FormData elements and shared buffers should be more memory
// efficient.
//
// This possibly isn't handling file uploads/attachments, for which
// shared buffers or streaming should definitely be used.
Vector<char> body;
httpBody->flatten(body);
soup_message_set_request(msg, d->m_request.httpContentType().utf8().data(),
SOUP_MEMORY_COPY, body.data(), body.size());
}
d->m_msg = static_cast<SoupMessage*>(g_object_ref(msg));
soup_session_queue_message(session, d->m_msg, finishedCallback, this);
return true;
}
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;
}
void NetworkProcess::platformInitializeNetworkProcess(const NetworkProcessCreationParameters& parameters)
{
ASSERT(!parameters.diskCacheDirectory.isEmpty());
GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(parameters.diskCacheDirectory.utf8().data(), SOUP_CACHE_SINGLE_USER));
soup_session_add_feature(WebCore::ResourceHandle::defaultSession(), SOUP_SESSION_FEATURE(soupCache.get()));
soup_cache_load(soupCache.get());
if (!parameters.cookiePersistentStoragePath.isEmpty()) {
supplement<WebCookieManager>()->setCookiePersistentStorage(parameters.cookiePersistentStoragePath,
parameters.cookiePersistentStorageType);
}
supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy);
setIgnoreTLSErrors(parameters.ignoreTLSErrors);
}
void SoupNetworkSession::setHTTPProxy(const char* httpProxy, const char* httpProxyExceptions)
{
#if PLATFORM(EFL)
// Only for EFL because GTK port uses the default resolver, which uses GIO's proxy resolver.
if (!httpProxy) {
soup_session_remove_feature_by_type(m_soupSession.get(), SOUP_TYPE_PROXY_URI_RESOLVER);
return;
}
GRefPtr<SoupProxyURIResolver> resolver = adoptGRef(soupProxyResolverWkNew(httpProxy, httpProxyExceptions));
soup_session_add_feature(m_soupSession.get(), SOUP_SESSION_FEATURE(resolver.get()));
#else
UNUSED_PARAM(httpProxy);
UNUSED_PARAM(httpProxyExceptions);
#endif
}
WK_EXPORT int WebProcessMainNix(int argc, char* argv[])
{
// WebProcess should be launched with an option.
if (argc != 2)
return 1;
#ifdef WTF_USE_SOUP
#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
#endif
InitializeWebKit2();
#ifdef WTF_USE_SOUP
SoupSession* session = WebCore::ResourceHandle::defaultSession();
g_object_set(G_OBJECT(session), "ssl-use-system-ca-file", true, NULL);
const char* httpProxy = getenv("http_proxy");
if (httpProxy) {
const char* noProxy = getenv("no_proxy");
SoupProxyURIResolver* resolverNix = soupProxyResolverWkNew(httpProxy, noProxy);
soup_session_add_feature(session, SOUP_SESSION_FEATURE(resolverNix));
g_object_unref(resolverNix);
}
#endif
int socket = atoi(argv[1]);
ChildProcessInitializationParameters parameters;
parameters.connectionIdentifier = socket;
WebProcess::shared().initialize(parameters);
RunLoop::run();
#ifdef WTF_USE_SOUP
if (SoupSessionFeature* soupCache = soup_session_get_feature(session, SOUP_TYPE_CACHE)) {
soup_cache_flush(SOUP_CACHE(soupCache));
soup_cache_dump(SOUP_CACHE(soupCache));
}
#endif
return 0;
}
void
network_init (void)
{
gchar *useragent;
SoupCookieJar *cookies;
gchar *filename;
SoupLogger *logger;
SoupURI *proxy;
/* Set an appropriate user agent */
if (g_getenv ("LANG")) {
/* e.g. "Liferea/1.6.0 (Linux; de_DE; http://liferea.sf.net/)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s; %s)", VERSION, OSNAME, g_getenv ("LANG"), HOMEPAGE);
} else {
/* e.g. "Liferea/1.6.0 (Linux; http://liferea.sf.net/)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s)", VERSION, OSNAME, HOMEPAGE);
}
/* Cookies */
filename = common_create_cache_filename ("", "cookies", "txt");
cookies = soup_cookie_jar_text_new (filename, FALSE);
g_free (filename);
/* Initialize libsoup */
proxy = network_get_proxy_uri ();
session = soup_session_async_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
SOUP_SESSION_TIMEOUT, 120,
SOUP_SESSION_IDLE_TIMEOUT, 30,
SOUP_SESSION_PROXY_URI, proxy,
SOUP_SESSION_ADD_FEATURE, cookies,
NULL);
if (proxy)
soup_uri_free (proxy);
g_signal_connect (session, "authenticate", G_CALLBACK (network_authenticate), NULL);
/* Soup debugging */
if (debug_level & DEBUG_NET) {
logger = soup_logger_new (SOUP_LOGGER_LOG_HEADERS, -1);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
}
g_free (useragent);
}
WK_EXPORT int WebProcessMainGtk(int argc, char* argv[])
{
ASSERT(argc == 2);
#ifndef NDEBUG
if (g_getenv("WEBKIT2_PAUSE_WEB_PROCESS_ON_LAUNCH"))
sleep(30);
#endif
gtk_init(&argc, &argv);
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
JSC::initializeThreading();
WTF::initializeMainThread();
RunLoop::initializeMainRunLoop();
int socket = atoi(argv[1]);
ChildProcessInitializationParameters parameters;
parameters.connectionIdentifier = socket;
WebProcess::shared().initialize(parameters);
// Despite using system CAs to validate certificates we're
// accepting invalid certificates by default. New API will be
// added later to let client accept/discard invalid certificates.
SoupSession* session = WebCore::ResourceHandle::defaultSession();
g_object_set(session, SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
SOUP_SESSION_SSL_STRICT, FALSE, NULL);
GOwnPtr<char> soupCacheDirectory(g_build_filename(g_get_user_cache_dir(), g_get_prgname(), NULL));
GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(soupCacheDirectory.get(), SOUP_CACHE_SINGLE_USER));
soup_session_add_feature(session, SOUP_SESSION_FEATURE(soupCache.get()));
soup_cache_load(soupCache.get());
RunLoop::run();
soup_cache_flush(soupCache.get());
soup_cache_dump(soupCache.get());
return 0;
}
void load_data(void)
{
SoupCookieJar *cookie_jar;
GTlsDatabase *tlsdb;
GError *error = NULL;
/* load cookies */
if (!private_browsing) {
ripcurl->Files.cookie_file = g_build_filename(ripcurl->Files.config_dir, cookie_file, NULL);
if (!ripcurl->Files.cookie_file) {
print_err("error building cookie file path\n");
} else {
cookie_jar = soup_cookie_jar_text_new(ripcurl->Files.cookie_file, FALSE);
soup_session_add_feature(ripcurl->Global.soup_session, SOUP_SESSION_FEATURE(cookie_jar));
}
}
/* ssl */
tlsdb = g_tls_file_database_new(ca_file, &error);
if (error) {
print_err("error loading ssl database %s: %s\n", ca_file, error->message);
g_error_free(error);
}
g_object_set(G_OBJECT(ripcurl->Global.soup_session), "tls-database", tlsdb, NULL);
g_object_set(G_OBJECT(ripcurl->Global.soup_session), "ssl-strict", strict_ssl, NULL);
/* load bookmarks */
ripcurl->Files.bookmarks_file = g_build_filename(ripcurl->Files.config_dir, bookmarks_file, NULL);
if (!ripcurl->Files.bookmarks_file) {
print_err("error building bookmarks file path\n");
} else {
ripcurl->Global.bookmarks = read_file(ripcurl->Files.bookmarks_file, ripcurl->Global.bookmarks);
ripcurl->Global.bookmarks= g_list_reverse(ripcurl->Global.bookmarks);
}
/* load history */
ripcurl->Files.history_file = g_build_filename(ripcurl->Files.config_dir, history_file, NULL);
if (!ripcurl->Files.history_file) {
print_err("error building history file path\n");
} else {
ripcurl->Global.history = read_file(ripcurl->Files.history_file, ripcurl->Global.history);
}
}
void WebSoupRequestManager::registerURIScheme(const String& scheme)
{
if (m_schemes->len)
g_ptr_array_remove_index_fast(m_schemes.get(), m_schemes->len - 1);
g_ptr_array_add(m_schemes.get(), g_strdup(scheme.utf8().data()));
g_ptr_array_add(m_schemes.get(), 0);
SoupSession* session = WebCore::ResourceHandle::defaultSession();
GRefPtr<SoupRequester> requester = SOUP_REQUESTER(soup_session_get_feature(session, SOUP_TYPE_REQUESTER));
if (requester)
soup_session_feature_remove_feature(SOUP_SESSION_FEATURE(requester.get()), WEBKIT_TYPE_SOUP_REQUEST_GENERIC);
else {
requester = adoptGRef(soup_requester_new());
soup_session_add_feature(session, SOUP_SESSION_FEATURE(requester.get()));
}
SoupRequestClass* genericRequestClass = static_cast<SoupRequestClass*>(g_type_class_ref(WEBKIT_TYPE_SOUP_REQUEST_GENERIC));
genericRequestClass->schemes = const_cast<const char**>(reinterpret_cast<char**>(m_schemes->pdata));
soup_session_feature_add_feature(SOUP_SESSION_FEATURE(requester.get()), WEBKIT_TYPE_SOUP_REQUEST_GENERIC);
}
