void
setup(void) {
char *proxy;
char *new_proxy;
SoupURI *puri;
SoupSession *s;
/* clean up any zombies immediately */
sigchld(0);
gtk_init(NULL, NULL);
if (!g_thread_supported())
g_thread_init(NULL);
dpy = GDK_DISPLAY();
s = webkit_get_default_session();
/* atoms */
atoms[AtomFind] = XInternAtom(dpy, "_SURF_FIND", False);
atoms[AtomGo] = XInternAtom(dpy, "_SURF_GO", False);
atoms[AtomUri] = XInternAtom(dpy, "_SURF_URI", False);
/* dirs and files */
cookiefile = buildpath(cookiefile);
scriptfile = buildpath(scriptfile);
stylefile = buildpath(stylefile);
/* request handler */
s = webkit_get_default_session();
soup_session_remove_feature_by_type(s, soup_cookie_get_type());
soup_session_remove_feature_by_type(s, soup_cookie_jar_get_type());
g_signal_connect_after(G_OBJECT(s), "request-started", G_CALLBACK(newrequest), NULL);
/* proxy */
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);
}
XSetErrorHandler(&xerrorhandler);
}
static void
select_auth_test_one (SoupURI *uri,
gboolean disable_digest, const char *password,
const char *first_headers, const char *first_response,
const char *second_headers, const char *second_response,
guint final_status)
{
SelectAuthData sad;
SoupMessage *msg;
SoupSession *session;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
if (disable_digest)
soup_session_remove_feature_by_type (session, SOUP_TYPE_AUTH_DIGEST);
g_signal_connect (session, "authenticate",
G_CALLBACK (select_auth_authenticate), &sad);
memset (&sad, 0, sizeof (sad));
sad.password = password;
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
soup_test_assert (strcmp (sad.round[0].headers, first_headers) == 0,
"Header order wrong: expected %s, got %s",
first_headers, sad.round[0].headers);
soup_test_assert (strcmp (sad.round[0].response, first_response) == 0,
"Selected auth type wrong: expected %s, got %s",
first_response, sad.round[0].response);
soup_test_assert (sad.round[1].headers || !second_headers,
"Expected a second round");
soup_test_assert (!sad.round[1].headers || second_headers,
"Didn't expect a second round");
if (second_headers && second_response) {
soup_test_assert (strcmp (sad.round[1].headers, second_headers) == 0,
"Second round header order wrong: expected %s, got %s\n",
second_headers, sad.round[1].headers);
soup_test_assert (strcmp (sad.round[1].response, second_response) == 0,
"Second round selected auth type wrong: expected %s, got %s\n",
second_response, sad.round[1].response);
}
soup_test_assert_message_status (msg, final_status);
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
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
}
static void
katze_http_auth_session_request_queued_cb (SoupSession* session,
SoupMessage* msg,
KatzeHttpAuth* http_auth)
{
/* WebKit has its own authentication dialog in recent versions.
We want only one, and we choose our own to have localization. */
GType type = g_type_from_name ("WebKitSoupAuthDialog");
if (type)
soup_session_remove_feature_by_type (session, type);
g_signal_connect (session, "authenticate",
G_CALLBACK (katze_http_auth_session_authenticate_cb), http_auth);
g_signal_handlers_disconnect_by_func (session,
katze_http_auth_session_request_queued_cb, http_auth);
}
void
set_proxy_url() {
SoupURI *suri;
if(uzbl.net.proxy_url == NULL || *uzbl.net.proxy_url == ' ') {
soup_session_remove_feature_by_type(uzbl.net.soup_session,
(GType) SOUP_SESSION_PROXY_URI);
}
else {
suri = soup_uri_new(uzbl.net.proxy_url);
g_object_set(G_OBJECT(uzbl.net.soup_session),
SOUP_SESSION_PROXY_URI,
suri, NULL);
soup_uri_free(suri);
}
return;
}
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;
}
/**
* 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;
}
void
gs_plugin_initialize (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_alloc_data (plugin, sizeof(GsPluginData));
g_autofree gchar *user_agent = NULL;
g_autoptr(SoupSession) soup_session = NULL;
priv->client = fwupd_client_new ();
/* use a custom user agent to provide the fwupd version */
user_agent = fwupd_build_user_agent (PACKAGE_NAME, PACKAGE_VERSION);
soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, user_agent,
SOUP_SESSION_TIMEOUT, 10,
NULL);
soup_session_remove_feature_by_type (soup_session,
SOUP_TYPE_CONTENT_DECODER);
gs_plugin_set_soup_session (plugin, soup_session);
/* set name of MetaInfo file */
gs_plugin_set_appstream_id (plugin, "org.gnome.Software.Plugin.Fwupd");
}
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;
}
}
/**
* fu_util_download_file:
**/
static gboolean
fu_util_download_file (FuUtilPrivate *priv,
const gchar *uri,
const gchar *fn,
const gchar *checksum_expected,
GError **error)
{
guint status_code;
_cleanup_error_free_ GError *error_local = NULL;
_cleanup_free_ gchar *checksum_actual = NULL;
_cleanup_object_unref_ SoupMessage *msg = NULL;
_cleanup_object_unref_ SoupSession *session = NULL;
session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT,
"fwupdmgr",
NULL);
if (session == NULL) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"%s: failed to setup networking");
return FALSE;
}
/* this disables the double-compression of the firmware.xml.gz file */
soup_session_remove_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
/* download data */
g_debug ("downloading %s to %s:", uri, fn);
msg = soup_message_new (SOUP_METHOD_GET, uri);
status_code = soup_session_send_message (session, msg);
if (status_code != SOUP_STATUS_OK) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Failed to download %s: %s",
uri, soup_status_get_phrase (status_code));
return FALSE;
}
/* verify checksum */
if (checksum_expected != NULL) {
checksum_actual = g_compute_checksum_for_data (G_CHECKSUM_SHA1,
(guchar *) msg->response_body->data,
msg->response_body->length);
if (g_strcmp0 (checksum_expected, checksum_actual) != 0) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Checksum invalid, expected %s got %s",
checksum_expected, checksum_actual);
return FALSE;
}
}
/* save file */
if (!g_file_set_contents (fn,
msg->response_body->data,
msg->response_body->length,
&error_local)) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_WRITE,
"Failed to save file: %s",
error_local->message);
return FALSE;
}
return TRUE;
}
