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;
}
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;
}
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));
}
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
_web_service_send_message (WebService *self,
SoupMessage *msg,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data,
gpointer source_tag,
SoupSessionCallback soup_session_cb,
gpointer soup_session_cb_data)
{
if (self->priv->session == NULL) {
self->priv->session = soup_session_new ();
#ifdef DEBUG_WEB_CONNECTION
{
SoupLogger *logger;
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_session_add_feature (self->priv->session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
#endif
}
_g_object_unref (self->priv->cancellable);
self->priv->cancellable = _g_object_ref (cancellable);
_g_object_unref (self->priv->result);
self->priv->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
source_tag);
self->priv->msg = msg;
g_object_add_weak_pointer (G_OBJECT (msg), (gpointer *) &self->priv->msg);
soup_session_queue_message (self->priv->session,
msg,
soup_session_cb,
soup_session_cb_data);
}
/**
* grl_net_wc_set_log_level:
* @self: a #GrlNetWc instance
* @log_level: the libsoup log level to set [0,3]
*
* Setting the log level the logger feature is added into
* the libsoup session.
*/
void
grl_net_wc_set_log_level (GrlNetWc *self,
guint log_level)
{
SoupLogger *logger;
g_return_if_fail (log_level <= 3);
g_return_if_fail (GRL_IS_NET_WC (self));
if (self->priv->log_level == log_level)
return;
soup_session_remove_feature_by_type (self->priv->session, SOUP_TYPE_LOGGER);
logger = soup_logger_new ((SoupLoggerLogLevel) log_level, -1);
soup_session_add_feature (self->priv->session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
self->priv->log_level = (SoupLoggerLogLevel) log_level;
}
static void
e_cal_backend_http_constructed (GObject *object)
{
ECalBackendHttp *backend;
SoupSession *soup_session;
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (e_cal_backend_http_parent_class)->constructed (object);
soup_session = soup_session_sync_new ();
g_object_set (
soup_session,
SOUP_SESSION_TIMEOUT, 90,
SOUP_SESSION_SSL_STRICT, TRUE,
SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
backend = E_CAL_BACKEND_HTTP (object);
backend->priv->soup_session = soup_session;
e_binding_bind_property (
backend, "proxy-resolver",
backend->priv->soup_session, "proxy-resolver",
G_BINDING_SYNC_CREATE);
g_signal_connect (
backend->priv->soup_session, "authenticate",
G_CALLBACK (soup_authenticate), backend);
if (g_getenv ("WEBCAL_DEBUG") != NULL) {
SoupLogger *logger;
logger = soup_logger_new (
SOUP_LOGGER_LOG_BODY, 1024 * 1024);
soup_session_add_feature (
backend->priv->soup_session,
SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
}
void
setup(void) {
SoupSession *s;
char *proxy;
char *new_proxy;
SoupURI *puri;
/* clean up any zombies immediately */
sigchld(0);
gtk_init(NULL, NULL);
if (!g_thread_supported())
g_thread_init(NULL);
dpy = GDK_DISPLAY();
session = webkit_get_default_session();
uriprop = XInternAtom(dpy, "_SURF_URI", False);
findprop = XInternAtom(dpy, "_SURF_FIND", False);
/* create dirs and files */
cookiefile = buildpath(cookiefile);
dldir = buildpath(dldir);
scriptfile = buildpath(scriptfile);
stylefile = buildpath(stylefile);
/* cookie persistance */
s = webkit_get_default_session();
cookies = soup_cookie_jar_new();
soup_session_add_feature(s, SOUP_SESSION_FEATURE(cookies));
g_signal_connect(cookies, "changed", G_CALLBACK(changecookie), NULL);
if((proxy = getenv("http_proxy")) && strcmp(proxy, "")) {
new_proxy = g_strrstr(proxy, "http://") ? g_strdup(proxy) :
g_strdup_printf("http://%s", proxy);
puri = soup_uri_new(new_proxy);
g_object_set(G_OBJECT(s), "proxy-uri", puri, NULL);
soup_uri_free(puri);
g_free(new_proxy);
}
reloadcookies();
}
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);
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;
}
void LayoutTestController::setAlwaysAcceptCookies(bool alwaysAcceptCookies)
{
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);
}
Eina_Bool ewk_cookies_file_set(const char* filename)
{
SoupCookieJar* cookieJar = 0;
if (filename)
cookieJar = soup_cookie_jar_text_new(filename, FALSE);
else
cookieJar = soup_cookie_jar_new();
if (!cookieJar)
return 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 true;
}
static SoupSession *
create_hkp_soup_session (void)
{
SoupSession *session;
#ifdef WITH_DEBUG
g_autoptr(SoupLogger) logger = NULL;
const gchar *env;
#endif
session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
#ifdef 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));
}
#endif
return session;
}
static void
webdav_debug_setup (SoupSession *session)
{
const gchar *debug_str;
SoupLogger *logger;
SoupLoggerLogLevel level;
g_return_if_fail (session != NULL);
debug_str = g_getenv ("WEBDAV_DEBUG");
if (!debug_str || !*debug_str)
return;
if (g_ascii_strcasecmp (debug_str, "all") == 0)
level = SOUP_LOGGER_LOG_BODY;
else if (g_ascii_strcasecmp (debug_str, "headers") == 0)
level = SOUP_LOGGER_LOG_HEADERS;
else
level = SOUP_LOGGER_LOG_MINIMAL;
logger = soup_logger_new (level, 100 * 1024 * 1024);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
static void
settings_init () {
GKeyFile* config;
gboolean res = FALSE;
char *saveptr;
gchar** keys = NULL;
if (!config_file) {
const char* XDG_CONFIG_HOME = getenv ("XDG_CONFIG_HOME");
if (! XDG_CONFIG_HOME || ! strcmp (XDG_CONFIG_HOME, "")) {
XDG_CONFIG_HOME = (char*)XDG_CONFIG_HOME_default;
}
printf("XDG_CONFIG_HOME: %s\n", XDG_CONFIG_HOME);
strcpy (config_file_path, XDG_CONFIG_HOME);
strcat (config_file_path, "/uzbl/config");
if (file_exists (config_file_path)) {
printf ("Config file %s found.\n", config_file_path);
config_file = &config_file_path[0];
} else {
// Now we check $XDG_CONFIG_DIRS
char *XDG_CONFIG_DIRS = getenv ("XDG_CONFIG_DIRS");
if (! XDG_CONFIG_DIRS || ! strcmp (XDG_CONFIG_DIRS, ""))
XDG_CONFIG_DIRS = XDG_CONFIG_DIRS_default;
printf("XDG_CONFIG_DIRS: %s\n", XDG_CONFIG_DIRS);
char buffer[512];
strcpy (buffer, XDG_CONFIG_DIRS);
const gchar* dir = (char *) strtok_r (buffer, ":", &saveptr);
while (dir && ! file_exists (config_file_path)) {
strcpy (config_file_path, dir);
strcat (config_file_path, "/uzbl/config_file_pathig");
if (file_exists (config_file_path)) {
printf ("Config file %s found.\n", config_file_path);
config_file = &config_file_path[0];
}
dir = (char * ) strtok_r (NULL, ":", &saveptr);
}
}
}
if (config_file) {
config = g_key_file_new ();
res = g_key_file_load_from_file (config, config_file, G_KEY_FILE_NONE, NULL);
if (res) {
printf ("Config %s loaded\n", config_file);
} else {
fprintf (stderr, "Config %s loading failed\n", config_file);
}
} else {
printf ("No configuration.\n");
}
if (res) {
history_handler = g_key_file_get_value (config, "behavior", "history_handler", NULL);
download_handler = g_key_file_get_value (config, "behavior", "download_handler", NULL);
always_insert_mode = g_key_file_get_boolean (config, "behavior", "always_insert_mode", NULL);
show_status = g_key_file_get_boolean (config, "behavior", "show_status", NULL);
modkey = g_key_file_get_value (config, "behavior", "modkey", NULL);
status_top = g_key_file_get_boolean (config, "behavior", "status_top", NULL);
if (! fifo_dir)
fifo_dir = g_key_file_get_value (config, "behavior", "fifo_dir", NULL);
if (! socket_dir)
socket_dir = g_key_file_get_value (config, "behavior", "socket_dir", NULL);
keys = g_key_file_get_keys (config, "bindings", NULL, NULL);
}
printf ("History handler: %s\n", (history_handler ? history_handler : "disabled"));
printf ("Download manager: %s\n", (download_handler ? download_handler : "disabled"));
printf ("Fifo directory: %s\n", (fifo_dir ? fifo_dir : "disabled"));
printf ("Socket directory: %s\n", (socket_dir ? socket_dir : "disabled"));
printf ("Always insert mode: %s\n", (always_insert_mode ? "TRUE" : "FALSE"));
printf ("Show status: %s\n", (show_status ? "TRUE" : "FALSE"));
printf ("Status top: %s\n", (status_top ? "TRUE" : "FALSE"));
printf ("Modkey: %s\n", (modkey ? modkey : "disabled"));
if (! modkey)
modkey = "";
//POSSIBLE MODKEY VALUES (COMBINATIONS CAN BE USED)
gchar* modkeyup = g_utf8_strup (modkey, -1);
if (g_strrstr (modkeyup,"SHIFT") != NULL) modmask |= GDK_SHIFT_MASK; //the Shift key.
if (g_strrstr (modkeyup,"LOCK") != NULL) modmask |= GDK_LOCK_MASK; //a Lock key (depending on the modifier mapping of the X server this may either be CapsLock or ShiftLock).
if (g_strrstr (modkeyup,"CONTROL") != NULL) modmask |= GDK_CONTROL_MASK; //the Control key.
if (g_strrstr (modkeyup,"MOD1") != NULL) modmask |= GDK_MOD1_MASK; //the fourth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier, but normally it is the Alt key).
if (g_strrstr (modkeyup,"MOD2") != NULL) modmask |= GDK_MOD2_MASK; //the fifth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
if (g_strrstr (modkeyup,"MOD3") != NULL) modmask |= GDK_MOD3_MASK; //the sixth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
if (g_strrstr (modkeyup,"MOD4") != NULL) modmask |= GDK_MOD4_MASK; //the seventh modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
if (g_strrstr (modkeyup,"MOD5") != NULL) modmask |= GDK_MOD5_MASK; //the eighth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier).
if (g_strrstr (modkeyup,"BUTTON1") != NULL) modmask |= GDK_BUTTON1_MASK; //the first mouse button.
if (g_strrstr (modkeyup,"BUTTON2") != NULL) modmask |= GDK_BUTTON2_MASK; //the second mouse button.
if (g_strrstr (modkeyup,"BUTTON3") != NULL) modmask |= GDK_BUTTON3_MASK; //the third mouse button.
if (g_strrstr (modkeyup,"BUTTON4") != NULL) modmask |= GDK_BUTTON4_MASK; //the fourth mouse button.
if (g_strrstr (modkeyup,"BUTTON5") != NULL) modmask |= GDK_BUTTON5_MASK; //the fifth mouse button.
if (g_strrstr (modkeyup,"SUPER") != NULL) modmask |= GDK_SUPER_MASK; //the Super modifier. Since 2.10
if (g_strrstr (modkeyup,"HYPER") != NULL) modmask |= GDK_HYPER_MASK; //the Hyper modifier. Since 2.10
if (g_strrstr (modkeyup,"META") != NULL) modmask |= GDK_META_MASK; //the Meta modifier. Since 2.10 */
free (modkeyup);
if (keys) {
int i;
for (i = 0; keys[i]; i++) {
gchar *value = g_key_file_get_string (config, "bindings", keys[i], NULL);
add_binding(g_strstrip(keys[i]), value);
g_free(value);
}
g_strfreev(keys);
}
/* networking options */
if (res) {
proxy_url = g_key_file_get_value (config, "network", "proxy_server", NULL);
http_debug = g_key_file_get_integer (config, "network", "http_debug", NULL);
useragent = g_key_file_get_value (config, "network", "user-agent", NULL);
max_conns = g_key_file_get_integer (config, "network", "max_conns", NULL);
max_conns_host = g_key_file_get_integer (config, "network", "max_conns_per_host", NULL);
}
if(proxy_url){
g_object_set(G_OBJECT(soup_session), SOUP_SESSION_PROXY_URI, soup_uri_new(proxy_url), NULL);
}
if(!(http_debug <= 3)){
http_debug = 0;
fprintf(stderr, "Wrong http_debug level, ignoring.\n");
} else if (http_debug > 0) {
soup_logger = soup_logger_new(http_debug, -1);
soup_session_add_feature(soup_session, SOUP_SESSION_FEATURE(soup_logger));
}
if(useragent){
char* newagent = malloc(1024);
strcpy(newagent, str_replace("%webkit-major%", itos(WEBKIT_MAJOR_VERSION), useragent));
strcpy(newagent, str_replace("%webkit-minor%", itos(WEBKIT_MINOR_VERSION), newagent));
strcpy(newagent, str_replace("%webkit-micro%", itos(WEBKIT_MICRO_VERSION), newagent));
if (uname (&unameinfo) == -1) {
printf("Error getting uname info. Not replacing system-related user agent variables.\n");
} else {
strcpy(newagent, str_replace("%sysname%", unameinfo.sysname, newagent));
strcpy(newagent, str_replace("%nodename%", unameinfo.nodename, newagent));
strcpy(newagent, str_replace("%kernrel%", unameinfo.release, newagent));
strcpy(newagent, str_replace("%kernver%", unameinfo.version, newagent));
strcpy(newagent, str_replace("%arch-system%", unameinfo.machine, newagent));
#ifdef _GNU_SOURCE
strcpy(newagent, str_replace("%domainname%", unameinfo.domainname, newagent));
#endif
}
strcpy(newagent, str_replace("%arch-uzbl%", ARCH, newagent));
strcpy(newagent, str_replace("%commit%", COMMIT, newagent));
useragent = malloc(1024);
strcpy(useragent, newagent);
g_object_set(G_OBJECT(soup_session), SOUP_SESSION_USER_AGENT, useragent, NULL);
}
if(max_conns >= 1){
g_object_set(G_OBJECT(soup_session), SOUP_SESSION_MAX_CONNS, max_conns, NULL);
}
if(max_conns_host >= 1){
g_object_set(G_OBJECT(soup_session), SOUP_SESSION_MAX_CONNS_PER_HOST, max_conns_host, NULL);
}
printf("Proxy configured: %s\n", proxy_url ? proxy_url : "none");
printf("HTTP logging level: %d\n", http_debug);
printf("User-agent: %s\n", useragent? useragent : "default");
printf("Maximum connections: %d\n", max_conns ? max_conns : 0);
printf("Maximum connections per host: %d\n", max_conns_host ? max_conns_host: 0);
//Cookies
cookie_text_file = g_key_file_get_value (config, "behavior", "cookie_text_file", NULL);
if (cookie_text_file) {
printf("Cookie text file location: %s\n", cookie_text_file);
soup_cookie = soup_cookie_jar_text_new (cookie_text_file, FALSE);
soup_session_add_feature(soup_session, SOUP_SESSION_FEATURE(soup_cookie));
}
}
WK_EXPORT int WebProcessMainEfl(int argc, char* argv[])
{
// WebProcess should be launched with an option.
if (argc != 2)
return 1;
if (!eina_init())
return 1;
if (!ecore_init()) {
// Could not init ecore.
eina_shutdown();
return 1;
}
#ifdef HAVE_ECORE_X
XSetExtensionErrorHandler(dummyExtensionErrorHandler);
if (!ecore_x_init(0)) {
// Could not init ecore_x.
// PlatformScreenEfl and systemBeep() functions
// depend on ecore_x functionality.
ecore_shutdown();
eina_shutdown();
return 1;
}
#endif
#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
if (!ecore_main_loop_glib_integrate())
return 1;
JSC::initializeThreading();
WTF::initializeMainThread();
RunLoop::initializeMainRunLoop();
SoupSession* session = WebCore::ResourceHandle::defaultSession();
const char* httpProxy = getenv("http_proxy");
if (httpProxy) {
const char* noProxy = getenv("no_proxy");
SoupProxyURIResolver* resolverEfl = soupProxyResolverWkNew(httpProxy, noProxy);
soup_session_add_feature(session, SOUP_SESSION_FEATURE(resolverEfl));
g_object_unref(resolverEfl);
}
// Set SOUP cache.
String soupCacheDirectory = String::fromUTF8(efreet_cache_home_get()) + "/WebKitEfl";
SoupCache* soupCache = soup_cache_new(soupCacheDirectory.utf8().data(), SOUP_CACHE_SINGLE_USER);
soup_session_add_feature(session, SOUP_SESSION_FEATURE(soupCache));
soup_cache_load(soupCache);
int socket = atoi(argv[1]);
ChildProcessInitializationParameters parameters;
parameters.connectionIdentifier = socket;
WebProcess::shared().initialize(parameters);
RunLoop::run();
soup_cache_flush(soupCache);
soup_cache_dump(soupCache);
g_object_unref(soupCache);
ecore_x_shutdown();
ecore_shutdown();
eina_shutdown();
return 0;
}
bool oauth_login(
GtkBuilder *builder,
char **username_p,
char **auth_token_p,
char **auth_secret_p,
uint64_t *userid_p,
GError **err_p)
{
#if !USE_LOCAL_CGI
const char *token_uri = "https://api.twitter.com/oauth/request_token";
const char *access_uri = "https://api.twitter.com/oauth/access_token";
#else
const char *token_uri = "https://localhost/cgi-bin/oauth.cgi/request_token";
const char *access_uri = "https://localhost/cgi-bin/oauth.cgi/access_token";
#endif
SoupSession *ss = soup_session_async_new();
#if 0
SoupLogger *logger = soup_logger_new(1, -1);
soup_session_add_feature(ss, SOUP_SESSION_FEATURE(logger));
g_object_unref(logger);
#endif
SoupMessage *msg = make_token_request_msg(token_uri, CONSUMER_KEY,
CONSUMER_SECRET);
if(msg == NULL) {
/* FIXME */
abort();
}
soup_session_send_message(ss, msg);
bool ok;
if(msg->status_code != SOUP_STATUS_OK) {
fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
msg->status_code, soup_status_get_phrase(msg->status_code));
ok = false;
goto end;
}
/* interpret the response. */
char **rt_output = oa_parse_response(msg->response_body->data,
"oauth_token", "oauth_token_secret", NULL);
if(rt_output == NULL) {
g_set_error(err_p, 0, EINVAL, "can't parse response data");
ok = false;
goto end;
}
/* do out-of-band OAuth */
const char *req_token = rt_output[0], *req_secret = rt_output[1];
#if !USE_LOCAL_CGI
GError *err = NULL;
if(!launch_authorization_browser(req_token, &err)) {
fprintf(stderr, "warning: browser launching failed: %s\n",
err->message);
g_error_free(err);
}
#endif
char *pin = query_pin(builder);
printf("PIN is: `%s'\n", pin);
/* get an access token */
g_object_unref(msg);
msg = make_access_token_request_msg(access_uri, req_token, req_secret,
pin, CONSUMER_KEY, CONSUMER_SECRET);
g_free(pin);
if(msg == NULL) {
fprintf(stderr, "can't sign access request message!\n");
abort();
}
soup_session_send_message(ss, msg);
if(msg->status_code != SOUP_STATUS_OK) {
fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
msg->status_code, soup_status_get_phrase(msg->status_code));
/* FIXME: handle */
abort();
}
char **at_output = oa_parse_response(msg->response_body->data,
"oauth_token", "oauth_token_secret", "user_id", "screen_name", NULL);
if(at_output == NULL) {
/* FIXME: response data parsing fail */
abort();
}
/* the payoff */
*auth_token_p = g_strdup(at_output[0]);
*auth_secret_p = g_strdup(at_output[1]);
*userid_p = strtoull(at_output[2], NULL, 10);
*username_p = g_strdup(at_output[3]);
printf("login successful! username `%s', userid %llu\n", *username_p,
(unsigned long long)*userid_p);
g_strfreev(at_output);
g_strfreev(rt_output);
ok = true;
end:
g_object_unref(msg);
g_object_unref(ss);
return ok;
}
void SoupNetworkSession::setCache(SoupCache* cache)
{
ASSERT(!soup_session_get_feature(m_soupSession.get(), SOUP_TYPE_CACHE));
soup_session_add_feature(m_soupSession.get(), SOUP_SESSION_FEATURE(cache));
}
void SoupNetworkSession::setCookieJar(SoupCookieJar* jar)
{
if (SoupCookieJar* currentJar = cookieJar())
soup_session_remove_feature(m_soupSession.get(), SOUP_SESSION_FEATURE(currentJar));
soup_session_add_feature(m_soupSession.get(), SOUP_SESSION_FEATURE(jar));
}
static void add_cookie(char *cookie_file)
{
SoupSession *session = webkit_get_default_session();
SoupCookieJar *jar = soup_cookie_jar_text_new(cookie_file, false);
soup_session_add_feature(session, SOUP_SESSION_FEATURE(jar));
}
static 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;
}
}
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
g_vfs_backend_http_class_init (GVfsBackendHttpClass *klass)
{
const char *debug;
SoupSessionFeature *cookie_jar;
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GVfsBackendClass *backend_class;
gobject_class->finalize = g_vfs_backend_http_finalize;
backend_class = G_VFS_BACKEND_CLASS (klass);
backend_class->try_mount = try_mount;
backend_class->try_open_for_read = try_open_for_read;
backend_class->try_read = try_read;
backend_class->try_seek_on_read = try_seek_on_read;
backend_class->try_close_read = try_close_read;
backend_class->try_query_info = try_query_info;
backend_class->try_query_info_on_read = try_query_info_on_read;
backend_class->try_query_fs_info = try_query_fs_info;
/* Initialize the SoupSession, common to all backend instances */
the_session = soup_session_new_with_options ("user-agent",
"gvfs/" VERSION,
NULL);
g_object_set (the_session, "ssl-strict", FALSE, NULL);
/* 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 (the_session, cookie_jar);
g_object_unref (cookie_jar);
/* Send Accept-Language header (see bug 166795) */
g_object_set (the_session, "accept-language-auto", TRUE, NULL);
/* Prevent connection timeouts during long operations like COPY. */
g_object_set (the_session, "timeout", 0, NULL);
/* Logging */
debug = g_getenv ("GVFS_HTTP_DEBUG");
if (debug)
{
SoupLogger *logger;
SoupLoggerLogLevel level;
if (g_ascii_strcasecmp (debug, "all") == 0 ||
g_ascii_strcasecmp (debug, "body") == 0)
level = SOUP_LOGGER_LOG_BODY;
else if (g_ascii_strcasecmp (debug, "header") == 0)
level = SOUP_LOGGER_LOG_HEADERS;
else
level = SOUP_LOGGER_LOG_MINIMAL;
logger = soup_logger_new (level, DEBUG_MAX_BODY_SIZE);
soup_session_add_feature (the_session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
}
static void
do_timeout_req_test_for_session (SoupSession *session)
{
SoupRequester *requester;
SoupRequest *req;
SoupMessage *msg;
GInputStream *stream;
SoupSocket *sockets[4] = { NULL, NULL, NULL, NULL };
SoupURI *timeout_uri;
GError *error = NULL;
int i;
requester = soup_requester_new ();
soup_session_add_feature (session, SOUP_SESSION_FEATURE (requester));
g_object_unref (requester);
g_signal_connect (session, "request-started",
G_CALLBACK (request_started_socket_collector),
&sockets);
debug_printf (1, " First request\n");
timeout_uri = soup_uri_new_with_base (base_uri, "/timeout-persistent");
req = soup_requester_request_uri (requester, timeout_uri, NULL);
soup_uri_free (timeout_uri);
stream = soup_test_request_send (req, NULL, &error);
if (!stream) {
debug_printf (1, " Unexpected error on send: %s\n",
error->message);
errors++;
g_clear_error (&error);
} else {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " Unexpected error on close: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
g_object_unref (stream);
}
if (sockets[1]) {
debug_printf (1, " Message was retried??\n");
errors++;
sockets[1] = sockets[2] = sockets[3] = NULL;
}
g_object_unref (req);
debug_printf (1, " Second request\n");
req = soup_requester_request_uri (requester, base_uri, NULL);
stream = soup_test_request_send (req, NULL, &error);
if (!stream) {
debug_printf (1, " Unexpected error on send: %s\n",
error->message);
errors++;
g_clear_error (&error);
} else {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " Unexpected error on close: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
g_object_unref (stream);
}
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
if (msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
if (sockets[1] != sockets[0]) {
debug_printf (1, " Message was not retried on existing connection\n");
errors++;
} else if (!sockets[2]) {
debug_printf (1, " Message was not retried after disconnect\n");
errors++;
} else if (sockets[2] == sockets[1]) {
debug_printf (1, " Message was retried on closed connection??\n");
errors++;
} else if (sockets[3]) {
debug_printf (1, " Message was retried again??\n");
errors++;
}
g_object_unref (msg);
g_object_unref (req);
for (i = 0; sockets[i]; i++)
g_object_unref (sockets[i]);
}
/**
* soup_logger_detach:
* @logger: a #SoupLogger
* @session: a #SoupSession
*
* Stops @logger from watching @session.
*
* Deprecated: Use soup_session_remove_feature() instead.
**/
void
soup_logger_detach (SoupLogger *logger,
SoupSession *session)
{
soup_session_remove_feature (session, SOUP_SESSION_FEATURE (logger));
}
