void WebProcess::platformSetCacheModel(CacheModel cacheModel)
{
unsigned cacheTotalCapacity = 0;
unsigned cacheMinDeadCapacity = 0;
unsigned cacheMaxDeadCapacity = 0;
double deadDecodedDataDeletionInterval = 0;
unsigned pageCacheCapacity = 0;
unsigned long urlCacheMemoryCapacity = 0;
unsigned long urlCacheDiskCapacity = 0;
SoupSession* session = WebCore::ResourceHandle::defaultSession();
SoupCache* cache = SOUP_CACHE(soup_session_get_feature(session, SOUP_TYPE_CACHE));
uint64_t diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024;
uint64_t memSize = getMemorySize();
calculateCacheSizes(cacheModel, memSize, diskFreeSize,
cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
WebCore::memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
WebCore::memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
WebCore::pageCache()->setCapacity(pageCacheCapacity);
if (urlCacheDiskCapacity > soup_cache_get_max_size(cache))
soup_cache_set_max_size(cache, urlCacheDiskCapacity);
}
/**
* 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 void
cache_down (GrlNetWc *self)
{
GFile *cache_dir_file;
GrlNetWcPrivate *priv = self->priv;
SoupSessionFeature *cache = soup_session_get_feature (priv->session, SOUP_TYPE_CACHE);
gchar *cache_dir;
GRL_DEBUG ("cache down");
if (!cache) {
return;
}
soup_cache_clear (SOUP_CACHE (cache));
g_object_get (cache, "cache-dir", &cache_dir, NULL);
cache_dir_file = g_file_new_for_path (cache_dir);
g_free (cache_dir);
g_file_delete (cache_dir_file, NULL, NULL);
g_object_unref (G_OBJECT (cache_dir_file));
soup_session_remove_feature (priv->session, cache);
}
void WebProcess::platformTerminate()
{
SoupSession* session = WebCore::ResourceHandle::defaultSession();
SoupCache* cache = SOUP_CACHE(soup_session_get_feature(session, SOUP_TYPE_CACHE));
soup_cache_flush(cache);
soup_cache_dump(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
}
static bool sessionCanSavePasswords(SoupSession* session)
{
#ifdef SOUP_TYPE_PASSWORD_MANAGER
return soup_session_get_feature(session, SOUP_TYPE_PASSWORD_MANAGER);
#else
return false;
#endif
}
void NetworkProcess::clearCacheForAllOrigins(uint32_t cachesToClear)
{
if (cachesToClear == InMemoryResourceCachesOnly)
return;
SoupSession* session = ResourceHandle::defaultSession();
soup_cache_clear(SOUP_CACHE(soup_session_get_feature(session, SOUP_TYPE_CACHE)));
}
static gboolean session_can_save_passwords(SoupSession* session)
{
#ifdef SOUP_TYPE_PASSWORD_MANAGER
return soup_session_get_feature(session, SOUP_TYPE_PASSWORD_MANAGER) != NULL;
#else
return FALSE;
#endif
}
void WebProcess::platformClearResourceCaches(ResourceCachesToClear cachesToClear)
{
if (cachesToClear == InMemoryResourceCachesOnly)
return;
SoupSession* session = WebCore::ResourceHandle::defaultSession();
soup_cache_clear(SOUP_CACHE(soup_session_get_feature(session, SOUP_TYPE_CACHE)));
}
JNIEXPORT jintLong JNICALL WebKitGTK_NATIVE(_1soup_1session_1get_1feature)
(JNIEnv *env, jclass that, jintLong arg0, jintLong arg1)
{
jintLong rc = 0;
WebKitGTK_NATIVE_ENTER(env, that, _1soup_1session_1get_1feature_FUNC);
rc = (jintLong)soup_session_get_feature((SoupSession *)arg0, (GType)arg1);
WebKitGTK_NATIVE_EXIT(env, that, _1soup_1session_1get_1feature_FUNC);
return rc;
}
static void
do_cookies_accept_policy_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupCookieJar *jar;
GSList *l, *p;
int i;
debug_printf (1, "SoupCookieJarAcceptPolicy test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR);
jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR));
for (i = 0; i < G_N_ELEMENTS (validResults); i++) {
soup_cookie_jar_set_accept_policy (jar, validResults[i].policy);
uri = soup_uri_new_with_base (first_party_uri, "/index.html");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, first_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
/* We can't use two servers due to limitations in
* test_server, so let's swap first and third party here
* to simulate a cookie coming from a third party.
*/
uri = soup_uri_new_with_base (first_party_uri, "/foo.jpg");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, third_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
l = soup_cookie_jar_all_cookies (jar);
if (g_slist_length (l) < validResults[i].n_cookies) {
debug_printf (1, " accepted less cookies than it should have\n");
errors++;
} else if (g_slist_length (l) > validResults[i].n_cookies) {
debug_printf (1, " accepted more cookies than it should have\n");
errors++;
}
for (p = l; p; p = p->next) {
soup_cookie_jar_delete_cookie (jar, p->data);
soup_cookie_free (p->data);
}
g_slist_free (l);
}
soup_test_session_abort_unref (session);
}
static void ensureSessionIsInitialized(SoupSession* session)
{
if (g_object_get_data(G_OBJECT(session), "webkit-init"))
return;
SoupCookieJar* jar = reinterpret_cast<SoupCookieJar*>(soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR));
if (!jar)
soup_session_add_feature(session, SOUP_SESSION_FEATURE(defaultCookieJar()));
else
setDefaultCookieJar(jar);
if (!soup_session_get_feature(session, SOUP_TYPE_LOGGER) && LogNetwork.state == WTFLogChannelOn) {
SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(SOUP_LOGGER_LOG_BODY), -1);
soup_logger_attach(logger, session);
g_object_unref(logger);
}
g_object_set_data(G_OBJECT(session), "webkit-init", reinterpret_cast<void*>(0xdeadbeef));
}
static void
do_message_has_authorization_header_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupAuthManager *manager;
SoupAuth *auth = NULL;
char *token;
guint auth_id;
char *uri;
g_test_bug ("775882");
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
msg = soup_message_new ("GET", uri);
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (has_authorization_header_authenticate), &auth);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
soup_test_assert (SOUP_IS_AUTH (auth), "Expected a SoupAuth");
token = soup_auth_get_authorization (auth, msg);
g_object_unref (auth);
g_object_unref (msg);
g_signal_handler_disconnect (session, auth_id);
manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
soup_auth_manager_clear_cached_credentials (manager);
msg = soup_message_new ("GET", uri);
soup_message_headers_replace (msg->request_headers, "Authorization", token);
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (has_authorization_header_authenticate_assert),
NULL);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
/* Check that we can also provide our own Authorization header when not using credentials cache. */
soup_auth_manager_clear_cached_credentials (manager);
msg = soup_message_new ("GET", uri);
soup_message_headers_replace (msg->request_headers, "Authorization", token);
soup_message_set_flags (msg, soup_message_get_flags (msg) | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
g_free (token);
g_signal_handler_disconnect (session, auth_id);
g_free (uri);
soup_test_session_abort_unref (session);
}
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;
}
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 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 WebProcess::platformClearResourceCaches(ResourceCachesToClear cachesToClear)
{
if (cachesToClear == InMemoryResourceCachesOnly)
return;
// If we're using the network process then it is the only one that needs to clear the disk cache.
if (usesNetworkProcess())
return;
soup_cache_clear(SOUP_CACHE(soup_session_get_feature(WebCore::ResourceHandle::defaultSession(), SOUP_TYPE_CACHE)));
}
static void
katze_http_cookies_attach (SoupSessionFeature* feature,
SoupSession* session)
{
KatzeHttpCookies* http_cookies = (KatzeHttpCookies*)feature;
SoupSessionFeature* jar = soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR);
g_return_if_fail (jar != NULL);
http_cookies->filename = g_object_get_data (G_OBJECT (feature), "filename");
g_return_if_fail (http_cookies->filename != NULL);
http_cookies->jar = g_object_ref (jar);
cookie_jar_load (http_cookies->jar, http_cookies->filename);
g_signal_connect (jar, "changed",
G_CALLBACK (katze_http_cookies_jar_changed_cb), feature);
}
char* SoupNetworkSession::httpProxy() const
{
#if PLATFORM(EFL)
SoupSessionFeature* soupResolver = soup_session_get_feature(m_soupSession.get(), SOUP_TYPE_PROXY_URI_RESOLVER);
if (!soupResolver)
return nullptr;
GUniqueOutPtr<SoupURI> uri;
g_object_get(soupResolver, SOUP_PROXY_RESOLVER_WK_PROXY_URI, &uri.outPtr(), nullptr);
return uri ? soup_uri_to_string(uri.get(), FALSE) : nullptr;
#else
return nullptr;
#endif
}
static void
conditional_get_ready_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
ConditionalHelper *helper = (ConditionalHelper *)user_data;
GSimpleAsyncResult *simple;
SoupHTTPInputStream *httpstream;
simple = g_simple_async_result_new (G_OBJECT (helper->req),
helper->callback, helper->user_data,
conditional_get_ready_cb);
if (msg->status_code == SOUP_STATUS_NOT_MODIFIED) {
SoupCache *cache = (SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE);
httpstream = (SoupHTTPInputStream *)soup_cache_send_response (cache, msg);
if (httpstream) {
g_simple_async_result_set_op_res_gpointer (simple, httpstream, g_object_unref);
soup_message_got_headers (helper->original);
if (soup_session_get_feature_for_message (session, SOUP_TYPE_CONTENT_SNIFFER, helper->original)) {
const char *content_type = soup_message_headers_get_content_type (msg->response_headers, NULL);
soup_message_content_sniffed (helper->original, content_type, NULL);
}
g_simple_async_result_complete (simple);
soup_message_finished (helper->original);
g_object_unref (simple);
} else {
/* Ask again for the resource, somehow the cache cannot locate it */
httpstream = soup_http_input_stream_new (session, helper->original);
soup_http_input_stream_send_async (httpstream, G_PRIORITY_DEFAULT,
helper->cancellable, sent_async, simple);
}
} else {
/* It is in the cache but it was modified remotely */
httpstream = soup_http_input_stream_new (session, helper->original);
soup_http_input_stream_send_async (httpstream, G_PRIORITY_DEFAULT,
helper->cancellable, sent_async, simple);
}
g_object_unref (helper->req);
g_object_unref (helper->original);
g_slice_free (ConditionalHelper, helper);
}
/* 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);
}
/**
* grl_net_wc_set_cache_size:
* @self: a #GrlNetWc instance
* @cache_size: size of cache (in Mb)
*
* Sets the new maximum size of cache, in Megabytes. Default value is 10. Using
* 0 means no cache will be done.
*
* Since: 0.1.12
**/
void
grl_net_wc_set_cache_size (GrlNetWc *self,
guint size)
{
g_return_if_fail (GRL_IS_NET_WC (self));
if (self->priv->cache_size == size)
return;
self->priv->cache_size = size;
SoupSessionFeature *cache = soup_session_get_feature (self->priv->session, SOUP_TYPE_CACHE);
if (!cache)
return;
soup_cache_set_max_size (SOUP_CACHE (cache), size * 1024 * 1024);
}
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 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);
}
static void
do_message_do_not_use_auth_cache_test (void)
{
SoupSession *session;
SoupAuthManager *manager;
SoupURI *soup_uri;
char *uri;
char *uri_with_credentials;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
/* First check that cached credentials are not used */
do_digest_nonce_test (session, "First", uri, TRUE, TRUE, TRUE);
do_digest_nonce_test (session, "Second", uri, TRUE, FALSE, FALSE);
do_digest_nonce_test (session, "Third", uri, FALSE, TRUE, TRUE);
/* Passing credentials in the URI should always authenticate
* no matter whether the cache is used or not
*/
soup_uri = soup_uri_new (uri);
soup_uri_set_user (soup_uri, "user1");
soup_uri_set_password (soup_uri, "realm1");
uri_with_credentials = soup_uri_to_string (soup_uri, FALSE);
soup_uri_free (soup_uri);
do_digest_nonce_test (session, "Fourth", uri_with_credentials, FALSE, TRUE, FALSE);
g_free (uri_with_credentials);
manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
soup_auth_manager_clear_cached_credentials (manager);
/* Now check that credentials are not stored */
do_digest_nonce_test (session, "First", uri, FALSE, TRUE, TRUE);
do_digest_nonce_test (session, "Second", uri, TRUE, TRUE, TRUE);
do_digest_nonce_test (session, "Third", uri, TRUE, FALSE, FALSE);
g_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_coding_empty_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupRequester *requester;
SoupRequest *req;
GByteArray *body;
debug_printf (1, "\nEmpty allegedly-encoded body test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
NULL);
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
uri = soup_uri_new_with_base (base_uri, "/mbox");
debug_printf (1, " SoupMessage\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
soup_session_send_message (session, msg);
check_response (msg, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_object_unref (msg);
debug_printf (1, " SoupRequest\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
g_object_unref (msg);
body = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_byte_array_free (body, TRUE);
g_object_unref (req);
soup_uri_free (uri);
soup_test_session_abort_unref (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);
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
InitializeWebKit2();
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);
RunLoop::run();
if (SoupSessionFeature* soupCache = soup_session_get_feature(session, SOUP_TYPE_CACHE)) {
soup_cache_flush(SOUP_CACHE(soupCache));
soup_cache_dump(SOUP_CACHE(soupCache));
}
return 0;
}
/* 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);
}
static void
do_clear_credentials_test (void)
{
SoupSession *session;
SoupAuthManager *manager;
char *uri;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
do_digest_nonce_test (session, "First", uri, TRUE, TRUE, TRUE);
manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
soup_auth_manager_clear_cached_credentials (manager);
do_digest_nonce_test (session, "Second", uri, TRUE, TRUE, TRUE);
g_free (uri);
soup_test_session_abort_unref (session);
}
SoupCache* SoupNetworkSession::cache() const
{
SoupSessionFeature* soupCache = soup_session_get_feature(m_soupSession.get(), SOUP_TYPE_CACHE);
return soupCache ? SOUP_CACHE(soupCache) : nullptr;
}
