init

Telegram/ThirdParty/xdg-desktop-portal/document-portal/document-enums.h

@@ -0,0 +1,23 @@
+#pragma once
+
+G_BEGIN_DECLS
+
+typedef enum {
+  DOCUMENT_PERMISSION_FLAGS_READ               = (1 << 0),
+  DOCUMENT_PERMISSION_FLAGS_WRITE              = (1 << 1),
+  DOCUMENT_PERMISSION_FLAGS_GRANT_PERMISSIONS  = (1 << 2),
+  DOCUMENT_PERMISSION_FLAGS_DELETE             = (1 << 3),
+
+  DOCUMENT_PERMISSION_FLAGS_ALL               = ((1 << 4) - 1)
+} DocumentPermissionFlags;
+
+typedef enum {
+  DOCUMENT_ADD_FLAGS_REUSE_EXISTING             = (1 << 0),
+  DOCUMENT_ADD_FLAGS_PERSISTENT                 = (1 << 1),
+  DOCUMENT_ADD_FLAGS_AS_NEEDED_BY_APP           = (1 << 2),
+  DOCUMENT_ADD_FLAGS_DIRECTORY                  = (1 << 3),
+
+  DOCUMENT_ADD_FLAGS_FLAGS_ALL                  = ((1 << 4) - 1)
+} DocumentAddFullFlags;
+
+G_END_DECLS

Telegram/ThirdParty/xdg-desktop-portal/document-portal/document-portal-fuse.h

@@ -0,0 +1,25 @@
+#ifndef XDP_FUSE_H
+#define XDP_FUSE_H
+
+#include <glib.h>
+#include "permission-db.h"
+
+G_BEGIN_DECLS
+
+char **        xdp_list_apps (void);
+char **        xdp_list_docs (void);
+PermissionDbEntry *xdp_lookup_doc (const char *doc_id);
+
+gboolean    xdp_fuse_init (GError **error);
+void        xdp_fuse_exit (void);
+const char *xdp_fuse_get_mountpoint (void);
+void        xdp_fuse_invalidate_doc_app (const char *doc_id,
+                                         const char *opt_app_id);
+char      *xdp_fuse_lookup_id_for_inode (ino_t    inode,
+                                         gboolean directory,
+                                         char   **real_path_out);
+
+
+G_END_DECLS
+
+#endif /* XDP_FUSE_H */

Telegram/ThirdParty/xdg-desktop-portal/document-portal/document-portal.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2018 Red Hat, Inc
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This program 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:
+ *       Matthias Clasen <mclasen@redhat.com>
+ */
+
+#pragma once
+
+#include <gio/gio.h>
+#include "document-enums.h"
+
+typedef enum {
+      VALIDATE_FD_FILE_TYPE_REGULAR,
+      VALIDATE_FD_FILE_TYPE_DIR,
+      VALIDATE_FD_FILE_TYPE_ANY,
+} ValidateFdType;
+
+gboolean validate_fd (int           fd,
+                      XdpAppInfo   *app_info,
+                      ValidateFdType ensure_type,
+                      struct stat  *st_buf,
+                      struct stat  *real_parent_st_buf,
+                      char        **path_out,
+                      gboolean     *writable_out,
+                      GError      **error);
+
+char ** document_add_full (int                      *fd,
+                           int                      *parent_dev,
+                           int                      *parent_ino,
+                           DocumentAddFullFlags     *documents_flags,
+                           int                       n_args,
+                           XdpAppInfo               *app_info,
+                           const char               *target_app_id,
+                           DocumentPermissionFlags   target_perms,
+                           GError                  **error);

Telegram/ThirdParty/xdg-desktop-portal/document-portal/document-store.c

@@ -0,0 +1,158 @@
+#include "config.h"
+#include <string.h>
+#include <errno.h>
+#include <gio/gio.h>
+#include "document-store.h"
+
+const char **
+xdg_unparse_permissions (DocumentPermissionFlags permissions)
+{
+  GPtrArray *array;
+
+  array = g_ptr_array_new ();
+
+  if (permissions & DOCUMENT_PERMISSION_FLAGS_READ)
+    g_ptr_array_add (array, "read");
+  if (permissions & DOCUMENT_PERMISSION_FLAGS_WRITE)
+    g_ptr_array_add (array, "write");
+  if (permissions & DOCUMENT_PERMISSION_FLAGS_GRANT_PERMISSIONS)
+    g_ptr_array_add (array, "grant-permissions");
+  if (permissions & DOCUMENT_PERMISSION_FLAGS_DELETE)
+    g_ptr_array_add (array, "delete");
+
+  g_ptr_array_add (array, NULL);
+  return (const char **) g_ptr_array_free (array, FALSE);
+}
+
+DocumentPermissionFlags
+xdp_parse_permissions (const char **permissions,
+                       GError     **error)
+{
+  DocumentPermissionFlags perms;
+  int i;
+
+  perms = 0;
+  for (i = 0; permissions[i]; i++)
+    {
+      if (strcmp (permissions[i], "read") == 0)
+        perms |= DOCUMENT_PERMISSION_FLAGS_READ;
+      else if (strcmp (permissions[i], "write") == 0)
+        perms |= DOCUMENT_PERMISSION_FLAGS_WRITE;
+      else if (strcmp (permissions[i], "grant-permissions") == 0)
+        perms |= DOCUMENT_PERMISSION_FLAGS_GRANT_PERMISSIONS;
+      else if (strcmp (permissions[i], "delete") == 0)
+        perms |= DOCUMENT_PERMISSION_FLAGS_DELETE;
+      else
+        {
+          g_set_error (error,
+                       XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_INVALID_ARGUMENT,
+                       "No such permission");
+          return 0;
+        }
+    }
+
+  return perms;
+}
+
+DocumentPermissionFlags
+document_entry_get_permissions_by_app_id (PermissionDbEntry *entry,
+                                          const char        *app_id)
+{
+  g_autofree const char **permissions = NULL;
+
+  if (strcmp (app_id, "") == 0)
+    return DOCUMENT_PERMISSION_FLAGS_ALL;
+
+  permissions = permission_db_entry_list_permissions (entry, app_id);
+  return xdp_parse_permissions (permissions, NULL);
+}
+
+DocumentPermissionFlags
+document_entry_get_permissions (PermissionDbEntry *entry,
+                                XdpAppInfo        *app_info)
+{
+  const char *app_id = xdp_app_info_get_id (app_info);
+
+  if (xdp_app_info_is_host (app_info))
+    return DOCUMENT_PERMISSION_FLAGS_ALL;
+
+  return document_entry_get_permissions_by_app_id (entry, app_id);
+}
+
+gboolean
+document_entry_has_permissions_by_app_id (PermissionDbEntry       *entry,
+                                          const char              *app_id,
+                                          DocumentPermissionFlags  perms)
+{
+  DocumentPermissionFlags current_perms;
+
+  current_perms = document_entry_get_permissions_by_app_id (entry, app_id);
+
+  return (current_perms & perms) == perms;
+}
+
+gboolean
+document_entry_has_permissions (PermissionDbEntry       *entry,
+                                XdpAppInfo              *app_info,
+                                DocumentPermissionFlags  perms)
+{
+  DocumentPermissionFlags current_perms;
+
+  current_perms = document_entry_get_permissions (entry, app_info);
+
+  return (current_perms & perms) == perms;
+}
+
+char *
+xdp_name_from_id (guint32 doc_id)
+{
+  return g_strdup_printf ("%x", doc_id);
+}
+
+const char *
+document_entry_get_path (PermissionDbEntry *entry)
+{
+  g_autoptr(GVariant) v = permission_db_entry_get_data (entry);
+  g_autoptr(GVariant) c = g_variant_get_child_value (v, 0);
+  return g_variant_get_bytestring (c);
+}
+
+char *
+document_entry_dup_basename (PermissionDbEntry *entry)
+{
+  const char *path = document_entry_get_path (entry);
+
+  return g_path_get_basename (path);
+}
+
+char *
+document_entry_dup_dirname (PermissionDbEntry *entry)
+{
+  const char *path = document_entry_get_path (entry);
+
+  return g_path_get_dirname (path);
+}
+
+guint64
+document_entry_get_device (PermissionDbEntry *entry)
+{
+  g_autoptr(GVariant) v = permission_db_entry_get_data (entry);
+  g_autoptr(GVariant) c = g_variant_get_child_value (v, 1);
+  return g_variant_get_uint64 (c);
+}
+
+guint64
+document_entry_get_inode (PermissionDbEntry *entry)
+{
+  g_autoptr(GVariant) v = permission_db_entry_get_data (entry);
+  g_autoptr(GVariant) c = g_variant_get_child_value (v, 2);
+  return g_variant_get_uint64 (c);
+}
+
+guint32
+document_entry_get_flags (PermissionDbEntry *entry)
+{
+  g_autoptr(GVariant) v = permission_db_entry_get_data (entry);
+  g_autoptr(GVariant) c = g_variant_get_child_value (v, 3);
+  return g_variant_get_uint32 (c);
+}

Telegram/ThirdParty/xdg-desktop-portal/document-portal/document-store.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <gio/gio.h>
+#include "permission-db.h"
+#include "document-enums.h"
+#include "src/xdp-app-info.h"
+#include "src/xdp-utils.h"
+
+G_BEGIN_DECLS
+
+#define DOCUMENT_ENTRY_FLAG_UNIQUE (1 << 0)
+#define DOCUMENT_ENTRY_FLAG_TRANSIENT (1 << 1)
+#define DOCUMENT_ENTRY_FLAG_DIRECTORY (1 << 2)
+
+const char **      xdg_unparse_permissions (DocumentPermissionFlags permissions);
+DocumentPermissionFlags xdp_parse_permissions (const char **permissions,
+                                               GError     **error);
+
+DocumentPermissionFlags document_entry_get_permissions_by_app_id (PermissionDbEntry *entry,
+                                                                  const char        *app_id);
+DocumentPermissionFlags document_entry_get_permissions (PermissionDbEntry *entry,
+                                                        XdpAppInfo        *app_info);
+gboolean           document_entry_has_permissions (PermissionDbEntry       *entry,
+                                                   XdpAppInfo              *app_info,
+                                                   DocumentPermissionFlags  perms);
+gboolean           document_entry_has_permissions_by_app_id (PermissionDbEntry       *entry,
+                                                             const char              *app_id,
+                                                             DocumentPermissionFlags  perms);
+const char *       document_entry_get_path (PermissionDbEntry *entry);
+char *             document_entry_dup_basename (PermissionDbEntry *entry);
+char *             document_entry_dup_dirname (PermissionDbEntry *entry);
+guint64            document_entry_get_device (PermissionDbEntry *entry);
+guint64            document_entry_get_inode (PermissionDbEntry *entry);
+guint32            document_entry_get_flags (PermissionDbEntry *entry);
+
+char *  xdp_name_from_id (guint32 doc_id);
+
+
+G_END_DECLS

Telegram/ThirdParty/xdg-desktop-portal/document-portal/file-transfer.c

