static void
seahorse_hkp_operation_init (SeahorseHKPOperation *hop)
{
SoupURI *uri;
gchar *host;
#if DEBUG_HKP_ENABLE
SoupLogger *logger;
#endif
if (seahorse_gconf_get_boolean (GCONF_USE_HTTP_PROXY)) {
host = seahorse_gconf_get_string (GCONF_HTTP_PROXY_HOST);
if (host) {
uri = soup_uri_new (NULL);
if (!uri) {
g_warning ("creation of SoupURI from '%s' failed", host);
} else {
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (uri, host);
g_free (host);
soup_uri_set_port (uri, seahorse_gconf_get_integer (GCONF_PROXY_PORT));
if (seahorse_gconf_get_boolean (GCONF_USE_AUTH)) {
char *user, *pass;
user = seahorse_gconf_get_string (GCONF_AUTH_USER);
soup_uri_set_user (uri, user);
g_free (user);
pass = seahorse_gconf_get_string (GCONF_AUTH_PASS);
soup_uri_set_password (uri, pass);
g_free (pass);
}
hop->session = soup_session_async_new_with_options (SOUP_SESSION_PROXY_URI, uri, NULL);
soup_uri_free (uri);
}
}
}
/* Without a proxy */
if (!hop->session)
hop->session = soup_session_async_new ();
#if DEBUG_HKP_ENABLE
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_logger_attach (logger, hop->session);
g_object_unref (logger);
#endif
}
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;
}
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));
}
