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)
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
-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)
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
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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,
{
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;
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);
}
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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,
{
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;
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 *
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
} 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
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);
}
/**
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);
+
+ data = g_task_propagate_pointer (G_TASK (result), error);
- if (g_simple_async_result_propagate_error (simple, 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;
/*
* Copyright (C) 2016 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
#include "ostree-repo-private.h"
#include "otutil.h"
-#include "ostree-soup-uri.h"
-
typedef struct FetcherRequest FetcherRequest;
typedef struct SockInfo SockInfo;
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);
}
}
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);
}
}
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);
{
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)
{
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);
}
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.
*/
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);
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))
_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 =
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);
}
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 */
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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);
{
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);
}
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)
/*
* Copyright (C) 2011,2017 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
#include "config.h"
-
-#ifdef HAVE_LIBCURL
-#include "ostree-soup-uri.h"
-#else
-#define LIBSOUP_USE_UNSTABLE_REQUEST_API
-#include <libsoup/soup.h>
-#include <libsoup/soup-requester.h>
-#include <libsoup/soup-request-http.h>
-#endif
+#include <glib.h>
#include "ostree-fetcher.h"
_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 *
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 *
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);
}
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")))
{
/*
* Copyright (C) 2017 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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;
}
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
* Copyright (C) 2013 Sjoerd Simons <sjoerd.simons@collabora.co.uk>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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);
}
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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,
{
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;
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 *
/*
* Copyright (C) 2014 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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);
}
/*
* Copyright (C) 2011,2013 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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;
}
char *expected_checksum;
GVariant *object;
GCancellable *cancellable;
- GSimpleAsyncResult *result;
-
guchar *result_csum;
} WriteMetadataAsyncData;
}
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);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
+ g_autoptr(GTask) task = NULL;
WriteMetadataAsyncData *asyncdata;
asyncdata = g_new0 (WriteMetadataAsyncData, 1);
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);
}
/**
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;
GInputStream *object;
guint64 file_object_length;
GCancellable *cancellable;
- GSimpleAsyncResult *result;
guchar *result_csum;
} WriteContentAsyncData;
}
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);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
+ g_autoptr(GTask) task = NULL;
WriteContentAsyncData *asyncdata;
asyncdata = g_new0 (WriteContentAsyncData, 1);
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);
}
/**
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;
}
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);
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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);
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);
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);
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);
*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;
}
return g_file_read (dest, cancellable, error);
}
- return g_steal_pointer (&ret_stream);
+ return (GFileInputStream *)g_steal_pointer (&ret_stream);
}
static void
/*
* Copyright © 2016 Kinvolk GmbH
* Copyright © 2017 Endless Mobile, Inc.
+ * Copyright © 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
#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 */
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))
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;
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++)
{
/*
* Copyright (C) 2011,2012,2013 Colin Walters <walters@verbum.org>
* Copyright © 2017 Endless Mobile, Inc.
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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;
}
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,
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,
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;
}
{
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;
}
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;
}
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;
}
}
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;
}
/*
* Copyright (C) 2013,2014 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
GVariant *header;
GVariant *part;
GCancellable *cancellable;
- GSimpleAsyncResult *result;
} StaticDeltaPartExecuteAsyncData;
static void
}
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
GAsyncReadyCallback callback,
gpointer user_data)
{
+ g_autoptr(GTask) task = NULL;
StaticDeltaPartExecuteAsyncData *asyncdata;
asyncdata = g_new0 (StaticDeltaPartExecuteAsyncData, 1);
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
GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
-
- g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == _ostree_static_delta_part_execute_async);
+ 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);
- if (g_simple_async_result_propagate_error (simple, error))
- return FALSE;
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
static gboolean
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
* Copyright (C) 2015 Red Hat, Inc.
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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);
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.
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,
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;
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);
}
+++ /dev/null
-/* -*- 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 <config.h>
-
-#include <string.h>
-
-#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 <ulink
- * url="http://www.w3.org/TR/html401/interact/forms.html#h-17.13">the
- * HTML 4.01 specification</ulink>.
- **/
-
-/**
- * SOUP_FORM_MIME_TYPE_URLENCODED:
- *
- * A macro containing the value
- * <literal>"application/x-www-form-urlencoded"</literal>; the default
- * MIME type for POSTing HTML form data.
- *
- * Since: 2.26
- **/
-
-/**
- * SOUP_FORM_MIME_TYPE_MULTIPART:
- *
- * A macro containing the value
- * <literal>"multipart/form-data"</literal>; 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);
-}
+++ /dev/null
-/* -*- 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 <string.h>
-#include <stdlib.h>
-
-#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 <literal>scheme</literal> field using
- * <literal>==</literal>.
- */
-/**
- * SOUP_URI_SCHEME_HTTPS:
- *
- * "https" as an interned string; you can compare this directly to a
- * #SoupURI's <literal>scheme</literal> field using
- * <literal>==</literal>.
- */
-/**
- * SOUP_URI_SCHEME_FTP:
- *
- * "ftp" as an interned string; you can compare this directly to a
- * #SoupURI's <literal>scheme</literal> field using
- * <literal>==</literal>.
- *
- * Since: 2.30
- */
-/**
- * SOUP_URI_SCHEME_FILE:
- *
- * "file" as an interned string; you can compare this directly to a
- * #SoupURI's <literal>scheme</literal> field using
- * <literal>==</literal>.
- *
- * Since: 2.30
- */
-/**
- * SOUP_URI_SCHEME_DATA:
- *
- * "data" as an interned string; you can compare this directly to a
- * #SoupURI's <literal>scheme</literal> field using
- * <literal>==</literal>.
- *
- * Since: 2.30
- */
-/**
- * SOUP_URI_SCHEME_RESOURCE:
- *
- * "data" as an interned string; you can compare this directly to a
- * #SoupURI's <literal>scheme</literal> field using
- * <literal>==</literal>.
- *
- * Since: 2.42
- */
-/**
- * SOUP_URI_SCHEME_WS:
- *
- * "ws" (WebSocket) as an interned string; you can compare this
- * directly to a #SoupURI's <literal>scheme</literal> field using
- * <literal>==</literal>.
- *
- * Since: 2.50
- */
-/**
- * SOUP_URI_SCHEME_WSS:
- *
- * "wss" (WebSocket over TLS) as an interned string; you can compare
- * this directly to a #SoupURI's <literal>scheme</literal> field using
- * <literal>==</literal>.
- *
- * 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 "<segment>/../" where <segment> != ".." */
- 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 "<segment>/.." at end where <segment> != ".." */
- 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
- * <literal>http://example.com/foo/b%<!-- -->61r</literal> into
- * <literal>http://example.com/foo/bar</literal>, which is guaranteed
- * to mean the same thing. However, "/" is "reserved", so
- * <literal>http://example.com/foo%<!-- -->2Fbar</literal> 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) */
+++ /dev/null
-/* -*- 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 <gio/gio.h>
-#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*/
/*
* Copyright (C) 2013 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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);
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;
/*
* Copyright (C) 2017 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
#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,
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;
}
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 *
/*
* Copyright (C) 2015 Red Hat, Inc.
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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)
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
}
}
- 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",
/*
* Copyright (C) 2011 Colin Walters <walters@verbum.org>
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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 */
}
/*
* Copyright © 2017 Endless Mobile, Inc.
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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
/*
* Copyright © 2017 Endless Mobile, Inc.
+ * Copyright (C) 2022 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.0+
*
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
projects / ostree.git / commitdiff