@@ -0,0 +1,592 @@
+/*
+ * Copyright © 2018 Red Hat, Inc
+ * Copyright © 2023 GNOME Foundation Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This program 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:
+ *       Matthias Clasen <mclasen@redhat.com>
+ *       Hubert Figuière <hub@figuiere.net>
+ */
+
+#include "config.h"
+
+#include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <gio/gio.h>
+#include <gio/gunixfdlist.h>
+
+#include "file-transfer.h"
+#include "src/xdp-app-info.h"
+#include "src/xdp-utils.h"
+#include "document-portal-dbus.h"
+#include "document-enums.h"
+#include "document-portal.h"
+#include "document-portal-fuse.h"
+
+static XdpDbusFileTransfer *file_transfer;
+
+typedef struct
+{
+  char *path;
+  int parent_dev;
+  int parent_ino;
+  gboolean is_dir;
+} ExportedFile;
+
+static void
+exported_file_free (gpointer data)
+{
+  ExportedFile *file = data;
+
+  g_free (file->path);
+  g_free (file);
+}
+
+typedef struct
+{
+  GObject object;
+  GMutex mutex;
+
+  GPtrArray *files;
+  gboolean writable;
+  gboolean autostop;
+  char *key;
+  char *sender;
+  XdpAppInfo *app_info;
+} FileTransfer;
+
+typedef struct
+{
+  GObjectClass parent_class;
+} FileTransferClass;
+
+static GType file_transfer_get_type (void);
+
+G_DEFINE_TYPE (FileTransfer, file_transfer, G_TYPE_OBJECT)
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FileTransfer, g_object_unref);
+
+static void
+file_transfer_init (FileTransfer *transfer)
+{
+  g_mutex_init (&transfer->mutex);
+}
+
+static void
+file_transfer_finalize (GObject *object)
+{
+  FileTransfer *transfer = (FileTransfer *)object;
+
+  g_mutex_clear (&transfer->mutex);
+  g_clear_object (&transfer->app_info);
+  g_clear_pointer (&transfer->files, g_ptr_array_unref);
+  g_clear_pointer (&transfer->key, g_free);
+  g_clear_pointer (&transfer->sender, g_free);
+
+  G_OBJECT_CLASS (file_transfer_parent_class)->finalize (object);
+}
+
+static void
+file_transfer_class_init (FileTransferClass *class)
+{
+  G_OBJECT_CLASS (class)->finalize = file_transfer_finalize;
+}
+
+static inline void
+auto_unlock_unref_helper (FileTransfer **transfer)
+{
+  if (!*transfer)
+    return;
+
+  g_mutex_unlock (&(*transfer)->mutex);
+  g_object_unref (*transfer);
+}
+
+static inline FileTransfer *
+auto_lock_helper (FileTransfer *transfer)
+{
+  if (transfer)
+    g_mutex_lock (&transfer->mutex);
+  return transfer;
+}
+
+#define TRANSFER_AUTOLOCK_UNREF(transfer) \
+  G_GNUC_UNUSED __attribute__((cleanup (auto_unlock_unref_helper))) \
+  FileTransfer * G_PASTE (auto_unlock_unref, __LINE__) = \
+    auto_lock_helper (transfer);
+
+G_LOCK_DEFINE (transfers);
+static GHashTable *transfers;
+
+static FileTransfer *
+lookup_transfer (const char *key)
+{
+  FileTransfer *transfer;
+
+  G_LOCK (transfers);
+  transfer = (FileTransfer *)g_hash_table_lookup (transfers, key);
+  if (transfer)
+    g_object_ref (transfer);
+  G_UNLOCK (transfers);
+
+  return transfer;
+}
+
+static FileTransfer *
+file_transfer_start (XdpAppInfo *app_info,
+                     const char *sender,
+                     gboolean    writable,
+                     gboolean    autostop)
+{
+  FileTransfer *transfer;
+
+  transfer = g_object_new (file_transfer_get_type (), NULL);
+
+  transfer->app_info = g_object_ref (app_info);
+  transfer->sender = g_strdup (sender);
+  transfer->writable = writable;
+  transfer->autostop = autostop;
+  transfer->files = g_ptr_array_new_with_free_func (exported_file_free);
+
+  G_LOCK (transfers);
+  do {
+    guint64 key;
+    g_free (transfer->key);
+    key = g_random_int ();
+    key = (key << 32) | g_random_int ();
+    transfer->key = g_strdup_printf ("%" G_GUINT64_FORMAT, key);
+  }
+  while (g_hash_table_contains (transfers, transfer->key));
+  g_hash_table_insert (transfers, transfer->key, g_object_ref (transfer));
+  G_UNLOCK (transfers);
+
+  g_debug ("start file transfer owned by '%s' (%s)",
+           xdp_app_info_get_id (transfer->app_info),
+           transfer->sender);
+
+  return transfer;
+}
+
+static gboolean
+stop (gpointer data)
+{
+  FileTransfer *transfer = data;
+
+  g_object_unref (transfer);
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+file_transfer_stop (FileTransfer *transfer)
+{
+  GDBusConnection *bus;
+
+  g_debug ("stop file transfer owned by '%s' (%s)",
+           xdp_app_info_get_id (transfer->app_info),
+           transfer->sender);
+
+  bus = g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (file_transfer));
+  g_dbus_connection_emit_signal (bus,
+                                 transfer->sender,
+                                 "/org/freedesktop/portal/documents",
+                                 "org.freedesktop.portal.FileTransfer",
+                                 "TransferClosed",
+                                 g_variant_new ("(s)", transfer->key),
+                                 NULL);
+
+  G_LOCK (transfers);
+  g_hash_table_steal (transfers, transfer->key);
+  G_UNLOCK (transfers);
+
+  g_idle_add (stop, transfer);
+}
+
+static void
+file_transfer_add_file (FileTransfer *transfer,
+                        const char *path,
+                        struct stat *st_buf,
+                        struct stat *parent_st_buf)
+{
+  ExportedFile *file;
+
+  file = g_new (ExportedFile, 1);
+  file->path = g_strdup (path);
+  file->is_dir = S_ISDIR (st_buf->st_mode);
+  file->parent_dev = parent_st_buf->st_dev;
+  file->parent_ino = parent_st_buf->st_ino;
+
+  g_ptr_array_add (transfer->files, file);
+}
+
+static char **
+file_transfer_execute (FileTransfer *transfer,
+                       XdpAppInfo *target_app_info,
+                       GError **error)
+{
+  DocumentAddFullFlags common_flags;
+  DocumentPermissionFlags perms;
+  const char *target_app_id;
+  int n_fds;
+  g_autofree int *fds = NULL;
+  g_autofree int *parent_devs = NULL;
+  g_autofree int *parent_inos = NULL;
+  g_autofree DocumentAddFullFlags *documents_flags = NULL;
+  int i;
+  g_auto(GStrv) ids = NULL;
+  char **files = NULL;
+
+  g_debug ("retrieve %d files for %s from file transfer owned by '%s' (%s)",
+           transfer->files->len,
+           xdp_app_info_get_id (target_app_info),
+           xdp_app_info_get_id (transfer->app_info),
+           transfer->sender);
+
+  /* if the target is unsandboxed, just return the files as-is */
+  if (xdp_app_info_is_host (target_app_info))
+    {
+      files = g_new (char *, transfer->files->len + 1);
+      for (i = 0; i < transfer->files->len; i++)
+        {
+          ExportedFile *file = (ExportedFile*)g_ptr_array_index (transfer->files, i);
+          files[i] = g_strdup (file->path);
+        }
+      files[i] = NULL;
+      return files;
+    }
+
+  common_flags = DOCUMENT_ADD_FLAGS_REUSE_EXISTING | DOCUMENT_ADD_FLAGS_AS_NEEDED_BY_APP;
+
+  perms = DOCUMENT_PERMISSION_FLAGS_READ;
+  if (transfer->writable)
+    perms |= DOCUMENT_PERMISSION_FLAGS_WRITE;
+
+  target_app_id = xdp_app_info_get_id (target_app_info);
+
+  n_fds = transfer->files->len;
+  fds = g_new (int, n_fds);
+  parent_devs = g_new (int, n_fds);
+  parent_inos = g_new (int, n_fds);
+  documents_flags = g_new (DocumentAddFullFlags, n_fds);
+  for (i = 0; i < n_fds; i++)
+    {
+      ExportedFile *file = (ExportedFile*)g_ptr_array_index (transfer->files, i);
+
+      fds[i] = open (file->path, O_PATH | O_CLOEXEC);
+      if (fds[i] == -1)
+        {
+          g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "File transfer %s failed", transfer->key);
+          for (; i > 0; i--)
+            close (fds[i - 1]);
+          return NULL;
+        }
+
+      documents_flags[i] = common_flags | (file->is_dir ? DOCUMENT_ADD_FLAGS_DIRECTORY : 0);
+      parent_devs[i] = file->parent_dev;
+      parent_inos[i] = file->parent_ino;
+    }
+
+  ids = document_add_full (fds, parent_devs, parent_inos, documents_flags, n_fds, transfer->app_info, target_app_id, perms, error);
+
+  for (i = 0; i < n_fds; i++)
+    close (fds[i]);
+
+  if (ids)
+    {
+      const char *mountpoint = xdp_fuse_get_mountpoint ();
+      files = g_new (char *, n_fds + 1);
+      for (i = 0; i < n_fds; i++)
+        {
+          ExportedFile *file = (ExportedFile *) g_ptr_array_index (transfer->files, i);
+
+          if (ids[i][0] == '\0')
+            files[i] = g_strdup (file->path);
+          else
+            {
+              g_autofree char *name = g_path_get_basename (file->path);
+              files[i] = g_build_filename (mountpoint, ids[i], name, NULL);
+            }
+        }
+      files[n_fds] = NULL;
+    }
+
+  return files;
+}
+
+static void
+start_transfer (GDBusMethodInvocation *invocation,
+                GVariant *parameters,
+                XdpAppInfo *app_info)
+{
+  g_autoptr(GVariant) options = NULL;
+  g_autoptr(FileTransfer) transfer = NULL;
+  gboolean writable;
+  gboolean autostop;
+  const char *sender;
+
+  g_variant_get (parameters, "(@a{sv})", &options);
+  if (!g_variant_lookup (options, "writable", "b", &writable))
+    writable = FALSE;
+
+  if (!g_variant_lookup (options, "autostop", "b", &autostop))
+    autostop = TRUE;
+
+  sender = g_dbus_method_invocation_get_sender (invocation);
+
+  transfer = file_transfer_start (app_info, sender, writable, autostop);
+
+  g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", transfer->key));
+}
+
+static void
+add_files (GDBusMethodInvocation *invocation,
+           GVariant *parameters,
+           XdpAppInfo *app_info)
+{
+  FileTransfer *transfer;
+  const char *key;
+  g_autoptr(GVariant) options = NULL;
+  GDBusMessage *message;
+  GUnixFDList *fd_list;
+  g_autoptr(GVariantIter) iter = NULL;
+  int fd_id;
+  const int *fds;
+  int n_fds;
+
+  g_variant_get (parameters, "(&sah@a{sv})", &key, &iter, &options);
+
+  transfer = lookup_transfer (key);
+  if (transfer == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             G_DBUS_ERROR,
+                                             G_DBUS_ERROR_ACCESS_DENIED,
+                                             "Invalid transfer");
+      return;
+    }
+
+  TRANSFER_AUTOLOCK_UNREF (transfer);
+
+  if (strcmp (transfer->sender, g_dbus_method_invocation_get_sender (invocation)) != 0)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             G_DBUS_ERROR,
+                                             G_DBUS_ERROR_ACCESS_DENIED,
+                                             "Invalid transfer");
+      return;
+    }
+
+  message = g_dbus_method_invocation_get_message (invocation);
+  fd_list = g_dbus_message_get_unix_fd_list (message);
+
+  if (fd_list == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             G_DBUS_ERROR,
+                                             G_DBUS_ERROR_INVALID_ARGS,
+                                             "Invalid transfer");
+      return;
+    }
+
+  fds = g_unix_fd_list_peek_fds (fd_list, &n_fds);
+
+  g_debug ("add %d files to file transfer owned by '%s' (%s)", n_fds,
+           xdp_app_info_get_id (transfer->app_info),
+           transfer->sender);
+
+  while (g_variant_iter_next (iter, "h", &fd_id))
+    {
+      int fd = -1;
+      g_autofree char *path = NULL;
+      gboolean fd_is_writable;
+      struct stat st_buf;
+      struct stat parent_st_buf;
+
+      if (fd_id < n_fds)
+        fd = fds[fd_id];
+
+      if (fd == -1)
+        {
+          g_dbus_method_invocation_return_error (invocation,
+                                                 G_DBUS_ERROR,
+                                                 G_DBUS_ERROR_ACCESS_DENIED,
+                                                 "Invalid transfer");
+          return;
+        }
+
+      if (!validate_fd (fd, app_info, VALIDATE_FD_FILE_TYPE_ANY, &st_buf, &parent_st_buf, &path, &fd_is_writable, NULL) ||
+          (transfer->writable && !fd_is_writable))
+        {
+          g_dbus_method_invocation_return_error (invocation,
+                                                 XDG_DESKTOP_PORTAL_ERROR,
+                                                 XDG_DESKTOP_PORTAL_ERROR_NOT_ALLOWED,
+                                                 "Can't export file");
+          return;
+        }
+
+      file_transfer_add_file (transfer, path, &st_buf, &parent_st_buf);
+    }
+
+  g_dbus_method_invocation_return_value (invocation, NULL);
+}
+
+
+static void
+retrieve_files (GDBusMethodInvocation *invocation,
+                GVariant *parameters,
+                XdpAppInfo *app_info)
+{
+  const char *key;
+  FileTransfer *transfer;
+  g_auto(GStrv) files = NULL;
+  g_autoptr(GError) error = NULL;
+
+  g_variant_get (parameters, "(&s@a{sv})", &key, NULL);
+
+  transfer = lookup_transfer (key);
+  if (transfer == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             G_DBUS_ERROR,
+                                             G_DBUS_ERROR_ACCESS_DENIED,
+                                             "Invalid transfer");
+      return;
+    }
+
+  TRANSFER_AUTOLOCK_UNREF (transfer);
+
+  files = file_transfer_execute (transfer, app_info, &error);
+  if (files == NULL)
+    g_dbus_method_invocation_return_gerror (invocation, error);
+  else
+    g_dbus_method_invocation_return_value (invocation, g_variant_new ("(^as)", files));
+
+  if (transfer->autostop)
+    file_transfer_stop (transfer);
+}
+
+static void
+stop_transfer (GDBusMethodInvocation *invocation,
+                GVariant *parameters,
+                XdpAppInfo *app_info)
+{
+  const char *key;
+  FileTransfer *transfer;
+
+  g_variant_get (parameters, "(&s)", &key);
+
+  transfer = lookup_transfer (key);
+  if (transfer == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             G_DBUS_ERROR,
+                                             G_DBUS_ERROR_ACCESS_DENIED,
+                                             "Invalid transfer");
+      return;
+    }
+
+  TRANSFER_AUTOLOCK_UNREF (transfer);
+
+  file_transfer_stop (transfer);
+
+  g_dbus_method_invocation_return_value (invocation, NULL);
+}
+
+typedef void (*PortalMethod) (GDBusMethodInvocation *invocation,
+                              GVariant              *parameters,
+                              XdpAppInfo            *app_info);
+
+static gboolean
+handle_method (GCallback              method_callback,
+               GDBusMethodInvocation *invocation)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(XdpAppInfo) app_info = NULL;
+  PortalMethod portal_method = (PortalMethod)method_callback;
+
+  app_info = xdp_invocation_ensure_app_info_sync (invocation, NULL, &error);
+  if (app_info == NULL)
+    g_dbus_method_invocation_return_gerror (invocation, error);
+  else
+    portal_method (invocation, g_dbus_method_invocation_get_parameters (invocation), app_info);
+
+  return TRUE;
+}
+
+GDBusInterfaceSkeleton *
+file_transfer_create (void)
+{
+  file_transfer = xdp_dbus_file_transfer_skeleton_new ();
+
+  g_signal_connect_swapped (file_transfer, "handle-start-transfer", G_CALLBACK (handle_method), start_transfer);
+  g_signal_connect_swapped (file_transfer, "handle-add-files", G_CALLBACK (handle_method), add_files);
+  g_signal_connect_swapped (file_transfer, "handle-retrieve-files", G_CALLBACK (handle_method), retrieve_files);
+  g_signal_connect_swapped (file_transfer, "handle-stop-transfer", G_CALLBACK (handle_method), stop_transfer);
+
+  xdp_dbus_file_transfer_set_version (XDP_DBUS_FILE_TRANSFER (file_transfer), 1);
+
+  transfers = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
+
+  return G_DBUS_INTERFACE_SKELETON (file_transfer);
+}
+
+void
+stop_file_transfers_in_thread_func (GTask        *task,
+                                    gpointer      source_object,
+                                    gpointer      task_data,
+                                    GCancellable *cancellable)
+{
+  const char *sender = (const char *)task_data;
+  GHashTableIter iter;
+  FileTransfer *transfer;
+
+  G_LOCK (transfers);
+  if (transfers)
+    {
+      g_hash_table_iter_init (&iter, transfers);
+      while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&transfer))
+        {
+          if (strcmp (sender, transfer->sender) == 0)
+            {
+              g_print ("removing transfer %s for dead peer %s\n", transfer->key, transfer->sender);
+              g_hash_table_iter_remove (&iter);
+            }
+        }
+    }
+  G_UNLOCK (transfers);
+  g_task_return_boolean (task, TRUE);
+}
+
+void
+stop_file_transfers_for_sender (const char *sender)
+{
+  GTask *task;
+
+  task = g_task_new (NULL, NULL, NULL, NULL);
+  g_task_set_task_data (task, g_strdup (sender), g_free);
+  g_task_run_in_thread (task, stop_file_transfers_in_thread_func);
+  g_object_unref (task);
+}

