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;
}
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();
int socket = atoi(argv[1]);
WebProcess::shared().initialize(socket, RunLoop::main());
SoupSession* session = WebCore::ResourceHandle::defaultSession();
soup_session_add_feature_by_type(session, WEB_TYPE_AUTH_DIALOG);
// 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);
RunLoop::run();
return 0;
}
JNIEXPORT void JNICALL WebKitGTK_NATIVE(_1soup_1session_1add_1feature_1by_1type)
(JNIEnv *env, jclass that, jintLong arg0, jintLong arg1)
{
WebKitGTK_NATIVE_ENTER(env, that, _1soup_1session_1add_1feature_1by_1type_FUNC);
soup_session_add_feature_by_type((SoupSession *)arg0, (GType)arg1);
WebKitGTK_NATIVE_EXIT(env, that, _1soup_1session_1add_1feature_1by_1type_FUNC);
}
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);
}
/**
* asb_plugin_initialize:
*/
void
asb_plugin_initialize (AsbPlugin *plugin)
{
plugin->priv = ASB_PLUGIN_GET_PRIVATE (AsbPluginPrivate);
plugin->priv->filenames = g_ptr_array_new_with_free_func (g_free);
g_mutex_init (&plugin->priv->filenames_mutex);
plugin->priv->session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, "createrepo_as",
SOUP_SESSION_TIMEOUT, 5000,
NULL);
soup_session_add_feature_by_type (plugin->priv->session,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
}
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::SoupNetworkSession::defaultSession().soupSession();
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_add_feature_by_type(session, WEBKIT_TYPE_SOUP_REQUEST_GENERIC);
}
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;
}
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;
}
//this will insert proxy in the session
void
proxify_session(EProxy *proxy, SoupSession *session, gchar *uri)
{
SoupURI *proxy_uri = NULL;
#if EVOLUTION_VERSION < 30304
gint ptype = gconf_client_get_int (
rss_gconf, KEY_GCONF_EVO_PROXY_TYPE, NULL);
#else
GSettings *settings = g_settings_new(CONF_SCHEMA_EVO_NETWORK);
gint ptype = g_settings_get_int (
settings, CONF_EVO_PROXY_TYPE);
#endif
switch (ptype) {
#ifndef HAVE_LIBSOUP_GNOME
case 0:
#endif
case 2:
if (e_proxy_require_proxy_for_uri (proxy, uri)) {
#if (DATASERVER_VERSION >=2026000)
proxy_uri = e_proxy_peek_uri_for (proxy, uri);
#else
g_print("WARN: e_proxy_peek_uri_for() requires evolution-data-server 2.26\n");
return;
#endif
if (proxy_uri) {
d("proxified %s with %s:%d\n", uri, proxy_uri->host, proxy_uri->port);
}
} else {
d("no PROXY-%s\n", uri);
}
g_object_set (
G_OBJECT (session),
SOUP_SESSION_PROXY_URI,
proxy_uri, NULL);
break;
#ifdef HAVE_LIBSOUP_GNOME
case 0:
soup_session_add_feature_by_type (
session, SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
break;
#endif
}
}
void
set_authentication_handler() {
/* Check if WEBKIT_TYPE_SOUP_AUTH_DIALOG feature is set */
GSList *flist = soup_session_get_features (uzbl.net.soup_session, (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG);
guint feature_is_set = g_slist_length(flist);
g_slist_free(flist);
if (uzbl.behave.authentication_handler == NULL || *uzbl.behave.authentication_handler == 0) {
if (!feature_is_set)
soup_session_add_feature_by_type
(uzbl.net.soup_session, (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG);
} else {
if (feature_is_set)
soup_session_remove_feature_by_type
(uzbl.net.soup_session, (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG);
}
return;
}
static gboolean
as_app_validate_setup_networking (AsAppValidateHelper *helper, GError **error)
{
helper->session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT,
"libappstream-glib",
SOUP_SESSION_TIMEOUT,
5000,
NULL);
if (helper->session == NULL) {
g_set_error_literal (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"Failed to set up networking");
return FALSE;
}
soup_session_add_feature_by_type (helper->session,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
return TRUE;
}
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);
}
int
main (int argc, char **argv)
{
SoupServer *server;
test_init (argc, argv, NULL);
buffer = g_malloc (READ_BUFFER_SIZE);
server = soup_test_server_new (FALSE);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
base_uri = soup_uri_new ("http://127.0.0.1");
soup_uri_set_port (base_uri, soup_server_get_port (server));
base_uri_string = soup_uri_to_string (base_uri, FALSE);
/* FIXME: I had to raise the number of connections allowed here, otherwise I
* was hitting the limit, which indicates some connections are not dying.
*/
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
"use-thread-context", TRUE,
"max-conns", 20,
"max-conns-per-host", 20,
NULL);
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_SNIFFER);
test_multipart (1, 1, NO_MULTIPART);
test_multipart (1, 1, SYNC_MULTIPART);
test_multipart (1, 1, ASYNC_MULTIPART);
test_multipart (1, 1, ASYNC_MULTIPART_SMALL_READS);
soup_uri_free (base_uri);
g_free (base_uri_string);
g_free (buffer);
soup_test_session_abort_unref (session);
soup_test_server_quit_unref (server);
test_cleanup ();
return errors != 0;
}
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;
}
static void
do_coding_req_test (void)
{
SoupSession *session;
SoupRequester *requester;
SoupRequest *req;
SoupMessage *msg;
SoupURI *uri;
GByteArray *plain, *cmp;
debug_printf (1, "\nSoupRequest tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
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");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
req = soup_requester_request_uri (requester, uri, NULL);
plain = do_single_coding_req_test (req, NULL, "text/plain", EXPECT_NOT_DECODED);
g_object_unref (req);
/* Plain text data, claim gzip */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
req = soup_requester_request_uri (requester, uri, NULL);
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (req);
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\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", "trailing-junk");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\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", "force-encode");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
/* Failed content-decoding should have left the body untouched
* from what the server sent... which happens to be the
* uncompressed data.
*/
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\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", "prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\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", "prefer-deflate-zlib, trailing-junk");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\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", "force-encode, prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\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", "prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\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", "force-encode, prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
g_byte_array_free (plain, TRUE);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_coding_test (void)
{
SoupSession *session;
SoupMessage *msg, *msgz, *msgj, *msge, *msgzl, *msgzlj, *msgzle, *msgzlr, *msgzlre;
SoupURI *uri;
debug_printf (1, "SoupMessage tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/mbox");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
check_response (msg, NULL, "text/plain", EXPECT_NOT_DECODED);
/* Plain text data, claim gzip */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
msgz = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msgz);
check_response (msgz, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgz, "plain", "compressed");
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
msgj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgj->request_headers,
"X-Test-Options", "trailing-junk");
soup_session_send_message (session, msgj);
check_response (msgj, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgj, "plain", "compressed w/ junk");
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\n");
msge = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msge->request_headers,
"X-Test-Options", "force-encode");
soup_session_send_message (session, msge);
check_response (msge, "gzip", "text/plain", EXPECT_NOT_DECODED);
/* Failed content-decoding should have left the body untouched
* from what the server sent... which happens to be the
* uncompressed data.
*/
check_msg_bodies (msg, msge, "plain", "mis-encoded");
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\n");
msgzl = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzl->request_headers,
"X-Test-Options", "prefer-deflate-zlib");
soup_session_send_message (session, msgzl);
check_response (msgzl, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzl, "plain", "compressed");
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
msgzlj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlj->request_headers,
"X-Test-Options", "prefer-deflate-zlib, trailing-junk");
soup_session_send_message (session, msgzlj);
check_response (msgzlj, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlj, "plain", "compressed w/ junk");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\n");
msgzle = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzle->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-zlib");
soup_session_send_message (session, msgzle);
check_response (msgzle, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzle, "plain", "mis-encoded");
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\n");
msgzlr = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlr->request_headers,
"X-Test-Options", "prefer-deflate-raw");
soup_session_send_message (session, msgzlr);
check_response (msgzlr, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlr, "plain", "compressed");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
msgzlre = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlre->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-raw");
soup_session_send_message (session, msgzlre);
check_response (msgzlre, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzlre, "plain", "mis-encoded");
g_object_unref (msg);
g_object_unref (msgzlre);
g_object_unref (msgzlr);
g_object_unref (msgzlj);
g_object_unref (msgzle);
g_object_unref (msgzl);
g_object_unref (msgz);
g_object_unref (msgj);
g_object_unref (msge);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
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
do_ntlm_round (SoupURI *base_uri, gboolean use_ntlm,
const char *user, gboolean use_builtin_ntlm)
{
SoupSession *session;
gboolean alice = !g_strcmp0 (user, "alice");
gboolean bob = !g_strcmp0 (user, "bob");
gboolean alice_via_ntlm = use_ntlm && alice;
gboolean bob_via_ntlm = use_ntlm && bob;
gboolean alice_via_basic = !use_ntlm && alice;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
if (user) {
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), (char *)user);
if (use_ntlm && !use_builtin_ntlm)
g_setenv ("NTLMUSER", user, TRUE);
}
if (use_ntlm) {
SoupAuthManager *auth_manager;
SoupAuth *ntlm;
soup_session_add_feature_by_type (session, SOUP_TYPE_AUTH_NTLM);
auth_manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
ntlm = g_object_new (SOUP_TYPE_AUTH_NTLM, NULL);
soup_auth_manager_use_auth (auth_manager, base_uri, ntlm);
g_object_unref (ntlm);
}
/* 1. Server doesn't request auth, so both get_ntlm_prompt and
* get_basic_prompt are both FALSE, and likewise do_basic. But
* if we're using NTLM we'll try that even without the server
* asking.
*/
authenticated_ntlm = FALSE;
do_message (session, base_uri, "/noauth",
FALSE, use_ntlm,
FALSE, FALSE,
SOUP_STATUS_OK);
if (authenticated_ntlm != (use_ntlm && use_builtin_ntlm)) {
debug_printf (1, " ERROR: %s built-in NTLM support, but authenticate signal %s emitted\n",
use_builtin_ntlm ? "Using" : "Not using",
authenticated_ntlm ? "was" : "wasn't");
errors++;
}
/* 2. Server requires auth as Alice, so it will request that
* if we didn't already authenticate the connection to her in
* the previous step. If we authenticated as Bob in the
* previous step, then we'll just immediately get a 401 here.
* So in no case will we see the client try to do_ntlm.
*/
do_message (session, base_uri, "/alice",
!alice_via_ntlm, FALSE,
!alice_via_ntlm, alice_via_basic,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 3. Server still requires auth as Alice, but this URI
* doesn't exist, so Alice should get a 404, but others still
* get 401. Alice-via-NTLM is still authenticated, and so
* won't get prompts, and Alice-via-Basic knows at this point
* to send auth without it being requested, so also won't get
* prompts. But Bob/nobody will.
*/
do_message (session, base_uri, "/alice/404",
!alice, bob_via_ntlm,
!alice, alice_via_basic,
alice ? SOUP_STATUS_NOT_FOUND :
SOUP_STATUS_UNAUTHORIZED);
/* 4. Should be exactly the same as #3, except the status code */
do_message (session, base_uri, "/alice",
!alice, bob_via_ntlm,
!alice, alice_via_basic,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 5. This path requires auth as Bob; Alice-via-NTLM will get
* an immediate 401 and not try to reauthenticate.
* Alice-via-Basic will get a 401 and then try to do Basic
* (and fail). Bob-via-NTLM will try to do NTLM right away and
* succeed.
*/
do_message (session, base_uri, "/bob",
!bob_via_ntlm, bob_via_ntlm,
!bob_via_ntlm, alice_via_basic,
bob ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 6. Back to /alice. Somewhat the inverse of #5; Bob-via-NTLM
* will get an immediate 401 and not try again, Alice-via-NTLM
* will try to do NTLM right away and succeed. Alice-via-Basic
* still knows about this path, so will try Basic right away
* and succeed.
*/
do_message (session, base_uri, "/alice",
!alice_via_ntlm, alice_via_ntlm,
!alice_via_ntlm, alice_via_basic,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 7. Server accepts Basic auth from either user, but not NTLM.
* Since Bob-via-NTLM is unauthenticated at this point, he'll try
* NTLM before realizing that the server doesn't support it.
*/
do_message (session, base_uri, "/basic",
FALSE, bob_via_ntlm,
TRUE, user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
/* 8. Server accepts Basic or NTLM from either user.
* Alice-via-NTLM is still authenticated at this point from #6,
* and Bob-via-NTLM is authenticated from #7, so neither
* of them will do anything.
*/
do_message (session, base_uri, "/either",
!use_ntlm, FALSE,
!use_ntlm, !use_ntlm && user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
soup_test_session_abort_unref (session);
}
int
main (int argc, char **argv)
{
GOptionContext *opts;
const char *url;
SoupURI *proxy_uri, *parsed;
GError *error = NULL;
SoupLogger *logger = NULL;
opts = g_option_context_new (NULL);
g_option_context_add_main_entries (opts, entries, NULL);
if (!g_option_context_parse (opts, &argc, &argv, &error)) {
g_printerr ("Could not parse arguments: %s\n",
error->message);
g_printerr ("%s",
g_option_context_get_help (opts, TRUE, NULL));
exit (1);
}
if (argc != 2) {
g_printerr ("%s",
g_option_context_get_help (opts, TRUE, NULL));
exit (1);
}
g_option_context_free (opts);
url = argv[1];
parsed = soup_uri_new (url);
if (!parsed) {
g_printerr ("Could not parse '%s' as a URL\n", url);
exit (1);
}
soup_uri_free (parsed);
session = g_object_new (SOUP_TYPE_SESSION,
SOUP_SESSION_SSL_CA_FILE, ca_file,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
SOUP_SESSION_USER_AGENT, "get ",
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
if (ntlm)
soup_session_add_feature_by_type (session, SOUP_TYPE_AUTH_NTLM);
if (debug) {
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
if (proxy) {
proxy_uri = soup_uri_new (proxy);
if (!proxy_uri) {
g_printerr ("Could not parse '%s' as URI\n",
proxy);
exit (1);
}
g_object_set (G_OBJECT (session),
SOUP_SESSION_PROXY_URI, proxy_uri,
NULL);
soup_uri_free (proxy_uri);
}
if (!synchronous)
loop = g_main_loop_new (NULL, TRUE);
get_url (url);
if (!synchronous)
g_main_loop_unref (loop);
return 0;
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
SoupSession *session = SOUP_SESSION (object);
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupURI *uri;
gboolean ca_file_changed = FALSE;
const char *new_ca_file, *user_agent;
switch (prop_id) {
case PROP_PROXY_URI:
uri = g_value_get_boxed (value);
if (uri) {
soup_session_remove_feature_by_type (session, SOUP_TYPE_PROXY_RESOLVER);
priv->proxy_resolver = SOUP_PROXY_URI_RESOLVER (soup_proxy_resolver_static_new (uri));
soup_session_add_feature (session, SOUP_SESSION_FEATURE (priv->proxy_resolver));
g_object_unref (priv->proxy_resolver);
} else if (priv->proxy_resolver && SOUP_IS_PROXY_RESOLVER_STATIC (priv->proxy_resolver))
soup_session_remove_feature_by_type (session, SOUP_TYPE_PROXY_RESOLVER);
soup_session_abort (session);
break;
case PROP_MAX_CONNS:
priv->max_conns = g_value_get_int (value);
break;
case PROP_MAX_CONNS_PER_HOST:
priv->max_conns_per_host = g_value_get_int (value);
break;
case PROP_USE_NTLM:
g_object_set_property (G_OBJECT (priv->auth_manager),
SOUP_AUTH_MANAGER_NTLM_USE_NTLM,
value);
break;
case PROP_SSL_CA_FILE:
new_ca_file = g_value_get_string (value);
if (!safe_str_equal (priv->ssl_ca_file, new_ca_file))
ca_file_changed = TRUE;
g_free (priv->ssl_ca_file);
priv->ssl_ca_file = g_strdup (new_ca_file);
if (ca_file_changed && priv->ssl_creds) {
soup_ssl_free_client_credentials (priv->ssl_creds);
priv->ssl_creds = NULL;
}
break;
case PROP_ASYNC_CONTEXT:
priv->async_context = g_value_get_pointer (value);
if (priv->async_context)
g_main_context_ref (priv->async_context);
break;
case PROP_TIMEOUT:
priv->io_timeout = g_value_get_uint (value);
break;
case PROP_USER_AGENT:
g_free (priv->user_agent);
user_agent = g_value_get_string (value);
if (!user_agent)
priv->user_agent = NULL;
else if (!*user_agent) {
priv->user_agent =
g_strdup (SOUP_SESSION_USER_AGENT_BASE);
} else if (g_str_has_suffix (user_agent, " ")) {
priv->user_agent =
g_strdup_printf ("%s%s", user_agent,
SOUP_SESSION_USER_AGENT_BASE);
} else
priv->user_agent = g_strdup (user_agent);
break;
case PROP_IDLE_TIMEOUT:
priv->idle_timeout = g_value_get_uint (value);
break;
case PROP_ADD_FEATURE:
soup_session_add_feature (session, g_value_get_object (value));
break;
case PROP_ADD_FEATURE_BY_TYPE:
soup_session_add_feature_by_type (session, g_value_get_gtype (value));
break;
case PROP_REMOVE_FEATURE_BY_TYPE:
soup_session_remove_feature_by_type (session, g_value_get_gtype (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
g_vfs_backend_http_init (GVfsBackendHttp *backend)
{
const char *debug;
SoupSessionFeature *proxy_resolver;
SoupSessionFeature *cookie_jar;
SoupSessionFeature *content_decoder;
g_vfs_backend_set_user_visible (G_VFS_BACKEND (backend), FALSE);
backend->session = soup_session_sync_new_with_options ("user-agent",
"gvfs/" VERSION,
NULL);
backend->session_async = soup_session_async_new_with_options ("user-agent",
"gvfs/" VERSION,
NULL);
/* SoupRequester seems to depend on use-thread-context */
g_object_set (G_OBJECT (backend->session_async), "use-thread-context", TRUE, NULL);
/* Proxy handling */
proxy_resolver = g_object_new (SOUP_TYPE_PROXY_RESOLVER_GNOME, NULL);
soup_session_add_feature (backend->session, proxy_resolver);
soup_session_add_feature (backend->session_async, proxy_resolver);
g_object_unref (proxy_resolver);
/* Cookie handling - stored temporarlly in memory, mostly useful for
* authentication in WebDAV. */
cookie_jar = g_object_new (SOUP_TYPE_COOKIE_JAR, NULL);
soup_session_add_feature (backend->session, cookie_jar);
soup_session_add_feature (backend->session_async, cookie_jar);
g_object_unref (cookie_jar);
/* Send Accept-Language header (see bug 166795) */
g_object_set (backend->session, "accept-language-auto", TRUE, NULL);
g_object_set (backend->session_async, "accept-language-auto", TRUE, NULL);
/* Handle decompression automatically */
content_decoder = g_object_new (SOUP_TYPE_CONTENT_DECODER, NULL);
soup_session_add_feature (backend->session, content_decoder);
soup_session_add_feature (backend->session_async, content_decoder);
g_object_unref (content_decoder);
/* Request API */
soup_session_add_feature_by_type (backend->session, SOUP_TYPE_REQUESTER);
soup_session_add_feature_by_type (backend->session_async, SOUP_TYPE_REQUESTER);
/* Logging */
debug = g_getenv ("GVFS_HTTP_DEBUG");
if (debug)
{
SoupLogger *logger;
SoupLoggerLogLevel level;
if (g_ascii_strcasecmp (debug, "all") ||
g_ascii_strcasecmp (debug, "body"))
level = SOUP_LOGGER_LOG_BODY;
else if (g_ascii_strcasecmp (debug, "header"))
level = SOUP_LOGGER_LOG_HEADERS;
else
level = SOUP_LOGGER_LOG_MINIMAL;
logger = soup_logger_new (level, DEBUG_MAX_BODY_SIZE);
soup_session_add_feature (backend->session, SOUP_SESSION_FEATURE (logger));
soup_session_add_feature (backend->session_async, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
}
//this will insert proxy in the session
//and queue the message to be sent
void
proxify_session_async(EProxy *proxy, STNET *stnet)
{
SoupURI *proxy_uri = NULL, *su;
#if EVOLUTION_VERSION < 30304
gint ptype = gconf_client_get_int (
rss_gconf, KEY_GCONF_EVO_PROXY_TYPE, NULL);
#else
GSettings *settings = g_settings_new(CONF_SCHEMA_EVO_NETWORK);
gint ptype = g_settings_get_int (
settings, CONF_EVO_PROXY_TYPE);
#endif
switch (ptype) {
#ifndef HAVE_LIBSOUP_GNOME
case 0:
#endif
case 2:
su = soup_uri_new (stnet->url);
stnet->host = su->host;
if (su) {
if (su->scheme == SOUP_URI_SCHEME_HTTPS) {
if (rss_ep_need_proxy_https (proxy, su->host)) {
#if (DATASERVER_VERSION >=2026000)
proxy_uri = e_proxy_peek_uri_for (proxy, stnet->url);
#else
g_print("WARN: e_proxy_peek_uri_for() requires evolution-data-server 2.26\n");
soup_uri_free(su);
return;
#endif
if (proxy_uri) {
d("proxified %s with %s:%d\n", stnet->url, proxy_uri->host, proxy_uri->port);
}
} else {
d("no PROXY-%s\n", stnet->url);
}
g_object_set (
G_OBJECT (stnet->ss),
SOUP_SESSION_PROXY_URI,
proxy_uri, NULL);
soup_uri_free(su);
goto out;
} else {
stnet->addr = soup_address_new (su->host, 0);
soup_uri_free(su);
soup_address_resolve_async (stnet->addr, NULL, NULL,
rss_resolve_callback, stnet);
return;
}
}
break;
#ifdef HAVE_LIBSOUP_GNOME
case 0:
soup_session_add_feature_by_type (
stnet->ss, SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
break;
#endif
}
out: stnet->callback(stnet->data);
//free stnet
}
/* FIXME: moar tests! */
static void
do_cookies_parsing_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupCookieJar *jar;
GSList *cookies, *iter;
SoupCookie *cookie;
gboolean got1, got2, got3;
debug_printf (1, "\nSoupCookie parsing 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));
/* "httponly" is case-insensitive, and its value (if any) is ignored */
msg = soup_message_new_from_uri ("GET", first_party_uri);
soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
"one=1; httponly; max-age=100");
soup_session_send_message (session, msg);
g_object_unref (msg);
msg = soup_message_new_from_uri ("GET", first_party_uri);
soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
"two=2; HttpOnly; max-age=100");
soup_session_send_message (session, msg);
g_object_unref (msg);
msg = soup_message_new_from_uri ("GET", first_party_uri);
soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
"three=3; httpONLY=Wednesday; max-age=100");
soup_session_send_message (session, msg);
g_object_unref (msg);
cookies = soup_cookie_jar_get_cookie_list (jar, first_party_uri, TRUE);
got1 = got2 = got3 = FALSE;
for (iter = cookies; iter; iter = iter->next) {
cookie = iter->data;
if (!strcmp (soup_cookie_get_name (cookie), "one")) {
got1 = TRUE;
if (!soup_cookie_get_http_only (cookie)) {
debug_printf (1, " cookie 1 is not HttpOnly!\n");
errors++;
}
if (!soup_cookie_get_expires (cookie)) {
debug_printf (1, " cookie 1 did not fully parse!\n");
errors++;
}
} else if (!strcmp (soup_cookie_get_name (cookie), "two")) {
got2 = TRUE;
if (!soup_cookie_get_http_only (cookie)) {
debug_printf (1, " cookie 2 is not HttpOnly!\n");
errors++;
}
if (!soup_cookie_get_expires (cookie)) {
debug_printf (1, " cookie 3 did not fully parse!\n");
errors++;
}
} else if (!strcmp (soup_cookie_get_name (cookie), "three")) {
got3 = TRUE;
if (!soup_cookie_get_http_only (cookie)) {
debug_printf (1, " cookie 3 is not HttpOnly!\n");
errors++;
}
if (!soup_cookie_get_expires (cookie)) {
debug_printf (1, " cookie 3 did not fully parse!\n");
errors++;
}
} else {
debug_printf (1, " got unexpected cookie '%s'\n",
soup_cookie_get_name (cookie));
errors++;
}
soup_cookie_free (cookie);
}
g_slist_free (cookies);
if (!got1) {
debug_printf (1, " didn't get cookie 1\n");
errors++;
}
if (!got2) {
debug_printf (1, " didn't get cookie 2\n");
errors++;
}
if (!got3) {
debug_printf (1, " didn't get cookie 3\n");
errors++;
}
soup_test_session_abort_unref (session);
}
int ewk_init(void)
{
if (_ewk_init_count)
return ++_ewk_init_count;
if (!eina_init())
goto error_eina;
_ewk_log_dom = eina_log_domain_register("ewebkit", EINA_COLOR_ORANGE);
if (_ewk_log_dom < 0) {
EINA_LOG_CRIT("could not register log domain 'ewebkit'");
goto error_log_domain;
}
if (!evas_init()) {
CRITICAL("could not init evas.");
goto error_evas;
}
if (!ecore_init()) {
CRITICAL("could not init ecore.");
goto error_ecore;
}
if (!ecore_evas_init()) {
CRITICAL("could not init ecore_evas.");
goto error_ecore_evas;
}
if (!edje_init()) {
CRITICAL("could not init edje.");
goto error_edje;
}
#ifdef ENABLE_GLIB_SUPPORT
g_type_init();
if (!g_thread_supported())
g_thread_init(0);
#ifdef ENABLE_GTK_PLUGINS_SUPPORT
gdk_threads_init();
if (!gtk_init_check(0, 0))
WRN("Could not initialize GTK support.");
#endif
if (!ecore_main_loop_glib_integrate())
WRN("Ecore was not compiled with GLib support, some plugins will not "
"work (ie: Adobe Flash)");
#endif
JSC::initializeThreading();
WTF::initializeMainThread();
WebCore::InitializeLoggingChannelsIfNecessary();
// Page cache capacity (in pages). Comment from Mac port:
// (Research indicates that value / page drops substantially after 3 pages.)
// FIXME: Expose this with an API and/or calculate based on available resources
WebCore::pageCache()->setCapacity(3);
WebCore::PageGroup::setShouldTrackVisitedLinks(true);
// TODO: this should move to WebCore, already reported to webkit-gtk folks:
if (1) {
SoupSession* session = WebCore::ResourceHandle::defaultSession();
soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_SNIFFER);
}
return ++_ewk_init_count;
error_edje:
ecore_evas_shutdown();
error_ecore_evas:
ecore_shutdown();
error_ecore:
evas_shutdown();
error_evas:
eina_log_domain_unregister(_ewk_log_dom);
_ewk_log_dom = -1;
error_log_domain:
eina_shutdown();
error_eina:
return 0;
}
GtkWidget *
html_create_widget (GtkWidget * dlg)
{
GtkWidget *sw;
WebKitSettings *settings;
SoupSession *sess;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), options.hscroll_policy, options.vscroll_policy);
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_object_set (G_OBJECT(settings), "user-agent", "YAD3/" VERSION " (KHTML, like Gecko)", NULL);
g_object_set (G_OBJECT(settings), "default-charset", "utf-8", NULL);
g_object_set (G_OBJECT(settings), "enable-fullscreen", options.data.fullscreen, NULL);
g_signal_connect (view, "decide-policy", G_CALLBACK (policy_cb), NULL);
if (options.html_data.browser)
{
g_signal_connect (view, "context-menu", G_CALLBACK (menu_cb), NULL);
if (!options.data.dialog_title)
g_signal_connect (view, "notify::title", G_CALLBACK (title_cb), dlg);
if (strcmp (options.data.window_icon, "yad") == 0)
g_signal_connect (view, "notify::favicon", G_CALLBACK (icon_cb), dlg);
}
else
{
g_object_set (G_OBJECT(settings), "enable-caret-browsing", FALSE, NULL);
g_object_set (G_OBJECT(settings), "enable-developer-extras", FALSE, NULL);
g_object_set (G_OBJECT(settings), "enable-html5-database", FALSE, NULL);
g_object_set (G_OBJECT(settings), "enable-html5-local-storage", FALSE, NULL);
g_object_set (G_OBJECT(settings), "enable-offline-web-application-cache", FALSE, NULL);
g_object_set (G_OBJECT(settings), "enable-page-cache", FALSE, NULL);
g_object_set (G_OBJECT(settings), "enable-plugins", FALSE, NULL);
g_object_set (G_OBJECT (settings), "enable-private-browsing", TRUE, NULL);
g_signal_connect (view, "load-changed", G_CALLBACK (loaded_cb), NULL);
}
#if 0
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);
#endif
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;
}
static void
do_coding_test (void)
{
SoupSession *session;
SoupMessage *msg, *msgz, *msgj;
SoupURI *uri;
const char *coding;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/mbox");
debug_printf (1, "GET /mbox, plain\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msg->response_headers, "Content-Encoding");
if (coding) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding);
errors++;
}
if (soup_message_get_flags (msg) & SOUP_MESSAGE_CONTENT_DECODED) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED set!\n");
errors++;
}
debug_printf (1, "GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
msgz = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msgz);
if (!SOUP_STATUS_IS_SUCCESSFUL (msgz->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msgz->status_code, msgz->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msgz->response_headers, "Content-Encoding");
if (!coding || g_ascii_strcasecmp (coding, "gzip") != 0) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding ? coding : "(none)");
errors++;
}
if (!(soup_message_get_flags (msgz) & SOUP_MESSAGE_CONTENT_DECODED)) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED not set!\n");
errors++;
}
if (msg->response_body->length != msgz->response_body->length) {
debug_printf (1, " Message length mismatch: %lu (plain) vs %lu (compressed)\n",
(gulong)msg->response_body->length,
(gulong)msgz->response_body->length);
errors++;
} else if (memcmp (msg->response_body->data,
msgz->response_body->data,
msg->response_body->length) != 0) {
debug_printf (1, " Message data mismatch (plain/compressed)\n");
errors++;
}
debug_printf (1, "GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
msgj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgj->request_headers,
"X-Trailing-Junk", "junk!");
soup_session_send_message (session, msgj);
if (!SOUP_STATUS_IS_SUCCESSFUL (msgj->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msgj->status_code, msgj->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msgj->response_headers, "Content-Encoding");
if (!coding || g_ascii_strcasecmp (coding, "gzip") != 0) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding ? coding : "(none)");
errors++;
}
if (!(soup_message_get_flags (msgj) & SOUP_MESSAGE_CONTENT_DECODED)) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED not set!\n");
errors++;
}
if (msg->response_body->length != msgj->response_body->length) {
debug_printf (1, " Message length mismatch: %lu (plain) vs %lu (compressed w/ junk)\n",
(gulong)msg->response_body->length,
(gulong)msgj->response_body->length);
errors++;
} else if (memcmp (msg->response_body->data,
msgj->response_body->data,
msg->response_body->length) != 0) {
debug_printf (1, " Message data mismatch (plain/compressed w/ junk)\n");
errors++;
}
g_object_unref (msg);
g_object_unref (msgz);
g_object_unref (msgj);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
