static gchar* _make_base_string(
GSignondSessionData *session_data,
SoupURI* uri, gchar* nonce, gchar* timestamp)
{
GString* base_string = g_string_new("POST&");
gchar* base_uri;
if (soup_uri_uses_default_port(uri))
base_uri = g_strdup_printf("https://%s%s", soup_uri_get_host(uri),
soup_uri_get_path(uri));
else
base_uri = g_strdup_printf("https://%s:%u%s", soup_uri_get_host(uri),
soup_uri_get_port(uri),
soup_uri_get_path(uri));
gchar* base_uri_e = _percent_encode(base_uri);
g_string_append(base_string, base_uri_e);
g_string_append(base_string, "&");
g_free(base_uri);
g_free(base_uri_e);
GTree* parameters = g_tree_new((GCompareFunc)g_strcmp0);
const gchar* query_s = soup_uri_get_query(uri);
GHashTable* query;
if (query_s != NULL)
query = soup_form_decode(query_s);
else
query = soup_form_decode("");
g_hash_table_foreach(query, _insert_into_tree, parameters);
const gchar* callback_uri = gsignond_dictionary_get_string(session_data, "Callback");
if (callback_uri != NULL)
g_tree_insert(parameters, "oauth_callback", (gchar*)callback_uri);
const gchar* oauth_verifier = gsignond_dictionary_get_string(session_data, "_OauthVerifier");
if (oauth_verifier != NULL)
g_tree_insert(parameters, "oauth_verifier", (gchar*)oauth_verifier);
g_tree_insert(parameters, "oauth_consumer_key", (gchar*)gsignond_dictionary_get_string(session_data, "ConsumerKey"));
const gchar* oauth_temp_token = gsignond_dictionary_get_string(session_data, "_OauthTemporaryToken");
if (oauth_temp_token != NULL)
g_tree_insert(parameters, "oauth_token", (gchar*)oauth_temp_token);
g_tree_insert(parameters, "oauth_signature_method", (gchar*)gsignond_dictionary_get_string(session_data, "SignatureMethod"));
g_tree_insert(parameters, "oauth_nonce", nonce);
g_tree_insert(parameters, "oauth_timestamp", timestamp);
g_tree_insert(parameters, "oauth_version", "1.0");
GString* parameters_string = g_string_new(NULL);
g_tree_foreach(parameters, _make_parameters_string, parameters_string);
gchar* parameters_s = g_string_free(parameters_string, FALSE);
parameters_s[strlen(parameters_s)-1] = '\0'; //remove trailing '&'
gchar* parameters_encoded = _percent_encode(parameters_s);
g_string_append(base_string, parameters_encoded);
g_free(parameters_encoded);
g_free(parameters_s);
g_tree_destroy(parameters);
g_hash_table_destroy(query);
return g_string_free(base_string, FALSE);
}
char *
ephy_sync_utils_make_audience (const char *url)
{
SoupURI *uri;
const char *scheme;
const char *host;
char *audience;
char *port;
g_return_val_if_fail (url != NULL, NULL);
uri = soup_uri_new (url);
scheme = soup_uri_get_scheme (uri);
host = soup_uri_get_host (uri);
port = g_strdup_printf (":%u", soup_uri_get_port (uri));
/* Even if the url doesn't contain the port, soup_uri_get_port() will return
* the default port for the url's scheme so we need to check if the port was
* really present in the url.
*/
if (g_strstr_len (url, -1, port) != NULL)
audience = g_strdup_printf ("%s://%s%s", scheme, host, port);
else
audience = g_strdup_printf ("%s://%s", scheme, host);
g_free (port);
soup_uri_free (uri);
return audience;
}
static guint
get_port_from_server (SoupServer * server)
{
GSList *uris;
guint port;
uris = soup_server_get_uris (server);
g_assert (g_slist_length (uris) == 1);
port = soup_uri_get_port (uris->data);
g_slist_free_full (uris, (GDestroyNotify) soup_uri_free);
return port;
}
static char *
get_server_uri (SoupServer *server,
const char *filename)
{
GSList *uris;
SoupURI *uri;
char *ret;
uris = soup_server_get_uris (server);
g_assert (uris);
uri = uris->data;
ret = g_strdup_printf ("%s://%s:%d/%s",
soup_uri_get_scheme (uri),
soup_uri_get_host (uri),
soup_uri_get_port (uri),
filename);
g_slist_free_full (uris, (GDestroyNotify) soup_uri_free);
return ret;
}
static ProtectionSpace protectionSpaceFromSoupAuthAndMessage(SoupAuth* soupAuth, SoupMessage* message)
{
const char* schemeName = soup_auth_get_scheme_name(soupAuth);
ProtectionSpaceAuthenticationScheme scheme;
if (!g_ascii_strcasecmp(schemeName, "basic"))
scheme = ProtectionSpaceAuthenticationSchemeHTTPBasic;
else if (!g_ascii_strcasecmp(schemeName, "digest"))
scheme = ProtectionSpaceAuthenticationSchemeHTTPDigest;
else if (!g_ascii_strcasecmp(schemeName, "ntlm"))
scheme = ProtectionSpaceAuthenticationSchemeNTLM;
else if (!g_ascii_strcasecmp(schemeName, "negotiate"))
scheme = ProtectionSpaceAuthenticationSchemeNegotiate;
else
scheme = ProtectionSpaceAuthenticationSchemeUnknown;
SoupURI* soupURI = soup_message_get_uri(message);
return ProtectionSpace(String::fromUTF8(soup_uri_get_host(soupURI)), soup_uri_get_port(soupURI),
protectionSpaceServerTypeFromURI(soupURI, soup_auth_is_for_proxy(soupAuth)),
String::fromUTF8(soup_auth_get_realm(soupAuth)), scheme);
}
/**
* e_webdav_discover_content_refresh:
* @content: a WebDAV discovery content, created by e_webdav_discover_content_new()
* @display_name: (allow-none): optional display name to use for scratch sources
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @callback: (scope async): a #GAsyncReadyCallback to call when the request
* is satisfied
* @user_data: (closure): data to pass to the callback function
*
* Asynchronously starts refresh of the @content. This means to access the server
* and search it for available sources. The @content shows a feedback and a Cancel
* button during the operation.
*
* The @display_name is used only if the @content wasn't created with an #ESource and
* it's shown in the password prompts, if there are required any.
*
* When the operation is finished, @callback will be called. You can then
* call e_webdav_discover_content_refresh_finish() to get the result of the operation.
*
* Since: 3.18
**/
void
e_webdav_discover_content_refresh (GtkWidget *content,
const gchar *display_name,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
EWebDAVDiscoverContentData *data;
RefreshData *rd;
ESource *source;
SoupURI *soup_uri;
GtkWidget *label;
g_return_if_fail (GTK_IS_GRID (content));
data = g_object_get_data (G_OBJECT (content), WEBDAV_DISCOVER_CONTENT_DATA_KEY);
g_return_if_fail (data != NULL);
g_return_if_fail (data->base_url != NULL);
soup_uri = soup_uri_new (data->base_url);
if (!soup_uri) {
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid URL"));
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
if (!soup_uri_get_user (soup_uri)) {
GSimpleAsyncResult *simple;
soup_uri_free (soup_uri);
simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("User name not filled"));
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
rd = g_new0 (RefreshData, 1);
rd->content = g_object_ref (content);
rd->cancellable = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
rd->simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
rd->base_url = g_strdup (data->base_url);
rd->credentials = NULL;
if (data->source) {
source = g_object_ref (data->source);
} else {
ESourceWebdav *webdav_extension;
ESourceAuthentication *auth_extension;
source = e_source_new_with_uid (data->base_url, NULL, NULL);
g_return_if_fail (source != NULL);
webdav_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND);
auth_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION);
if (display_name && *display_name)
e_source_set_display_name (source, display_name);
e_source_webdav_set_soup_uri (webdav_extension, soup_uri);
e_source_authentication_set_host (auth_extension, soup_uri_get_host (soup_uri));
e_source_authentication_set_port (auth_extension, soup_uri_get_port (soup_uri));
e_source_authentication_set_user (auth_extension, soup_uri_get_user (soup_uri));
}
gtk_list_store_clear (GTK_LIST_STORE (gtk_tree_view_get_model (data->sources_tree_view)));
if (data->email_addresses_combo)
gtk_combo_box_text_remove_all (GTK_COMBO_BOX_TEXT (data->email_addresses_combo));
if (data->info_bar)
gtk_widget_destroy (GTK_WIDGET (data->info_bar));
data->info_bar = GTK_INFO_BAR (gtk_info_bar_new_with_buttons (_("Cancel"), GTK_RESPONSE_CANCEL, NULL));
gtk_info_bar_set_message_type (data->info_bar, GTK_MESSAGE_INFO);
gtk_info_bar_set_show_close_button (data->info_bar, FALSE);
label = gtk_label_new (_("Searching server sources..."));
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (data->info_bar)), label);
gtk_widget_show (label);
gtk_widget_show (GTK_WIDGET (data->info_bar));
g_signal_connect (data->info_bar, "response", G_CALLBACK (e_webdav_discover_info_bar_response_cb), rd);
gtk_widget_set_sensitive (GTK_WIDGET (data->sources_tree_view), FALSE);
if (data->email_addresses_combo)
gtk_widget_set_sensitive (GTK_WIDGET (data->email_addresses_combo), FALSE);
gtk_grid_attach (GTK_GRID (content), GTK_WIDGET (data->info_bar), 0, 2, 1, 1);
e_webdav_discover_sources (source, rd->base_url, E_WEBDAV_DISCOVER_SUPPORTS_NONE, rd->credentials, rd->cancellable,
e_webdav_discover_content_refresh_done_cb, rd);
g_object_unref (source);
soup_uri_free (soup_uri);
}
static void
do_soup_uri_null_tests (void)
{
SoupURI *uri, *uri2;
char *uri_string;
debug_printf (1, "\nsoup_uri_new (NULL)\n");
uri = soup_uri_new (NULL);
if (SOUP_URI_IS_VALID (uri) || SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: soup_uri_new(NULL) returns valid URI?\n");
errors++;
}
/* This implicitly also verifies that none of these methods g_warn */
if (soup_uri_get_scheme (uri) ||
soup_uri_get_user (uri) ||
soup_uri_get_password (uri) ||
soup_uri_get_host (uri) ||
soup_uri_get_port (uri) ||
soup_uri_get_path (uri) ||
soup_uri_get_query (uri) ||
soup_uri_get_fragment (uri)) {
debug_printf (1, " ERROR: soup_uri_new(NULL) returns non-empty URI?\n");
errors++;
}
expect_warning = TRUE;
uri2 = soup_uri_new_with_base (uri, "/path");
if (uri2 || expect_warning) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't fail on NULL URI?\n");
errors++;
expect_warning = FALSE;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on NULL URI?\n");
errors++;
expect_warning = FALSE;
} else if (*uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string on NULL URI returned '%s'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
if (SOUP_URI_IS_VALID (uri) || SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme on NULL URI makes it valid?\n");
errors++;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on scheme-only URI?\n");
errors++;
expect_warning = FALSE;
} else if (strcmp (uri_string, "http:") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string returned '%s' instead of 'http:'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_set_host (uri, "localhost");
if (SOUP_URI_IS_VALID (uri)) {
debug_printf (1, " ERROR: setting scheme+host on NULL URI makes it valid?\n");
errors++;
}
if (SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme+host on NULL URI makes it valid for http?\n");
errors++;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on scheme+host URI?\n");
errors++;
expect_warning = FALSE;
} else if (strcmp (uri_string, "http://localhost/") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string with NULL path returned '%s' instead of 'http://localhost/'\n",
uri_string);
errors++;
}
g_free (uri_string);
expect_warning = TRUE;
uri2 = soup_uri_new_with_base (uri, "/path");
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't warn on NULL+scheme URI?\n");
errors++;
expect_warning = FALSE;
} else if (!uri2) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't fix path on NULL+scheme URI\n");
errors++;
}
if (uri2) {
uri_string = soup_uri_to_string (uri2, FALSE);
if (!uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string failed on uri2?\n");
errors++;
} else if (strcmp (uri_string, "http://localhost/path") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string returned '%s' instead of 'http://localhost/path'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_free (uri2);
}
expect_warning = TRUE;
soup_uri_set_path (uri, NULL);
if (expect_warning) {
debug_printf (1, " ERROR: setting path to NULL doesn't warn\n");
errors++;
expect_warning = FALSE;
}
if (!uri->path || *uri->path) {
debug_printf (1, " ERROR: setting path to NULL != \"\"\n");
errors++;
soup_uri_set_path (uri, "");
}
uri_string = soup_uri_to_string (uri, FALSE);
if (!uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string failed on complete URI?\n");
errors++;
} else if (strcmp (uri_string, "http://localhost/") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string with empty path returned '%s' instead of 'http://localhost/'\n",
uri_string);
errors++;
}
g_free (uri_string);
if (!SOUP_URI_IS_VALID (uri)) {
debug_printf (1, " ERROR: setting scheme+path on NULL URI doesn't make it valid?\n");
errors++;
}
if (!SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme+host+path on NULL URI doesn't make it valid for http?\n");
errors++;
}
soup_uri_free (uri);
}