Telegram/ThirdParty/xdg-desktop-portal/document-portal/file-transfer.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright © 2018 Red Hat, Inc
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This program 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:
+ *       Matthias Clasen <mclasen@redhat.com>
+ */
+
+#pragma once
+
+#include <gio/gio.h>
+
+GDBusInterfaceSkeleton *file_transfer_create (void);
+
+void stop_file_transfers_for_sender (const char *name);

Telegram/ThirdParty/xdg-desktop-portal/document-portal/gvdb/README

@@ -0,0 +1,7 @@
+DO NOT MODIFY ANY FILE IN THIS DIRECTORY
+
+(except maybe the Makefile.am)
+
+This directory is the result of a git subtree merge with the 'gvdb'
+module on git.gnome.org.  Please apply fixes to the 'gvdb' module and
+perform a git merge.

Telegram/ThirdParty/xdg-desktop-portal/document-portal/gvdb/gvdb-builder.c

@@ -0,0 +1,539 @@
+/*
+ * Copyright © 2010 Codethink Limited
+ *
+ * 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 of the licence, 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: Ryan Lortie <desrt@desrt.ca>
+ */
+
+#include "gvdb-builder.h"
+#include "gvdb-format.h"
+
+#include <glib.h>
+#include <fcntl.h>
+#if !defined(G_OS_WIN32) || !defined(_MSC_VER)
+#include <unistd.h>
+#endif
+#include <string.h>
+
+
+struct _GvdbItem
+{
+  gchar *key;
+  guint32 hash_value;
+  guint32_le assigned_index;
+  GvdbItem *parent;
+  GvdbItem *sibling;
+  GvdbItem *next;
+
+  /* one of:
+   * this:
+   */
+  GVariant *value;
+
+  /* this: */
+  GHashTable *table;
+
+  /* or this: */
+  GvdbItem *child;
+};
+
+static void
+gvdb_item_free (gpointer data)
+{
+  GvdbItem *item = data;
+
+  g_free (item->key);
+
+  if (item->value)
+    g_variant_unref (item->value);
+
+  if (item->table)
+    g_hash_table_unref (item->table);
+
+  g_slice_free (GvdbItem, item);
+}
+
+GHashTable *
+gvdb_hash_table_new (GHashTable  *parent,
+                     const gchar *name_in_parent)
+{
+  GHashTable *table;
+
+  table = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                 g_free, gvdb_item_free);
+
+  if (parent)
+    {
+      GvdbItem *item;
+
+      item = gvdb_hash_table_insert (parent, name_in_parent);
+      gvdb_item_set_hash_table (item, table);
+    }
+
+  return table;
+}
+
+static guint32
+djb_hash (const gchar *key)
+{
+  guint32 hash_value = 5381;
+
+  while (*key)
+    hash_value = hash_value * 33 + *(signed char *)key++;
+
+  return hash_value;
+}
+
+GvdbItem *
+gvdb_hash_table_insert (GHashTable  *table,
+                        const gchar *key)
+{
+  GvdbItem *item;
+
+  item = g_slice_new0 (GvdbItem);
+  item->key = g_strdup (key);
+  item->hash_value = djb_hash (key);
+
+  g_hash_table_insert (table, g_strdup (key), item);
+
+  return item;
+}
+
+void
+gvdb_hash_table_insert_string (GHashTable  *table,
+                               const gchar *key,
+                               const gchar *value)
+{
+  GvdbItem *item;
+
+  item = gvdb_hash_table_insert (table, key);
+  gvdb_item_set_value (item, g_variant_new_string (value));
+}
+
+void
+gvdb_item_set_value (GvdbItem *item,
+                     GVariant *value)
+{
+  g_return_if_fail (!item->value && !item->table && !item->child);
+
+  item->value = g_variant_ref_sink (value);
+}
+
+void
+gvdb_item_set_hash_table (GvdbItem   *item,
+                          GHashTable *table)
+{
+  g_return_if_fail (!item->value && !item->table && !item->child);
+
+  item->table = g_hash_table_ref (table);
+}
+
+void
+gvdb_item_set_parent (GvdbItem *item,
+                      GvdbItem *parent)
+{
+  GvdbItem **node;
+
+  g_return_if_fail (g_str_has_prefix (item->key, parent->key));
+  g_return_if_fail (!parent->value && !parent->table);
+  g_return_if_fail (!item->parent && !item->sibling);
+
+  for (node = &parent->child; *node; node = &(*node)->sibling)
+    if (strcmp ((*node)->key, item->key) > 0)
+      break;
+
+  item->parent = parent;
+  item->sibling = *node;
+  *node = item;
+}
+
+typedef struct
+{
+  GvdbItem **buckets;
+  gint n_buckets;
+} HashTable;
+
+static HashTable *
+hash_table_new (gint n_buckets)
+{
+  HashTable *table;
+
+  table = g_slice_new (HashTable);
+  table->buckets = g_new0 (GvdbItem *, n_buckets);
+  table->n_buckets = n_buckets;
+
+  return table;
+}
+
+static void
+hash_table_free (HashTable *table)
+{
+  g_free (table->buckets);
+
+  g_slice_free (HashTable, table);
+}
+
+static void
+hash_table_insert (gpointer key,
+                   gpointer value,
+                   gpointer data)
+{
+  guint32 hash_value, bucket;
+  HashTable *table = data;
+  GvdbItem *item = value;
+
+  hash_value = djb_hash (key);
+  bucket = hash_value % table->n_buckets;
+  item->next = table->buckets[bucket];
+  table->buckets[bucket] = item;
+}
+
+static guint32_le
+item_to_index (GvdbItem *item)
+{
+  if (item != NULL)
+    return item->assigned_index;
+
+  return guint32_to_le (-1u);
+}
+
+typedef struct
+{
+  GQueue *chunks;
+  guint64 offset;
+  gboolean byteswap;
+} FileBuilder;
+
+typedef struct
+{
+  gsize offset;
+  gsize size;
+  gpointer data;
+} FileChunk;
+
+static gpointer
+file_builder_allocate (FileBuilder         *fb,
+                       guint                alignment,
+                       gsize                size,
+                       struct gvdb_pointer *pointer)
+{
+  FileChunk *chunk;
+
+  if (size == 0)
+    return NULL;
+
+  fb->offset += (-fb->offset) & (alignment - 1);
+  chunk = g_slice_new (FileChunk);
+  chunk->offset = fb->offset;
+  chunk->size = size;
+  chunk->data = g_malloc (size);
+
+  pointer->start = guint32_to_le (fb->offset);
+  fb->offset += size;
+  pointer->end = guint32_to_le (fb->offset);
+
+  g_queue_push_tail (fb->chunks, chunk);
+
+  return chunk->data;
+}
+
+static void
+file_builder_add_value (FileBuilder         *fb,
+                        GVariant            *value,
+                        struct gvdb_pointer *pointer)
+{
+  GVariant *variant, *normal;
+  gpointer data;
+  gsize size;
+
+  if (fb->byteswap)
+    {
+      value = g_variant_byteswap (value);
+      variant = g_variant_new_variant (value);
+      g_variant_unref (value);
+    }
+  else
+    variant = g_variant_new_variant (value);
+
+  normal = g_variant_get_normal_form (variant);
+  g_variant_unref (variant);
+
+  size = g_variant_get_size (normal);
+  data = file_builder_allocate (fb, 8, size, pointer);
+  g_variant_store (normal, data);
+  g_variant_unref (normal);
+}
+
+static void
+file_builder_add_string (FileBuilder *fb,
+                         const gchar *string,
+                         guint32_le  *start,
+                         guint16_le  *size)
+{
+  FileChunk *chunk;
+  gsize length;
+
+  length = strlen (string);
+
+  chunk = g_slice_new (FileChunk);
+  chunk->offset = fb->offset;
+  chunk->size = length;
+  chunk->data = g_malloc (length);
+  if (length != 0)
+    memcpy (chunk->data, string, length);
+
+  *start = guint32_to_le (fb->offset);
+  *size = guint16_to_le (length);
+  fb->offset += length;
+
+  g_queue_push_tail (fb->chunks, chunk);
+}
+
+static void
+file_builder_allocate_for_hash (FileBuilder            *fb,
+                                gsize                   n_buckets,
+                                gsize                   n_items,
+                                guint                   bloom_shift,
+                                gsize                   n_bloom_words,
+                                guint32_le            **bloom_filter,
+                                guint32_le            **hash_buckets,
+                                struct gvdb_hash_item **hash_items,
+                                struct gvdb_pointer    *pointer)
+{
+  guint32_le bloom_hdr, table_hdr;
+  guchar *data;
+  gsize size;
+
+  g_assert (n_bloom_words < (1u << 27));
+
+  bloom_hdr = guint32_to_le (bloom_shift << 27 | n_bloom_words);
+  table_hdr = guint32_to_le (n_buckets);
+
+  size = sizeof bloom_hdr + sizeof table_hdr +
+         n_bloom_words * sizeof (guint32_le) +
+         n_buckets     * sizeof (guint32_le) +
+         n_items       * sizeof (struct gvdb_hash_item);
+
+  data = file_builder_allocate (fb, 4, size, pointer);
+
+#define chunk(s) (size -= (s), data += (s), data - (s))
+  memcpy (chunk (sizeof bloom_hdr), &bloom_hdr, sizeof bloom_hdr);
+  memcpy (chunk (sizeof table_hdr), &table_hdr, sizeof table_hdr);
+  *bloom_filter = (guint32_le *) chunk (n_bloom_words * sizeof (guint32_le));
+  *hash_buckets = (guint32_le *) chunk (n_buckets * sizeof (guint32_le));
+  *hash_items = (struct gvdb_hash_item *) chunk (n_items *
+                  sizeof (struct gvdb_hash_item));
+  g_assert (size == 0);
+#undef chunk
+
+  memset (*bloom_filter, 0, n_bloom_words * sizeof (guint32_le));
+
+  /* NOTE - the code to actually fill in the bloom filter here is missing.
+   * Patches welcome! 
+   *
+   * http://en.wikipedia.org/wiki/Bloom_filter
+   * http://0pointer.de/blog/projects/bloom.html
+   */
+}
+
+static void
+file_builder_add_hash (FileBuilder         *fb,
+                       GHashTable          *table,
+                       struct gvdb_pointer *pointer)
+{
+  guint32_le *buckets, *bloom_filter;
+  struct gvdb_hash_item *items;
+  HashTable *mytable;
+  GvdbItem *item;
+  guint32 index;
+  gint bucket;
+
+  mytable = hash_table_new (g_hash_table_size (table));
+  g_hash_table_foreach (table, hash_table_insert, mytable);
+  index = 0;
+
+  for (bucket = 0; bucket < mytable->n_buckets; bucket++)
+    for (item = mytable->buckets[bucket]; item; item = item->next)
+      item->assigned_index = guint32_to_le (index++);
+
+  file_builder_allocate_for_hash (fb, mytable->n_buckets, index, 5, 0,
+                                  &bloom_filter, &buckets, &items, pointer);
+
+  index = 0;
+  for (bucket = 0; bucket < mytable->n_buckets; bucket++)
+    {
+      buckets[bucket] = guint32_to_le (index);
+
+      for (item = mytable->buckets[bucket]; item; item = item->next)
+        {
+          struct gvdb_hash_item *entry = items++;
+          const gchar *basename;
+
+          g_assert (index == guint32_from_le (item->assigned_index));
+          entry->hash_value = guint32_to_le (item->hash_value);
+          entry->parent = item_to_index (item->parent);
+          entry->unused = 0;
+
+          if (item->parent != NULL)
+            basename = item->key + strlen (item->parent->key);
+          else
+            basename = item->key;
+
+          file_builder_add_string (fb, basename,
+                                   &entry->key_start,
+                                   &entry->key_size);
+
+          if (item->value != NULL)
+            {
+              g_assert (item->child == NULL && item->table == NULL);
+
+              file_builder_add_value (fb, item->value, &entry->value.pointer);
+              entry->type = 'v';
+            }
+
+          if (item->child != NULL)
+            {
+              guint32 children = 0, i = 0;
+              guint32_le *offsets;
+              GvdbItem *child;
+
+              g_assert (item->table == NULL);
+
+              for (child = item->child; child; child = child->sibling)
+                children++;
+
+              offsets = file_builder_allocate (fb, 4, 4 * children,
+                                               &entry->value.pointer);
+              entry->type = 'L';
+
+              for (child = item->child; child; child = child->sibling)
+                offsets[i++] = child->assigned_index;
+
+              g_assert (children == i);
+            }
+
+          if (item->table != NULL)
+            {
+              entry->type = 'H';
+              file_builder_add_hash (fb, item->table, &entry->value.pointer);
+            }
+
+          index++;
+        }
+    }
+
+  hash_table_free (mytable);
+}
+
+static FileBuilder *
+file_builder_new (gboolean byteswap)
+{
+  FileBuilder *builder;
+
+  builder = g_slice_new (FileBuilder);
+  builder->chunks = g_queue_new ();
+  builder->offset = sizeof (struct gvdb_header);
+  builder->byteswap = byteswap;
+
+  return builder;
+}
+
+static GString *
+file_builder_serialise (FileBuilder          *fb,
+                        struct gvdb_pointer   root)
+{
+  struct gvdb_header header = { { 0, }, };
+  GString *result;
+
+  if (fb->byteswap)
+    {
+      header.signature[0] = GVDB_SWAPPED_SIGNATURE0;
+      header.signature[1] = GVDB_SWAPPED_SIGNATURE1;
+    }
+  else
+    {
+      header.signature[0] = GVDB_SIGNATURE0;
+      header.signature[1] = GVDB_SIGNATURE1;
+    }
+
+  result = g_string_new (NULL);
+
+  header.root = root;
+  g_string_append_len (result, (gpointer) &header, sizeof header);
+
+  while (!g_queue_is_empty (fb->chunks))
+    {
+      FileChunk *chunk = g_queue_pop_head (fb->chunks);
+
+      if (result->len != chunk->offset)
+        {
+          gchar zero[8] = { 0, };
+
+          g_assert (chunk->offset > result->len);
+          g_assert (chunk->offset - result->len < 8);
+
+          g_string_append_len (result, zero, chunk->offset - result->len);
+          g_assert (result->len == chunk->offset);
+        }
+
+      g_string_append_len (result, chunk->data, chunk->size);
+      g_free (chunk->data);
+
+      g_slice_free (FileChunk, chunk);
+    }
+
+  g_queue_free (fb->chunks);
+  g_slice_free (FileBuilder, fb);
+
+  return result;
+}
+
+GBytes *
+gvdb_table_get_content (GHashTable     *table,
+                        gboolean        byteswap)
+{
+  struct gvdb_pointer root;
+  FileBuilder *fb;
+  GString *str;
+  GBytes *res;
+  gsize len;
+
+  fb = file_builder_new (byteswap);
+  file_builder_add_hash (fb, table, &root);
+  str = file_builder_serialise (fb, root);
+
+  len = str->len;
+  res = g_bytes_new_take (g_string_free (str, FALSE), len);
+
+  return res;
+}
+
+gboolean
+gvdb_table_write_contents (GHashTable   *table,
+                           const gchar  *filename,
+                           gboolean      byteswap,
+                           GError      **error)
+{
+  GBytes *content;
+  gboolean status;
+
+  content = gvdb_table_get_content (table, byteswap);
+
+  status = g_file_set_contents (filename, g_bytes_get_data (content, NULL), g_bytes_get_size (content), error);
+
+  g_bytes_unref (content);
+
+  return status;
+}

