From aca9e8e6a73c79554f320b85aafb4cb01e91ac5a Mon Sep 17 00:00:00 2001 From: Daniel Kolesa Date: Thu, 17 Feb 2022 20:12:18 +0100 Subject: [PATCH] glib: bump glib requirement to 2.66 and port to GUri This removes the old SoupURI copypasta from previous generation of libsoup and opens up a path for a simple libsoup3 port. --- Makefile-libostree.am | 9 - Makefile.am | 2 +- configure.ac | 2 +- src/libostree/ostree-chain-input-stream.c | 11 +- src/libostree/ostree-checksum-input-stream.c | 12 +- src/libostree/ostree-core.c | 38 +- src/libostree/ostree-fetcher-curl.c | 35 +- src/libostree/ostree-fetcher-soup.c | 13 +- src/libostree/ostree-fetcher-uri.c | 86 +- src/libostree/ostree-fetcher-util.c | 3 +- src/libostree/ostree-gpg-verifier.c | 3 +- .../ostree-libarchive-input-stream.c | 12 +- src/libostree/ostree-lzma-compressor.c | 3 +- src/libostree/ostree-repo-commit.c | 78 +- src/libostree/ostree-repo-file.c | 21 +- src/libostree/ostree-repo-finder-avahi.c | 16 +- src/libostree/ostree-repo-pull.c | 75 +- .../ostree-repo-static-delta-processing.c | 37 +- src/libostree/ostree-repo.c | 13 +- src/libostree/ostree-soup-form.c | 140 -- src/libostree/ostree-soup-uri.c | 1438 ----------------- src/libostree/ostree-soup-uri.h | 147 -- src/libostree/ostree-sysroot.c | 5 +- src/libotutil/ot-checksum-instream.c | 9 +- src/libotutil/ot-gpg-utils.c | 3 +- src/ostree/ot-builtin-fsck.c | 3 +- src/ostree/ot-builtin-prune.c | 3 +- tests/repo-finder-mount.c | 3 +- tests/test-mock-gio.c | 3 +- 29 files changed, 266 insertions(+), 1957 deletions(-) delete mode 100644 src/libostree/ostree-soup-form.c delete mode 100644 src/libostree/ostree-soup-uri.c delete mode 100644 src/libostree/ostree-soup-uri.h diff --git a/Makefile-libostree.am b/Makefile-libostree.am index f125adb8..b58106aa 100644 --- a/Makefile-libostree.am +++ b/Makefile-libostree.am @@ -221,8 +221,6 @@ endif if USE_CURL libostree_1_la_SOURCES += src/libostree/ostree-fetcher-curl.c \ - src/libostree/ostree-soup-uri.h src/libostree/ostree-soup-uri.c \ - src/libostree/ostree-soup-form.c \ $(NULL) libostree_1_la_CFLAGS += $(OT_DEP_CURL_CFLAGS) libostree_1_la_LIBADD += $(OT_DEP_CURL_LIBS) @@ -231,13 +229,6 @@ if USE_LIBSOUP libostree_1_la_SOURCES += src/libostree/ostree-fetcher-soup.c libostree_1_la_CFLAGS += $(OT_INTERNAL_SOUP_CFLAGS) libostree_1_la_LIBADD += $(OT_INTERNAL_SOUP_LIBS) -else -if USE_AVAHI -libostree_1_la_SOURCES += src/libostree/ostree-soup-uri.h \ - src/libostree/ostree-soup-uri.c \ - src/libostree/ostree-soup-form.c \ - $(NULL) -endif endif endif diff --git a/Makefile.am b/Makefile.am index ce90ca45..6eb88388 100644 --- a/Makefile.am +++ b/Makefile.am @@ -29,7 +29,7 @@ AM_CPPFLAGS += -DDATADIR='"$(datadir)"' -DLIBEXECDIR='"$(libexecdir)"' \ -DOSTREE_COMPILATION \ -DG_LOG_DOMAIN=\"OSTree\" \ -DOSTREE_GITREV='"$(OSTREE_GITREV)"' \ - -DGLIB_VERSION_MIN_REQUIRED=GLIB_VERSION_2_44 '-DGLIB_VERSION_MAX_ALLOWED=G_ENCODE_VERSION(2,50)' \ + -DGLIB_VERSION_MIN_REQUIRED=GLIB_VERSION_2_66 '-DGLIB_VERSION_MAX_ALLOWED=G_ENCODE_VERSION(2,70)' \ -DSOUP_VERSION_MIN_REQUIRED=SOUP_VERSION_2_40 '-DSOUP_VERSION_MAX_ALLOWED=G_ENCODE_VERSION(2,48)' # For strict aliasing, see https://bugzilla.gnome.org/show_bug.cgi?id=791622 AM_CFLAGS += -std=gnu99 -fno-strict-aliasing $(WARN_CFLAGS) diff --git a/configure.ac b/configure.ac index 95e22438..8ca2f451 100644 --- a/configure.ac +++ b/configure.ac @@ -113,7 +113,7 @@ AM_PATH_GLIB_2_0(,,AC_MSG_ERROR([GLib not found])) dnl When bumping the gio-unix-2.0 dependency (or glib-2.0 in general), dnl remember to bump GLIB_VERSION_MIN_REQUIRED and dnl GLIB_VERSION_MAX_ALLOWED in Makefile.am -GIO_DEPENDENCY="gio-unix-2.0 >= 2.44.0" +GIO_DEPENDENCY="gio-unix-2.0 >= 2.66.0" PKG_CHECK_MODULES(OT_DEP_GIO_UNIX, $GIO_DEPENDENCY) dnl 5.1.0 is an arbitrary version here diff --git a/src/libostree/ostree-chain-input-stream.c b/src/libostree/ostree-chain-input-stream.c index 879d10c7..5ff4392a 100644 --- a/src/libostree/ostree-chain-input-stream.c +++ b/src/libostree/ostree-chain-input-stream.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -26,13 +27,13 @@ enum { PROP_STREAMS }; -G_DEFINE_TYPE (OstreeChainInputStream, ostree_chain_input_stream, G_TYPE_INPUT_STREAM) - struct _OstreeChainInputStreamPrivate { GPtrArray *streams; guint index; }; +G_DEFINE_TYPE_WITH_PRIVATE (OstreeChainInputStream, ostree_chain_input_stream, G_TYPE_INPUT_STREAM) + static void ostree_chain_input_stream_set_property (GObject *object, guint prop_id, const GValue *value, @@ -56,8 +57,6 @@ ostree_chain_input_stream_class_init (OstreeChainInputStreamClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass); - - g_type_class_add_private (klass, sizeof (OstreeChainInputStreamPrivate)); gobject_class->get_property = ostree_chain_input_stream_get_property; gobject_class->set_property = ostree_chain_input_stream_set_property; @@ -137,9 +136,7 @@ ostree_chain_input_stream_finalize (GObject *object) static void ostree_chain_input_stream_init (OstreeChainInputStream *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - OSTREE_TYPE_CHAIN_INPUT_STREAM, - OstreeChainInputStreamPrivate); + self->priv = ostree_chain_input_stream_get_instance_private (self); } diff --git a/src/libostree/ostree-checksum-input-stream.c b/src/libostree/ostree-checksum-input-stream.c index 8cef10d3..7cdf2048 100644 --- a/src/libostree/ostree-checksum-input-stream.c +++ b/src/libostree/ostree-checksum-input-stream.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -26,12 +27,12 @@ enum { PROP_CHECKSUM }; -G_DEFINE_TYPE (OstreeChecksumInputStream, ostree_checksum_input_stream, G_TYPE_FILTER_INPUT_STREAM) - struct _OstreeChecksumInputStreamPrivate { GChecksum *checksum; }; +G_DEFINE_TYPE_WITH_PRIVATE (OstreeChecksumInputStream, ostree_checksum_input_stream, G_TYPE_FILTER_INPUT_STREAM) + static void ostree_checksum_input_stream_set_property (GObject *object, guint prop_id, const GValue *value, @@ -51,8 +52,6 @@ ostree_checksum_input_stream_class_init (OstreeChecksumInputStreamClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass); - - g_type_class_add_private (klass, sizeof (OstreeChecksumInputStreamPrivate)); gobject_class->get_property = ostree_checksum_input_stream_get_property; gobject_class->set_property = ostree_checksum_input_stream_set_property; @@ -118,10 +117,7 @@ ostree_checksum_input_stream_get_property (GObject *object, static void ostree_checksum_input_stream_init (OstreeChecksumInputStream *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - OSTREE_TYPE_CHECKSUM_INPUT_STREAM, - OstreeChecksumInputStreamPrivate); - + self->priv = ostree_checksum_input_stream_get_instance_private (self); } OstreeChecksumInputStream * diff --git a/src/libostree/ostree-core.c b/src/libostree/ostree-core.c index f0d0e698..794f0e11 100644 --- a/src/libostree/ostree-core.c +++ b/src/libostree/ostree-core.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -1031,19 +1032,22 @@ typedef struct { } ChecksumFileAsyncData; static void -checksum_file_async_thread (GSimpleAsyncResult *res, +checksum_file_async_thread (GTask *task, GObject *object, + gpointer datap, GCancellable *cancellable) { GError *error = NULL; - ChecksumFileAsyncData *data; + ChecksumFileAsyncData *data = datap; guchar *csum = NULL; - data = g_simple_async_result_get_op_res_gpointer (res); if (!ostree_checksum_file (data->f, data->objtype, &csum, cancellable, &error)) - g_simple_async_result_take_error (res, error); + g_task_return_error (task, error); else - data->csum = csum; + { + data->csum = csum; + g_task_return_pointer (task, data, NULL); + } } static void @@ -1076,18 +1080,18 @@ ostree_checksum_file_async (GFile *f, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *res; + g_autoptr(GTask) task = NULL; ChecksumFileAsyncData *data; data = g_new0 (ChecksumFileAsyncData, 1); data->f = g_object_ref (f); data->objtype = objtype; - res = g_simple_async_result_new (G_OBJECT (f), callback, user_data, ostree_checksum_file_async); - g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify)checksum_file_async_data_free); - - g_simple_async_result_run_in_thread (res, checksum_file_async_thread, io_priority, cancellable); - g_object_unref (res); + task = g_task_new (G_OBJECT (f), cancellable, callback, user_data); + g_task_set_task_data (task, data, (GDestroyNotify)checksum_file_async_data_free); + g_task_set_priority (task, io_priority); + g_task_set_source_tag (task, ostree_checksum_file_async); + g_task_run_in_thread (task, (GTaskThreadFunc)checksum_file_async_thread); } /** @@ -1106,15 +1110,19 @@ ostree_checksum_file_async_finish (GFile *f, guchar **out_csum, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); ChecksumFileAsyncData *data; - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == ostree_checksum_file_async); + g_return_val_if_fail (G_IS_FILE (f), FALSE); + g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail (g_task_is_valid (result, f), FALSE); + g_return_val_if_fail (g_async_result_is_tagged (result, ostree_checksum_file_async), FALSE); - if (g_simple_async_result_propagate_error (simple, error)) + data = g_task_propagate_pointer (G_TASK (result), error); + + if (data == NULL) return FALSE; - data = g_simple_async_result_get_op_res_gpointer (simple); /* Transfer ownership */ *out_csum = data->csum; data->csum = NULL; diff --git a/src/libostree/ostree-fetcher-curl.c b/src/libostree/ostree-fetcher-curl.c index 35769f8a..c63369fd 100644 --- a/src/libostree/ostree-fetcher-curl.c +++ b/src/libostree/ostree-fetcher-curl.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2016 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -50,8 +51,6 @@ #include "ostree-repo-private.h" #include "otutil.h" -#include "ostree-soup-uri.h" - typedef struct FetcherRequest FetcherRequest; typedef struct SockInfo SockInfo; @@ -183,13 +182,13 @@ _ostree_fetcher_finalize (GObject *object) g_free (self->cookie_jar_path); g_free (self->proxy); g_assert_cmpint (g_hash_table_size (self->outstanding_requests), ==, 0); - g_clear_pointer (&self->extra_headers, (GDestroyNotify)curl_slist_free_all); + g_clear_pointer (&self->extra_headers, curl_slist_free_all); g_hash_table_unref (self->outstanding_requests); g_hash_table_unref (self->sockets); - g_clear_pointer (&self->timer_event, (GDestroyNotify)destroy_and_unref_source); + g_clear_pointer (&self->timer_event, destroy_and_unref_source); if (self->mainctx) g_main_context_unref (self->mainctx); - g_clear_pointer (&self->custom_user_agent, (GDestroyNotify)g_free); + g_clear_pointer (&self->custom_user_agent, g_free); G_OBJECT_CLASS (_ostree_fetcher_parent_class)->finalize (object); } @@ -266,11 +265,11 @@ destroy_and_unref_source (GSource *source) } static char * -request_get_uri (FetcherRequest *req, SoupURI *baseuri) +request_get_uri (FetcherRequest *req, GUri *baseuri) { if (!req->filename) - return soup_uri_to_string (baseuri, FALSE); - { g_autofree char *uristr = soup_uri_to_string (baseuri, FALSE); + return g_uri_to_string_partial (baseuri, G_URI_HIDE_PASSWORD); + { g_autofree char *uristr = g_uri_to_string_partial (baseuri, G_URI_HIDE_PASSWORD); return g_build_filename (uristr, req->filename, NULL); } } @@ -424,7 +423,7 @@ static gboolean timer_cb (gpointer data) { OstreeFetcher *fetcher = data; - g_clear_pointer (&fetcher->timer_event, (GDestroyNotify)destroy_and_unref_source); + g_clear_pointer (&fetcher->timer_event, destroy_and_unref_source); (void)curl_multi_socket_action (fetcher->multi, CURL_SOCKET_TIMEOUT, 0, &fetcher->curl_running); check_multi_info (fetcher); @@ -437,7 +436,7 @@ update_timeout_cb (CURLM *multi, long timeout_ms, void *userp) { OstreeFetcher *fetcher = userp; - g_clear_pointer (&fetcher->timer_event, (GDestroyNotify)destroy_and_unref_source); + g_clear_pointer (&fetcher->timer_event, destroy_and_unref_source); if (timeout_ms != -1) { @@ -479,7 +478,7 @@ sock_unref (SockInfo *f) return; if (--f->refcount != 0) return; - g_clear_pointer (&f->ch, (GDestroyNotify)destroy_and_unref_source); + g_clear_pointer (&f->ch, destroy_and_unref_source); g_free (f); } @@ -492,7 +491,7 @@ setsock (SockInfo*f, curl_socket_t s, int act, OstreeFetcher *fetcher) f->sockfd = s; f->action = act; - g_clear_pointer (&f->ch, (GDestroyNotify)destroy_and_unref_source); + g_clear_pointer (&f->ch, destroy_and_unref_source); /* TODO - investigate new g_source_modify_unix_fd() so changing the poll * flags involves less allocation. */ @@ -648,7 +647,7 @@ request_unref (FetcherRequest *req) g_string_free (req->output_buf, TRUE); g_free (req->if_none_match); g_free (req->out_etag); - g_clear_pointer (&req->req_headers, (GDestroyNotify)curl_slist_free_all); + g_clear_pointer (&req->req_headers, curl_slist_free_all); curl_easy_cleanup (req->easy); g_free (req); @@ -705,7 +704,7 @@ _ostree_fetcher_set_extra_headers (OstreeFetcher *self, const char *key; const char *value; - g_clear_pointer (&self->extra_headers, (GDestroyNotify)curl_slist_free_all); + g_clear_pointer (&self->extra_headers, curl_slist_free_all); g_variant_iter_init (&viter, extra_headers); while (g_variant_iter_loop (&viter, "(&s&s)", &key, &value)) @@ -719,7 +718,7 @@ void _ostree_fetcher_set_extra_user_agent (OstreeFetcher *self, const char *extra_user_agent) { - g_clear_pointer (&self->custom_user_agent, (GDestroyNotify)g_free); + g_clear_pointer (&self->custom_user_agent, g_free); if (extra_user_agent) { self->custom_user_agent = @@ -763,7 +762,7 @@ initiate_next_curl_request (FetcherRequest *req, g_assert_cmpint (req->idx, <, req->mirrorlist->len); - SoupURI *baseuri = req->mirrorlist->pdata[req->idx]; + GUri *baseuri = req->mirrorlist->pdata[req->idx]; { g_autofree char *uri = request_get_uri (req, baseuri); curl_easy_setopt (req->easy, CURLOPT_URL, uri); } @@ -842,9 +841,9 @@ initiate_next_curl_request (FetcherRequest *req, curl_easy_setopt (req->easy, CURLOPT_ACCEPT_ENCODING, ""); /* If we have e.g. basic auth in the URL string, let's honor that */ - const char *username = soup_uri_get_user (baseuri); + const char *username = g_uri_get_user (baseuri); curl_easy_setopt (req->easy, CURLOPT_USERNAME, username); - const char *password = soup_uri_get_password (baseuri); + const char *password = g_uri_get_password (baseuri); curl_easy_setopt (req->easy, CURLOPT_PASSWORD, password); /* We should only speak HTTP; TODO: only enable file if specified */ diff --git a/src/libostree/ostree-fetcher-soup.c b/src/libostree/ostree-fetcher-soup.c index be87f81e..ec1d8e09 100644 --- a/src/libostree/ostree-fetcher-soup.c +++ b/src/libostree/ostree-fetcher-soup.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -153,7 +154,7 @@ thread_closure_unref (ThreadClosure *thread_closure) g_clear_pointer (&thread_closure->main_context, g_main_context_unref); - g_clear_pointer (&thread_closure->extra_headers, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&thread_closure->extra_headers, g_variant_unref); g_clear_pointer (&thread_closure->output_stream_set, g_hash_table_unref); g_mutex_clear (&thread_closure->output_stream_set_lock); @@ -329,7 +330,7 @@ session_thread_set_headers_cb (ThreadClosure *thread_closure, { GVariant *headers = data; - g_clear_pointer (&thread_closure->extra_headers, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&thread_closure->extra_headers, g_variant_unref); thread_closure->extra_headers = g_variant_ref (headers); } @@ -431,11 +432,15 @@ create_pending_soup_request (OstreeFetcherPendingURI *pending, next_mirror = g_ptr_array_index (pending->mirrorlist, pending->mirrorlist_idx); if (pending->filename) uri = _ostree_fetcher_uri_new_subpath (next_mirror, pending->filename); + if (!uri) + uri = (OstreeFetcherURI*)g_uri_ref ((GUri*)next_mirror); g_clear_object (&pending->request); - pending->request = soup_session_request_uri (pending->thread_closure->session, - (SoupURI*)(uri ? uri : next_mirror), error); + { + g_autofree gchar *uri_str = g_uri_to_string ((GUri*)uri); + pending->request = soup_session_request (pending->thread_closure->session, uri_str, error); + } /* Add caching headers. */ if (SOUP_IS_REQUEST_HTTP (pending->request) && pending->if_none_match != NULL) diff --git a/src/libostree/ostree-fetcher-uri.c b/src/libostree/ostree-fetcher-uri.c index 13bcb8f2..d5ed576d 100644 --- a/src/libostree/ostree-fetcher-uri.c +++ b/src/libostree/ostree-fetcher-uri.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011,2017 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -21,15 +22,7 @@ #include "config.h" - -#ifdef HAVE_LIBCURL -#include "ostree-soup-uri.h" -#else -#define LIBSOUP_USE_UNSTABLE_REQUEST_API -#include -#include -#include -#endif +#include #include "ostree-fetcher.h" @@ -39,21 +32,52 @@ void _ostree_fetcher_uri_free (OstreeFetcherURI *uri) { if (uri) - soup_uri_free ((SoupURI*)uri); + g_uri_unref ((GUri*)uri); } OstreeFetcherURI * _ostree_fetcher_uri_parse (const char *str, GError **error) { - SoupURI *soupuri = soup_uri_new (str); - if (soupuri == NULL) + GUri *uri = NULL; +#if GLIB_CHECK_VERSION(2, 68, 0) + uri = g_uri_parse (str, G_URI_FLAGS_HAS_PASSWORD | G_URI_FLAGS_ENCODED | G_URI_FLAGS_SCHEME_NORMALIZE, error); +#else + /* perform manual scheme normalization for older glib */ + uri = g_uri_parse (str, G_URI_FLAGS_HAS_PASSWORD | G_URI_FLAGS_ENCODED, error); + if (uri) { - g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, - "Failed to parse uri: %s", str); - return NULL; + GUri *nuri = NULL; + switch (g_uri_get_port (uri)) + { + case 21: + if (!strcmp (g_uri_get_scheme (uri), "ftp")) + break; + return (OstreeFetcherURI*)uri; + case 80: + if (!strcmp (g_uri_get_scheme (uri), "http")) + break; + return (OstreeFetcherURI*)uri; + case 443: + if (!strcmp (g_uri_get_scheme (uri), "https")) + break; + return (OstreeFetcherURI*)uri; + default: + return (OstreeFetcherURI*)uri; + } + nuri = g_uri_build_with_user (g_uri_get_flags (uri), "http", + g_uri_get_user (uri), + g_uri_get_password (uri), + NULL, + g_uri_get_host (uri), -1, + g_uri_get_path (uri), + g_uri_get_query (uri), + g_uri_get_fragment (uri)); + g_uri_unref (uri); + uri = nuri; } - return (OstreeFetcherURI*)soupuri; +#endif + return (OstreeFetcherURI*)uri; } static OstreeFetcherURI * @@ -61,21 +85,31 @@ _ostree_fetcher_uri_new_path_internal (OstreeFetcherURI *uri, gboolean extend, const char *path) { - SoupURI *newuri = soup_uri_copy ((SoupURI*)uri); + GUri *guri = (GUri*)uri; + const char *opath = g_uri_get_path (guri); + g_autofree char *newpath = NULL; if (path) { if (extend) { - const char *origpath = soup_uri_get_path ((SoupURI*)uri); - g_autofree char *newpath = g_build_filename (origpath, path, NULL); - soup_uri_set_path (newuri, newpath); + newpath = g_build_filename (opath, path, NULL); + opath = newpath; } else { - soup_uri_set_path (newuri, path); + opath = path; } } - return (OstreeFetcherURI*)newuri; + return (OstreeFetcherURI*)g_uri_build_with_user (g_uri_get_flags (guri), + g_uri_get_scheme (guri), + g_uri_get_user (guri), + g_uri_get_password (guri), + NULL, + g_uri_get_host (guri), + g_uri_get_port (guri), + opath, + g_uri_get_query (guri), + g_uri_get_fragment (guri)); } OstreeFetcherURI * @@ -101,19 +135,19 @@ _ostree_fetcher_uri_clone (OstreeFetcherURI *uri) char * _ostree_fetcher_uri_get_scheme (OstreeFetcherURI *uri) { - return g_strdup (soup_uri_get_scheme ((SoupURI*)uri)); + return g_strdup (g_uri_get_scheme ((GUri*)uri)); } char * _ostree_fetcher_uri_get_path (OstreeFetcherURI *uri) { - return g_strdup (soup_uri_get_path ((SoupURI*)uri)); + return g_strdup (g_uri_get_path ((GUri*)uri)); } char * _ostree_fetcher_uri_to_string (OstreeFetcherURI *uri) { - return soup_uri_to_string ((SoupURI*)uri, FALSE); + return g_uri_to_string_partial ((GUri*)uri, G_URI_HIDE_PASSWORD); } @@ -124,7 +158,7 @@ _ostree_fetcher_uri_to_string (OstreeFetcherURI *uri) gboolean _ostree_fetcher_uri_validate (OstreeFetcherURI *uri, GError **error) { - const char *scheme = soup_uri_get_scheme ((SoupURI*)uri); + const char *scheme = g_uri_get_scheme ((GUri*)uri); // TODO only allow file if explicitly requested by a higher level if (!(g_str_equal (scheme, "http") || g_str_equal (scheme, "https") || g_str_equal (scheme, "file"))) { diff --git a/src/libostree/ostree-fetcher-util.c b/src/libostree/ostree-fetcher-util.c index 7aeb035a..450a3abe 100644 --- a/src/libostree/ostree-fetcher-util.c +++ b/src/libostree/ostree-fetcher-util.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2017 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -124,7 +125,7 @@ _ostree_fetcher_mirrored_request_to_membuf_once (OstreeFetcher *fe out: if (mainctx) g_main_context_pop_thread_default (mainctx); - g_clear_pointer (&data.result_buf, (GDestroyNotify)g_bytes_unref); + g_clear_pointer (&data.result_buf, g_bytes_unref); g_clear_pointer (&data.result_etag, g_free); return ret; } diff --git a/src/libostree/ostree-gpg-verifier.c b/src/libostree/ostree-gpg-verifier.c index 16b87c6f..1c8d9464 100644 --- a/src/libostree/ostree-gpg-verifier.c +++ b/src/libostree/ostree-gpg-verifier.c @@ -1,6 +1,7 @@ /* * Copyright (C) 2011 Colin Walters * Copyright (C) 2013 Sjoerd Simons + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -53,7 +54,7 @@ ostree_gpg_verifier_finalize (GObject *object) g_list_free_full (self->keyrings, g_object_unref); if (self->key_ascii_files) g_ptr_array_unref (self->key_ascii_files); - g_clear_pointer (&self->keyring_data, (GDestroyNotify)g_ptr_array_unref); + g_clear_pointer (&self->keyring_data, g_ptr_array_unref); G_OBJECT_CLASS (_ostree_gpg_verifier_parent_class)->finalize (object); } diff --git a/src/libostree/ostree-libarchive-input-stream.c b/src/libostree/ostree-libarchive-input-stream.c index f80bd77c..3c313c1d 100644 --- a/src/libostree/ostree-libarchive-input-stream.c +++ b/src/libostree/ostree-libarchive-input-stream.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -29,12 +30,12 @@ enum { PROP_ARCHIVE }; -G_DEFINE_TYPE (OstreeLibarchiveInputStream, _ostree_libarchive_input_stream, G_TYPE_INPUT_STREAM) - struct _OstreeLibarchiveInputStreamPrivate { struct archive *archive; }; +G_DEFINE_TYPE_WITH_PRIVATE (OstreeLibarchiveInputStream, _ostree_libarchive_input_stream, G_TYPE_INPUT_STREAM) + static void ostree_libarchive_input_stream_set_property (GObject *object, guint prop_id, const GValue *value, @@ -63,8 +64,6 @@ _ostree_libarchive_input_stream_class_init (OstreeLibarchiveInputStreamClass *kl { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass); - - g_type_class_add_private (klass, sizeof (OstreeLibarchiveInputStreamPrivate)); gobject_class->get_property = ostree_libarchive_input_stream_get_property; gobject_class->set_property = ostree_libarchive_input_stream_set_property; @@ -132,10 +131,7 @@ ostree_libarchive_input_stream_get_property (GObject *object, static void _ostree_libarchive_input_stream_init (OstreeLibarchiveInputStream *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - OSTREE_TYPE_LIBARCHIVE_INPUT_STREAM, - OstreeLibarchiveInputStreamPrivate); - + self->priv = _ostree_libarchive_input_stream_get_instance_private (self); } GInputStream * diff --git a/src/libostree/ostree-lzma-compressor.c b/src/libostree/ostree-lzma-compressor.c index 3b201418..c60e6b71 100644 --- a/src/libostree/ostree-lzma-compressor.c +++ b/src/libostree/ostree-lzma-compressor.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2014 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -66,7 +67,7 @@ _ostree_lzma_compressor_finalize (GObject *object) OstreeLzmaCompressor *self = OSTREE_LZMA_COMPRESSOR (object); lzma_end (&self->lstream); - g_clear_pointer (&self->params, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&self->params, g_variant_unref); G_OBJECT_CLASS (_ostree_lzma_compressor_parent_class)->finalize (object); } diff --git a/src/libostree/ostree-repo-commit.c b/src/libostree/ostree-repo-commit.c index 5b16be5b..d688e9b7 100644 --- a/src/libostree/ostree-repo-commit.c +++ b/src/libostree/ostree-repo-commit.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011,2013 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -640,8 +641,8 @@ _ostree_repo_bare_content_cleanup (OstreeRepoBareContent *regwrite) return; glnx_tmpfile_clear (&real->tmpf); ot_checksum_clear (&real->checksum); - g_clear_pointer (&real->expected_checksum, (GDestroyNotify)g_free); - g_clear_pointer (&real->xattrs, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&real->expected_checksum, g_free); + g_clear_pointer (&real->xattrs, g_variant_unref); real->initialized = FALSE; } @@ -2584,8 +2585,6 @@ typedef struct { char *expected_checksum; GVariant *object; GCancellable *cancellable; - GSimpleAsyncResult *result; - guchar *result_csum; } WriteMetadataAsyncData; @@ -2603,19 +2602,21 @@ write_metadata_async_data_free (gpointer user_data) } static void -write_metadata_thread (GSimpleAsyncResult *res, +write_metadata_thread (GTask *task, GObject *object, + gpointer datap, GCancellable *cancellable) { GError *error = NULL; - WriteMetadataAsyncData *data; + WriteMetadataAsyncData *data = datap; - data = g_simple_async_result_get_op_res_gpointer (res); if (!ostree_repo_write_metadata (data->repo, data->objtype, data->expected_checksum, data->object, &data->result_csum, cancellable, &error)) - g_simple_async_result_take_error (res, error); + g_task_return_error (task, error); + else + g_task_return_pointer (task, data, NULL); } /** @@ -2640,6 +2641,7 @@ ostree_repo_write_metadata_async (OstreeRepo *self, GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(GTask) task = NULL; WriteMetadataAsyncData *asyncdata; asyncdata = g_new0 (WriteMetadataAsyncData, 1); @@ -2649,14 +2651,10 @@ ostree_repo_write_metadata_async (OstreeRepo *self, asyncdata->object = g_variant_ref (object); asyncdata->cancellable = cancellable ? g_object_ref (cancellable) : NULL; - asyncdata->result = g_simple_async_result_new ((GObject*) self, - callback, user_data, - ostree_repo_write_metadata_async); - - g_simple_async_result_set_op_res_gpointer (asyncdata->result, asyncdata, - write_metadata_async_data_free); - g_simple_async_result_run_in_thread (asyncdata->result, write_metadata_thread, G_PRIORITY_DEFAULT, cancellable); - g_object_unref (asyncdata->result); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); + g_task_set_task_data (task, asyncdata, write_metadata_async_data_free); + g_task_set_source_tag (task, ostree_repo_write_metadata_async); + g_task_run_in_thread (task, (GTaskThreadFunc)write_metadata_thread); } /** @@ -2674,15 +2672,18 @@ ostree_repo_write_metadata_finish (OstreeRepo *self, guchar **out_csum, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); WriteMetadataAsyncData *data; - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == ostree_repo_write_metadata_async); + g_return_val_if_fail (OSTREE_IS_REPO (self), FALSE); + g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + g_return_val_if_fail (g_async_result_is_tagged (result, ostree_repo_write_metadata_async), FALSE); - if (g_simple_async_result_propagate_error (simple, error)) + data = g_task_propagate_pointer (G_TASK (result), error); + if (data == NULL) return FALSE; - data = g_simple_async_result_get_op_res_gpointer (simple); /* Transfer ownership */ *out_csum = data->result_csum; data->result_csum = NULL; @@ -2920,7 +2921,6 @@ typedef struct { GInputStream *object; guint64 file_object_length; GCancellable *cancellable; - GSimpleAsyncResult *result; guchar *result_csum; } WriteContentAsyncData; @@ -2939,19 +2939,21 @@ write_content_async_data_free (gpointer user_data) } static void -write_content_thread (GSimpleAsyncResult *res, +write_content_thread (GTask *task, GObject *object, + gpointer datap, GCancellable *cancellable) { GError *error = NULL; - WriteContentAsyncData *data; + WriteContentAsyncData *data = datap; - data = g_simple_async_result_get_op_res_gpointer (res); if (!ostree_repo_write_content (data->repo, data->expected_checksum, data->object, data->file_object_length, &data->result_csum, cancellable, &error)) - g_simple_async_result_take_error (res, error); + g_task_return_error (task, error); + else + g_task_return_pointer (task, data, NULL); } /** @@ -2976,6 +2978,7 @@ ostree_repo_write_content_async (OstreeRepo *self, GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(GTask) task = NULL; WriteContentAsyncData *asyncdata; asyncdata = g_new0 (WriteContentAsyncData, 1); @@ -2985,14 +2988,10 @@ ostree_repo_write_content_async (OstreeRepo *self, asyncdata->file_object_length = length; asyncdata->cancellable = cancellable ? g_object_ref (cancellable) : NULL; - asyncdata->result = g_simple_async_result_new ((GObject*) self, - callback, user_data, - ostree_repo_write_content_async); - - g_simple_async_result_set_op_res_gpointer (asyncdata->result, asyncdata, - write_content_async_data_free); - g_simple_async_result_run_in_thread (asyncdata->result, write_content_thread, G_PRIORITY_DEFAULT, cancellable); - g_object_unref (asyncdata->result); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); + g_task_set_task_data (task, asyncdata, (GDestroyNotify)write_content_async_data_free); + g_task_set_source_tag (task, ostree_repo_write_content_async); + g_task_run_in_thread (task, (GTaskThreadFunc)write_content_thread); } /** @@ -3010,15 +3009,18 @@ ostree_repo_write_content_finish (OstreeRepo *self, guchar **out_csum, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); WriteContentAsyncData *data; - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == ostree_repo_write_content_async); + g_return_val_if_fail (OSTREE_IS_REPO (self), FALSE); + g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + g_return_val_if_fail (g_async_result_is_tagged (result, ostree_repo_write_content_async), FALSE); - if (g_simple_async_result_propagate_error (simple, error)) + data = g_task_propagate_pointer (G_TASK (result), error); + if (data == NULL) return FALSE; - data = g_simple_async_result_get_op_res_gpointer (simple); ot_transfer_out_value (out_csum, &data->result_csum); return TRUE; } @@ -4336,7 +4338,7 @@ ostree_repo_commit_modifier_unref (OstreeRepoCommitModifier *modifier) if (modifier->xattr_destroy) modifier->xattr_destroy (modifier->xattr_user_data); - g_clear_pointer (&modifier->devino_cache, (GDestroyNotify)g_hash_table_unref); + g_clear_pointer (&modifier->devino_cache, g_hash_table_unref); g_clear_object (&modifier->sepolicy); diff --git a/src/libostree/ostree-repo-file.c b/src/libostree/ostree-repo-file.c index 082588a5..3d396ced 100644 --- a/src/libostree/ostree-repo-file.c +++ b/src/libostree/ostree-repo-file.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -55,8 +56,8 @@ ostree_repo_file_finalize (GObject *object) self = OSTREE_REPO_FILE (object); - g_clear_pointer (&self->tree_contents, (GDestroyNotify) g_variant_unref); - g_clear_pointer (&self->tree_metadata, (GDestroyNotify) g_variant_unref); + g_clear_pointer (&self->tree_contents, g_variant_unref); + g_clear_pointer (&self->tree_metadata, g_variant_unref); g_free (self->cached_file_checksum); g_free (self->tree_contents_checksum); g_free (self->tree_metadata_checksum); @@ -236,7 +237,7 @@ do_resolve_nonroot (OstreeRepoFile *self, files_variant = g_variant_get_child_value (self->parent->tree_contents, 0); self->index = g_variant_n_children (files_variant) + i; - g_clear_pointer (&files_variant, (GDestroyNotify) g_variant_unref); + g_clear_pointer (&files_variant, g_variant_unref); g_variant_get_child (container, i, "(&s@ay@ay)", &name, &contents_csum_v, &metadata_csum_v); @@ -337,7 +338,7 @@ ostree_repo_file_tree_set_metadata (OstreeRepoFile *self, const char *checksum, GVariant *metadata) { - g_clear_pointer (&self->tree_metadata, (GDestroyNotify) g_variant_unref); + g_clear_pointer (&self->tree_metadata, g_variant_unref); self->tree_metadata = g_variant_ref (metadata); g_free (self->tree_metadata_checksum); self->tree_metadata_checksum = g_strdup (checksum); @@ -414,8 +415,8 @@ ostree_repo_file_get_checksum (OstreeRepoFile *self) g_variant_get_child (files_variant, n, "(@s@ay)", NULL, &csum_bytes); } - g_clear_pointer (&files_variant, (GDestroyNotify) g_variant_unref); - g_clear_pointer (&dirs_variant, (GDestroyNotify) g_variant_unref); + g_clear_pointer (&files_variant, g_variant_unref); + g_clear_pointer (&dirs_variant, g_variant_unref); self->cached_file_checksum = ostree_checksum_from_bytes_v (csum_bytes); @@ -775,9 +776,9 @@ ostree_repo_file_tree_find_child (OstreeRepoFile *self, *out_container = ret_container; ret_container = NULL; } - g_clear_pointer (&ret_container, (GDestroyNotify) g_variant_unref); - g_clear_pointer (&files_variant, (GDestroyNotify) g_variant_unref); - g_clear_pointer (&dirs_variant, (GDestroyNotify) g_variant_unref); + g_clear_pointer (&ret_container, g_variant_unref); + g_clear_pointer (&files_variant, g_variant_unref); + g_clear_pointer (&dirs_variant, g_variant_unref); return i; } @@ -969,7 +970,7 @@ ostree_repo_file_read (GFile *file, return g_file_read (dest, cancellable, error); } - return g_steal_pointer (&ret_stream); + return (GFileInputStream *)g_steal_pointer (&ret_stream); } static void diff --git a/src/libostree/ostree-repo-finder-avahi.c b/src/libostree/ostree-repo-finder-avahi.c index 76153b01..7555df6e 100644 --- a/src/libostree/ostree-repo-finder-avahi.c +++ b/src/libostree/ostree-repo-finder-avahi.c @@ -1,6 +1,7 @@ /* * Copyright © 2016 Kinvolk GmbH * Copyright © 2017 Endless Mobile, Inc. + * Copyright © 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -53,7 +54,6 @@ #include "ostree-repo-private.h" #include "ostree-repo.h" #include "ostree-repo-finder-avahi-private.h" -#include "ostree-soup-uri.h" #include "otutil.h" #endif /* HAVE_AVAHI */ @@ -490,7 +490,7 @@ fill_refs_and_checksums_from_summary (GVariant *summary, return FALSE; } - g_clear_pointer (&ref_map, (GDestroyNotify) g_variant_iter_free); + g_clear_pointer (&ref_map, g_variant_iter_free); /* Repeat for the other collections listed in the summary. */ if (g_variant_dict_lookup (&additional_metadata, OSTREE_SUMMARY_COLLECTION_MAP, "a{sa(s(taya{sv}))}", &collection_map)) @@ -705,7 +705,7 @@ ostree_avahi_service_build_repo_finder_result (OstreeAvahiService g_autoptr(GVariant) repo_index = NULL; g_autofree gchar *repo_path = NULL; g_autoptr(GPtrArray) possible_refs = NULL; /* (element-type OstreeCollectionRef) */ - SoupURI *_uri = NULL; + GUri *_uri = NULL; g_autofree gchar *uri = NULL; g_autoptr(GError) error = NULL; gsize i; @@ -772,13 +772,9 @@ ostree_avahi_service_build_repo_finder_result (OstreeAvahiService repo_to_refs = g_hash_table_new_full (uri_and_keyring_hash, uri_and_keyring_equal, (GDestroyNotify) uri_and_keyring_free, (GDestroyNotify) g_hash_table_unref); - _uri = soup_uri_new (NULL); - soup_uri_set_scheme (_uri, "http"); - soup_uri_set_host (_uri, service->address); - soup_uri_set_port (_uri, service->port); - soup_uri_set_path (_uri, repo_path); - uri = soup_uri_to_string (_uri, FALSE); - soup_uri_free (_uri); + _uri = g_uri_build (G_URI_FLAGS_ENCODED, "http", NULL, service->address, service->port, repo_path, NULL, NULL); + uri = g_uri_to_string (_uri); + g_uri_unref (_uri); for (i = 0; i < possible_refs->len; i++) { diff --git a/src/libostree/ostree-repo-pull.c b/src/libostree/ostree-repo-pull.c index 1d61faaf..4819a40a 100644 --- a/src/libostree/ostree-repo-pull.c +++ b/src/libostree/ostree-repo-pull.c @@ -1,6 +1,7 @@ /* * Copyright (C) 2011,2012,2013 Colin Walters * Copyright © 2017 Endless Mobile, Inc. + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -435,7 +436,7 @@ idle_worker (gpointer user_data) scan_data = g_queue_pop_head (&pull_data->scan_object_queue); if (!scan_data) { - g_clear_pointer (&pull_data->idle_src, (GDestroyNotify) g_source_destroy); + g_clear_pointer (&pull_data->idle_src, g_source_destroy); return G_SOURCE_REMOVE; } @@ -4476,7 +4477,7 @@ ostree_repo_pull_with_options (OstreeRepo *self, pull_data->remote_name); summary_from_cache = FALSE; - g_clear_pointer (&bytes_summary, (GDestroyNotify)g_bytes_unref); + g_clear_pointer (&bytes_summary, g_bytes_unref); g_clear_pointer (&summary_etag, g_free); summary_last_modified = 0; if (!_ostree_fetcher_mirrored_request_to_membuf (pull_data->fetcher, @@ -4544,7 +4545,7 @@ ostree_repo_pull_with_options (OstreeRepo *self, pull_data->remote_name); summary_from_cache = FALSE; - g_clear_pointer (&bytes_summary, (GDestroyNotify)g_bytes_unref); + g_clear_pointer (&bytes_summary, g_bytes_unref); g_clear_pointer (&summary_etag, g_free); summary_last_modified = 0; if (!_ostree_fetcher_mirrored_request_to_membuf (pull_data->fetcher, @@ -5153,46 +5154,46 @@ ostree_repo_pull_with_options (OstreeRepo *self, g_source_destroy (update_timeout); g_strfreev (configured_branches); g_clear_object (&pull_data->fetcher); - g_clear_pointer (&pull_data->extra_headers, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&pull_data->extra_headers, g_variant_unref); g_clear_object (&pull_data->cancellable); - g_clear_pointer (&pull_data->localcache_repos, (GDestroyNotify)g_ptr_array_unref); + g_clear_pointer (&pull_data->localcache_repos, g_ptr_array_unref); g_clear_object (&pull_data->remote_repo_local); g_free (pull_data->remote_refspec_name); g_free (pull_data->remote_name); g_free (pull_data->append_user_agent); - g_clear_pointer (&pull_data->signapi_commit_verifiers, (GDestroyNotify) g_ptr_array_unref); - g_clear_pointer (&pull_data->signapi_summary_verifiers, (GDestroyNotify) g_ptr_array_unref); - g_clear_pointer (&pull_data->meta_mirrorlist, (GDestroyNotify) g_ptr_array_unref); - g_clear_pointer (&pull_data->content_mirrorlist, (GDestroyNotify) g_ptr_array_unref); - g_clear_pointer (&pull_data->summary_data, (GDestroyNotify) g_bytes_unref); + g_clear_pointer (&pull_data->signapi_commit_verifiers, g_ptr_array_unref); + g_clear_pointer (&pull_data->signapi_summary_verifiers, g_ptr_array_unref); + g_clear_pointer (&pull_data->meta_mirrorlist, g_ptr_array_unref); + g_clear_pointer (&pull_data->content_mirrorlist, g_ptr_array_unref); + g_clear_pointer (&pull_data->summary_data, g_bytes_unref); g_clear_pointer (&pull_data->summary_etag, g_free); - g_clear_pointer (&pull_data->summary_data_sig, (GDestroyNotify) g_bytes_unref); + g_clear_pointer (&pull_data->summary_data_sig, g_bytes_unref); g_clear_pointer (&pull_data->summary_sig_etag, g_free); - g_clear_pointer (&pull_data->summary, (GDestroyNotify) g_variant_unref); - g_clear_pointer (&pull_data->static_delta_superblocks, (GDestroyNotify) g_ptr_array_unref); - g_clear_pointer (&pull_data->commit_to_depth, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->expected_commit_sizes, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->scanned_metadata, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->fetched_detached_metadata, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->summary_deltas_checksums, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->ref_original_commits, (GDestroyNotify) g_hash_table_unref); + g_clear_pointer (&pull_data->summary, g_variant_unref); + g_clear_pointer (&pull_data->static_delta_superblocks, g_ptr_array_unref); + g_clear_pointer (&pull_data->commit_to_depth, g_hash_table_unref); + g_clear_pointer (&pull_data->expected_commit_sizes, g_hash_table_unref); + g_clear_pointer (&pull_data->scanned_metadata, g_hash_table_unref); + g_clear_pointer (&pull_data->fetched_detached_metadata, g_hash_table_unref); + g_clear_pointer (&pull_data->summary_deltas_checksums, g_hash_table_unref); + g_clear_pointer (&pull_data->ref_original_commits, g_hash_table_unref); g_free (pull_data->timestamp_check_from_rev); - g_clear_pointer (&pull_data->verified_commits, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->signapi_verified_commits, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->ref_keyring_map, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->requested_content, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->requested_fallback_content, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->requested_metadata, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->pending_fetch_content, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->pending_fetch_metadata, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->pending_fetch_delta_indexes, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->pending_fetch_delta_superblocks, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&pull_data->pending_fetch_deltaparts, (GDestroyNotify) g_hash_table_unref); + g_clear_pointer (&pull_data->verified_commits, g_hash_table_unref); + g_clear_pointer (&pull_data->signapi_verified_commits, g_hash_table_unref); + g_clear_pointer (&pull_data->ref_keyring_map, g_hash_table_unref); + g_clear_pointer (&pull_data->requested_content, g_hash_table_unref); + g_clear_pointer (&pull_data->requested_fallback_content, g_hash_table_unref); + g_clear_pointer (&pull_data->requested_metadata, g_hash_table_unref); + g_clear_pointer (&pull_data->pending_fetch_content, g_hash_table_unref); + g_clear_pointer (&pull_data->pending_fetch_metadata, g_hash_table_unref); + g_clear_pointer (&pull_data->pending_fetch_delta_indexes, g_hash_table_unref); + g_clear_pointer (&pull_data->pending_fetch_delta_superblocks, g_hash_table_unref); + g_clear_pointer (&pull_data->pending_fetch_deltaparts, g_hash_table_unref); g_queue_foreach (&pull_data->scan_object_queue, (GFunc) scan_object_queue_data_free, NULL); g_queue_clear (&pull_data->scan_object_queue); - g_clear_pointer (&pull_data->idle_src, (GDestroyNotify) g_source_destroy); - g_clear_pointer (&pull_data->dirs, (GDestroyNotify) g_ptr_array_unref); - g_clear_pointer (&remote_config, (GDestroyNotify) g_key_file_unref); + g_clear_pointer (&pull_data->idle_src, g_source_destroy); + g_clear_pointer (&pull_data->dirs, g_ptr_array_unref); + g_clear_pointer (&remote_config, g_key_file_unref); return ret; } @@ -5838,7 +5839,7 @@ find_remotes_cb (GObject *obj, { g_debug ("%s: Failed to download summary for result ‘%s’. Ignoring. %s", G_STRFUNC, result->remote->name, error->message); - g_clear_pointer (&g_ptr_array_index (results, i), (GDestroyNotify) ostree_repo_finder_result_free); + g_clear_pointer (&g_ptr_array_index (results, i), ostree_repo_finder_result_free); g_clear_error (&error); continue; } @@ -5847,7 +5848,7 @@ find_remotes_cb (GObject *obj, g_debug ("%s: Failed to download summary for result ‘%s’. Ignoring. %s", G_STRFUNC, result->remote->name, "No summary file exists on server"); - g_clear_pointer (&g_ptr_array_index (results, i), (GDestroyNotify) ostree_repo_finder_result_free); + g_clear_pointer (&g_ptr_array_index (results, i), ostree_repo_finder_result_free); continue; } @@ -5869,7 +5870,7 @@ find_remotes_cb (GObject *obj, if (!find_remotes_process_refs (self, refs, result, i, summary_collection_id, summary_refs, commit_metadatas, refs_and_remotes_table)) { - g_clear_pointer (&g_ptr_array_index (results, i), (GDestroyNotify) ostree_repo_finder_result_free); + g_clear_pointer (&g_ptr_array_index (results, i), ostree_repo_finder_result_free); continue; } } @@ -5890,7 +5891,7 @@ find_remotes_cb (GObject *obj, if (!find_remotes_process_refs (self, refs, result, i, summary_collection_id, summary_refs, commit_metadatas, refs_and_remotes_table)) { - g_clear_pointer (&g_ptr_array_index (results, i), (GDestroyNotify) ostree_repo_finder_result_free); + g_clear_pointer (&g_ptr_array_index (results, i), ostree_repo_finder_result_free); invalid_result = TRUE; break; } diff --git a/src/libostree/ostree-repo-static-delta-processing.c b/src/libostree/ostree-repo-static-delta-processing.c index 6e093121..47e6c064 100644 --- a/src/libostree/ostree-repo-static-delta-processing.c +++ b/src/libostree/ostree-repo-static-delta-processing.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2013,2014 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -285,7 +286,6 @@ typedef struct { GVariant *header; GVariant *part; GCancellable *cancellable; - GSimpleAsyncResult *result; } StaticDeltaPartExecuteAsyncData; static void @@ -301,20 +301,22 @@ static_delta_part_execute_async_data_free (gpointer user_data) } static void -static_delta_part_execute_thread (GSimpleAsyncResult *res, +static_delta_part_execute_thread (GTask *task, GObject *object, + gpointer datap, GCancellable *cancellable) { GError *error = NULL; - StaticDeltaPartExecuteAsyncData *data; + StaticDeltaPartExecuteAsyncData *data = datap; - data = g_simple_async_result_get_op_res_gpointer (res); if (!_ostree_static_delta_part_execute (data->repo, data->header, data->part, FALSE, NULL, cancellable, &error)) - g_simple_async_result_take_error (res, error); + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); } void @@ -325,6 +327,7 @@ _ostree_static_delta_part_execute_async (OstreeRepo *repo, GAsyncReadyCallback callback, gpointer user_data) { + g_autoptr(GTask) task = NULL; StaticDeltaPartExecuteAsyncData *asyncdata; asyncdata = g_new0 (StaticDeltaPartExecuteAsyncData, 1); @@ -333,14 +336,10 @@ _ostree_static_delta_part_execute_async (OstreeRepo *repo, asyncdata->part = g_variant_ref (part); asyncdata->cancellable = cancellable ? g_object_ref (cancellable) : NULL; - asyncdata->result = g_simple_async_result_new ((GObject*) repo, - callback, user_data, - _ostree_static_delta_part_execute_async); - - g_simple_async_result_set_op_res_gpointer (asyncdata->result, asyncdata, - static_delta_part_execute_async_data_free); - g_simple_async_result_run_in_thread (asyncdata->result, static_delta_part_execute_thread, G_PRIORITY_DEFAULT, cancellable); - g_object_unref (asyncdata->result); + task = g_task_new (G_OBJECT (repo), cancellable, callback, user_data); + g_task_set_task_data (task, asyncdata, (GDestroyNotify)static_delta_part_execute_async_data_free); + g_task_set_source_tag (task, _ostree_static_delta_part_execute_async); + g_task_run_in_thread (task, (GTaskThreadFunc)static_delta_part_execute_thread); } gboolean @@ -348,13 +347,13 @@ _ostree_static_delta_part_execute_finish (OstreeRepo *repo, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); + g_return_val_if_fail (OSTREE_IS_REPO (repo), FALSE); + g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail (g_task_is_valid (result, repo), FALSE); + g_return_val_if_fail (g_async_result_is_tagged (result, _ostree_static_delta_part_execute_async), FALSE); - g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == _ostree_static_delta_part_execute_async); - - if (g_simple_async_result_propagate_error (simple, error)) - return FALSE; - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } static gboolean diff --git a/src/libostree/ostree-repo.c b/src/libostree/ostree-repo.c index a27591b3..54438b78 100644 --- a/src/libostree/ostree-repo.c +++ b/src/libostree/ostree-repo.c @@ -1,6 +1,7 @@ /* * Copyright (C) 2011 Colin Walters * Copyright (C) 2015 Red Hat, Inc. + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -1208,8 +1209,8 @@ ostree_repo_finalize (GObject *object) g_clear_pointer (&self->txn.refs, g_hash_table_destroy); g_clear_pointer (&self->txn.collection_refs, g_hash_table_destroy); g_clear_error (&self->writable_error); - g_clear_pointer (&self->object_sizes, (GDestroyNotify) g_hash_table_unref); - g_clear_pointer (&self->dirmeta_cache, (GDestroyNotify) g_hash_table_unref); + g_clear_pointer (&self->object_sizes, g_hash_table_unref); + g_clear_pointer (&self->dirmeta_cache, g_hash_table_unref); g_mutex_clear (&self->cache_lock); g_mutex_clear (&self->txn_lock); g_free (self->collection_id); @@ -2306,7 +2307,7 @@ ostree_repo_remote_gpg_import (OstreeRepo *self, goto out; } - g_clear_pointer (&data_buffer, (GDestroyNotify) gpgme_data_release); + g_clear_pointer (&data_buffer, gpgme_data_release); } /* Retrieve all keys or specific keys from the source GPGME context. @@ -3179,7 +3180,7 @@ reload_core_config (OstreeRepo *self, gboolean is_archive; gsize len; - g_clear_pointer (&self->config, (GDestroyNotify)g_key_file_unref); + g_clear_pointer (&self->config, g_key_file_unref); self->config = g_key_file_new (); contents = glnx_file_get_contents_utf8_at (self->repo_dir_fd, "config", &len, @@ -6274,7 +6275,7 @@ ostree_repo_regenerate_summary (OstreeRepo *self, g_autoptr(GHashTable) collection_map = NULL; /* (element-type utf8 GHashTable) */ g_hash_table_iter_init (&iter, collection_refs); collection_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, - (GDestroyNotify) g_hash_table_unref); + (GDestroyNotify)g_hash_table_unref); const OstreeCollectionRef *c_ref; const char *checksum; @@ -6594,7 +6595,7 @@ _ostree_repo_memory_cache_ref_destroy (OstreeRepoMemoryCacheRef *state) g_mutex_lock (lock); repo->dirmeta_cache_refcount--; if (repo->dirmeta_cache_refcount == 0) - g_clear_pointer (&repo->dirmeta_cache, (GDestroyNotify) g_hash_table_unref); + g_clear_pointer (&repo->dirmeta_cache, g_hash_table_unref); g_mutex_unlock (lock); g_object_unref (repo); } diff --git a/src/libostree/ostree-soup-form.c b/src/libostree/ostree-soup-form.c deleted file mode 100644 index dfaffb96..00000000 --- a/src/libostree/ostree-soup-form.c +++ /dev/null @@ -1,140 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ -/* soup-form.c : utility functions for HTML forms */ - -/* - * Copyright 2008 Red Hat, Inc. - */ - -/* This one is stripped down to only have soup_form_encode_hash() - * and soup_form_encode_valist() which are the only bits that soup-uri.c - * calls. - */ - -#include - -#include - -#include "ostree-soup-uri.h" - -/** - * SECTION:soup-form - * @short_description: HTML form handling - * @see_also: #SoupMultipart - * - * libsoup contains several help methods for processing HTML forms as - * defined by the - * HTML 4.01 specification. - **/ - -/** - * SOUP_FORM_MIME_TYPE_URLENCODED: - * - * A macro containing the value - * "application/x-www-form-urlencoded"; the default - * MIME type for POSTing HTML form data. - * - * Since: 2.26 - **/ - -/** - * SOUP_FORM_MIME_TYPE_MULTIPART: - * - * A macro containing the value - * "multipart/form-data"; the MIME type used for - * posting form data that contains files to be uploaded. - * - * Since: 2.26 - **/ - -#define XDIGIT(c) ((c) <= '9' ? (c) - '0' : ((c) & 0x4F) - 'A' + 10) -#define HEXCHAR(s) ((XDIGIT (s[1]) << 4) + XDIGIT (s[2])) - -static void -append_form_encoded (GString *str, const char *in) -{ - const unsigned char *s = (const unsigned char *)in; - - while (*s) { - if (*s == ' ') { - g_string_append_c (str, '+'); - s++; - } else if (!g_ascii_isalnum (*s) && (*s != '-') && (*s != '_') - && (*s != '.')) - g_string_append_printf (str, "%%%02X", (int)*s++); - else - g_string_append_c (str, *s++); - } -} - -static void -encode_pair (GString *str, const char *name, const char *value) -{ - g_return_if_fail (name != NULL); - g_return_if_fail (value != NULL); - - if (str->len) - g_string_append_c (str, '&'); - append_form_encoded (str, name); - g_string_append_c (str, '='); - append_form_encoded (str, value); -} - -/** - * soup_form_encode_hash: - * @form_data_set: (element-type utf8 utf8) (transfer none): a hash table containing - * name/value pairs (as strings) - * - * Encodes @form_data_set into a value of type - * "application/x-www-form-urlencoded", as defined in the HTML 4.01 - * spec. - * - * Note that the HTML spec states that "The control names/values are - * listed in the order they appear in the document." Since this method - * takes a hash table, it cannot enforce that; if you care about the - * ordering of the form fields, use soup_form_encode_datalist(). - * - * Return value: the encoded form - **/ -char * -soup_form_encode_hash (GHashTable *form_data_set) -{ - GString *str = g_string_new (NULL); - GHashTableIter iter; - gpointer name, value; - - g_hash_table_iter_init (&iter, form_data_set); - while (g_hash_table_iter_next (&iter, &name, &value)) - encode_pair (str, name, value); - return g_string_free (str, FALSE); -} - -/** - * soup_form_encode_valist: - * @first_field: name of the first form field - * @args: pointer to additional values, as in soup_form_encode() - * - * See soup_form_encode(). This is mostly an internal method, used by - * various other methods such as soup_uri_set_query_from_fields() and - * soup_form_request_new(). - * - * Return value: the encoded form - **/ -char * -soup_form_encode_valist (const char *first_field, va_list args) -{ - GString *str = g_string_new (NULL); - const char *name, *value; - - name = first_field; - value = va_arg (args, const char *); - while (name && value) { - encode_pair (str, name, value); - - name = va_arg (args, const char *); - if (name) - value = va_arg (args, const char *); - } - - return g_string_free (str, FALSE); -} diff --git a/src/libostree/ostree-soup-uri.c b/src/libostree/ostree-soup-uri.c deleted file mode 100644 index bfc5dd1a..00000000 --- a/src/libostree/ostree-soup-uri.c +++ /dev/null @@ -1,1438 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ -/* soup-uri.c : utility functions to parse URLs */ - -/* - * Copyright 1999-2003 Ximian, Inc. - */ - -#include "config.h" - -#include -#include - -#include "ostree-soup-uri.h" - -/* OSTREECHANGE: definitions from soup-misc-private.h */ -char *soup_uri_decoded_copy (const char *str, int length, int *decoded_length); -char *soup_uri_to_string_internal (SoupURI *uri, gboolean just_path_and_query, - gboolean force_port); - -/* OSTREECHANGE: import soup-misc's char helpers */ -#define SOUP_CHAR_URI_PERCENT_ENCODED 0x01 -#define SOUP_CHAR_URI_GEN_DELIMS 0x02 -#define SOUP_CHAR_URI_SUB_DELIMS 0x04 -#define SOUP_CHAR_HTTP_SEPARATOR 0x08 -#define SOUP_CHAR_HTTP_CTL 0x10 - -/* 00 URI_UNRESERVED - * 01 URI_PCT_ENCODED - * 02 URI_GEN_DELIMS - * 04 URI_SUB_DELIMS - * 08 HTTP_SEPARATOR - * 10 HTTP_CTL - */ -const char soup_char_attributes[] = { - /* 0x00 - 0x07 */ - 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, - /* 0x08 - 0x0f */ - 0x11, 0x19, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, - /* 0x10 - 0x17 */ - 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, - /* 0x18 - 0x1f */ - 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, - /* !"#$%&' */ - 0x09, 0x04, 0x09, 0x02, 0x04, 0x01, 0x04, 0x04, - /* ()*+,-./ */ - 0x0c, 0x0c, 0x04, 0x04, 0x0c, 0x00, 0x00, 0x0a, - /* 01234567 */ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* 89:;<=>? */ - 0x00, 0x00, 0x0a, 0x0c, 0x09, 0x0a, 0x09, 0x0a, - /* @ABCDEFG */ - 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* HIJKLMNO */ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* PQRSTUVW */ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* XYZ[\]^_ */ - 0x00, 0x00, 0x00, 0x0a, 0x09, 0x0a, 0x01, 0x00, - /* `abcdefg */ - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* hijklmno */ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* pqrstuvw */ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* xyz{|}~ */ - 0x00, 0x00, 0x00, 0x09, 0x01, 0x09, 0x00, 0x11, - /* 0x80 - 0xFF */ - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 -}; - -#define soup_char_is_uri_percent_encoded(ch) (soup_char_attributes[(guchar)ch] & SOUP_CHAR_URI_PERCENT_ENCODED) -#define soup_char_is_uri_gen_delims(ch) (soup_char_attributes[(guchar)ch] & SOUP_CHAR_URI_GEN_DELIMS) -#define soup_char_is_uri_sub_delims(ch) (soup_char_attributes[(guchar)ch] & SOUP_CHAR_URI_SUB_DELIMS) -#define soup_char_is_uri_unreserved(ch) (!(soup_char_attributes[(guchar)ch] & (SOUP_CHAR_URI_PERCENT_ENCODED | SOUP_CHAR_URI_GEN_DELIMS | SOUP_CHAR_URI_SUB_DELIMS))) -#define soup_char_is_token(ch) (!(soup_char_attributes[(guchar)ch] & (SOUP_CHAR_HTTP_SEPARATOR | SOUP_CHAR_HTTP_CTL))) - -/** - * soup_str_case_hash: - * @key: ASCII string to hash - * - * Hashes @key in a case-insensitive manner. - * - * Return value: the hash code. - **/ -static guint -soup_str_case_hash (gconstpointer key) -{ - const char *p = key; - guint h = g_ascii_toupper(*p); - - if (h) - for (p += 1; *p != '\0'; p++) - h = (h << 5) - h + g_ascii_toupper(*p); - - return h; -} - -/** - * SECTION:soup-uri - * @short_description: URIs - * - * A #SoupURI represents a (parsed) URI. - * - * Many applications will not need to use #SoupURI directly at all; on - * the client side, soup_message_new() takes a stringified URI, and on - * the server side, the path and query components are provided for you - * in the server callback. - **/ - -/** - * SoupURI: - * @scheme: the URI scheme (eg, "http") - * @user: a username, or %NULL - * @password: a password, or %NULL - * @host: the hostname or IP address - * @port: the port number on @host - * @path: the path on @host - * @query: a query for @path, or %NULL - * @fragment: a fragment identifier within @path, or %NULL - * - * A #SoupURI represents a (parsed) URI. #SoupURI supports RFC 3986 - * (URI Generic Syntax), and can parse any valid URI. However, libsoup - * only uses "http" and "https" URIs internally; You can use - * SOUP_URI_VALID_FOR_HTTP() to test if a #SoupURI is a valid HTTP - * URI. - * - * @scheme will always be set in any URI. It is an interned string and - * is always all lowercase. (If you parse a URI with a non-lowercase - * scheme, it will be converted to lowercase.) The macros - * %SOUP_URI_SCHEME_HTTP and %SOUP_URI_SCHEME_HTTPS provide the - * interned values for "http" and "https" and can be compared against - * URI @scheme values. - * - * @user and @password are parsed as defined in the older URI specs - * (ie, separated by a colon; RFC 3986 only talks about a single - * "userinfo" field). Note that @password is not included in the - * output of soup_uri_to_string(). libsoup does not normally use these - * fields; authentication is handled via #SoupSession signals. - * - * @host contains the hostname, and @port the port specified in the - * URI. If the URI doesn't contain a hostname, @host will be %NULL, - * and if it doesn't specify a port, @port may be 0. However, for - * "http" and "https" URIs, @host is guaranteed to be non-%NULL - * (trying to parse an http URI with no @host will return %NULL), and - * @port will always be non-0 (because libsoup knows the default value - * to use when it is not specified in the URI). - * - * @path is always non-%NULL. For http/https URIs, @path will never be - * an empty string either; if the input URI has no path, the parsed - * #SoupURI will have a @path of "/". - * - * @query and @fragment are optional for all URI types. - * soup_form_decode() may be useful for parsing @query. - * - * Note that @path, @query, and @fragment may contain - * %-encoded characters. soup_uri_new() calls - * soup_uri_normalize() on them, but not soup_uri_decode(). This is - * necessary to ensure that soup_uri_to_string() will generate a URI - * that has exactly the same meaning as the original. (In theory, - * #SoupURI should leave @user, @password, and @host partially-encoded - * as well, but this would be more annoying than useful.) - **/ - -/** - * SOUP_URI_IS_VALID: - * @uri: a #SoupURI - * - * Tests whether @uri is a valid #SoupURI; that is, that it is non-%NULL - * and its @scheme and @path members are also non-%NULL. - * - * This macro does not check whether http and https URIs have a non-%NULL - * @host member. - * - * Return value: %TRUE if @uri is valid for use. - * - * Since: 2.38 - **/ - -/** - * SOUP_URI_VALID_FOR_HTTP: - * @uri: a #SoupURI - * - * Tests if @uri is a valid #SoupURI for HTTP communication; that is, if - * it can be used to construct a #SoupMessage. - * - * Return value: %TRUE if @uri is a valid "http" or "https" URI. - * - * Since: 2.24 - **/ - -/** - * SOUP_URI_SCHEME_HTTP: - * - * "http" as an interned string; you can compare this directly to a - * #SoupURI's scheme field using - * ==. - */ -/** - * SOUP_URI_SCHEME_HTTPS: - * - * "https" as an interned string; you can compare this directly to a - * #SoupURI's scheme field using - * ==. - */ -/** - * SOUP_URI_SCHEME_FTP: - * - * "ftp" as an interned string; you can compare this directly to a - * #SoupURI's scheme field using - * ==. - * - * Since: 2.30 - */ -/** - * SOUP_URI_SCHEME_FILE: - * - * "file" as an interned string; you can compare this directly to a - * #SoupURI's scheme field using - * ==. - * - * Since: 2.30 - */ -/** - * SOUP_URI_SCHEME_DATA: - * - * "data" as an interned string; you can compare this directly to a - * #SoupURI's scheme field using - * ==. - * - * Since: 2.30 - */ -/** - * SOUP_URI_SCHEME_RESOURCE: - * - * "data" as an interned string; you can compare this directly to a - * #SoupURI's scheme field using - * ==. - * - * Since: 2.42 - */ -/** - * SOUP_URI_SCHEME_WS: - * - * "ws" (WebSocket) as an interned string; you can compare this - * directly to a #SoupURI's scheme field using - * ==. - * - * Since: 2.50 - */ -/** - * SOUP_URI_SCHEME_WSS: - * - * "wss" (WebSocket over TLS) as an interned string; you can compare - * this directly to a #SoupURI's scheme field using - * ==. - * - * Since: 2.50 - */ - -struct _SoupURI { - const char *scheme; - - char *user; - char *password; - - char *host; - guint port; - - char *path; - char *query; - - char *fragment; -}; - -static void append_uri_encoded (GString *str, const char *in, const char *extra_enc_chars); -static char *uri_normalized_copy (const char *str, int length, const char *unescape_extra); - -gpointer _SOUP_URI_SCHEME_HTTP, _SOUP_URI_SCHEME_HTTPS; -gpointer _SOUP_URI_SCHEME_WS, _SOUP_URI_SCHEME_WSS; -gpointer _SOUP_URI_SCHEME_FTP; -gpointer _SOUP_URI_SCHEME_FILE, _SOUP_URI_SCHEME_DATA, _SOUP_URI_SCHEME_RESOURCE; - -static inline const char * -soup_uri_parse_scheme (const char *scheme, int len) -{ - if (len == 4 && !g_ascii_strncasecmp (scheme, "http", len)) { - return SOUP_URI_SCHEME_HTTP; - } else if (len == 5 && !g_ascii_strncasecmp (scheme, "https", len)) { - return SOUP_URI_SCHEME_HTTPS; - } else if (len == 8 && !g_ascii_strncasecmp (scheme, "resource", len)) { - return SOUP_URI_SCHEME_RESOURCE; - } else if (len == 2 && !g_ascii_strncasecmp (scheme, "ws", len)) { - return SOUP_URI_SCHEME_WS; - } else if (len == 3 && !g_ascii_strncasecmp (scheme, "wss", len)) { - return SOUP_URI_SCHEME_WSS; - } else { - char *lower_scheme; - - lower_scheme = g_ascii_strdown (scheme, len); - scheme = g_intern_static_string (lower_scheme); - if (scheme != (const char *)lower_scheme) - g_free (lower_scheme); - return scheme; - } -} - -static inline guint -soup_scheme_default_port (const char *scheme) -{ - if (scheme == SOUP_URI_SCHEME_HTTP || scheme == SOUP_URI_SCHEME_WS) - return 80; - else if (scheme == SOUP_URI_SCHEME_HTTPS || scheme == SOUP_URI_SCHEME_WSS) - return 443; - else if (scheme == SOUP_URI_SCHEME_FTP) - return 21; - else - return 0; -} - -/** - * soup_uri_new_with_base: - * @base: a base URI - * @uri_string: the URI - * - * Parses @uri_string relative to @base. - * - * Return value: a parsed #SoupURI. - **/ -SoupURI * -soup_uri_new_with_base (SoupURI *base, const char *uri_string) -{ - SoupURI *uri, fixed_base; - const char *end, *hash, *colon, *at, *path, *question; - const char *c, *hostend; - gboolean remove_dot_segments = TRUE; - int len; - - g_return_val_if_fail (uri_string != NULL, NULL); - - /* Allow a %NULL path in @base, for compatibility */ - if (base && base->scheme && !base->path) { - g_warn_if_fail (SOUP_URI_IS_VALID (base)); - - memcpy (&fixed_base, base, sizeof (SoupURI)); - fixed_base.path = ""; - base = &fixed_base; - } - - g_return_val_if_fail (base == NULL || SOUP_URI_IS_VALID (base), NULL); - - /* First some cleanup steps (which are supposed to all be no-ops, - * but...). Skip initial whitespace, strip out internal tabs and - * line breaks, and ignore trailing whitespace. - */ - while (g_ascii_isspace (*uri_string)) - uri_string++; - - len = strcspn (uri_string, "\t\n\r"); - if (uri_string[len]) { - char *clean = g_malloc (strlen (uri_string) + 1), *d; - const char *s; - - for (s = uri_string, d = clean; *s; s++) { - if (*s != '\t' && *s != '\n' && *s != '\r') - *d++ = *s; - } - *d = '\0'; - - uri = soup_uri_new_with_base (base, clean); - g_free (clean); - return uri; - } - end = uri_string + len; - while (end > uri_string && g_ascii_isspace (end[-1])) - end--; - - uri = g_slice_new0 (SoupURI); - - /* Find fragment. */ - hash = strchr (uri_string, '#'); - if (hash) { - uri->fragment = uri_normalized_copy (hash + 1, end - hash + 1, - NULL); - end = hash; - } - - /* Find scheme */ - c = uri_string; - while (c < end && (g_ascii_isalpha (*c) || - (c > uri_string && (g_ascii_isdigit (*c) || - *c == '.' || - *c == '+' || - *c == '-')))) - c++; - - if (c > uri_string && *c == ':') { - uri->scheme = soup_uri_parse_scheme (uri_string, c - uri_string); - uri_string = c + 1; - } - - if (uri_string == end && !base && !uri->fragment) { - uri->path = g_strdup (""); - return uri; - } - - /* Check for authority */ - if (strncmp (uri_string, "//", 2) == 0) { - uri_string += 2; - - path = uri_string + strcspn (uri_string, "/?#"); - if (path > end) - path = end; - at = strchr (uri_string, '@'); - if (at && at < path) { - colon = strchr (uri_string, ':'); - if (colon && colon < at) { - uri->password = soup_uri_decoded_copy (colon + 1, - at - colon - 1, NULL); - } else { - uri->password = NULL; - colon = at; - } - - uri->user = soup_uri_decoded_copy (uri_string, - colon - uri_string, NULL); - uri_string = at + 1; - } else - uri->user = uri->password = NULL; - - /* Find host and port. */ - if (*uri_string == '[') { - const char *pct; - - uri_string++; - hostend = strchr (uri_string, ']'); - if (!hostend || hostend > path) { - soup_uri_free (uri); - return NULL; - } - if (*(hostend + 1) == ':') - colon = hostend + 1; - else - colon = NULL; - - pct = memchr (uri_string, '%', hostend - uri_string); - if (!pct || (pct[1] == '2' && pct[2] == '5')) { - uri->host = soup_uri_decoded_copy (uri_string, - hostend - uri_string, NULL); - } else - uri->host = g_strndup (uri_string, hostend - uri_string); - } else { - colon = memchr (uri_string, ':', path - uri_string); - hostend = colon ? colon : path; - uri->host = soup_uri_decoded_copy (uri_string, - hostend - uri_string, NULL); - } - - if (colon && colon != path - 1) { - char *portend; - uri->port = strtoul (colon + 1, &portend, 10); - if (portend != (char *)path) { - soup_uri_free (uri); - return NULL; - } - } - - uri_string = path; - } - - /* Find query */ - question = memchr (uri_string, '?', end - uri_string); - if (question) { - uri->query = uri_normalized_copy (question + 1, - end - (question + 1), - NULL); - end = question; - } - - if (end != uri_string) { - uri->path = uri_normalized_copy (uri_string, end - uri_string, - NULL); - } - - /* Apply base URI. This is spelled out in RFC 3986. */ - if (base && !uri->scheme && uri->host) - uri->scheme = base->scheme; - else if (base && !uri->scheme) { - uri->scheme = base->scheme; - uri->user = g_strdup (base->user); - uri->password = g_strdup (base->password); - uri->host = g_strdup (base->host); - uri->port = base->port; - - if (!uri->path) { - uri->path = g_strdup (base->path); - if (!uri->query) - uri->query = g_strdup (base->query); - remove_dot_segments = FALSE; - } else if (*uri->path != '/') { - char *newpath, *last; - - last = strrchr (base->path, '/'); - if (last) { - newpath = g_strdup_printf ("%.*s%s", - (int)(last + 1 - base->path), - base->path, - uri->path); - } else - newpath = g_strdup_printf ("/%s", uri->path); - - g_free (uri->path); - uri->path = newpath; - } - } - - if (remove_dot_segments && uri->path && *uri->path) { - char *p, *q; - - /* Remove "./" where "." is a complete segment. */ - for (p = uri->path + 1; *p; ) { - if (*(p - 1) == '/' && - *p == '.' && *(p + 1) == '/') - memmove (p, p + 2, strlen (p + 2) + 1); - else - p++; - } - /* Remove "." at end. */ - if (p > uri->path + 2 && - *(p - 1) == '.' && *(p - 2) == '/') - *(p - 1) = '\0'; - - /* Remove "/../" where != ".." */ - for (p = uri->path + 1; *p; ) { - if (!strncmp (p, "../", 3)) { - p += 3; - continue; - } - q = strchr (p + 1, '/'); - if (!q) - break; - if (strncmp (q, "/../", 4) != 0) { - p = q + 1; - continue; - } - memmove (p, q + 4, strlen (q + 4) + 1); - p = uri->path + 1; - } - /* Remove "/.." at end where != ".." */ - q = strrchr (uri->path, '/'); - if (q && !strcmp (q, "/..")) { - p = q - 1; - while (p > uri->path && *p != '/') - p--; - if (strncmp (p, "/../", 4) != 0) - *(p + 1) = 0; - } - - /* Remove extraneous initial "/.."s */ - while (!strncmp (uri->path, "/../", 4)) - memmove (uri->path, uri->path + 3, strlen (uri->path) - 2); - if (!strcmp (uri->path, "/..")) - uri->path[1] = '\0'; - } - - /* HTTP-specific stuff */ - if (uri->scheme == SOUP_URI_SCHEME_HTTP || - uri->scheme == SOUP_URI_SCHEME_HTTPS) { - if (!uri->path) - uri->path = g_strdup ("/"); - if (!SOUP_URI_VALID_FOR_HTTP (uri)) { - soup_uri_free (uri); - return NULL; - } - } - - if (uri->scheme == SOUP_URI_SCHEME_FTP) { - if (!uri->host) { - soup_uri_free (uri); - return NULL; - } - } - - if (!uri->port) - uri->port = soup_scheme_default_port (uri->scheme); - if (!uri->path) - uri->path = g_strdup (""); - - return uri; -} - -/** - * soup_uri_new: - * @uri_string: (allow-none): a URI - * - * Parses an absolute URI. - * - * You can also pass %NULL for @uri_string if you want to get back an - * "empty" #SoupURI that you can fill in by hand. (You will need to - * call at least soup_uri_set_scheme() and soup_uri_set_path(), since - * those fields are required.) - * - * Return value: (nullable): a #SoupURI, or %NULL if the given string - * was found to be invalid. - **/ -SoupURI * -soup_uri_new (const char *uri_string) -{ - SoupURI *uri; - - if (!uri_string) - return g_slice_new0 (SoupURI); - - uri = soup_uri_new_with_base (NULL, uri_string); - if (!uri) - return NULL; - if (!SOUP_URI_IS_VALID (uri)) { - soup_uri_free (uri); - return NULL; - } - - return uri; -} - - -char * -soup_uri_to_string_internal (SoupURI *uri, gboolean just_path_and_query, - gboolean force_port) -{ - GString *str; - char *return_result; - - g_return_val_if_fail (uri != NULL, NULL); - g_warn_if_fail (SOUP_URI_IS_VALID (uri)); - - str = g_string_sized_new (40); - - if (uri->scheme && !just_path_and_query) - g_string_append_printf (str, "%s:", uri->scheme); - if (uri->host && !just_path_and_query) { - g_string_append (str, "//"); - if (uri->user) { - append_uri_encoded (str, uri->user, ":;@?/"); - g_string_append_c (str, '@'); - } - if (strchr (uri->host, ':')) { - const char *pct; - - g_string_append_c (str, '['); - pct = strchr (uri->host, '%'); - if (pct) { - g_string_append_printf (str, "%.*s%%25%s", - (int) (pct - uri->host), - uri->host, pct + 1); - } else - g_string_append (str, uri->host); - g_string_append_c (str, ']'); - } else - append_uri_encoded (str, uri->host, ":/"); - if (uri->port && (force_port || uri->port != soup_scheme_default_port (uri->scheme))) - g_string_append_printf (str, ":%u", uri->port); - if (!uri->path && (uri->query || uri->fragment)) - g_string_append_c (str, '/'); - else if ((!uri->path || !*uri->path) && - (uri->scheme == SOUP_URI_SCHEME_HTTP || - uri->scheme == SOUP_URI_SCHEME_HTTPS)) - g_string_append_c (str, '/'); - } - - if (uri->path && *uri->path) - g_string_append (str, uri->path); - else if (just_path_and_query) - g_string_append_c (str, '/'); - - if (uri->query) { - g_string_append_c (str, '?'); - g_string_append (str, uri->query); - } - if (uri->fragment && !just_path_and_query) { - g_string_append_c (str, '#'); - g_string_append (str, uri->fragment); - } - - return_result = str->str; - g_string_free (str, FALSE); - - return return_result; -} - -/** - * soup_uri_to_string: - * @uri: a #SoupURI - * @just_path_and_query: if %TRUE, output just the path and query portions - * - * Returns a string representing @uri. - * - * If @just_path_and_query is %TRUE, this concatenates the path and query - * together. That is, it constructs the string that would be needed in - * the Request-Line of an HTTP request for @uri. - * - * Note that the output will never contain a password, even if @uri - * does. - * - * Return value: a string representing @uri, which the caller must free. - **/ -char * -soup_uri_to_string (SoupURI *uri, gboolean just_path_and_query) -{ - return soup_uri_to_string_internal (uri, just_path_and_query, FALSE); -} - -/** - * soup_uri_copy: - * @uri: a #SoupURI - * - * Copies @uri - * - * Return value: a copy of @uri, which must be freed with soup_uri_free() - **/ -SoupURI * -soup_uri_copy (SoupURI *uri) -{ - SoupURI *dup; - - g_return_val_if_fail (uri != NULL, NULL); - g_warn_if_fail (SOUP_URI_IS_VALID (uri)); - - dup = g_slice_new0 (SoupURI); - dup->scheme = uri->scheme; - dup->user = g_strdup (uri->user); - dup->password = g_strdup (uri->password); - dup->host = g_strdup (uri->host); - dup->port = uri->port; - dup->path = g_strdup (uri->path); - dup->query = g_strdup (uri->query); - dup->fragment = g_strdup (uri->fragment); - - return dup; -} - -static inline gboolean -parts_equal (const char *one, const char *two, gboolean insensitive) -{ - if (!one && !two) - return TRUE; - if (!one || !two) - return FALSE; - return insensitive ? !g_ascii_strcasecmp (one, two) : !strcmp (one, two); -} - -/** - * soup_uri_equal: - * @uri1: a #SoupURI - * @uri2: another #SoupURI - * - * Tests whether or not @uri1 and @uri2 are equal in all parts - * - * Return value: %TRUE or %FALSE - **/ -gboolean -soup_uri_equal (SoupURI *uri1, SoupURI *uri2) -{ - g_return_val_if_fail (uri1 != NULL, FALSE); - g_return_val_if_fail (uri2 != NULL, FALSE); - g_warn_if_fail (SOUP_URI_IS_VALID (uri1)); - g_warn_if_fail (SOUP_URI_IS_VALID (uri2)); - - if (uri1->scheme != uri2->scheme || - uri1->port != uri2->port || - !parts_equal (uri1->user, uri2->user, FALSE) || - !parts_equal (uri1->password, uri2->password, FALSE) || - !parts_equal (uri1->host, uri2->host, TRUE) || - !parts_equal (uri1->path, uri2->path, FALSE) || - !parts_equal (uri1->query, uri2->query, FALSE) || - !parts_equal (uri1->fragment, uri2->fragment, FALSE)) - return FALSE; - - return TRUE; -} - -/** - * soup_uri_free: - * @uri: a #SoupURI - * - * Frees @uri. - **/ -void -soup_uri_free (SoupURI *uri) -{ - g_return_if_fail (uri != NULL); - - g_free (uri->user); - g_free (uri->password); - g_free (uri->host); - g_free (uri->path); - g_free (uri->query); - g_free (uri->fragment); - - g_slice_free (SoupURI, uri); -} - -static void -append_uri_encoded (GString *str, const char *in, const char *extra_enc_chars) -{ - const unsigned char *s = (const unsigned char *)in; - - while (*s) { - if (soup_char_is_uri_percent_encoded (*s) || - soup_char_is_uri_gen_delims (*s) || - (extra_enc_chars && strchr (extra_enc_chars, *s))) - g_string_append_printf (str, "%%%02X", (int)*s++); - else - g_string_append_c (str, *s++); - } -} - -/** - * soup_uri_encode: - * @part: a URI part - * @escape_extra: (allow-none): additional reserved characters to - * escape (or %NULL) - * - * This %-encodes the given URI part and returns the escaped - * version in allocated memory, which the caller must free when it is - * done. - * - * Return value: the encoded URI part - **/ -char * -soup_uri_encode (const char *part, const char *escape_extra) -{ - GString *str; - char *encoded; - - g_return_val_if_fail (part != NULL, NULL); - - str = g_string_new (NULL); - append_uri_encoded (str, part, escape_extra); - encoded = str->str; - g_string_free (str, FALSE); - - return encoded; -} - -#define XDIGIT(c) ((c) <= '9' ? (c) - '0' : ((c) & 0x4F) - 'A' + 10) -#define HEXCHAR(s) ((XDIGIT (s[1]) << 4) + XDIGIT (s[2])) - -char * -soup_uri_decoded_copy (const char *part, int length, int *decoded_length) -{ - unsigned char *s, *d; - char *decoded; - - g_return_val_if_fail (part != NULL, NULL); - - decoded = g_strndup (part, length); - s = d = (unsigned char *)decoded; - do { - if (*s == '%') { - if (!g_ascii_isxdigit (s[1]) || - !g_ascii_isxdigit (s[2])) { - *d++ = *s; - continue; - } - *d++ = HEXCHAR (s); - s += 2; - } else - *d++ = *s; - } while (*s++); - - if (decoded_length) - *decoded_length = d - (unsigned char *)decoded - 1; - - return decoded; -} - -/** - * soup_uri_decode: - * @part: a URI part - * - * Fully %-decodes @part. - * - * In the past, this would return %NULL if @part contained invalid - * percent-encoding, but now it just ignores the problem (as - * soup_uri_new() already did). - * - * Return value: the decoded URI part. - */ -char * -soup_uri_decode (const char *part) -{ - g_return_val_if_fail (part != NULL, NULL); - - return soup_uri_decoded_copy (part, strlen (part), NULL); -} - -static char * -uri_normalized_copy (const char *part, int length, - const char *unescape_extra) -{ - unsigned char *s, *d, c; - char *normalized = g_strndup (part, length); - gboolean need_fixup = FALSE; - - if (!unescape_extra) - unescape_extra = ""; - - s = d = (unsigned char *)normalized; - while (*s) { - if (*s == '%') { - if (!g_ascii_isxdigit (s[1]) || - !g_ascii_isxdigit (s[2])) { - *d++ = *s++; - continue; - } - - c = HEXCHAR (s); - if (soup_char_is_uri_unreserved (c) || - (c && strchr (unescape_extra, c))) { - *d++ = c; - s += 3; - } else { - /* We leave it unchanged. We used to uppercase percent-encoded - * triplets but we do not do it any more as RFC3986 Section 6.2.2.1 - * says that they only SHOULD be case normalized. - */ - *d++ = *s++; - *d++ = *s++; - *d++ = *s++; - } - } else { - if (!g_ascii_isgraph (*s) && - !strchr (unescape_extra, *s)) - need_fixup = TRUE; - *d++ = *s++; - } - } - *d = '\0'; - - if (need_fixup) { - GString *fixed; - - fixed = g_string_new (NULL); - s = (guchar *)normalized; - while (*s) { - if (g_ascii_isgraph (*s) || - strchr (unescape_extra, *s)) - g_string_append_c (fixed, *s); - else - g_string_append_printf (fixed, "%%%02X", (int)*s); - s++; - } - g_free (normalized); - normalized = g_string_free (fixed, FALSE); - } - - return normalized; -} - -/** - * soup_uri_normalize: - * @part: a URI part - * @unescape_extra: (allow-none): reserved characters to unescape (or %NULL) - * - * %-decodes any "unreserved" characters (or characters in - * @unescape_extra) in @part, and %-encodes any non-ASCII - * characters, spaces, and non-printing characters in @part. - * - * "Unreserved" characters are those that are not allowed to be used - * for punctuation according to the URI spec. For example, letters are - * unreserved, so soup_uri_normalize() will turn - * http://example.com/foo/b%61r into - * http://example.com/foo/bar, which is guaranteed - * to mean the same thing. However, "/" is "reserved", so - * http://example.com/foo%2Fbar would not - * be changed, because it might mean something different to the - * server. - * - * In the past, this would return %NULL if @part contained invalid - * percent-encoding, but now it just ignores the problem (as - * soup_uri_new() already did). - * - * Return value: the normalized URI part - */ -char * -soup_uri_normalize (const char *part, const char *unescape_extra) -{ - g_return_val_if_fail (part != NULL, NULL); - - return uri_normalized_copy (part, strlen (part), unescape_extra); -} - - -/** - * soup_uri_uses_default_port: - * @uri: a #SoupURI - * - * Tests if @uri uses the default port for its scheme. (Eg, 80 for - * http.) (This only works for http, https and ftp; libsoup does not know - * the default ports of other protocols.) - * - * Return value: %TRUE or %FALSE - **/ -gboolean -soup_uri_uses_default_port (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, FALSE); - g_warn_if_fail (SOUP_URI_IS_VALID (uri)); - - return uri->port == soup_scheme_default_port (uri->scheme); -} - -/** - * soup_uri_get_scheme: - * @uri: a #SoupURI - * - * Gets @uri's scheme. - * - * Return value: @uri's scheme. - * - * Since: 2.32 - **/ -const char * -soup_uri_get_scheme (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, NULL); - - return uri->scheme; -} - -/** - * soup_uri_set_scheme: - * @uri: a #SoupURI - * @scheme: the URI scheme - * - * Sets @uri's scheme to @scheme. This will also set @uri's port to - * the default port for @scheme, if known. - **/ -void -soup_uri_set_scheme (SoupURI *uri, const char *scheme) -{ - g_return_if_fail (uri != NULL); - g_return_if_fail (scheme != NULL); - - uri->scheme = soup_uri_parse_scheme (scheme, strlen (scheme)); - uri->port = soup_scheme_default_port (uri->scheme); -} - -/** - * soup_uri_get_user: - * @uri: a #SoupURI - * - * Gets @uri's user. - * - * Return value: @uri's user. - * - * Since: 2.32 - **/ -const char * -soup_uri_get_user (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, NULL); - - return uri->user; -} - -/** - * soup_uri_set_user: - * @uri: a #SoupURI - * @user: (allow-none): the username, or %NULL - * - * Sets @uri's user to @user. - **/ -void -soup_uri_set_user (SoupURI *uri, const char *user) -{ - g_return_if_fail (uri != NULL); - - g_free (uri->user); - uri->user = g_strdup (user); -} - -/** - * soup_uri_get_password: - * @uri: a #SoupURI - * - * Gets @uri's password. - * - * Return value: @uri's password. - * - * Since: 2.32 - **/ -const char * -soup_uri_get_password (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, NULL); - - return uri->password; -} - -/** - * soup_uri_set_password: - * @uri: a #SoupURI - * @password: (allow-none): the password, or %NULL - * - * Sets @uri's password to @password. - **/ -void -soup_uri_set_password (SoupURI *uri, const char *password) -{ - g_return_if_fail (uri != NULL); - - g_free (uri->password); - uri->password = g_strdup (password); -} - -/** - * soup_uri_get_host: - * @uri: a #SoupURI - * - * Gets @uri's host. - * - * Return value: @uri's host. - * - * Since: 2.32 - **/ -const char * -soup_uri_get_host (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, NULL); - - return uri->host; -} - -/** - * soup_uri_set_host: - * @uri: a #SoupURI - * @host: (allow-none): the hostname or IP address, or %NULL - * - * Sets @uri's host to @host. - * - * If @host is an IPv6 IP address, it should not include the brackets - * required by the URI syntax; they will be added automatically when - * converting @uri to a string. - * - * http and https URIs should not have a %NULL @host. - **/ -void -soup_uri_set_host (SoupURI *uri, const char *host) -{ - g_return_if_fail (uri != NULL); - - g_free (uri->host); - uri->host = g_strdup (host); -} - -/** - * soup_uri_get_port: - * @uri: a #SoupURI - * - * Gets @uri's port. - * - * Return value: @uri's port. - * - * Since: 2.32 - **/ -guint -soup_uri_get_port (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, 0); - - return uri->port; -} - -/** - * soup_uri_set_port: - * @uri: a #SoupURI - * @port: the port, or 0 - * - * Sets @uri's port to @port. If @port is 0, @uri will not have an - * explicitly-specified port. - **/ -void -soup_uri_set_port (SoupURI *uri, guint port) -{ - g_return_if_fail (uri != NULL); - - uri->port = port; -} - -/** - * soup_uri_get_path: - * @uri: a #SoupURI - * - * Gets @uri's path. - * - * Return value: @uri's path. - * - * Since: 2.32 - **/ -const char * -soup_uri_get_path (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, NULL); - - return uri->path; -} - -/** - * soup_uri_set_path: - * @uri: a #SoupURI - * @path: the non-%NULL path - * - * Sets @uri's path to @path. - **/ -void -soup_uri_set_path (SoupURI *uri, const char *path) -{ - g_return_if_fail (uri != NULL); - - /* We allow a NULL path for compatibility, but warn about it. */ - if (!path) { - g_warn_if_fail (path != NULL); - path = ""; - } - - g_free (uri->path); - uri->path = g_strdup (path); -} - -/** - * soup_uri_get_query: - * @uri: a #SoupURI - * - * Gets @uri's query. - * - * Return value: @uri's query. - * - * Since: 2.32 - **/ -const char * -soup_uri_get_query (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, NULL); - - return uri->query; -} - -/** - * soup_uri_set_query: - * @uri: a #SoupURI - * @query: (allow-none): the query - * - * Sets @uri's query to @query. - **/ -void -soup_uri_set_query (SoupURI *uri, const char *query) -{ - g_return_if_fail (uri != NULL); - - g_free (uri->query); - uri->query = g_strdup (query); -} - -/** - * soup_uri_set_query_from_form: - * @uri: a #SoupURI - * @form: (element-type utf8 utf8) (transfer none): a #GHashTable containing HTML form - * information - * - * Sets @uri's query to the result of encoding @form according to the - * HTML form rules. See soup_form_encode_hash() for more information. - **/ -void -soup_uri_set_query_from_form (SoupURI *uri, GHashTable *form) -{ - g_return_if_fail (uri != NULL); - - g_free (uri->query); - uri->query = soup_form_encode_hash (form); -} - -/** - * soup_uri_set_query_from_fields: - * @uri: a #SoupURI - * @first_field: name of the first form field to encode into query - * @...: value of @first_field, followed by additional field names - * and values, terminated by %NULL. - * - * Sets @uri's query to the result of encoding the given form fields - * and values according to the * HTML form rules. See - * soup_form_encode() for more information. - **/ -void -soup_uri_set_query_from_fields (SoupURI *uri, - const char *first_field, - ...) -{ - va_list args; - - g_return_if_fail (uri != NULL); - - g_free (uri->query); - va_start (args, first_field); - uri->query = soup_form_encode_valist (first_field, args); - va_end (args); -} - -/** - * soup_uri_get_fragment: - * @uri: a #SoupURI - * - * Gets @uri's fragment. - * - * Return value: @uri's fragment. - * - * Since: 2.32 - **/ -const char * -soup_uri_get_fragment (SoupURI *uri) -{ - g_return_val_if_fail (uri != NULL, NULL); - - return uri->fragment; -} - -/** - * soup_uri_set_fragment: - * @uri: a #SoupURI - * @fragment: (allow-none): the fragment - * - * Sets @uri's fragment to @fragment. - **/ -void -soup_uri_set_fragment (SoupURI *uri, const char *fragment) -{ - g_return_if_fail (uri != NULL); - - g_free (uri->fragment); - uri->fragment = g_strdup (fragment); -} - -/** - * soup_uri_copy_host: - * @uri: a #SoupURI - * - * Makes a copy of @uri, considering only the protocol, host, and port - * - * Return value: the new #SoupURI - * - * Since: 2.28 - **/ -SoupURI * -soup_uri_copy_host (SoupURI *uri) -{ - SoupURI *dup; - - g_return_val_if_fail (uri != NULL, NULL); - g_warn_if_fail (SOUP_URI_IS_VALID (uri)); - - dup = soup_uri_new (NULL); - dup->scheme = uri->scheme; - dup->host = g_strdup (uri->host); - dup->port = uri->port; - dup->path = g_strdup (""); - - return dup; -} - -/** - * soup_uri_host_hash: - * @key: (type Soup.URI): a #SoupURI with a non-%NULL @host member - * - * Hashes @key, considering only the scheme, host, and port. - * - * Return value: a hash - * - * Since: 2.28 - **/ -guint -soup_uri_host_hash (gconstpointer key) -{ - const SoupURI *uri = key; - - g_return_val_if_fail (uri != NULL && uri->host != NULL, 0); - g_warn_if_fail (SOUP_URI_IS_VALID (uri)); - - return GPOINTER_TO_UINT (uri->scheme) + uri->port + - soup_str_case_hash (uri->host); -} - -/** - * soup_uri_host_equal: - * @v1: (type Soup.URI): a #SoupURI with a non-%NULL @host member - * @v2: (type Soup.URI): a #SoupURI with a non-%NULL @host member - * - * Compares @v1 and @v2, considering only the scheme, host, and port. - * - * Return value: whether or not the URIs are equal in scheme, host, - * and port. - * - * Since: 2.28 - **/ -gboolean -soup_uri_host_equal (gconstpointer v1, gconstpointer v2) -{ - const SoupURI *one = v1; - const SoupURI *two = v2; - - g_return_val_if_fail (one != NULL && two != NULL, one == two); - g_return_val_if_fail (one->host != NULL && two->host != NULL, one->host == two->host); - g_warn_if_fail (SOUP_URI_IS_VALID (one)); - g_warn_if_fail (SOUP_URI_IS_VALID (two)); - - if (one->scheme != two->scheme) - return FALSE; - if (one->port != two->port) - return FALSE; - - return g_ascii_strcasecmp (one->host, two->host) == 0; -} - -/* OSTREECHANGE: drop boxed type definition */ -/* G_DEFINE_BOXED_TYPE (SoupURI, soup_uri, soup_uri_copy, soup_uri_free) */ diff --git a/src/libostree/ostree-soup-uri.h b/src/libostree/ostree-soup-uri.h deleted file mode 100644 index 650b7efc..00000000 --- a/src/libostree/ostree-soup-uri.h +++ /dev/null @@ -1,147 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ - -/* - * Copyright 1999-2002 Ximian, Inc. - */ - -/* NOTE - taken from the libsoup codebase for use by the ostree curl backend - * (yes, ironically enough). - * - * Please watch for future changes in libsoup. - */ - - -#ifndef SOUP_URI_H -#define SOUP_URI_H 1 - -/* OSTREECHANGE: make struct private - * Only include gio, and skip available definitions. - */ -#include -#define SOUP_AVAILABLE_IN_2_4 -#define SOUP_AVAILABLE_IN_2_28 -#define SOUP_AVAILABLE_IN_2_32 - -G_BEGIN_DECLS - -/* OSTREECHANGE: make struct private */ -typedef struct _SoupURI SoupURI; - -/* OSTREECHANGE: import soup-misc's interning */ -#define SOUP_VAR extern -#define _SOUP_ATOMIC_INTERN_STRING(variable, value) ((const char *)(g_atomic_pointer_get (&(variable)) ? (variable) : (g_atomic_pointer_set (&(variable), (gpointer)g_intern_static_string (value)), (variable)))) -#define SOUP_URI_SCHEME_HTTP _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_HTTP, "http") -#define SOUP_URI_SCHEME_HTTPS _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_HTTPS, "https") -#define SOUP_URI_SCHEME_FTP _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_FTP, "ftp") -#define SOUP_URI_SCHEME_FILE _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_FILE, "file") -#define SOUP_URI_SCHEME_DATA _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_DATA, "data") -#define SOUP_URI_SCHEME_RESOURCE _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_RESOURCE, "resource") -#define SOUP_URI_SCHEME_WS _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_WS, "ws") -#define SOUP_URI_SCHEME_WSS _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_WSS, "wss") - -/* OSTREECHANGE: import soup-form bits */ -SOUP_AVAILABLE_IN_2_4 -char *soup_form_encode_hash (GHashTable *form_data_set); -SOUP_AVAILABLE_IN_2_4 -char *soup_form_encode_valist (const char *first_field, - va_list args); - -SOUP_VAR gpointer _SOUP_URI_SCHEME_HTTP, _SOUP_URI_SCHEME_HTTPS; -SOUP_VAR gpointer _SOUP_URI_SCHEME_FTP; -SOUP_VAR gpointer _SOUP_URI_SCHEME_FILE, _SOUP_URI_SCHEME_DATA, _SOUP_URI_SCHEME_RESOURCE; -SOUP_VAR gpointer _SOUP_URI_SCHEME_WS, _SOUP_URI_SCHEME_WSS; - -SOUP_AVAILABLE_IN_2_4 -SoupURI *soup_uri_new_with_base (SoupURI *base, - const char *uri_string); -SOUP_AVAILABLE_IN_2_4 -SoupURI *soup_uri_new (const char *uri_string); - -SOUP_AVAILABLE_IN_2_4 -char *soup_uri_to_string (SoupURI *uri, - gboolean just_path_and_query); - -SOUP_AVAILABLE_IN_2_4 -SoupURI *soup_uri_copy (SoupURI *uri); - -SOUP_AVAILABLE_IN_2_4 -gboolean soup_uri_equal (SoupURI *uri1, - SoupURI *uri2); - -SOUP_AVAILABLE_IN_2_4 -void soup_uri_free (SoupURI *uri); - -SOUP_AVAILABLE_IN_2_4 -char *soup_uri_encode (const char *part, - const char *escape_extra); -SOUP_AVAILABLE_IN_2_4 -char *soup_uri_decode (const char *part); -SOUP_AVAILABLE_IN_2_4 -char *soup_uri_normalize (const char *part, - const char *unescape_extra); - -SOUP_AVAILABLE_IN_2_4 -gboolean soup_uri_uses_default_port (SoupURI *uri); - -SOUP_AVAILABLE_IN_2_32 -const char *soup_uri_get_scheme (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_scheme (SoupURI *uri, - const char *scheme); -SOUP_AVAILABLE_IN_2_32 -const char *soup_uri_get_user (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_user (SoupURI *uri, - const char *user); -SOUP_AVAILABLE_IN_2_32 -const char *soup_uri_get_password (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_password (SoupURI *uri, - const char *password); -SOUP_AVAILABLE_IN_2_32 -const char *soup_uri_get_host (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_host (SoupURI *uri, - const char *host); -SOUP_AVAILABLE_IN_2_32 -guint soup_uri_get_port (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_port (SoupURI *uri, - guint port); -SOUP_AVAILABLE_IN_2_32 -const char *soup_uri_get_path (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_path (SoupURI *uri, - const char *path); -SOUP_AVAILABLE_IN_2_32 -const char *soup_uri_get_query (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_query (SoupURI *uri, - const char *query); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_query_from_form (SoupURI *uri, - GHashTable *form); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_query_from_fields (SoupURI *uri, - const char *first_field, - ...) G_GNUC_NULL_TERMINATED; -SOUP_AVAILABLE_IN_2_32 -const char *soup_uri_get_fragment (SoupURI *uri); -SOUP_AVAILABLE_IN_2_4 -void soup_uri_set_fragment (SoupURI *uri, - const char *fragment); - -SOUP_AVAILABLE_IN_2_28 -SoupURI *soup_uri_copy_host (SoupURI *uri); -SOUP_AVAILABLE_IN_2_28 -guint soup_uri_host_hash (gconstpointer key); -SOUP_AVAILABLE_IN_2_28 -gboolean soup_uri_host_equal (gconstpointer v1, - gconstpointer v2); - -#define SOUP_URI_IS_VALID(uri) ((uri) && (uri)->scheme && (uri)->path) -#define SOUP_URI_VALID_FOR_HTTP(uri) ((uri) && ((uri)->scheme == SOUP_URI_SCHEME_HTTP || (uri)->scheme == SOUP_URI_SCHEME_HTTPS) && (uri)->host && (uri)->path) - -G_END_DECLS - -#endif /*SOUP_URI_H*/ diff --git a/src/libostree/ostree-sysroot.c b/src/libostree/ostree-sysroot.c index 266a2975..0e0521da 100644 --- a/src/libostree/ostree-sysroot.c +++ b/src/libostree/ostree-sysroot.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2013 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -82,7 +83,7 @@ ostree_sysroot_finalize (GObject *object) g_clear_pointer (&self->deployments, g_ptr_array_unref); g_clear_object (&self->booted_deployment); g_clear_object (&self->staged_deployment); - g_clear_pointer (&self->staged_deployment_data, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&self->staged_deployment_data, g_variant_unref); glnx_release_lock_file (&self->lock); @@ -1016,7 +1017,7 @@ _ostree_sysroot_reload_staged (OstreeSysroot *self, g_assert (self->booted_deployment); g_clear_object (&self->staged_deployment); - g_clear_pointer (&self->staged_deployment_data, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&self->staged_deployment_data, g_variant_unref); /* Read the staged state from disk */ glnx_autofd int fd = -1; diff --git a/src/libotutil/ot-checksum-instream.c b/src/libotutil/ot-checksum-instream.c index 6555eb8a..e89d68e4 100644 --- a/src/libotutil/ot-checksum-instream.c +++ b/src/libotutil/ot-checksum-instream.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2017 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -22,12 +23,12 @@ #include "ot-checksum-instream.h" #include "ot-checksum-utils.h" -G_DEFINE_TYPE (OtChecksumInstream, ot_checksum_instream, G_TYPE_FILTER_INPUT_STREAM) - struct _OtChecksumInstreamPrivate { OtChecksum checksum; }; +G_DEFINE_TYPE_WITH_PRIVATE (OtChecksumInstream, ot_checksum_instream, G_TYPE_FILTER_INPUT_STREAM) + static gssize ot_checksum_instream_read (GInputStream *stream, void *buffer, gsize count, @@ -50,8 +51,6 @@ ot_checksum_instream_class_init (OtChecksumInstreamClass *klass) GObjectClass *object_class = G_OBJECT_CLASS (klass); GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass); - g_type_class_add_private (klass, sizeof (OtChecksumInstreamPrivate)); - object_class->finalize = ot_checksum_instream_finalize; stream_class->read_fn = ot_checksum_instream_read; } @@ -59,7 +58,7 @@ ot_checksum_instream_class_init (OtChecksumInstreamClass *klass) static void ot_checksum_instream_init (OtChecksumInstream *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, OT_TYPE_CHECKSUM_INSTREAM, OtChecksumInstreamPrivate); + self->priv = ot_checksum_instream_get_instance_private (self); } OtChecksumInstream * diff --git a/src/libotutil/ot-gpg-utils.c b/src/libotutil/ot-gpg-utils.c index 63d6e503..fd65e120 100644 --- a/src/libotutil/ot-gpg-utils.c +++ b/src/libotutil/ot-gpg-utils.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2015 Red Hat, Inc. + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -129,7 +130,7 @@ ot_gpgme_ctx_tmp_home_dir (gpgme_ctx_t gpgme_ctx, goto out; /* Sneaky cast from GFileOutputStream to GOutputStream. */ - *out_pubring_stream = g_steal_pointer (&pubring_stream); + *out_pubring_stream = (GOutputStream *)g_steal_pointer (&pubring_stream); } if (out_tmp_home_dir != NULL) diff --git a/src/ostree/ot-builtin-fsck.c b/src/ostree/ot-builtin-fsck.c index 8e3266a1..042b157d 100644 --- a/src/ostree/ot-builtin-fsck.c +++ b/src/ostree/ot-builtin-fsck.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -419,7 +420,7 @@ ostree_builtin_fsck (int argc, char **argv, OstreeCommandInvocation *invocation, } } - g_clear_pointer (&objects, (GDestroyNotify) g_hash_table_unref); + g_clear_pointer (&objects, g_hash_table_unref); if (!opt_quiet) g_print ("Verifying content integrity of %u commit objects...\n", diff --git a/src/ostree/ot-builtin-prune.c b/src/ostree/ot-builtin-prune.c index b2dd407a..73dfe5e5 100644 --- a/src/ostree/ot-builtin-prune.c +++ b/src/ostree/ot-builtin-prune.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2011 Colin Walters + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -133,7 +134,7 @@ traverse_keep_younger_than (OstreeRepo *repo, const char *checksum, g_free (next_checksum); next_checksum = ostree_commit_get_parent (commit); if (next_checksum) - g_clear_pointer (&commit, (GDestroyNotify)g_variant_unref); + g_clear_pointer (&commit, g_variant_unref); else break; /* No parent, we're done */ } diff --git a/tests/repo-finder-mount.c b/tests/repo-finder-mount.c index 184148cc..66c4ecd7 100644 --- a/tests/repo-finder-mount.c +++ b/tests/repo-finder-mount.c @@ -1,5 +1,6 @@ /* * Copyright © 2017 Endless Mobile, Inc. + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -47,7 +48,7 @@ result_cb (GObject *source_object, static void collection_ref_free0 (OstreeCollectionRef *ref) { - g_clear_pointer (&ref, (GDestroyNotify) ostree_collection_ref_free); + g_clear_pointer (&ref, ostree_collection_ref_free); } int diff --git a/tests/test-mock-gio.c b/tests/test-mock-gio.c index bf7f5fcb..719dc6cd 100644 --- a/tests/test-mock-gio.c +++ b/tests/test-mock-gio.c @@ -1,5 +1,6 @@ /* * Copyright © 2017 Endless Mobile, Inc. + * Copyright (C) 2022 Igalia S.L. * * SPDX-License-Identifier: LGPL-2.0+ * @@ -136,7 +137,7 @@ ostree_mock_volume_monitor_new (GList *mounts, monitor->mounts = g_list_copy_deep (mounts, (GCopyFunc) g_object_ref, NULL); monitor->volumes = g_list_copy_deep (volumes, (GCopyFunc) g_object_ref, NULL); - return g_steal_pointer (&monitor); + return (GVolumeMonitor *)g_steal_pointer (&monitor); } /* Mock volume class. This returns a static set of data to the caller, which it