@img/sharp-libvips-dev 0.0.1

package/include/glib-2.0/gio/gdatagrambased.h

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2015 Collabora Ltd.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Philip Withnall <philip.withnall@collabora.co.uk>
+ */
+
+#ifndef __G_DATAGRAM_BASED_H__
+#define __G_DATAGRAM_BASED_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DATAGRAM_BASED             (g_datagram_based_get_type ())
+#define G_DATAGRAM_BASED(inst)            (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
+                                           G_TYPE_DATAGRAM_BASED, GDatagramBased))
+#define G_IS_DATAGRAM_BASED(inst)         (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
+                                           G_TYPE_DATAGRAM_BASED))
+#define G_DATAGRAM_BASED_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), \
+                                           G_TYPE_DATAGRAM_BASED, \
+                                           GDatagramBasedInterface))
+#define G_TYPE_IS_DATAGRAM_BASED(type)    (g_type_is_a ((type), \
+                                           G_TYPE_DATAGRAM_BASED))
+
+/**
+ * GDatagramBased:
+ *
+ * Interface for socket-like objects with datagram semantics.
+ *
+ * Since: 2.48
+ */
+typedef struct _GDatagramBasedInterface GDatagramBasedInterface;
+
+/**
+ * GDatagramBasedInterface:
+ * @g_iface: The parent interface.
+ * @receive_messages: Virtual method for g_datagram_based_receive_messages().
+ * @send_messages: Virtual method for g_datagram_based_send_messages().
+ * @create_source: Virtual method for g_datagram_based_create_source().
+ * @condition_check: Virtual method for g_datagram_based_condition_check().
+ * @condition_wait: Virtual method for
+ *   g_datagram_based_condition_wait().
+ *
+ * Provides an interface for socket-like objects which have datagram semantics,
+ * following the Berkeley sockets API. The interface methods are thin wrappers
+ * around the corresponding virtual methods, and no pre-processing of inputs is
+ * implemented — so implementations of this API must handle all functionality
+ * documented in the interface methods.
+ *
+ * Since: 2.48
+ */
+struct _GDatagramBasedInterface
+{
+  GTypeInterface g_iface;
+
+  /* Virtual table */
+  gint          (*receive_messages)     (GDatagramBased       *datagram_based,
+                                         GInputMessage        *messages,
+                                         guint                 num_messages,
+                                         gint                  flags,
+                                         gint64                timeout,
+                                         GCancellable         *cancellable,
+                                         GError              **error);
+  gint          (*send_messages)        (GDatagramBased       *datagram_based,
+                                         GOutputMessage       *messages,
+                                         guint                 num_messages,
+                                         gint                  flags,
+                                         gint64                timeout,
+                                         GCancellable         *cancellable,
+                                         GError              **error);
+
+  GSource      *(*create_source)        (GDatagramBased       *datagram_based,
+                                         GIOCondition          condition,
+                                         GCancellable         *cancellable);
+  GIOCondition  (*condition_check)      (GDatagramBased       *datagram_based,
+                                         GIOCondition          condition);
+  gboolean      (*condition_wait)       (GDatagramBased       *datagram_based,
+                                         GIOCondition          condition,
+                                         gint64                timeout,
+                                         GCancellable         *cancellable,
+                                         GError              **error);
+};
+
+GIO_AVAILABLE_IN_2_48
+GType
+g_datagram_based_get_type             (void);
+
+GIO_AVAILABLE_IN_2_48
+gint
+g_datagram_based_receive_messages     (GDatagramBased       *datagram_based,
+                                       GInputMessage        *messages,
+                                       guint                 num_messages,
+                                       gint                  flags,
+                                       gint64                timeout,
+                                       GCancellable         *cancellable,
+                                       GError              **error);
+
+GIO_AVAILABLE_IN_2_48
+gint
+g_datagram_based_send_messages        (GDatagramBased       *datagram_based,
+                                       GOutputMessage       *messages,
+                                       guint                 num_messages,
+                                       gint                  flags,
+                                       gint64                timeout,
+                                       GCancellable         *cancellable,
+                                       GError              **error);
+
+GIO_AVAILABLE_IN_2_48
+GSource *
+g_datagram_based_create_source        (GDatagramBased       *datagram_based,
+                                       GIOCondition          condition,
+                                       GCancellable         *cancellable);
+GIO_AVAILABLE_IN_2_48
+GIOCondition
+g_datagram_based_condition_check      (GDatagramBased       *datagram_based,
+                                       GIOCondition          condition);
+GIO_AVAILABLE_IN_2_48
+gboolean
+g_datagram_based_condition_wait       (GDatagramBased       *datagram_based,
+                                       GIOCondition          condition,
+                                       gint64                timeout,
+                                       GCancellable         *cancellable,
+                                       GError              **error);
+
+G_END_DECLS
+
+#endif /* __G_DATAGRAM_BASED_H__ */