Telegram/ThirdParty/xdg-desktop-portal/document-portal/gvdb/gvdb-builder.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2010 Codethink Limited
+ *
+ * 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 of the licence, 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: Ryan Lortie <desrt@desrt.ca>
+ */
+
+#ifndef __gvdb_builder_h__
+#define __gvdb_builder_h__
+
+#include <gio/gio.h>
+
+typedef struct _GvdbItem GvdbItem;
+
+G_GNUC_INTERNAL
+GHashTable *            gvdb_hash_table_new                             (GHashTable    *parent,
+                                                                         const gchar   *key);
+
+G_GNUC_INTERNAL
+GvdbItem *              gvdb_hash_table_insert                          (GHashTable    *table,
+                                                                         const gchar   *key);
+G_GNUC_INTERNAL
+void                    gvdb_hash_table_insert_string                   (GHashTable    *table,
+                                                                         const gchar   *key,
+                                                                         const gchar   *value);
+
+G_GNUC_INTERNAL
+void                    gvdb_item_set_value                             (GvdbItem      *item,
+                                                                         GVariant      *value);
+G_GNUC_INTERNAL
+void                    gvdb_item_set_hash_table                        (GvdbItem      *item,
+                                                                         GHashTable    *table);
+G_GNUC_INTERNAL
+void                    gvdb_item_set_parent                            (GvdbItem      *item,
+                                                                         GvdbItem      *parent);
+
+G_GNUC_INTERNAL
+gboolean                gvdb_table_write_contents                       (GHashTable     *table,
+                                                                         const gchar    *filename,
+                                                                         gboolean        byteswap,
+                                                                         GError        **error);
+
+G_GNUC_INTERNAL
+GBytes *                gvdb_table_get_content                          (GHashTable     *table,
+                                                                         gboolean        byteswap);
+
+
+#endif /* __gvdb_builder_h__ */

Telegram/ThirdParty/xdg-desktop-portal/document-portal/gvdb/gvdb-format.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2010 Codethink Limited
+ *
+ * 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 of the licence, 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: Ryan Lortie <desrt@desrt.ca>
+ */
+
+#ifndef __gvdb_format_h__
+#define __gvdb_format_h__
+
+#include <glib.h>
+
+typedef struct { guint16 value; } guint16_le;
+typedef struct { guint32 value; } guint32_le;
+
+struct gvdb_pointer {
+  guint32_le start;
+  guint32_le end;
+};
+
+struct gvdb_hash_header {
+  guint32_le n_bloom_words;
+  guint32_le n_buckets;
+};
+
+struct gvdb_hash_item {
+  guint32_le hash_value;
+  guint32_le parent;
+
+  guint32_le key_start;
+  guint16_le key_size;
+  gchar type;
+  gchar unused;
+
+  union
+  {
+    struct gvdb_pointer pointer;
+    gchar direct[8];
+  } value;
+};
+
+struct gvdb_header {
+  guint32 signature[2];
+  guint32_le version;
+  guint32_le options;
+
+  struct gvdb_pointer root;
+};
+
+static inline guint32_le guint32_to_le (guint32 value) {
+  guint32_le result = { GUINT32_TO_LE (value) };
+  return result;
+}
+
+static inline guint32 guint32_from_le (guint32_le value) {
+  return GUINT32_FROM_LE (value.value);
+}
+
+static inline guint16_le guint16_to_le (guint16 value) {
+  guint16_le result = { GUINT16_TO_LE (value) };
+  return result;
+}
+
+static inline guint16 guint16_from_le (guint16_le value) {
+  return GUINT16_FROM_LE (value.value);
+}
+
+#define GVDB_SIGNATURE0 1918981703
+#define GVDB_SIGNATURE1 1953390953
+#define GVDB_SWAPPED_SIGNATURE0 GUINT32_SWAP_LE_BE (GVDB_SIGNATURE0)
+#define GVDB_SWAPPED_SIGNATURE1 GUINT32_SWAP_LE_BE (GVDB_SIGNATURE1)
+
+#endif /* __gvdb_format_h__ */

Telegram/ThirdParty/xdg-desktop-portal/document-portal/gvdb/gvdb-reader.c

