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);
}
static void
t5_http_req_callback (SoupSession *session, SoupMessage *msg, gpointer data)
{
guint status_code;
gchar *method;
SoupURI *uri;
const gchar *header;
g_object_get (G_OBJECT (msg), "method", &method, "status-code",
&status_code, "uri", &uri, NULL);
GST_WARNING ("%s %s status code: %d, expected %d", method, soup_uri_get_path (uri),
status_code, SOUP_STATUS_CANCELLED);
BOOST_CHECK (status_code == SOUP_STATUS_CANCELLED);
/* TODO: Check why soup_cookies_from_response does not work */
header = soup_message_headers_get_list (msg->response_headers, "Set-Cookie");
BOOST_CHECK (header != NULL);
cookie = soup_cookie_parse (header, NULL);
BOOST_CHECK (cookie != NULL);
t5_send_get_request_2();
soup_uri_free (uri);
g_free (method);
}
static void
t4_http_req_callback (SoupSession *session, SoupMessage *msg, gpointer data)
{
SoupKnownStatusCode *expected = (SoupKnownStatusCode *) data;
guint status_code;
gchar *method;
SoupURI *uri;
const gchar *cookie_str;
g_object_get (G_OBJECT (msg), "method", &method, "status-code",
&status_code, "uri", &uri, NULL);
GST_DEBUG ("%s %s status code: %d, expected %d", method, soup_uri_get_path (uri),
status_code, *expected);
BOOST_CHECK (status_code == *expected);
/* TODO: Check why soup_cookies_from_response does not work */
cookie_str = soup_message_headers_get_list (msg->response_headers, "Set-Cookie");
BOOST_CHECK (cookie_str != NULL);
if (++counted == urls_registered)
g_main_loop_quit (loop);
soup_uri_free (uri);
g_free (method);
}
static GBytes *
download_file (SoupURI *uri)
{
g_autoptr(GBytes) contents = NULL;
if (soup_uri_get_scheme (uri) == SOUP_URI_SCHEME_FILE)
{
g_autoptr(GFile) file = g_file_new_for_path (soup_uri_get_path (uri));
eos_updater_read_file_to_bytes (file, NULL, &contents, NULL);
}
else
{
g_autoptr(SoupSession) soup = soup_session_new ();
g_autoptr(SoupMessage) msg = soup_message_new_from_uri ("GET", uri);
guint status = soup_session_send_message (soup, msg);
if (SOUP_STATUS_IS_SUCCESSFUL (status))
g_object_get (msg,
SOUP_MESSAGE_RESPONSE_BODY_DATA, &contents,
NULL);
}
return g_steal_pointer (&contents);
}
static SoupURI *
suburi_new (SoupURI *base,
const char *first,
...)
{
va_list args;
GPtrArray *arg_array;
const char *arg;
char *subpath;
SoupURI *ret;
arg_array = g_ptr_array_new ();
g_ptr_array_add (arg_array, (char*)soup_uri_get_path (base));
g_ptr_array_add (arg_array, (char*)first);
va_start (args, first);
while ((arg = va_arg (args, const char *)) != NULL)
g_ptr_array_add (arg_array, (char*)arg);
g_ptr_array_add (arg_array, NULL);
subpath = g_build_filenamev ((char**)arg_array->pdata);
g_ptr_array_unref (arg_array);
ret = soup_uri_copy (base);
soup_uri_set_path (ret, subpath);
g_free (subpath);
va_end (args);
return ret;
}
ScLocalStorageManager* sc_local_storage_manager_new(const gchar *url) {
ScLocalStorageManager *manager = g_new0(ScLocalStorageManager, 1);
SoupURI *uri = soup_uri_new(url);
GString *filename = g_string_new(NULL);
const gchar *host = soup_uri_get_host(uri);
const gchar *path = soup_uri_get_path(uri);
const gchar *query = soup_uri_get_query(uri);
const gchar *fragment = soup_uri_get_fragment(uri);
GFile *parent = NULL;
GError *error = NULL;
g_string_append_printf(filename, "%s/%s", host, path);
if(url[strlen(url) - 1] == '/' || g_strcmp0("/", path) == 0)
g_string_append(filename, "/index.html");
if(query) g_string_append_printf(filename, "/%s\n", query);
if(fragment) g_string_append_printf(filename, "#%s\n", fragment);
manager->file = g_file_new_for_commandline_arg(filename->str);
g_string_free(filename, TRUE);
if(g_file_query_exists(manager->file, NULL)) {
g_file_delete(manager->file, NULL, &error);
if(error && !g_error_matches(error, G_IO_ERROR,G_IO_ERROR_EXISTS)) {
g_critical(G_STRLOC ": %d : %s", error->code, error->message);
g_error_free(error);
g_object_unref(parent);
g_object_unref(manager->file);
g_free(manager);
return NULL;
}
}
parent = g_file_get_parent(manager->file);
g_file_make_directory_with_parents(parent, NULL, &error);
if(error && !g_error_matches(error, G_IO_ERROR,G_IO_ERROR_EXISTS)) {
g_critical(G_STRLOC ": %d : %s", error->code, error->message);
g_error_free(error);
g_object_unref(parent);
g_object_unref(manager->file);
g_free(manager);
return NULL;
}
error = NULL;
manager->ostream = g_file_create(manager->file, G_FILE_CREATE_NONE, NULL, &error);
if(error) {
g_critical(G_STRLOC ": %d : %s", error->code, error->message);
g_error_free(error);
g_object_unref(parent);
g_object_unref(manager->file);
g_free(manager);
return NULL;
}
return manager;
}
static SoupURI *
get_uri_to_sig (SoupURI *uri)
{
g_autofree gchar *sig_path = NULL;
SoupURI *sig_uri = soup_uri_copy (uri);
sig_path = g_strconcat (soup_uri_get_path (uri), ".sig", NULL);
soup_uri_set_path (sig_uri, sig_path);
return sig_uri;
}
static SnraClientFlags
get_flag_from_msg (SoupMessage *msg)
{
SnraClientFlags flag;
SoupURI *uri = soup_message_get_uri (msg);
if (g_str_equal (soup_uri_get_path (uri), "/client/control_events"))
flag = SNRA_CLIENT_CONTROLLER;
else
flag = SNRA_CLIENT_PLAYER;
return flag;
}
static void
postal_http_request_finished (SoupServer *server,
SoupMessage *message,
SoupClientContext *client,
gpointer user_data)
{
const gchar *path;
PostalHttp *http = user_data;
SoupURI *uri;
g_assert(POSTAL_IS_HTTP(http));
if (message && (uri = soup_message_get_uri(message))) {
path = soup_uri_get_path(uri);
postal_http_log_message(http, message, path, client);
}
}
static void
icon_loaded_cb (WebKitFaviconDatabase *database,
const char *address,
GtkTreeModel *model)
{
GtkTreeIter iter;
GdkPixbuf *favicon;
int cmp;
char *host_address;
gboolean done, valid;
SoupURI *uri;
valid = gtk_tree_model_get_iter_first (model, &iter);
/* If the address has a path, this icon is not for a host, so it can
be skipped. */
uri = soup_uri_new (address);
done = strcmp (soup_uri_get_path (uri), "/") != 0;
soup_uri_free (uri);
while (valid && !done) {
gtk_tree_model_get (model, &iter,
EPHY_HOSTS_STORE_COLUMN_ADDRESS, &host_address, -1);
cmp = g_strcmp0 (host_address, address);
g_free (host_address);
if (cmp == 0) {
favicon = webkit_favicon_database_try_get_favicon_pixbuf (database,
address,
FAVICON_SIZE,
FAVICON_SIZE);
if (favicon) {
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
EPHY_HOSTS_STORE_COLUMN_FAVICON, favicon,
-1);
g_object_unref (favicon);
}
}
valid = gtk_tree_model_iter_next (model, &iter);
/* Since the list is sorted alphanumerically, if the result of the
comparison is > 0, there is no point in searching any
further. */
done = cmp >= 0;
}
}
static GFile *
get_download_location (BuilderSourceFile *self,
gboolean *is_inline,
BuilderContext *context,
GError **error)
{
g_autoptr(SoupURI) uri = NULL;
const char *path;
g_autofree char *base_name = NULL;
GFile *download_dir = NULL;
g_autoptr(GFile) sha256_dir = NULL;
g_autoptr(GFile) file = NULL;
uri = get_uri (self, error);
if (uri == NULL)
return FALSE;
path = soup_uri_get_path (uri);
if (g_str_has_prefix (self->url, "data:"))
{
*is_inline = TRUE;
return g_file_new_for_path ("inline data");
}
base_name = g_path_get_basename (path);
if (self->sha256 == NULL || *self->sha256 == 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Sha256 not specified");
return FALSE;
}
download_dir = builder_context_get_download_dir (context);
sha256_dir = g_file_get_child (download_dir, self->sha256);
file = g_file_get_child (sha256_dir, base_name);
*is_inline = FALSE;
return g_steal_pointer (&file);
}
static void
http_req_callback (SoupSession *session, SoupMessage *msg, gpointer data)
{
SoupKnownStatusCode *expected = (SoupKnownStatusCode *) data;
guint status_code;
gchar *method;
SoupURI *uri;
g_object_get (G_OBJECT (msg), "method", &method, "status-code",
&status_code, "uri", &uri, NULL);
GST_DEBUG ("%s %s status code: %d, expected %d", method, soup_uri_get_path (uri),
status_code, *expected);
BOOST_CHECK_EQUAL (*expected, status_code);
if (*expected == expected_404 && ++counted == urls_registered)
g_main_loop_quit (loop);
soup_uri_free (uri);
g_free (method);
}
GFile *
fetch_archive (const gchar *url,
const gchar *sha,
const gchar *module_name,
GFile *destination,
guint strip_components,
GError **error)
{
g_autoptr(GFile) archive_file = NULL;
g_autoptr(GFile) source_dir = NULL;
g_autoptr(SoupURI) uri = NULL;
g_autofree char *archive_name = NULL;
GError *local_error = NULL;
source_dir = g_file_get_child (destination, module_name);
if (!g_file_make_directory_with_parents (source_dir, NULL, &local_error))
{
if (!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_EXISTS))
{
g_propagate_error (error, local_error);
return NULL;
}
g_error_free (local_error);
}
uri = soup_uri_new (url);
archive_name = g_path_get_basename (soup_uri_get_path (uri));
archive_file = g_file_get_child (source_dir, archive_name);
if (!download_archive (uri, sha, archive_file, error))
return NULL;
if (!extract_archive (source_dir, archive_file, strip_components, error))
return NULL;
return g_steal_pointer (&source_dir);
}
static void
t5_request_with_expired_cookie (SoupSession *session, SoupMessage *msg,
gpointer user_data)
{
guint status_code;
SoupURI *uri;
gchar *method;
GST_DEBUG ("Response received");
g_object_get (G_OBJECT (msg), "method", &method, "status-code",
&status_code, "uri", &uri, NULL);
GST_WARNING ("%s %s status code: %d, expected %d", method, soup_uri_get_path (uri),
status_code, SOUP_STATUS_BAD_REQUEST);
BOOST_CHECK (status_code == SOUP_STATUS_BAD_REQUEST);
g_free (method);
soup_uri_free (uri);
g_main_loop_quit (loop);
}
static void
t5_request_with_cookie_cb (SoupSession *session, SoupMessage *msg,
gpointer user_data)
{
guint status_code;
gchar *method;
SoupURI *uri;
GST_DEBUG ("Request with cookie");
g_object_get (G_OBJECT (msg), "method", &method, "status-code",
&status_code, "uri", &uri, NULL);
GST_WARNING ("%s %s status code: %d, expected %d", method,
soup_uri_get_path (uri), status_code, SOUP_STATUS_CANCELLED);
BOOST_CHECK (status_code == SOUP_STATUS_CANCELLED);
t5_make_request_without_cookie();
g_free (method);
soup_uri_free (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);
}
gboolean
ostree_repo_pull (OstreeRepo *self,
const char *remote_name,
char **refs_to_fetch,
OstreeRepoPullFlags flags,
OstreeAsyncProgress *progress,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
GHashTableIter hash_iter;
gpointer key, value;
gboolean tls_permissive = FALSE;
OstreeFetcherConfigFlags fetcher_flags = 0;
gs_free char *remote_key = NULL;
gs_free char *path = NULL;
gs_free char *baseurl = NULL;
gs_free char *summary_data = NULL;
gs_unref_hashtable GHashTable *requested_refs_to_fetch = NULL;
gs_unref_hashtable GHashTable *updated_refs = NULL;
gs_unref_hashtable GHashTable *commits_to_fetch = NULL;
gs_free char *remote_mode_str = NULL;
GSource *queue_src = NULL;
OtPullData pull_data_real = { 0, };
OtPullData *pull_data = &pull_data_real;
SoupURI *summary_uri = NULL;
GKeyFile *config = NULL;
GKeyFile *remote_config = NULL;
char **configured_branches = NULL;
guint64 bytes_transferred;
guint64 start_time;
guint64 end_time;
pull_data->async_error = error;
pull_data->main_context = g_main_context_ref_thread_default ();
pull_data->loop = g_main_loop_new (pull_data->main_context, FALSE);
pull_data->flags = flags;
pull_data->repo = self;
pull_data->progress = progress;
pull_data->scanned_metadata = g_hash_table_new_full (ostree_hash_object_name, g_variant_equal,
(GDestroyNotify)g_variant_unref, NULL);
pull_data->requested_content = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify)g_free, NULL);
pull_data->requested_metadata = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify)g_free, NULL);
start_time = g_get_monotonic_time ();
pull_data->remote_name = g_strdup (remote_name);
config = ostree_repo_get_config (self);
remote_key = g_strdup_printf ("remote \"%s\"", pull_data->remote_name);
if (!repo_get_string_key_inherit (self, remote_key, "url", &baseurl, error))
goto out;
pull_data->base_uri = soup_uri_new (baseurl);
#ifdef HAVE_GPGME
if (!ot_keyfile_get_boolean_with_default (config, remote_key, "gpg-verify",
TRUE, &pull_data->gpg_verify, error))
goto out;
#else
pull_data->gpg_verify = FALSE;
#endif
if (!ot_keyfile_get_boolean_with_default (config, remote_key, "tls-permissive",
FALSE, &tls_permissive, error))
goto out;
if (tls_permissive)
fetcher_flags |= OSTREE_FETCHER_FLAGS_TLS_PERMISSIVE;
pull_data->fetcher = ostree_fetcher_new (pull_data->repo->tmp_dir,
fetcher_flags);
if (!pull_data->base_uri)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to parse url '%s'", baseurl);
goto out;
}
if (!load_remote_repo_config (pull_data, &remote_config, cancellable, error))
goto out;
if (!ot_keyfile_get_value_with_default (remote_config, "core", "mode", "bare",
&remote_mode_str, error))
goto out;
if (!ostree_repo_mode_from_string (remote_mode_str, &pull_data->remote_mode, error))
goto out;
if (pull_data->remote_mode != OSTREE_REPO_MODE_ARCHIVE_Z2)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Can't pull from archives with mode \"%s\"",
remote_mode_str);
goto out;
}
requested_refs_to_fetch = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
updated_refs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
commits_to_fetch = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
if (refs_to_fetch != NULL)
{
char **strviter;
for (strviter = refs_to_fetch; *strviter; strviter++)
{
const char *branch = *strviter;
char *contents;
if (ostree_validate_checksum_string (branch, NULL))
{
char *key = g_strdup (branch);
g_hash_table_insert (commits_to_fetch, key, key);
}
else
{
if (!fetch_ref_contents (pull_data, branch, &contents, cancellable, error))
goto out;
/* Transfer ownership of contents */
g_hash_table_insert (requested_refs_to_fetch, g_strdup (branch), contents);
}
}
}
else
{
GError *temp_error = NULL;
gboolean fetch_all_refs;
configured_branches = g_key_file_get_string_list (config, remote_key, "branches", NULL, &temp_error);
if (configured_branches == NULL && temp_error != NULL)
{
if (g_error_matches (temp_error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND))
{
g_clear_error (&temp_error);
fetch_all_refs = TRUE;
}
else
{
g_propagate_error (error, temp_error);
goto out;
}
}
else
fetch_all_refs = FALSE;
if (fetch_all_refs)
{
summary_uri = soup_uri_copy (pull_data->base_uri);
path = g_build_filename (soup_uri_get_path (summary_uri), "refs", "summary", NULL);
soup_uri_set_path (summary_uri, path);
if (!fetch_uri_contents_utf8_sync (pull_data, summary_uri, &summary_data, cancellable, error))
goto out;
if (!parse_ref_summary (summary_data, &requested_refs_to_fetch, error))
goto out;
}
else
{
char **branches_iter = configured_branches;
if (!(branches_iter && *branches_iter))
g_print ("No configured branches for remote %s\n", pull_data->remote_name);
for (;branches_iter && *branches_iter; branches_iter++)
{
const char *branch = *branches_iter;
char *contents;
if (!fetch_ref_contents (pull_data, branch, &contents, cancellable, error))
goto out;
/* Transfer ownership of contents */
g_hash_table_insert (requested_refs_to_fetch, g_strdup (branch), contents);
}
}
}
if (!ostree_repo_prepare_transaction (pull_data->repo, &pull_data->transaction_resuming,
cancellable, error))
goto out;
pull_data->metadata_objects_to_fetch = ot_waitable_queue_new ();
pull_data->metadata_objects_to_scan = ot_waitable_queue_new ();
pull_data->metadata_thread = g_thread_new ("metadatascan", metadata_thread_main, pull_data);
g_hash_table_iter_init (&hash_iter, commits_to_fetch);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
const char *commit = value;
ot_waitable_queue_push (pull_data->metadata_objects_to_scan,
pull_worker_message_new (PULL_MSG_SCAN,
ostree_object_name_serialize (commit, OSTREE_OBJECT_TYPE_COMMIT)));
}
g_hash_table_iter_init (&hash_iter, requested_refs_to_fetch);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
const char *ref = key;
const char *sha256 = value;
ot_waitable_queue_push (pull_data->metadata_objects_to_scan,
pull_worker_message_new (PULL_MSG_SCAN,
ostree_object_name_serialize (sha256, OSTREE_OBJECT_TYPE_COMMIT)));
g_hash_table_insert (updated_refs, g_strdup (ref), g_strdup (sha256));
}
{
queue_src = ot_waitable_queue_create_source (pull_data->metadata_objects_to_fetch);
g_source_set_callback (queue_src, (GSourceFunc)on_metadata_objects_to_fetch_ready, pull_data, NULL);
g_source_attach (queue_src, pull_data->main_context);
g_source_unref (queue_src);
}
/* Prime the message queue */
pull_data->idle_serial++;
ot_waitable_queue_push (pull_data->metadata_objects_to_scan,
pull_worker_message_new (PULL_MSG_MAIN_IDLE, GUINT_TO_POINTER (pull_data->idle_serial)));
/* Now await work completion */
if (!run_mainloop_monitor_fetcher (pull_data))
goto out;
g_hash_table_iter_init (&hash_iter, updated_refs);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
const char *ref = key;
const char *checksum = value;
gs_free char *remote_ref = NULL;
gs_free char *original_rev = NULL;
remote_ref = g_strdup_printf ("%s/%s", pull_data->remote_name, ref);
if (!ostree_repo_resolve_rev (pull_data->repo, remote_ref, TRUE, &original_rev, error))
goto out;
if (original_rev && strcmp (checksum, original_rev) == 0)
{
g_print ("remote %s is unchanged from %s\n", remote_ref, original_rev);
}
else
{
ostree_repo_transaction_set_ref (pull_data->repo, pull_data->remote_name, ref, checksum);
g_print ("remote %s is now %s\n", remote_ref, checksum);
}
}
if (!ostree_repo_commit_transaction (pull_data->repo, NULL, cancellable, error))
goto out;
end_time = g_get_monotonic_time ();
bytes_transferred = ostree_fetcher_bytes_transferred (pull_data->fetcher);
if (bytes_transferred > 0)
{
guint shift;
if (bytes_transferred < 1024)
shift = 1;
else
shift = 1024;
g_print ("%u metadata, %u content objects fetched; %" G_GUINT64_FORMAT " %s transferred in %u seconds\n",
pull_data->n_fetched_metadata, pull_data->n_fetched_content,
(guint64)(bytes_transferred / shift),
shift == 1 ? "B" : "KiB",
(guint) ((end_time - start_time) / G_USEC_PER_SEC));
}
ret = TRUE;
out:
if (pull_data->main_context)
g_main_context_unref (pull_data->main_context);
if (pull_data->loop)
g_main_loop_unref (pull_data->loop);
g_strfreev (configured_branches);
g_clear_object (&pull_data->fetcher);
g_free (pull_data->remote_name);
if (pull_data->base_uri)
soup_uri_free (pull_data->base_uri);
if (queue_src)
g_source_destroy (queue_src);
if (pull_data->metadata_thread)
{
ot_waitable_queue_push (pull_data->metadata_objects_to_scan,
pull_worker_message_new (PULL_MSG_QUIT, NULL));
g_thread_join (pull_data->metadata_thread);
}
g_clear_pointer (&pull_data->metadata_objects_to_scan, (GDestroyNotify) ot_waitable_queue_unref);
g_clear_pointer (&pull_data->metadata_objects_to_fetch, (GDestroyNotify) ot_waitable_queue_unref);
g_clear_pointer (&pull_data->scanned_metadata, (GDestroyNotify) g_hash_table_unref);
g_clear_pointer (&pull_data->requested_content, (GDestroyNotify) g_hash_table_unref);
g_clear_pointer (&pull_data->requested_metadata, (GDestroyNotify) g_hash_table_unref);
g_clear_pointer (&remote_config, (GDestroyNotify) g_key_file_unref);
if (summary_uri)
soup_uri_free (summary_uri);
return ret;
}
void
restraint_append_message (SoupSession *session,
SoupMessage *msg,
gpointer msg_data,
MessageFinishCallback finish_callback,
GCancellable *cancellable,
gpointer user_data)
{
ClientData *client_data = (ClientData *) msg_data;
time_t result;
result = time(NULL);
static time_t transaction_id = 0;
// calculate the transaction id. base it off of epoch
// incase the host reboots we shouldn't collide
if (transaction_id == 0) {
transaction_id = result;
}
MessageData *message_data;
message_data = g_slice_new0 (MessageData);
message_data->msg = msg;
message_data->user_data = user_data;
message_data->finish_callback = finish_callback;
if (client_data != NULL) {
GString *body = g_string_new("");
SoupURI *uri = soup_message_get_uri (msg);
soup_message_headers_foreach (msg->request_headers, append_header,
body);
// if we are doing a POST transaction
// increment transaction_id and add it to headers
// populate Location header in msg->reponse_headers
const gchar *path = soup_uri_get_path (uri);
if (g_strcmp0 (msg->method, "POST") == 0) {
g_string_append_printf (body,
"transaction-id: %jd\n", (intmax_t) transaction_id);
gchar *location_url = g_strdup_printf ("%s%jd", path, (intmax_t) transaction_id);
soup_message_headers_append (msg->response_headers, "Location", location_url);
g_free (location_url);
transaction_id++;
}
soup_message_set_status (msg, SOUP_STATUS_OK);
g_string_append_printf (body,
"rstrnt-path: %s\n"
"rstrnt-method: %s\n"
"Content-Length: %d\r\n\r\n",
path,
msg->method,
(guint) msg->request_body->length);
SoupBuffer *request = soup_message_body_flatten (msg->request_body);
body = g_string_append_len (body, request->data,
request->length);
g_string_append_printf (body,
"\r\n--cut-here\n");
soup_buffer_free (request);
soup_message_body_append (client_data->client_msg->response_body,
SOUP_MEMORY_TAKE,
body->str, body->len);
g_string_free (body, FALSE);
soup_server_unpause_message (client_data->server, client_data->client_msg);
}
if (finish_callback) {
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
message_finish,
message_data,
message_destroy);
} else {
g_object_unref (msg);
message_destroy (message_data);
}
}
static void
icon_changed_cb (WebKitFaviconDatabase *database,
const char *page_uri,
#ifdef HAVE_WEBKIT2
const char *favicon_uri,
#endif
GtkTreeModel *model)
{
GtkTreeIter iter;
int cmp;
char *host_address;
gboolean done, valid;
SoupURI *uri;
valid = gtk_tree_model_get_iter_first (model, &iter);
/* If the page_uri has a path, this icon is not for a host, so it
can be skipped. */
uri = soup_uri_new (page_uri);
done = strcmp (soup_uri_get_path (uri), "/") != 0;
soup_uri_free (uri);
while (valid && !done) {
gtk_tree_model_get (model, &iter,
EPHY_HOSTS_STORE_COLUMN_ADDRESS, &host_address, -1);
cmp = g_strcmp0 (host_address, page_uri);
g_free (host_address);
if (cmp == 0) {
#ifdef HAVE_WEBKIT2
IconLoadData *data;
GtkTreePath *path;
data = g_slice_new (IconLoadData);
data->model = GTK_LIST_STORE (g_object_ref (model));
path = gtk_tree_model_get_path (model, &iter);
data->row_reference = gtk_tree_row_reference_new (model, path);
gtk_tree_path_free (path);
webkit_favicon_database_get_favicon (database,
page_uri,
0,
async_update_favicon_icon,
data);
#else
GdkPixbuf *favicon = webkit_favicon_database_try_get_favicon_pixbuf (database,
page_uri,
FAVICON_SIZE,
FAVICON_SIZE);
if (favicon) {
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
EPHY_HOSTS_STORE_COLUMN_FAVICON, favicon,
-1);
g_object_unref (favicon);
}
#endif
}
valid = gtk_tree_model_iter_next (model, &iter);
/* Since the list is sorted alphanumerically, if the result of the
comparison is > 0, there is no point in searching any
further. */
done = cmp >= 0;
}
}
static void
catch_resource_group_api_fetch_cb (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
CatchResourceGroupPrivate *priv;
CatchMessageBuilder *builder;
GSimpleAsyncResult *simple = user_data;
CatchResourceGroup *group;
const gchar *uri;
JsonNode *node = NULL;
GError *error = NULL;
guint offset;
guint n_resources;
guint count;
guint index_;
ENTRY;
g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple));
group = CATCH_RESOURCE_GROUP(g_async_result_get_source_object(user_data));
g_return_if_fail(CATCH_IS_RESOURCE_GROUP(group));
priv = group->priv;
if (!(node = catch_resource_group_api_parse_response(group, message, &error))) {
g_simple_async_result_take_error(simple, error);
GOTO(finish);
}
if (g_type_is_a(priv->resource_type, CATCH_TYPE_SPACE)) {
if (!catch_resource_group_api_parse_spaces(group, node, &offset, &n_resources, &error)) {
g_simple_async_result_take_error(simple, error);
GOTO(finish);
}
g_simple_async_result_set_op_res_gboolean(simple, TRUE);
} else if (g_type_is_a(priv->resource_type, CATCH_TYPE_OBJECT)) {
if (!catch_resource_group_api_parse_objects(group, node, &offset, &n_resources, &error)) {
g_simple_async_result_take_error(simple, error);
GOTO(finish);
}
g_simple_async_result_set_op_res_gboolean(simple, TRUE);
} else if (g_type_is_a(priv->resource_type, CATCH_TYPE_ACTIVITY)) {
if (!catch_resource_group_api_parse_activities(group, node, &offset, &n_resources, &error)) {
g_simple_async_result_take_error(simple, error);
GOTO(finish);
}
g_simple_async_result_set_op_res_gboolean(simple, TRUE);
} else {
g_assert_not_reached();
}
/*
* If we did not satisfy the range of items to load on this query, we need
* to start another one.
*/
count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(simple), "count"));
index_ = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(simple), "index"));
if ((offset + n_resources) < (index_ + count)) {
offset += n_resources;
builder = catch_resource_group_get_builder(group);
catch_message_builder_add_int_param(builder, "offset", offset);
uri = soup_uri_get_path(soup_message_get_uri(message));
catch_message_builder_set_path(builder, uri, NULL);
message = catch_message_builder_build(builder);
/*
* TODO: Limit range to what we need, rather than server max.
*/
soup_session_queue_message(SOUP_SESSION(priv->session), message,
catch_resource_group_api_fetch_cb,
simple);
catch_message_builder_unref(builder);
if (node) {
json_node_free(node);
}
EXIT;
}
g_simple_async_result_set_op_res_gboolean(simple, TRUE);
finish:
if (node) {
json_node_free(node);
}
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
EXIT;
}
static SoupURI *
fwupd_remote_build_uri (FwupdRemote *self, const gchar *url, GError **error)
{
FwupdRemotePrivate *priv = GET_PRIVATE (self);
SoupURI *uri;
g_return_val_if_fail (FWUPD_IS_REMOTE (self), NULL);
g_return_val_if_fail (url != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
/* create URI, substituting if required */
if (priv->firmware_base_uri != NULL) {
g_autoptr(SoupURI) uri_tmp = NULL;
g_autofree gchar *basename = NULL;
g_autofree gchar *url2 = NULL;
uri_tmp = soup_uri_new (url);
if (uri_tmp == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Failed to parse URI '%s'", url);
return NULL;
}
basename = g_path_get_basename (soup_uri_get_path (uri_tmp));
url2 = g_build_filename (priv->firmware_base_uri, basename, NULL);
uri = soup_uri_new (url2);
if (uri == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Failed to parse URI '%s'", url2);
return NULL;
}
/* use the base URI of the metadata to build the full path */
} else if (g_strstr_len (url, -1, "/") == NULL) {
g_autofree gchar *basename = NULL;
g_autofree gchar *path = NULL;
uri = soup_uri_new (priv->metadata_uri);
if (uri == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Failed to parse metadata URI '%s'", url);
return NULL;
}
basename = g_path_get_dirname (soup_uri_get_path (uri));
path = g_build_filename (basename, url, NULL);
soup_uri_set_path (uri, path);
/* a normal URI */
} else {
uri = soup_uri_new (url);
if (uri == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Failed to parse URI '%s'", url);
return NULL;
}
}
/* set the username and password */
if (priv->username != NULL)
soup_uri_set_user (uri, priv->username);
if (priv->password != NULL)
soup_uri_set_password (uri, priv->password);
return uri;
}