package/include/glib-2.0/gio/gdatainputstream.h

@@ -0,0 +1,182 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2006-2007 Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Alexander Larsson <alexl@redhat.com>
+ */
+
+#ifndef __G_DATA_INPUT_STREAM_H__
+#define __G_DATA_INPUT_STREAM_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/gbufferedinputstream.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DATA_INPUT_STREAM         (g_data_input_stream_get_type ())
+#define G_DATA_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_DATA_INPUT_STREAM, GDataInputStream))
+#define G_DATA_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_DATA_INPUT_STREAM, GDataInputStreamClass))
+#define G_IS_DATA_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_DATA_INPUT_STREAM))
+#define G_IS_DATA_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_DATA_INPUT_STREAM))
+#define G_DATA_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_DATA_INPUT_STREAM, GDataInputStreamClass))
+
+/**
+ * GDataInputStream:
+ *
+ * An implementation of #GBufferedInputStream that allows for high-level
+ * data manipulation of arbitrary data (including binary operations).
+ **/
+typedef struct _GDataInputStreamClass    GDataInputStreamClass;
+typedef struct _GDataInputStreamPrivate  GDataInputStreamPrivate;
+
+struct _GDataInputStream
+{
+  GBufferedInputStream parent_instance;
+
+  /*< private >*/
+  GDataInputStreamPrivate *priv;
+};
+
+struct _GDataInputStreamClass
+{
+  GBufferedInputStreamClass parent_class;
+
+  /*< private >*/
+  /* Padding for future expansion */
+  void (*_g_reserved1) (void);
+  void (*_g_reserved2) (void);
+  void (*_g_reserved3) (void);
+  void (*_g_reserved4) (void);
+  void (*_g_reserved5) (void);
+};
+
+GIO_AVAILABLE_IN_ALL
+GType                  g_data_input_stream_get_type             (void) G_GNUC_CONST;
+GIO_AVAILABLE_IN_ALL
+GDataInputStream *     g_data_input_stream_new                  (GInputStream            *base_stream);
+
+GIO_AVAILABLE_IN_ALL
+void                   g_data_input_stream_set_byte_order       (GDataInputStream        *stream,
+                                                                 GDataStreamByteOrder     order);
+GIO_AVAILABLE_IN_ALL
+GDataStreamByteOrder   g_data_input_stream_get_byte_order       (GDataInputStream        *stream);
+GIO_AVAILABLE_IN_ALL
+void                   g_data_input_stream_set_newline_type     (GDataInputStream        *stream,
+                                                                 GDataStreamNewlineType   type);
+GIO_AVAILABLE_IN_ALL
+GDataStreamNewlineType g_data_input_stream_get_newline_type     (GDataInputStream        *stream);
+GIO_AVAILABLE_IN_ALL
+guchar                 g_data_input_stream_read_byte            (GDataInputStream        *stream,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+gint16                 g_data_input_stream_read_int16           (GDataInputStream        *stream,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+guint16                g_data_input_stream_read_uint16          (GDataInputStream        *stream,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+gint32                 g_data_input_stream_read_int32           (GDataInputStream        *stream,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+guint32                g_data_input_stream_read_uint32          (GDataInputStream        *stream,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+gint64                 g_data_input_stream_read_int64           (GDataInputStream        *stream,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+guint64                g_data_input_stream_read_uint64          (GDataInputStream        *stream,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+char *                 g_data_input_stream_read_line            (GDataInputStream        *stream,
+                                                                 gsize                   *length,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_2_30
+char *                 g_data_input_stream_read_line_utf8       (GDataInputStream        *stream,
+								 gsize                   *length,
+								 GCancellable            *cancellable,
+								 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+void                   g_data_input_stream_read_line_async      (GDataInputStream        *stream,
+                                                                 gint                     io_priority,
+                                                                 GCancellable            *cancellable,
+                                                                 GAsyncReadyCallback      callback,
+                                                                 gpointer                 user_data);
+GIO_AVAILABLE_IN_ALL
+char *                 g_data_input_stream_read_line_finish     (GDataInputStream        *stream,
+                                                                 GAsyncResult            *result,
+                                                                 gsize                   *length,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_2_30
+char *                 g_data_input_stream_read_line_finish_utf8(GDataInputStream        *stream,
+                                                                 GAsyncResult            *result,
+                                                                 gsize                   *length,
+                                                                 GError                 **error);
+GIO_DEPRECATED_IN_2_56_FOR (g_data_input_stream_read_upto)
+char *                 g_data_input_stream_read_until           (GDataInputStream        *stream,
+                                                                 const gchar             *stop_chars,
+                                                                 gsize                   *length,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_DEPRECATED_IN_2_56_FOR (g_data_input_stream_read_upto_async)
+void                   g_data_input_stream_read_until_async     (GDataInputStream        *stream,
+                                                                 const gchar             *stop_chars,
+                                                                 gint                     io_priority,
+                                                                 GCancellable            *cancellable,
+                                                                 GAsyncReadyCallback      callback,
+                                                                 gpointer                 user_data);
+GIO_DEPRECATED_IN_2_56_FOR (g_data_input_stream_read_upto_finish)
+char *                 g_data_input_stream_read_until_finish    (GDataInputStream        *stream,
+                                                                 GAsyncResult            *result,
+                                                                 gsize                   *length,
+                                                                 GError                 **error);
+
+GIO_AVAILABLE_IN_ALL
+char *                 g_data_input_stream_read_upto            (GDataInputStream        *stream,
+                                                                 const gchar             *stop_chars,
+                                                                 gssize                   stop_chars_len,
+                                                                 gsize                   *length,
+                                                                 GCancellable            *cancellable,
+                                                                 GError                 **error);
+GIO_AVAILABLE_IN_ALL
+void                   g_data_input_stream_read_upto_async      (GDataInputStream        *stream,
+                                                                 const gchar             *stop_chars,
+                                                                 gssize                   stop_chars_len,
+                                                                 gint                     io_priority,
+                                                                 GCancellable            *cancellable,
+                                                                 GAsyncReadyCallback      callback,
+                                                                 gpointer                 user_data);
+GIO_AVAILABLE_IN_ALL
+char *                 g_data_input_stream_read_upto_finish     (GDataInputStream        *stream,
+                                                                 GAsyncResult            *result,
+                                                                 gsize                   *length,
+                                                                 GError                 **error);
+
+G_END_DECLS
+
+#endif /* __G_DATA_INPUT_STREAM_H__ */

package/include/glib-2.0/gio/gdataoutputstream.h

@@ -0,0 +1,127 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2006-2007 Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Alexander Larsson <alexl@redhat.com>
+ */
+
+#ifndef __G_DATA_OUTPUT_STREAM_H__
+#define __G_DATA_OUTPUT_STREAM_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/gfilteroutputstream.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DATA_OUTPUT_STREAM         (g_data_output_stream_get_type ())
+#define G_DATA_OUTPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_DATA_OUTPUT_STREAM, GDataOutputStream))
+#define G_DATA_OUTPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_DATA_OUTPUT_STREAM, GDataOutputStreamClass))
+#define G_IS_DATA_OUTPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_DATA_OUTPUT_STREAM))
+#define G_IS_DATA_OUTPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_DATA_OUTPUT_STREAM))
+#define G_DATA_OUTPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_DATA_OUTPUT_STREAM, GDataOutputStreamClass))
+
+/**
+ * GDataOutputStream:
+ *
+ * An implementation of #GBufferedOutputStream that allows for high-level
+ * data manipulation of arbitrary data (including binary operations).
+ **/
+typedef struct _GDataOutputStream         GDataOutputStream;
+typedef struct _GDataOutputStreamClass    GDataOutputStreamClass;
+typedef struct _GDataOutputStreamPrivate  GDataOutputStreamPrivate;
+
+struct _GDataOutputStream
+{
+  GFilterOutputStream parent_instance;
+
+  /*< private >*/
+  GDataOutputStreamPrivate *priv;
+};
+
+struct _GDataOutputStreamClass
+{
+  GFilterOutputStreamClass parent_class;
+
+  /*< private >*/
+  /* Padding for future expansion */
+  void (*_g_reserved1) (void);
+  void (*_g_reserved2) (void);
+  void (*_g_reserved3) (void);
+  void (*_g_reserved4) (void);
+  void (*_g_reserved5) (void);
+};
+
+
+GIO_AVAILABLE_IN_ALL
+GType                g_data_output_stream_get_type       (void) G_GNUC_CONST;
+GIO_AVAILABLE_IN_ALL
+GDataOutputStream *  g_data_output_stream_new            (GOutputStream         *base_stream);
+
+GIO_AVAILABLE_IN_ALL
+void                 g_data_output_stream_set_byte_order (GDataOutputStream     *stream,
+							  GDataStreamByteOrder   order);
+GIO_AVAILABLE_IN_ALL
+GDataStreamByteOrder g_data_output_stream_get_byte_order (GDataOutputStream     *stream);
+
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_byte       (GDataOutputStream     *stream,
+							  guchar                 data,
+							  GCancellable          *cancellable,
+							  GError               **error);
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_int16      (GDataOutputStream     *stream,
+							  gint16                 data,
+							  GCancellable          *cancellable,
+							  GError               **error);
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_uint16     (GDataOutputStream     *stream,
+							  guint16                data,
+							  GCancellable          *cancellable,
+							  GError               **error);
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_int32      (GDataOutputStream     *stream,
+							  gint32                 data,
+							  GCancellable          *cancellable,
+							  GError               **error);
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_uint32     (GDataOutputStream     *stream,
+							  guint32                data,
+							  GCancellable          *cancellable,
+							  GError               **error);
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_int64      (GDataOutputStream     *stream,
+							  gint64                 data,
+							  GCancellable          *cancellable,
+							  GError               **error);
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_uint64     (GDataOutputStream     *stream,
+							  guint64                data,
+							  GCancellable          *cancellable,
+							  GError               **error);
+GIO_AVAILABLE_IN_ALL
+gboolean             g_data_output_stream_put_string     (GDataOutputStream     *stream,
+							  const char            *str,
+							  GCancellable          *cancellable,
+							  GError               **error);
+
+G_END_DECLS
+
+#endif /* __G_DATA_OUTPUT_STREAM_H__ */

package/include/glib-2.0/gio/gdbusactiongroup.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2010 Codethink Limited
+ * Copyright © 2011 Canonical Limited
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Ryan Lortie <desrt@desrt.ca>
+ */
+
+#ifndef __G_DBUS_ACTION_GROUP_H__
+#define __G_DBUS_ACTION_GROUP_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include "giotypes.h"
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DBUS_ACTION_GROUP                            (g_dbus_action_group_get_type ())
+#define G_DBUS_ACTION_GROUP(inst)                           (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
+                                                             G_TYPE_DBUS_ACTION_GROUP, GDBusActionGroup))
+#define G_DBUS_ACTION_GROUP_CLASS(class)                    (G_TYPE_CHECK_CLASS_CAST ((class),                       \
+                                                             G_TYPE_DBUS_ACTION_GROUP, GDBusActionGroupClass))
+#define G_IS_DBUS_ACTION_GROUP(inst)                        (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
+                                                             G_TYPE_DBUS_ACTION_GROUP))
+#define G_IS_DBUS_ACTION_GROUP_CLASS(class)                 (G_TYPE_CHECK_CLASS_TYPE ((class),                       \
+                                                             G_TYPE_DBUS_ACTION_GROUP))
+#define G_DBUS_ACTION_GROUP_GET_CLASS(inst)                 (G_TYPE_INSTANCE_GET_CLASS ((inst),                      \
+                                                             G_TYPE_DBUS_ACTION_GROUP, GDBusActionGroupClass))
+
+GIO_AVAILABLE_IN_ALL
+GType                   g_dbus_action_group_get_type                  (void) G_GNUC_CONST;
+
+GIO_AVAILABLE_IN_2_32
+GDBusActionGroup *      g_dbus_action_group_get                       (GDBusConnection        *connection,
+                                                                       const gchar            *bus_name,
+                                                                       const gchar            *object_path);
+
+G_END_DECLS
+
+#endif /* __G_DBUS_ACTION_GROUP_H__ */

package/include/glib-2.0/gio/gdbusaddress.h

@@ -0,0 +1,67 @@
+/* GDBus - GLib D-Bus Library
+ *
+ * Copyright (C) 2008-2010 Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: David Zeuthen <davidz@redhat.com>
+ */
+
+#ifndef __G_DBUS_ADDRESS_H__
+#define __G_DBUS_ADDRESS_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+GIO_AVAILABLE_IN_2_36
+gchar *g_dbus_address_escape_value (const gchar *string);
+
+GIO_AVAILABLE_IN_ALL
+gboolean g_dbus_is_address (const gchar *string);
+GIO_AVAILABLE_IN_ALL
+gboolean g_dbus_is_supported_address (const gchar  *string,
+                                      GError      **error);
+
+GIO_AVAILABLE_IN_ALL
+void                 g_dbus_address_get_stream        (const gchar          *address,
+                                                       GCancellable         *cancellable,
+                                                       GAsyncReadyCallback   callback,
+                                                       gpointer              user_data);
+
+GIO_AVAILABLE_IN_ALL
+GIOStream           *g_dbus_address_get_stream_finish (GAsyncResult         *res,
+                                                       gchar               **out_guid,
+                                                       GError              **error);
+
+GIO_AVAILABLE_IN_ALL
+GIOStream           *g_dbus_address_get_stream_sync   (const gchar          *address,
+                                                       gchar               **out_guid,
+                                                       GCancellable         *cancellable,
+                                                       GError              **error);
+
+GIO_AVAILABLE_IN_ALL
+gchar               *g_dbus_address_get_for_bus_sync  (GBusType              bus_type,
+                                                       GCancellable  *cancellable,
+                                                       GError              **error);
+
+G_END_DECLS
+
+#endif /* __G_DBUS_ADDRESS_H__ */

package/include/glib-2.0/gio/gdbusauthobserver.h

@@ -0,0 +1,53 @@
+/* GDBus - GLib D-Bus Library
+ *
+ * Copyright (C) 2008-2010 Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: David Zeuthen <davidz@redhat.com>
+ */
+
+#ifndef __G_DBUS_AUTH_OBSERVER_H__
+#define __G_DBUS_AUTH_OBSERVER_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DBUS_AUTH_OBSERVER         (g_dbus_auth_observer_get_type ())
+#define G_DBUS_AUTH_OBSERVER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_DBUS_AUTH_OBSERVER, GDBusAuthObserver))
+#define G_IS_DBUS_AUTH_OBSERVER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_DBUS_AUTH_OBSERVER))
+
+GIO_AVAILABLE_IN_ALL
+GType              g_dbus_auth_observer_get_type                     (void) G_GNUC_CONST;
+GIO_AVAILABLE_IN_ALL
+GDBusAuthObserver *g_dbus_auth_observer_new                          (void);
+GIO_AVAILABLE_IN_ALL
+gboolean           g_dbus_auth_observer_authorize_authenticated_peer (GDBusAuthObserver  *observer,
+                                                                      GIOStream          *stream,
+                                                                      GCredentials       *credentials);
+
+GIO_AVAILABLE_IN_2_34
+gboolean           g_dbus_auth_observer_allow_mechanism (GDBusAuthObserver  *observer,
+                                                         const gchar        *mechanism);
+
+G_END_DECLS
+
+#endif /* _G_DBUS_AUTH_OBSERVER_H__ */