@@ -0,0 +1,718 @@
+/*
+ * Copyright © 2010 Codethink Limited
+ *
+ * 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 of the licence, 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: Ryan Lortie <desrt@desrt.ca>
+ */
+
+#include "gvdb-reader.h"
+#include "gvdb-format.h"
+
+#include <string.h>
+
+struct _GvdbTable {
+  GBytes *bytes;
+
+  const gchar *data;
+  gsize size;
+
+  gboolean byteswapped;
+  gboolean trusted;
+
+  const guint32_le *bloom_words;
+  guint32 n_bloom_words;
+  guint bloom_shift;
+
+  const guint32_le *hash_buckets;
+  guint32 n_buckets;
+
+  struct gvdb_hash_item *hash_items;
+  guint32 n_hash_items;
+};
+
+static const gchar *
+gvdb_table_item_get_key (GvdbTable                   *file,
+                         const struct gvdb_hash_item *item,
+                         gsize                       *size)
+{
+  guint32 start, end;
+
+  start = guint32_from_le (item->key_start);
+  *size = guint16_from_le (item->key_size);
+  end = start + *size;
+
+  if G_UNLIKELY (start > end || end > file->size)
+    return NULL;
+
+  return file->data + start;
+}
+
+static gconstpointer
+gvdb_table_dereference (GvdbTable                 *file,
+                        const struct gvdb_pointer *pointer,
+                        gint                       alignment,
+                        gsize                     *size)
+{
+  guint32 start, end;
+
+  start = guint32_from_le (pointer->start);
+  end = guint32_from_le (pointer->end);
+
+  if G_UNLIKELY (start > end || end > file->size || start & (alignment - 1))
+    return NULL;
+
+  *size = end - start;
+
+  return file->data + start;
+}
+
+static void
+gvdb_table_setup_root (GvdbTable                 *file,
+                       const struct gvdb_pointer *pointer)
+{
+  const struct gvdb_hash_header *header;
+  guint32 n_bloom_words;
+  guint32 n_buckets;
+  gsize size;
+
+  header = gvdb_table_dereference (file, pointer, 4, &size);
+
+  if G_UNLIKELY (header == NULL || size < sizeof *header)
+    return;
+
+  size -= sizeof *header;
+
+  n_bloom_words = guint32_from_le (header->n_bloom_words);
+  n_buckets = guint32_from_le (header->n_buckets);
+  n_bloom_words &= (1u << 27) - 1;
+
+  if G_UNLIKELY (n_bloom_words * sizeof (guint32_le) > size)
+    return;
+
+  file->bloom_words = (gpointer) (header + 1);
+  size -= n_bloom_words * sizeof (guint32_le);
+  file->n_bloom_words = n_bloom_words;
+
+  if G_UNLIKELY (n_buckets > G_MAXUINT / sizeof (guint32_le) ||
+                 n_buckets * sizeof (guint32_le) > size)
+    return;
+
+  file->hash_buckets = file->bloom_words + file->n_bloom_words;
+  size -= n_buckets * sizeof (guint32_le);
+  file->n_buckets = n_buckets;
+
+  if G_UNLIKELY (size % sizeof (struct gvdb_hash_item))
+    return;
+
+  file->hash_items = (gpointer) (file->hash_buckets + n_buckets);
+  file->n_hash_items = size / sizeof (struct gvdb_hash_item);
+}
+
+/**
+ * gvdb_table_new_from_bytes:
+ * @bytes: the #GBytes with the data
+ * @trusted: if the contents of @bytes are trusted
+ * @error: %NULL, or a pointer to a %NULL #GError
+ * @returns: a new #GvdbTable
+ *
+ * Creates a new #GvdbTable from the contents of @bytes.
+ *
+ * This call can fail if the header contained in @bytes is invalid.
+ *
+ * You should call gvdb_table_free() on the return result when you no
+ * longer require it.
+ **/
+GvdbTable *
+gvdb_table_new_from_bytes (GBytes    *bytes,
+                           gboolean   trusted,
+                           GError   **error)
+{
+  const struct gvdb_header *header;
+  GvdbTable *file;
+
+  file = g_slice_new0 (GvdbTable);
+  file->bytes = g_bytes_ref (bytes);
+  file->data = g_bytes_get_data (bytes, &file->size);
+  file->trusted = trusted;
+
+  if (file->size < sizeof (struct gvdb_header))
+    goto invalid;
+
+  header = (gpointer) file->data;
+
+  if (header->signature[0] == GVDB_SIGNATURE0 &&
+      header->signature[1] == GVDB_SIGNATURE1 &&
+      guint32_from_le (header->version) == 0)
+    file->byteswapped = FALSE;
+
+  else if (header->signature[0] == GVDB_SWAPPED_SIGNATURE0 &&
+           header->signature[1] == GVDB_SWAPPED_SIGNATURE1 &&
+           guint32_from_le (header->version) == 0)
+    file->byteswapped = TRUE;
+
+  else
+    goto invalid;
+
+  gvdb_table_setup_root (file, &header->root);
+
+  return file;
+
+invalid:
+  g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_INVAL, "invalid gvdb header");
+
+  g_bytes_unref (file->bytes);
+
+  g_slice_free (GvdbTable, file);
+
+  return NULL;
+}
+
+/**
+ * gvdb_table_new:
+ * @filename: a filename
+ * @trusted: if the contents of @bytes are trusted
+ * @error: %NULL, or a pointer to a %NULL #GError
+ * @returns: a new #GvdbTable
+ *
+ * Creates a new #GvdbTable using the #GMappedFile for @filename as the
+ * #GBytes.
+ **/
+GvdbTable *
+gvdb_table_new (const gchar  *filename,
+                gboolean      trusted,
+                GError      **error)
+{
+  GMappedFile *mapped;
+  GvdbTable *table;
+  GBytes *bytes;
+
+  mapped = g_mapped_file_new (filename, FALSE, error);
+  if (!mapped)
+    return NULL;
+
+  bytes = g_mapped_file_get_bytes (mapped);
+  table = gvdb_table_new_from_bytes (bytes, trusted, error);
+  g_mapped_file_unref (mapped);
+  g_bytes_unref (bytes);
+
+  g_prefix_error (error, "%s: ", filename);
+
+  return table;
+}
+
+static gboolean
+gvdb_table_bloom_filter (GvdbTable *file,
+                          guint32    hash_value)
+{
+  guint32 word, mask;
+
+  if (file->n_bloom_words == 0)
+    return TRUE;
+
+  word = (hash_value / 32) % file->n_bloom_words;
+  mask = 1 << (hash_value & 31);
+  mask |= 1 << ((hash_value >> file->bloom_shift) & 31);
+
+  return (guint32_from_le (file->bloom_words[word]) & mask) == mask;
+}
+
+static gboolean
+gvdb_table_check_name (GvdbTable             *file,
+                       struct gvdb_hash_item *item,
+                       const gchar           *key,
+                       guint                  key_length)
+{
+  const gchar *this_key;
+  gsize this_size;
+  guint32 parent;
+
+  this_key = gvdb_table_item_get_key (file, item, &this_size);
+
+  if G_UNLIKELY (this_key == NULL || this_size > key_length)
+    return FALSE;
+
+  key_length -= this_size;
+
+  if G_UNLIKELY (memcmp (this_key, key + key_length, this_size) != 0)
+    return FALSE;
+
+  parent = guint32_from_le (item->parent);
+  if (key_length == 0 && parent == 0xffffffffu)
+    return TRUE;
+
+  if G_LIKELY (parent < file->n_hash_items && this_size > 0)
+    return gvdb_table_check_name (file,
+                                   &file->hash_items[parent],
+                                   key, key_length);
+
+  return FALSE;
+}
+
+static const struct gvdb_hash_item *
+gvdb_table_lookup (GvdbTable   *file,
+                   const gchar *key,
+                   gchar        type)
+{
+  guint32 hash_value = 5381;
+  guint key_length;
+  guint32 bucket;
+  guint32 lastno;
+  guint32 itemno;
+
+  if G_UNLIKELY (file->n_buckets == 0 || file->n_hash_items == 0)
+    return NULL;
+
+  for (key_length = 0; key[key_length]; key_length++)
+    hash_value = (hash_value * 33) + ((signed char *) key)[key_length];
+
+  if (!gvdb_table_bloom_filter (file, hash_value))
+    return NULL;
+
+  bucket = hash_value % file->n_buckets;
+  itemno = guint32_from_le (file->hash_buckets[bucket]);
+
+  if (bucket == file->n_buckets - 1 ||
+      (lastno = guint32_from_le(file->hash_buckets[bucket + 1])) > file->n_hash_items)
+    lastno = file->n_hash_items;
+
+  while G_LIKELY (itemno < lastno)
+    {
+      struct gvdb_hash_item *item = &file->hash_items[itemno];
+
+      if (hash_value == guint32_from_le (item->hash_value))
+        if G_LIKELY (gvdb_table_check_name (file, item, key, key_length))
+          if G_LIKELY (item->type == type)
+            return item;
+
+      itemno++;
+    }
+
+  return NULL;
+}
+
+static gboolean
+gvdb_table_list_from_item (GvdbTable                    *table,
+                           const struct gvdb_hash_item  *item,
+                           const guint32_le            **list,
+                           guint                        *length)
+{
+  gsize size;
+
+  *list = gvdb_table_dereference (table, &item->value.pointer, 4, &size);
+
+  if G_LIKELY (*list == NULL || size % 4)
+    return FALSE;
+
+  *length = size / 4;
+
+  return TRUE;
+}
+
+/**
+ * gvdb_table_get_names:
+ * @table: a #GvdbTable
+ * @length: the number of items returned, or %NULL
+ *
+ * Gets a list of all names contained in @table.
+ *
+ * No call to gvdb_table_get_table(), gvdb_table_list() or
+ * gvdb_table_get_value() will succeed unless it is for one of the
+ * names returned by this function.
+ *
+ * Note that some names that are returned may still fail for all of the
+ * above calls in the case of the corrupted file.  Note also that the
+ * returned strings may not be utf8.
+ *
+ * Returns: a %NULL-terminated list of strings, of length @length
+ **/
+gchar **
+gvdb_table_get_names (GvdbTable *table,
+                      gint      *length)
+{
+  gchar **names;
+  gint n_names;
+  gint filled;
+  gint total;
+  gint i;
+
+  /* We generally proceed by iterating over the list of items in the
+   * hash table (in order of appearance) recording them into an array.
+   *
+   * Each item has a parent item (except root items).  The parent item
+   * forms part of the name of the item.  We could go fetching the
+   * parent item chain at the point that we encounter each item but then
+   * we would need to implement some sort of recursion along with checks
+   * for self-referential items.
+   *
+   * Instead, we do a number of passes.  Each pass will build up one
+   * level of names (starting from the root).  We continue to do passes
+   * until no more items are left.  The first pass will only add root
+   * items and each further pass will only add items whose direct parent
+   * is an item added in the immediately previous pass.  It's also
+   * possible that items get filled if they follow their parent within a
+   * particular pass.
+   *
+   * At most we will have a number of passes equal to the depth of the
+   * tree.  Self-referential items will never be filled in (since their
+   * parent will have never been filled in).  We continue until we have
+   * a pass that fills in no additional items.
+   *
+   * This takes an O(n) algorithm and turns it into O(n*m) where m is
+   * the depth of the tree, but in all sane cases the tree won't be very
+   * deep and the constant factor of this algorithm is lower (and the
+   * complexity of coding it, as well).
+   */
+
+  n_names = table->n_hash_items;
+  names = g_new0 (gchar *, n_names + 1);
+
+  /* 'names' starts out all-NULL.  On each pass we record the number
+   * of items changed from NULL to non-NULL in 'filled' so we know if we
+   * should repeat the loop.  'total' counts the total number of items
+   * filled.  If 'total' ends up equal to 'n_names' then we know that
+   * 'names' has been completely filled.
+   */
+
+  total = 0;
+  do
+    {
+      /* Loop until we have filled no more entries */
+      filled = 0;
+
+      for (i = 0; i < n_names; i++)
+        {
+          const struct gvdb_hash_item *item = &table->hash_items[i];
+          const gchar *name;
+          gsize name_length;
+          guint32 parent;
+
+          /* already got it on a previous pass */
+          if (names[i] != NULL)
+            continue;
+
+          parent = guint32_from_le (item->parent);
+
+          if (parent == 0xffffffffu)
+            {
+              /* it's a root item */
+              name = gvdb_table_item_get_key (table, item, &name_length);
+
+              if (name != NULL)
+                {
+                  names[i] = g_strndup (name, name_length);
+                  filled++;
+                }
+            }
+
+          else if (parent < n_names && names[parent] != NULL)
+            {
+              /* It's a non-root item whose parent was filled in already.
+               *
+               * Calculate the name of this item by combining it with
+               * its parent name.
+               */
+              name = gvdb_table_item_get_key (table, item, &name_length);
+
+              if (name != NULL)
+                {
+                  const gchar *parent_name = names[parent];
+                  gsize parent_length;
+                  gchar *fullname;
+
+                  parent_length = strlen (parent_name);
+                  fullname = g_malloc (parent_length + name_length + 1);
+                  memcpy (fullname, parent_name, parent_length);
+                  memcpy (fullname + parent_length, name, name_length);
+                  fullname[parent_length + name_length] = '\0';
+                  names[i] = fullname;
+                  filled++;
+                }
+            }
+        }
+
+      total += filled;
+    }
+  while (filled && total < n_names);
+
+  /* If the table was corrupted then 'names' may have holes in it.
+   * Collapse those.
+   */
+  if G_UNLIKELY (total != n_names)
+    {
+      GPtrArray *fixed_names;
+
+      fixed_names = g_ptr_array_new ();
+      for (i = 0; i < n_names; i++)
+        if (names[i] != NULL)
+          g_ptr_array_add (fixed_names, names[i]);
+
+      g_free (names);
+      n_names = fixed_names->len;
+      g_ptr_array_add (fixed_names, NULL);
+      names = (gchar **) g_ptr_array_free (fixed_names, FALSE);
+    }
+
+  if (length)
+    *length = n_names;
+
+  return names;
+}
+
+/**
+ * gvdb_table_list:
+ * @file: a #GvdbTable
+ * @key: a string
+ * @returns: a %NULL-terminated string array
+ *
+ * List all of the keys that appear below @key.  The nesting of keys
+ * within the hash file is defined by the program that created the hash
+ * file.  One thing is constant: each item in the returned array can be
+ * concatenated to @key to obtain the full name of that key.
+ *
+ * It is not possible to tell from this function if a given key is
+ * itself a path, a value, or another hash table; you are expected to
+ * know this for yourself.
+ *
+ * You should call g_strfreev() on the return result when you no longer
+ * require it.
+ **/
+gchar **
+gvdb_table_list (GvdbTable   *file,
+                 const gchar *key)
+{
+  const struct gvdb_hash_item *item;
+  const guint32_le *list;
+  gchar **strv;
+  guint length;
+  guint i;
+
+  if ((item = gvdb_table_lookup (file, key, 'L')) == NULL)
+    return NULL;
+
+  if (!gvdb_table_list_from_item (file, item, &list, &length))
+    return NULL;
+
+  strv = g_new (gchar *, length + 1);
+  for (i = 0; i < length; i++)
+    {
+      guint32 itemno = guint32_from_le (list[i]);
+
+      if (itemno < file->n_hash_items)
+        {
+          const struct gvdb_hash_item *item;
+          const gchar *string;
+          gsize strsize;
+
+          item = file->hash_items + itemno;
+
+          string = gvdb_table_item_get_key (file, item, &strsize);
+
+          if (string != NULL)
+            strv[i] = g_strndup (string, strsize);
+          else
+            strv[i] = g_malloc0 (1);
+        }
+      else
+        strv[i] = g_malloc0 (1);
+    }
+
+  strv[i] = NULL;
+
+  return strv;
+}
+
+/**
+ * gvdb_table_has_value:
+ * @file: a #GvdbTable
+ * @key: a string
+ * @returns: %TRUE if @key is in the table
+ *
+ * Checks for a value named @key in @file.
+ *
+ * Note: this function does not consider non-value nodes (other hash
+ * tables, for example).
+ **/
+gboolean
+gvdb_table_has_value (GvdbTable    *file,
+                      const gchar  *key)
+{
+  static const struct gvdb_hash_item *item;
+  gsize size;
+
+  item = gvdb_table_lookup (file, key, 'v');
+
+  if (item == NULL)
+    return FALSE;
+
+  return gvdb_table_dereference (file, &item->value.pointer, 8, &size) != NULL;
+}
+
+static GVariant *
+gvdb_table_value_from_item (GvdbTable                   *table,
+                            const struct gvdb_hash_item *item)
+{
+  GVariant *variant, *value;
+  gconstpointer data;
+  GBytes *bytes;
+  gsize size;
+
+  data = gvdb_table_dereference (table, &item->value.pointer, 8, &size);
+
+  if G_UNLIKELY (data == NULL)
+    return NULL;
+
+  bytes = g_bytes_new_from_bytes (table->bytes, ((gchar *) data) - table->data, size);
+  variant = g_variant_new_from_bytes (G_VARIANT_TYPE_VARIANT, bytes, table->trusted);
+  value = g_variant_get_variant (variant);
+  g_variant_unref (variant);
+  g_bytes_unref (bytes);
+
+  return value;
+}
+
+/**
+ * gvdb_table_get_value:
+ * @file: a #GvdbTable
+ * @key: a string
+ * @returns: a #GVariant, or %NULL
+ *
+ * Looks up a value named @key in @file.
+ *
+ * If the value is not found then %NULL is returned.  Otherwise, a new
+ * #GVariant instance is returned.  The #GVariant does not depend on the
+ * continued existence of @file.
+ *
+ * You should call g_variant_unref() on the return result when you no
+ * longer require it.
+ **/
+GVariant *
+gvdb_table_get_value (GvdbTable    *file,
+                      const gchar  *key)
+{
+  const struct gvdb_hash_item *item;
+  GVariant *value;
+
+  if ((item = gvdb_table_lookup (file, key, 'v')) == NULL)
+    return NULL;
+
+  value = gvdb_table_value_from_item (file, item);
+
+  if (value && file->byteswapped)
+    {
+      GVariant *tmp;
+
+      tmp = g_variant_byteswap (value);
+      g_variant_unref (value);
+      value = tmp;
+    }
+
+  return value;
+}
+
+/**
+ * gvdb_table_get_raw_value:
+ * @table: a #GvdbTable
+ * @key: a string
+ * @returns: a #GVariant, or %NULL
+ *
+ * Looks up a value named @key in @file.
+ *
+ * This call is equivalent to gvdb_table_get_value() except that it
+ * never byteswaps the value.
+ **/
+GVariant *
+gvdb_table_get_raw_value (GvdbTable   *table,
+                          const gchar *key)
+{
+  const struct gvdb_hash_item *item;
+
+  if ((item = gvdb_table_lookup (table, key, 'v')) == NULL)
+    return NULL;
+
+  return gvdb_table_value_from_item (table, item);
+}
+
+/**
+ * gvdb_table_get_table:
+ * @file: a #GvdbTable
+ * @key: a string
+ * @returns: a new #GvdbTable, or %NULL
+ *
+ * Looks up the hash table named @key in @file.
+ *
+ * The toplevel hash table in a #GvdbTable can contain reference to
+ * child hash tables (and those can contain further references...).
+ *
+ * If @key is not found in @file then %NULL is returned.  Otherwise, a
+ * new #GvdbTable is returned, referring to the child hashtable as
+ * contained in the file.  This newly-created #GvdbTable does not depend
+ * on the continued existence of @file.
+ *
+ * You should call gvdb_table_free() on the return result when you no
+ * longer require it.
+ **/
+GvdbTable *
+gvdb_table_get_table (GvdbTable   *file,
+                      const gchar *key)
+{
+  const struct gvdb_hash_item *item;
+  GvdbTable *new;
+
+  item = gvdb_table_lookup (file, key, 'H');
+
+  if (item == NULL)
+    return NULL;
+
+  new = g_slice_new0 (GvdbTable);
+  new->bytes = g_bytes_ref (file->bytes);
+  new->byteswapped = file->byteswapped;
+  new->trusted = file->trusted;
+  new->data = file->data;
+  new->size = file->size;
+
+  gvdb_table_setup_root (new, &item->value.pointer);
+
+  return new;
+}
+
+/**
+ * gvdb_table_free:
+ * @file: a #GvdbTable
+ *
+ * Frees @file.
+ **/
+void
+gvdb_table_free (GvdbTable *file)
+{
+  g_bytes_unref (file->bytes);
+  g_slice_free (GvdbTable, file);
+}
+
+/**
+ * gvdb_table_is_valid:
+ * @table: a #GvdbTable
+ * @returns: %TRUE if @table is still valid
+ *
+ * Checks if the table is still valid.
+ *
+ * An on-disk GVDB can be marked as invalid.  This happens when the file
+ * has been replaced.  The appropriate action is typically to reopen the
+ * file.
+ **/
+gboolean
+gvdb_table_is_valid (GvdbTable *table)
+{
+  return !!*table->data;
+}

Telegram/ThirdParty/xdg-desktop-portal/document-portal/gvdb/gvdb-reader.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2010 Codethink Limited
+ *
+ * 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 of the licence, 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: Ryan Lortie <desrt@desrt.ca>
+ */
+
+#ifndef __gvdb_reader_h__
+#define __gvdb_reader_h__
+
+#include <glib.h>
+
+typedef struct _GvdbTable GvdbTable;
+
+G_BEGIN_DECLS
+
+G_GNUC_INTERNAL
+GvdbTable *             gvdb_table_new_from_bytes                       (GBytes       *bytes,
+                                                                         gboolean      trusted,
+                                                                         GError      **error);
+G_GNUC_INTERNAL
+GvdbTable *             gvdb_table_new                                  (const gchar  *filename,
+                                                                         gboolean      trusted,
+                                                                         GError      **error);
+G_GNUC_INTERNAL
+void                    gvdb_table_free                                 (GvdbTable    *table);
+G_GNUC_INTERNAL
+gchar **                gvdb_table_get_names                            (GvdbTable    *table,
+                                                                         gint         *length);
+G_GNUC_INTERNAL
+gchar **                gvdb_table_list                                 (GvdbTable    *table,
+                                                                         const gchar  *key);
+G_GNUC_INTERNAL
+GvdbTable *             gvdb_table_get_table                            (GvdbTable    *table,
+                                                                         const gchar  *key);
+G_GNUC_INTERNAL
+GVariant *              gvdb_table_get_raw_value                        (GvdbTable    *table,
+                                                                         const gchar  *key);
+G_GNUC_INTERNAL
+GVariant *              gvdb_table_get_value                            (GvdbTable    *table,
+                                                                         const gchar  *key);
+
+G_GNUC_INTERNAL
+gboolean                gvdb_table_has_value                            (GvdbTable    *table,
+                                                                         const gchar  *key);
+G_GNUC_INTERNAL
+gboolean                gvdb_table_is_valid                             (GvdbTable    *table);
+
+G_END_DECLS
+
+#endif /* __gvdb_reader_h__ */

Telegram/ThirdParty/xdg-desktop-portal/document-portal/gvdb/gvdb.doap

@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='utf-8'?>
+
+<Project xmlns='http://usefulinc.com/ns/doap#'
+         xmlns:foaf='http://xmlns.com/foaf/0.1/'
+         xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+         xmlns:gnome='http://api.gnome.org/doap-extensions#'>
+
+  <name xml:lang='en'>gvdb</name>
+  <shortdesc xml:lang='en'>GVariant Database file</shortdesc>
+  <description xml:lang='en'>
+    A simple database file format that stores a mapping from strings to
+    GVariant values in a way that is extremely efficient for lookups.
+
+    The database is written once and can not be modified.
+
+    Included here is reader code and a first-pass implementation of a
+    writer (that does not currently produce particularly optimised
+    output).
+
+    It is intended that this code be used by copy-pasting into your
+    project or by making use of git-merge(1).
+  </description>
+
+  <maintainer>
+    <foaf:Person>
+      <foaf:name>Ryan Lortie</foaf:name>
+      <foaf:mbox rdf:resource='mailto:desrt@desrt.ca'/>
+      <gnome:userid>ryanl</gnome:userid>
+    </foaf:Person>
+  </maintainer>
+
+</Project>

Telegram/ThirdParty/xdg-desktop-portal/document-portal/meson.build

@@ -0,0 +1,96 @@
+permission_store_built_sources = gnome.gdbus_codegen(
+  'permission-store-dbus',
+  sources: '../data/org.freedesktop.impl.portal.PermissionStore.xml',
+  interface_prefix: 'org.freedesktop.impl.portal',
+  namespace: 'Xdg',
+)
+
+db_sources = files(
+  'permission-db.c',
+  'gvdb/gvdb-reader.c',
+  'gvdb/gvdb-builder.c',
+)
+
+xdg_permission_store_sources = [
+  'permission-store.c',
+  'xdg-permission-store.c',
+  xdp_utils_sources,
+  db_sources,
+  sd_escape_sources,
+  permission_store_built_sources,
+]
+
+xdg_permission_store = executable(
+  'xdg-permission-store',
+  xdg_permission_store_sources,
+  dependencies: xdg_desktop_portal_deps,
+  include_directories: incs_xdg_desktop_portal,
+  install: true,
+  install_dir: libexecdir,
+)
+
+configure_file(
+  input: 'xdg-permission-store.service.in',
+  output: '@BASENAME@',
+  configuration: base_config,
+  install: true,
+  install_dir: systemd_userunit_dir,
+)
+
+document_portal_built_sources = gnome.gdbus_codegen(
+  'document-portal-dbus',
+  sources: [
+      '../data/org.freedesktop.portal.Documents.xml',
+      '../data/org.freedesktop.portal.FileTransfer.xml',
+  ],
+  interface_prefix: 'org.freedesktop.portal',
+  namespace: 'XdpDbus',
+)
+
+xdg_document_portal_sources = [
+  'document-portal.c',
+  'file-transfer.c',
+  'document-store.c',
+  'document-portal-fuse.c',
+  xdp_utils_sources,
+  db_sources,
+  sd_escape_sources,
+  document_portal_built_sources,
+  permission_store_built_sources,
+]
+
+xdg_document_portal = executable(
+  'xdg-document-portal',
+  xdg_document_portal_sources,
+  dependencies: [xdg_desktop_portal_deps, fuse3_dep],
+  include_directories: incs_xdg_desktop_portal,
+  install: true,
+  install_dir: libexecdir,
+)
+
+configure_file(
+  input: 'xdg-document-portal.service.in',
+  output: '@BASENAME@',
+  configuration: base_config,
+  install: true,
+  install_dir: systemd_userunit_dir,
+)
+
+
+doc_portal_service_file_sources = files('org.freedesktop.portal.Documents.service.in')
+doc_portal_service_file = configure_file(
+  input: doc_portal_service_file_sources,
+  output: '@BASENAME@',
+  configuration: base_config,
+  install: true,
+  install_dir: dbus_service_dir,
+)
+
+permission_portal_service_file_sources = files('org.freedesktop.impl.portal.PermissionStore.service.in')
+permission_portal_service_file = configure_file(
+  input: permission_portal_service_file_sources,
+  output: '@BASENAME@',
+  configuration: base_config,
+  install: true,
+  install_dir: dbus_service_dir,
+)

Telegram/ThirdParty/xdg-desktop-portal/document-portal/org.freedesktop.impl.portal.PermissionStore.service.in

@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=org.freedesktop.impl.portal.PermissionStore
+Exec=@libexecdir@/xdg-permission-store
+SystemdService=xdg-permission-store.service

Telegram/ThirdParty/xdg-desktop-portal/document-portal/org.freedesktop.portal.Documents.service.in

@@ -0,0 +1,5 @@
+[D-BUS Service]
+Name=org.freedesktop.portal.Documents
+Exec=@libexecdir@/xdg-document-portal
+SystemdService=xdg-document-portal.service
+AssumedAppArmorLabel=unconfined

Telegram/ThirdParty/xdg-desktop-portal/document-portal/permission-db.h

@@ -0,0 +1,106 @@
+/* permission-db.h
+ *
+ * Copyright © 2015 Red Hat, Inc
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * This file 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 file 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *       Alexander Larsson <alexl@redhat.com>
+ */
+
+#ifndef PERMISSION_DB_H
+#define PERMISSION_DB_H
+
+#include <string.h>
+
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+typedef struct PermissionDb       PermissionDb;
+typedef struct _PermissionDbEntry PermissionDbEntry;
+
+#define PERMISSION_TYPE_DB (permission_db_get_type ())
+#define PERMISSION_DB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PERMISSION_TYPE_DB, PermissionDb))
+#define PERMISSION_IS_DB(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PERMISSION_TYPE_DB))
+
+GType permission_db_get_type (void);
+
+PermissionDb *     permission_db_new (const char *path,
+                                      gboolean    fail_if_not_found,
+                                      GError    **error);
+char **        permission_db_list_ids (PermissionDb *self);
+char **        permission_db_list_apps (PermissionDb *self);
+char **        permission_db_list_ids_by_app (PermissionDb  *self,
+                                              const char *app);
+char **        permission_db_list_ids_by_value (PermissionDb *self,
+                                                GVariant  *data);
+PermissionDbEntry *permission_db_lookup (PermissionDb  *self,
+                                   const char *id);
+GString *      permission_db_print_string (PermissionDb *self,
+                                           GString   *string);
+char *         permission_db_print (PermissionDb *self);
+
+gboolean       permission_db_is_dirty (PermissionDb *self);
+void           permission_db_set_entry (PermissionDb      *self,
+                                        const char     *id,
+                                        PermissionDbEntry *entry);
+void           permission_db_update (PermissionDb *self);
+GBytes *       permission_db_get_content (PermissionDb *self);
+const char *   permission_db_get_path (PermissionDb *self);
+gboolean       permission_db_save_content (PermissionDb *self,
+                                           GError   **error);
+void           permission_db_save_content_async (PermissionDb          *self,
+                                                 GCancellable       *cancellable,
+                                                 GAsyncReadyCallback callback,
+                                                 gpointer            user_data);
+gboolean       permission_db_save_content_finish (PermissionDb    *self,
+                                                  GAsyncResult *res,
+                                                  GError      **error);
+void           permission_db_set_path (PermissionDb  *self,
+                                       const char *path);
+
+
+PermissionDbEntry  *permission_db_entry_ref (PermissionDbEntry *entry);
+void            permission_db_entry_unref (PermissionDbEntry *entry);
+GVariant *      permission_db_entry_get_data (PermissionDbEntry *entry);
+const char **   permission_db_entry_list_apps (PermissionDbEntry *entry);
+const char **   permission_db_entry_list_permissions (PermissionDbEntry *entry,
+                                                      const char     *app);
+gboolean        permission_db_entry_has_permission (PermissionDbEntry *entry,
+                                                    const char     *app,
+                                                    const char     *permission);
+gboolean        permission_db_entry_has_permissions (PermissionDbEntry *entry,
+                                                     const char     *app,
+                                                     const char    **permissions);
+GString *       permission_db_entry_print_string (PermissionDbEntry *entry,
+                                                  GString        *string);
+
+PermissionDbEntry  *permission_db_entry_new (GVariant *data);
+PermissionDbEntry  *permission_db_entry_modify_data (PermissionDbEntry *entry,
+                                                     GVariant       *data);
+PermissionDbEntry  *permission_db_entry_set_app_permissions (PermissionDbEntry *entry,
+                                                             const char     *app,
+                                                             const char    **permissions);
+PermissionDbEntry  *permission_db_entry_remove_app_permissions (PermissionDbEntry *entry,
+                                                                const char        *app);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (PermissionDb, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (PermissionDbEntry, permission_db_entry_unref)
+
+G_END_DECLS
+
+#endif /* PERMISSION_DB_H */

Telegram/ThirdParty/xdg-desktop-portal/document-portal/permission-store.c

@@ -0,0 +1,155 @@
+/*
+ * Copyright © 2014 Red Hat, Inc
+ *
+ * This program 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:
+ *       Alexander Larsson <alexl@redhat.com>
+ */
+
+#include "config.h"
+
+#include <locale.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <gio/gio.h>
+#include "glib-backports.h"
+#include "permission-store-dbus.h"
+#include "xdg-permission-store.h"
+
+static void
+on_bus_acquired (GDBusConnection *connection,
+                 const gchar     *name,
+                 gpointer         user_data)
+{
+  xdg_permission_store_start (connection);
+}
+
+static void
+on_name_acquired (GDBusConnection *connection,
+                  const gchar     *name,
+                  gpointer         user_data)
+{
+}
+
+static void
+on_name_lost (GDBusConnection *connection,
+              const gchar     *name,
+              gpointer         user_data)
+{
+  g_debug ("Name lost.");
+  exit (1);
+}
+
+static gboolean opt_verbose;
+static gboolean opt_replace;
+static gboolean opt_version;
+
+static GOptionEntry entries[] = {
+  { "verbose", 'v', 0, G_OPTION_ARG_NONE, &opt_verbose, "Print debug information", NULL },
+  { "replace", 'r', 0, G_OPTION_ARG_NONE, &opt_replace, "Replace", NULL },
+  { "version", 0, 0, G_OPTION_ARG_NONE, &opt_version, "Print version and exit", NULL },
+  { NULL }
+};
+
+static void
+message_handler (const gchar   *log_domain,
+                 GLogLevelFlags log_level,
+                 const gchar   *message,
+                 gpointer       user_data)
+{
+  /* Make this look like normal console output */
+  if (log_level & G_LOG_LEVEL_DEBUG)
+    printf ("XDP: %s\n", message);
+  else
+    printf ("%s: %s\n", g_get_prgname (), message);
+}
+
+static void
+printerr_handler (const gchar *string)
+{
+  fprintf (stderr, "error: %s\n", string);
+}
+
+int
+main (int    argc,
+      char **argv)
+{
+  guint owner_id;
+  GMainLoop *loop;
+  GOptionContext *context;
+  g_autoptr(GError) error = NULL;
+
+  if (g_getenv ("XDG_PERMISSION_STORE_WAIT_FOR_DEBUGGER") != NULL)
+    {
+      g_printerr ("\npermission store (PID %d) is waiting for a debugger. "
+                  "Use `gdb -p %d` to connect. \n",
+                  getpid (), getpid ());
+
+      if (raise (SIGSTOP) == -1)
+        {
+          g_printerr ("Failed waiting for debugger\n");
+          exit (1);
+        }
+
+      raise (SIGCONT);
+    }
+
+  g_log_writer_default_set_use_stderr (TRUE);
+
+  setlocale (LC_ALL, "");
+
+  g_setenv ("GIO_USE_VFS", "local", TRUE);
+
+  g_set_prgname (argv[0]);
+
+  g_set_printerr_handler (printerr_handler);
+
+  context = g_option_context_new ("- permission store");
+  g_option_context_add_main_entries (context, entries, NULL);
+  if (!g_option_context_parse (context, &argc, &argv, &error))
+    {
+      g_printerr ("Option parsing failed: %s", error->message);
+      return 1;
+    }
+
+  if (opt_version)
+    {
+      g_print ("%s\n", PACKAGE_STRING);
+      exit (EXIT_SUCCESS);
+    }
+
+  if (opt_verbose)
+    g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, message_handler, NULL);
+
+  g_set_prgname (argv[0]);
+
+  owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
+                             "org.freedesktop.impl.portal.PermissionStore",
+                             G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | (opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
+
+                             on_bus_acquired,
+                             on_name_acquired,
+                             on_name_lost,
+                             NULL,
+                             NULL);
+
+  loop = g_main_loop_new (NULL, FALSE);
+  g_main_loop_run (loop);
+
+  g_bus_unown_name (owner_id);
+
+  return 0;
+}

Telegram/ThirdParty/xdg-desktop-portal/document-portal/xdg-document-portal.service.in

@@ -0,0 +1,11 @@
+[Unit]
+Description=flatpak document portal service
+PartOf=graphical-session.target
+Requires=dbus.service
+After=dbus.service
+
+[Service]
+BusName=org.freedesktop.portal.Documents
+ExecStart=@libexecdir@/xdg-document-portal
+Type=dbus
+Slice=session.slice

Telegram/ThirdParty/xdg-desktop-portal/document-portal/xdg-permission-store.c

@@ -0,0 +1,541 @@
+/*
+ * Copyright © 2015 Red Hat, Inc
+ *
+ * This program 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:
+ *       Alexander Larsson <alexl@redhat.com>
+ */
+
+#include "config.h"
+
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+#include <gio/gio.h>
+#include "permission-store-dbus.h"
+#include "xdg-permission-store.h"
+#include "permission-db.h"
+#include "src/xdp-utils.h"
+
+GHashTable *tables = NULL;
+
+typedef struct
+{
+  char      *name;
+  PermissionDb *db;
+  GList     *outstanding_writes;
+  GList     *current_writes;
+  gboolean   writing;
+} Table;
+
+static void start_writeout (Table *table);
+
+static void
+table_free (Table *table)
+{
+  g_free (table->name);
+  g_object_unref (table->db);
+  g_free (table);
+}
+
+static Table *
+lookup_table (const char            *name,
+              GDBusMethodInvocation *invocation)
+{
+  Table *table;
+  PermissionDb *db;
+  g_autofree char *dir = NULL;
+  g_autofree char *path = NULL;
+
+  g_autoptr(GError) error = NULL;
+
+  table = g_hash_table_lookup (tables, name);
+  if (table != NULL)
+    return table;
+
+  dir = g_build_filename (g_get_user_data_dir (), "flatpak/db", NULL);
+  g_mkdir_with_parents (dir, 0755);
+
+  path = g_build_filename (dir, name, NULL);
+  db = permission_db_new (path, FALSE, &error);
+  if (db == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_FAILED,
+                                             "Unable to load db file %s: %s", name, error->message);
+      return NULL;
+    }
+
+  table = g_new0 (Table, 1);
+  table->name = g_strdup (name);
+  table->db = db;
+
+  g_hash_table_insert (tables, table->name, table);
+
+  return table;
+}
+
+static void
+writeout_done (GObject      *source_object,
+               GAsyncResult *res,
+               gpointer      user_data)
+{
+  Table *table = user_data;
+  GList *l;
+
+  g_autoptr(GError) error = NULL;
+  gboolean ok;
+
+  ok = permission_db_save_content_finish (table->db, res, &error);
+
+  for (l = table->current_writes; l != NULL; l = l->next)
+    {
+      GDBusMethodInvocation *invocation = l->data;
+
+      if (ok)
+        g_dbus_method_invocation_return_value (invocation,
+                                               g_variant_new ("()"));
+      else
+        g_dbus_method_invocation_return_error (invocation,
+                                               XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_FAILED,
+                                               "Unable to write db: %s", error->message);
+    }
+
+  g_list_free (table->current_writes);
+  table->current_writes = NULL;
+  table->writing = FALSE;
+
+  if (table->outstanding_writes != NULL)
+    start_writeout (table);
+}
+
+static void
+start_writeout (Table *table)
+{
+  g_assert (table->current_writes == NULL);
+  table->current_writes = table->outstanding_writes;
+  table->outstanding_writes = NULL;
+  table->writing = TRUE;
+
+  permission_db_update (table->db);
+
+  permission_db_save_content_async (table->db, NULL, writeout_done, table);
+}
+
+static void
+ensure_writeout (Table                 *table,
+                 GDBusMethodInvocation *invocation)
+{
+  table->outstanding_writes = g_list_prepend (table->outstanding_writes, invocation);
+
+  if (!table->writing)
+    start_writeout (table);
+}
+
+static gboolean
+handle_list (XdgPermissionStore     *object,
+             GDBusMethodInvocation  *invocation,
+             const gchar            *table_name)
+{
+  Table *table;
+
+  g_auto(GStrv) ids = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  ids = permission_db_list_ids (table->db);
+
+  xdg_permission_store_complete_list (object, invocation, (const char * const *) ids);
+
+  return TRUE;
+}
+
+static GVariant *
+get_app_permissions (PermissionDbEntry *entry)
+{
+  g_autofree const char **apps = NULL;
+  GVariantBuilder builder;
+  int i;
+
+  apps = permission_db_entry_list_apps (entry);
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sas}"));
+
+  for (i = 0; apps[i] != NULL; i++)
+    {
+      g_autofree const char **permissions = permission_db_entry_list_permissions (entry, apps[i]);
+      g_variant_builder_add_value (&builder,
+                                   g_variant_new ("{s@as}",
+                                                  apps[i],
+                                                  g_variant_new_strv (permissions, -1)));
+    }
+
+  return g_variant_ref_sink (g_variant_builder_end (&builder));
+}
+
+static gboolean
+handle_lookup (XdgPermissionStore     *object,
+               GDBusMethodInvocation  *invocation,
+               const gchar            *table_name,
+               const gchar            *id)
+{
+  Table *table;
+
+  g_autoptr(GVariant) data = NULL;
+  g_autoptr(GVariant) permissions = NULL;
+  g_autoptr(PermissionDbEntry) entry = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  entry = permission_db_lookup (table->db, id);
+  if (entry == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
+                                             "No entry for %s", id);
+      return TRUE;
+    }
+
+  data = permission_db_entry_get_data (entry);
+  permissions = get_app_permissions (entry);
+
+  xdg_permission_store_complete_lookup (object, invocation,
+                                        permissions,
+                                        g_variant_new_variant (data));
+
+  return TRUE;
+}
+
+static void
+emit_deleted (XdgPermissionStore     *object,
+              const gchar            *table_name,
+              const gchar            *id,
+              PermissionDbEntry         *entry)
+{
+  g_autoptr(GVariant) data = NULL;
+  g_autoptr(GVariant) permissions = NULL;
+
+  data = permission_db_entry_get_data (entry);
+  permissions = g_variant_ref_sink (g_variant_new_array (G_VARIANT_TYPE ("{sas}"), NULL, 0));
+
+  xdg_permission_store_emit_changed (object,
+                                     table_name, id,
+                                     TRUE,
+                                     g_variant_new_variant (data),
+                                     permissions);
+}
+
+
+static void
+emit_changed (XdgPermissionStore     *object,
+              const gchar            *table_name,
+              const gchar            *id,
+              PermissionDbEntry         *entry)
+{
+  g_autoptr(GVariant) data = NULL;
+  g_autoptr(GVariant) permissions = NULL;
+
+  data = permission_db_entry_get_data (entry);
+  permissions = get_app_permissions (entry);
+
+  xdg_permission_store_emit_changed (object,
+                                     table_name, id,
+                                     FALSE,
+                                     g_variant_new_variant (data),
+                                     permissions);
+}
+
+static gboolean
+handle_delete (XdgPermissionStore     *object,
+               GDBusMethodInvocation  *invocation,
+               const gchar            *table_name,
+               const gchar            *id)
+{
+  Table *table;
+
+  g_autoptr(PermissionDbEntry) entry = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  entry = permission_db_lookup (table->db, id);
+  if (entry == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
+                                             "No entry for %s", id);
+      return TRUE;
+    }
+
+  permission_db_set_entry (table->db, id, NULL);
+  emit_deleted (object, table_name, id, entry);
+
+  ensure_writeout (table, invocation);
+
+  return TRUE;
+}
+
+static gboolean
+handle_delete_permission (XdgPermissionStore     *object,
+                          GDBusMethodInvocation  *invocation,
+                          const char             *table_name,
+                          const char             *id,
+                          const char             *app)
+{
+  Table *table;
+
+  g_autoptr(PermissionDbEntry) entry = NULL;
+  g_autoptr(PermissionDbEntry) new_entry = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  entry = permission_db_lookup (table->db, id);
+  if (entry == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
+                                             "No entry for %s", id);
+      return TRUE;
+    }
+
+  new_entry = permission_db_entry_remove_app_permissions (entry, app);
+  permission_db_set_entry (table->db, id, new_entry);
+  emit_changed (object, table_name, id, new_entry);
+
+  ensure_writeout (table, invocation);
+
+  return TRUE;
+}
+
+static gboolean
+handle_get_permission (XdgPermissionStore     *object,
+                       GDBusMethodInvocation  *invocation,
+                       const char             *table_name,
+                       const char             *id,
+                       const char             *app)
+{
+  Table *table;
+
+  g_autoptr(PermissionDbEntry) entry = NULL;
+  g_autofree const char **permission = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  entry = permission_db_lookup (table->db, id);
+  if (entry == NULL)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
+                                             "No entry for %s", id);
+      return TRUE;
+    }
+
+  permission = permission_db_entry_list_permissions (entry, app);
+
+  xdg_permission_store_complete_get_permission (object, invocation, permission);
+
+  return TRUE;
+}
+
+static gboolean
+handle_set (XdgPermissionStore     *object,
+            GDBusMethodInvocation  *invocation,
+            const gchar            *table_name,
+            gboolean                create,
+            const gchar            *id,
+            GVariant               *app_permissions,
+            GVariant               *data)
+{
+  Table *table;
+  GVariantIter iter;
+  GVariant *child;
+
+  g_autoptr(GVariant) data_child = NULL;
+  g_autoptr(PermissionDbEntry) old_entry = NULL;
+  g_autoptr(PermissionDbEntry) new_entry = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  old_entry = permission_db_lookup (table->db, id);
+  if (old_entry == NULL && !create)
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
+                                             "Id %s not found", id);
+      return TRUE;
+    }
+
+  data_child = g_variant_get_child_value (data, 0);
+  new_entry = permission_db_entry_new (data_child);
+
+  /* Add all the given app permissions */
+
+  g_variant_iter_init (&iter, app_permissions);
+  while ((child = g_variant_iter_next_value (&iter)))
+    {
+      g_autoptr(PermissionDbEntry) old_entry = NULL;
+      const char *child_app_id;
+      g_autofree const char **permissions;
+
+      g_variant_get (child, "{&s^a&s}", &child_app_id, &permissions);
+
+      old_entry = new_entry;
+      new_entry = permission_db_entry_set_app_permissions (new_entry, child_app_id, (const char **) permissions);
+
+      g_variant_unref (child);
+    }
+
+  permission_db_set_entry (table->db, id, new_entry);
+  emit_changed (object, table_name, id, new_entry);
+
+  ensure_writeout (table, invocation);
+
+  return TRUE;
+}
+
+static gboolean
+handle_set_permission (XdgPermissionStore     *object,
+                       GDBusMethodInvocation  *invocation,
+                       const gchar            *table_name,
+                       gboolean                create,
+                       const gchar            *id,
+                       const gchar            *app,
+                       const gchar *const     *permissions)
+{
+  Table *table;
+
+  g_autoptr(PermissionDbEntry) entry = NULL;
+  g_autoptr(PermissionDbEntry) new_entry = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  entry = permission_db_lookup (table->db, id);
+  if (entry == NULL)
+    {
+      if (create)
+        {
+          entry = permission_db_entry_new (NULL);
+        }
+      else
+        {
+          g_dbus_method_invocation_return_error (invocation,
+                                                 XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
+                                                 "Id %s not found", id);
+          return TRUE;
+        }
+    }
+
+  new_entry = permission_db_entry_set_app_permissions (entry, app, (const char **) permissions);
+  permission_db_set_entry (table->db, id, new_entry);
+  emit_changed (object, table_name, id, new_entry);
+
+  ensure_writeout (table, invocation);
+
+  return TRUE;
+}
+
+static gboolean
+handle_set_value (XdgPermissionStore     *object,
+                  GDBusMethodInvocation  *invocation,
+                  const gchar            *table_name,
+                  gboolean                create,
+                  const gchar            *id,
+                  GVariant               *data)
+{
+  Table *table;
+
+  g_autoptr(GVariant) data_child = NULL;
+  g_autoptr(PermissionDbEntry) entry = NULL;
+  g_autoptr(PermissionDbEntry) new_entry = NULL;
+
+  table = lookup_table (table_name, invocation);
+  if (table == NULL)
+    return TRUE;
+
+  data_child = g_variant_get_child_value (data, 0);
+
+  entry = permission_db_lookup (table->db, id);
+  if (entry == NULL)
+    {
+      if (create)
+        {
+          new_entry = permission_db_entry_new (data_child);
+        }
+      else
+        {
+          g_dbus_method_invocation_return_error (invocation,
+                                                 XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
+                                                 "Id %s not found", id);
+          return TRUE;
+        }
+    }
+  else
+    {
+      new_entry = permission_db_entry_modify_data (entry, data_child);
+    }
+
+  permission_db_set_entry (table->db, id, new_entry);
+  emit_changed (object, table_name, id, new_entry);
+
+  ensure_writeout (table, invocation);
+
+  return TRUE;
+}
+
+void
+xdg_permission_store_start (GDBusConnection *connection)
+{
+  XdgPermissionStore *store;
+  GError *error = NULL;
+
+  g_debug ("Starting permission store");
+
+  tables = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                  g_free, (GDestroyNotify) table_free);
+
+  store = xdg_permission_store_skeleton_new ();
+
+  xdg_permission_store_set_version (XDG_PERMISSION_STORE (store), 2);
+
+  g_signal_connect (store, "handle-list", G_CALLBACK (handle_list), NULL);
+  g_signal_connect (store, "handle-lookup", G_CALLBACK (handle_lookup), NULL);
+  g_signal_connect (store, "handle-set", G_CALLBACK (handle_set), NULL);
+  g_signal_connect (store, "handle-set-permission", G_CALLBACK (handle_set_permission), NULL);
+  g_signal_connect (store, "handle-set-value", G_CALLBACK (handle_set_value), NULL);
+  g_signal_connect (store, "handle-delete", G_CALLBACK (handle_delete), NULL);
+  g_signal_connect (store, "handle-delete-permission", G_CALLBACK (handle_delete_permission), NULL);
+  g_signal_connect (store, "handle-get-permission", G_CALLBACK (handle_get_permission), NULL);
+
+  if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (store),
+                                         connection,
+                                         "/org/freedesktop/impl/portal/PermissionStore",
+                                         &error))
+    {
+      g_warning ("error: %s", error->message);
+      g_error_free (error);
+    }
+}

Telegram/ThirdParty/xdg-desktop-portal/document-portal/xdg-permission-store.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright © 2015 Red Hat, Inc
+ *
+ * This program 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:
+ *       Alexander Larsson <alexl@redhat.com>
+ */
+
+#pragma once
+
+void xdg_permission_store_start (GDBusConnection *connection);

Telegram/ThirdParty/xdg-desktop-portal/document-portal/xdg-permission-store.service.in

@@ -0,0 +1,11 @@
+[Unit]
+Description=sandboxed app permission store
+PartOf=graphical-session.target
+Requires=dbus.service
+After=dbus.service
+
+[Service]
+BusName=org.freedesktop.impl.portal.PermissionStore
+ExecStart=@libexecdir@/xdg-permission-store
+Type=dbus
+Slice=session.slice