path: root/src/libostree/ostree-repo-traverse.c

/*
 * Copyright (C) 2011 Colin Walters <walters@verbum.org>
 *
 * SPDX-License-Identifier: LGPL-2.0+
 *
 * 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 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, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author: Colin Walters <walters@verbum.org>
 */

#include "config.h"

#include "libglnx.h"
#include "ostree.h"
#include "otutil.h"

struct _OstreeRepoRealCommitTraverseIter {
  gboolean initialized;
  OstreeRepo *repo;
  GVariant *commit;
  GVariant *current_dir;
  const char *name;
  OstreeRepoCommitIterResult state;
  guint idx;
  char checksum_content[OSTREE_SHA256_STRING_LEN+1];
  char checksum_meta[OSTREE_SHA256_STRING_LEN+1];
};

/**
 * ostree_repo_commit_traverse_iter_init_commit:
 * @iter: An iter
 * @repo: A repo
 * @commit: Variant of type %OSTREE_OBJECT_TYPE_COMMIT
 * @flags: Flags
 * @error: Error
 *
 * Initialize (in place) an iterator over the root of a commit object.
 */
gboolean
ostree_repo_commit_traverse_iter_init_commit (OstreeRepoCommitTraverseIter   *iter,
                                              OstreeRepo                     *repo,
                                              GVariant                       *commit,
                                              OstreeRepoCommitTraverseFlags   flags,
                                              GError                        **error)
{
  struct _OstreeRepoRealCommitTraverseIter *real =
    (struct _OstreeRepoRealCommitTraverseIter*)iter;

  memset (real, 0, sizeof (*real));
  real->initialized = TRUE;
  real->repo = g_object_ref (repo);
  real->commit = g_variant_ref (commit);
  real->current_dir = NULL;
  real->idx = 0;

  g_autoptr(GVariant) content_csum_bytes = NULL;
  g_variant_get_child (commit, 6, "@ay", &content_csum_bytes);
  const guchar *csum = ostree_checksum_bytes_peek_validate (content_csum_bytes, error);
  if (!csum)
    return FALSE;
  ostree_checksum_inplace_from_bytes (csum, real->checksum_content);

  g_autoptr(GVariant) meta_csum_bytes = NULL;
  g_variant_get_child (commit, 7, "@ay", &meta_csum_bytes);
  csum = ostree_checksum_bytes_peek_validate (meta_csum_bytes, error);
  if (!csum)
    return FALSE;
  ostree_checksum_inplace_from_bytes (csum, real->checksum_meta);

  return TRUE;
}

/**
 * ostree_repo_commit_traverse_iter_init_dirtree:
 * @iter: An iter
 * @repo: A repo
 * @dirtree: Variant of type %OSTREE_OBJECT_TYPE_DIR_TREE
 * @flags: Flags
 * @error: Error
 *
 * Initialize (in place) an iterator over a directory tree.
 */
gboolean
ostree_repo_commit_traverse_iter_init_dirtree (OstreeRepoCommitTraverseIter   *iter,
                                               OstreeRepo                     *repo,
                                               GVariant                       *dirtree,
                                               OstreeRepoCommitTraverseFlags   flags,
                                               GError                        **error)
{
  struct _OstreeRepoRealCommitTraverseIter *real =
    (struct _OstreeRepoRealCommitTraverseIter*)iter;

  memset (real, 0, sizeof (*real));
  real->initialized = TRUE;
  real->repo = g_object_ref (repo);
  real->current_dir = g_variant_ref (dirtree);
  real->idx = 0;

  return TRUE;
}

/**
 * ostree_repo_commit_traverse_iter_next:
 * @iter: An iter
 * @cancellable: Cancellable
 * @error: Error
 *
 * Step the interator to the next item.  Files will be returned first,
 * then subdirectories.  Call this in a loop; upon encountering
 * %OSTREE_REPO_COMMIT_ITER_RESULT_END, there will be no more files or
 * directories.  If %OSTREE_REPO_COMMIT_ITER_RESULT_DIR is returned,
 * then call ostree_repo_commit_traverse_iter_get_dir() to retrieve
 * data for that directory.  Similarly, if
 * %OSTREE_REPO_COMMIT_ITER_RESULT_FILE is returned, call
 * ostree_repo_commit_traverse_iter_get_file().
 * 
 * If %OSTREE_REPO_COMMIT_ITER_RESULT_ERROR is returned, it is a
 * program error to call any further API on @iter except for
 * ostree_repo_commit_traverse_iter_clear().
 */
OstreeRepoCommitIterResult
ostree_repo_commit_traverse_iter_next (OstreeRepoCommitTraverseIter *iter,
                                       GCancellable                 *cancellable,
                                       GError                      **error)
{
  struct _OstreeRepoRealCommitTraverseIter *real =
    (struct _OstreeRepoRealCommitTraverseIter*)iter;
  OstreeRepoCommitIterResult res = OSTREE_REPO_COMMIT_ITER_RESULT_ERROR;

  if (!real->current_dir)
    {
      if (!ostree_repo_load_variant (real->repo, OSTREE_OBJECT_TYPE_DIR_TREE,
                                     real->checksum_content,
                                     &real->current_dir,
                                     error))
        goto out;
      res = OSTREE_REPO_COMMIT_ITER_RESULT_DIR;
    }
  else
    {
      guint nfiles;
      guint ndirs;
      guint idx;
      const guchar *csum;
      g_autoptr(GVariant) content_csum_v = NULL;
      g_autoptr(GVariant) meta_csum_v = NULL;
      g_autoptr(GVariant) files_variant = NULL;
      g_autoptr(GVariant) dirs_variant = NULL;

      files_variant = g_variant_get_child_value (real->current_dir, 0);
      dirs_variant = g_variant_get_child_value (real->current_dir, 1);

      nfiles = g_variant_n_children (files_variant);
      ndirs = g_variant_n_children (dirs_variant);
      if (real->idx < nfiles)
        {
          idx = real->idx;
          g_variant_get_child (files_variant, idx, "(&s@ay)",
                               &real->name,
                               &content_csum_v);

          csum = ostree_checksum_bytes_peek_validate (content_csum_v, error);
          if (!csum)
            goto out;
          ostree_checksum_inplace_from_bytes (csum, real->checksum_content);

          res = OSTREE_REPO_COMMIT_ITER_RESULT_FILE;

          real->idx++;
        }
      else if (real->idx < nfiles + ndirs)
        {
          idx = real->idx - nfiles;

          g_variant_get_child (dirs_variant, idx, "(&s@ay@ay)",
                               &real->name, &content_csum_v, &meta_csum_v);

          csum = ostree_checksum_bytes_peek_validate (content_csum_v, error);
          if (!csum)
            goto out;
          ostree_checksum_inplace_from_bytes (csum, real->checksum_content);

          csum = ostree_checksum_bytes_peek_validate (meta_csum_v, error);
          if (!csum)
            goto out;
          ostree_checksum_inplace_from_bytes (csum, real->checksum_meta);
          
          res = OSTREE_REPO_COMMIT_ITER_RESULT_DIR;

          real->idx++;
        }
      else
        res = OSTREE_REPO_COMMIT_ITER_RESULT_END;
    }
  
  real->state = res;
 out:
  return res;
}

/**
 * ostree_repo_commit_traverse_iter_get_file:
 * @iter: An iter
 * @out_name: (out) (transfer none): Name of current file
 * @out_checksum: (out) (transfer none): Checksum of current file
 *
 * Return information on the current file.  This function may only be
 * called if %OSTREE_REPO_COMMIT_ITER_RESULT_FILE was returned from
 * ostree_repo_commit_traverse_iter_next().
 */
void
ostree_repo_commit_traverse_iter_get_file (OstreeRepoCommitTraverseIter *iter,
                                           char                        **out_name,
                                           char                        **out_checksum)
{
  struct _OstreeRepoRealCommitTraverseIter *real =
    (struct _OstreeRepoRealCommitTraverseIter*)iter;
  *out_name = (char*)real->name;
  *out_checksum = (char*)real->checksum_content;
}

/**
 * ostree_repo_commit_traverse_iter_get_dir:
 * @iter: An iter
 * @out_name: (out) (transfer none): Name of current dir
 * @out_content_checksum: (out) (transfer none): Checksum of current content
 * @out_meta_checksum: (out) (transfer none): Checksum of current metadata
 *
 * Return information on the current directory.  This function may
 * only be called if %OSTREE_REPO_COMMIT_ITER_RESULT_DIR was returned
 * from ostree_repo_commit_traverse_iter_next().
 */
void
ostree_repo_commit_traverse_iter_get_dir (OstreeRepoCommitTraverseIter *iter,
                                          char                        **out_name,
                                          char                        **out_content_checksum,
                                          char                        **out_meta_checksum)
{
  struct _OstreeRepoRealCommitTraverseIter *real =
    (struct _OstreeRepoRealCommitTraverseIter*)iter;
  *out_name = (char*)real->name;
  *out_content_checksum = (char*)real->checksum_content;
  *out_meta_checksum = (char*)real->checksum_meta;
}

void
ostree_repo_commit_traverse_iter_clear (OstreeRepoCommitTraverseIter *iter)
{
  struct _OstreeRepoRealCommitTraverseIter *real =
    (struct _OstreeRepoRealCommitTraverseIter*)iter;
  g_clear_object (&real->repo);
  g_clear_pointer (&real->commit, g_variant_unref);
  g_clear_pointer (&real->current_dir, g_variant_unref);
}

void
ostree_repo_commit_traverse_iter_cleanup (void *p)
{
  OstreeRepoCommitTraverseIter *iter = p;
  struct _OstreeRepoRealCommitTraverseIter *real =
    (struct _OstreeRepoRealCommitTraverseIter*)iter;
  if (real->initialized)
    {
      ostree_repo_commit_traverse_iter_clear (iter);
      real->initialized = FALSE;
    }
}

/**
 * ostree_repo_traverse_new_reachable:
 *
 * This hash table is a set of #GVariant which can be accessed via
 * ostree_object_name_deserialize().
 *
 * Returns: (transfer container) (element-type GVariant GVariant): A new hash table
 */
GHashTable *
ostree_repo_traverse_new_reachable (void)
{
  return g_hash_table_new_full (ostree_hash_object_name, g_variant_equal,
                                NULL, (GDestroyNotify)g_variant_unref);
}

/**
 * ostree_repo_traverse_new_parents:
 *
 * This hash table is a mapping from #GVariant which can be accessed
 * via ostree_object_name_deserialize() to a #GVariant containing either
 * a similar #GVariant or and array of them, listing the parents of the key.
 *
 * Returns: (transfer container) (element-type GVariant GVariant): A new hash table
 *
 * Since: 2018.5
 */
GHashTable *
ostree_repo_traverse_new_parents (void)
{
  return g_hash_table_new_full (ostree_hash_object_name, g_variant_equal,
                                (GDestroyNotify)g_variant_unref, (GDestroyNotify)g_variant_unref);
}

static void
parents_get_commits (GHashTable *parents_ht, GVariant *object, GHashTable *res)
{
  const char *checksum;
  OstreeObjectType type;

  if (object == NULL)
    return;

  ostree_object_name_deserialize (object, &checksum, &type);
  if (type == OSTREE_OBJECT_TYPE_COMMIT)
    g_hash_table_add (res, g_strdup (checksum));
  else
    {
      GVariant *parents = g_hash_table_lookup (parents_ht, object);

      if (parents == NULL)
        g_debug ("Unexpected NULL parent");
      else if (g_variant_is_of_type (parents, G_VARIANT_TYPE_ARRAY))
        {
          gsize i, len = g_variant_n_children (parents);

          for (i = 0; i < len; i++)
            {
              g_autoptr(GVariant) parent = g_variant_get_child_value (parents, i);
              parents_get_commits (parents_ht, parent, res);
            }
        }
      else
        parents_get_commits (parents_ht, parents, res);
    }
}

/**
 * ostree_repo_traverse_parents_get_commits:
 *
 * Gets all the commits that a certain object belongs to, as recorded
 * by a parents table gotten from ostree_repo_traverse_commit_union_with_parents.
 *
 * Returns: (transfer full) (array zero-terminated=1): An array of checksums for
 * the commits the key belongs to.
 *
 * Since: 2018.5
 */
char **
ostree_repo_traverse_parents_get_commits (GHashTable *parents, GVariant *object)
{
  g_autoptr(GHashTable) res = g_hash_table_new (g_str_hash, g_str_equal);

  parents_get_commits (parents, object, res);

  return (char **)g_hash_table_get_keys_as_array (res, NULL);
}

static gboolean
traverse_dirtree (OstreeRepo           *repo,
                  const char           *checksum,
                  GVariant             *parent_key,
                  GHashTable           *inout_reachable,
                  GHashTable           *inout_parents,
                  gboolean              ignore_missing_dirs,
                  GCancellable         *cancellable,
                  GError              **error);

static void
add_parent_ref (GHashTable  *inout_parents,
                GVariant    *key,
                GVariant    *parent_key)
{
  GVariant *old_parents;

  if (inout_parents == NULL)
    return;

  old_parents = g_hash_table_lookup (inout_parents, key);
  if (old_parents == NULL)
    {
      /* For the common case of a single pointer we skip using an array to save memory. */
      g_hash_table_insert (inout_parents, g_variant_ref (key), g_variant_ref (parent_key));
    }
  else
    {
      g_autofree GVariant **new_parents = NULL;
      gsize i, len = 0;

      if (g_variant_is_of_type (old_parents, G_VARIANT_TYPE_ARRAY))
        {
          gsize old_parents_len = g_variant_n_children (old_parents);
          new_parents = g_new (GVariant *,  old_parents_len + 1);
          for (i = 0; i < old_parents_len ; i++)
            {
              g_autoptr(GVariant) old_parent = g_variant_get_child_value (old_parents, i);
              if (!g_variant_equal (old_parent, parent_key))
                new_parents[len++] = g_steal_pointer (&old_parent);
            }
        }
      else
        {
          new_parents = g_new (GVariant *, 2);
          if (!g_variant_equal (old_parents, parent_key))
            new_parents[len++] = g_variant_ref (old_parents);
        }
      new_parents[len++] = g_variant_ref (parent_key);
      g_hash_table_insert (inout_parents, g_variant_ref (key),
                           g_variant_ref_sink (g_variant_new_array (G_VARIANT_TYPE ("(su)"), new_parents , len)));
      for (i = 0; i < len; i++)
        g_variant_unref (new_parents[i]);
    }
}


static gboolean
traverse_iter (OstreeRepo                          *repo,
               OstreeRepoCommitTraverseIter        *iter,
               GVariant                            *parent_key,
               GHashTable                          *inout_reachable,
               GHashTable                          *inout_parents,
               gboolean                             ignore_missing_dirs,
               GCancellable                        *cancellable,
               GError                             **error)
{
  while (TRUE)
    {
      g_autoptr(GVariant) key = NULL;
      g_autoptr(GError) local_error = NULL;
      OstreeRepoCommitIterResult iterres =
        ostree_repo_commit_traverse_iter_next (iter, cancellable, &local_error);

      if (iterres == OSTREE_REPO_COMMIT_ITER_RESULT_ERROR)
        {
          /* There is only one kind of not-found error, which is
             failing to load the dirmeta itself, if so, we ignore that
             (and the whole subtree) if told to. */
          if (ignore_missing_dirs &&
              g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
            {
              g_debug ("Ignoring not-found dirmeta");
              return TRUE;  /* Note early return */
            }

          g_propagate_error (error, g_steal_pointer (&local_error));
          return FALSE;
        }
      else if (iterres == OSTREE_REPO_COMMIT_ITER_RESULT_END)
        break;
      else if (iterres == OSTREE_REPO_COMMIT_ITER_RESULT_FILE)
        {
          char *name;
          char *checksum;

          ostree_repo_commit_traverse_iter_get_file (iter, &name, &checksum);

          g_debug ("Found file object %s", checksum);
          key = g_variant_ref_sink (ostree_object_name_serialize (checksum, OSTREE_OBJECT_TYPE_FILE));
          add_parent_ref (inout_parents, key, parent_key);
          g_hash_table_add (inout_reachable, g_steal_pointer (&key));
        }
      else if (iterres == OSTREE_REPO_COMMIT_ITER_RESULT_DIR)
        {
          char *name;
          char *content_checksum;
          char *meta_checksum;

          ostree_repo_commit_traverse_iter_get_dir (iter, &name, &content_checksum,
                                                    &meta_checksum);

          g_debug ("Found dirtree object %s", content_checksum);
          g_debug ("Found dirmeta object %s", meta_checksum);
          key = g_variant_ref_sink (ostree_object_name_serialize (meta_checksum, OSTREE_OBJECT_TYPE_DIR_META));
          add_parent_ref (inout_parents, key, parent_key);
          g_hash_table_add (inout_reachable, g_steal_pointer (&key));

          key = g_variant_ref_sink (ostree_object_name_serialize (content_checksum, OSTREE_OBJECT_TYPE_DIR_TREE));
          add_parent_ref (inout_parents, key, parent_key);
          if (!g_hash_table_lookup (inout_reachable, key))
            {
              if (!traverse_dirtree (repo, content_checksum, key, inout_reachable, inout_parents,
                                     ignore_missing_dirs, cancellable, error))
                return FALSE;

              g_hash_table_add (inout_reachable, g_steal_pointer (&key));
            }
        }
      else
        g_assert_not_reached ();
    }

  return TRUE;
}

static gboolean
traverse_dirtree (OstreeRepo           *repo,
                  const char           *checksum,
                  GVariant             *parent_key,
                  GHashTable           *inout_reachable,
                  GHashTable           *inout_parents,
                  gboolean              ignore_missing_dirs,
                  GCancellable         *cancellable,
                  GError              **error)
{
  g_autoptr(GError) local_error = NULL;

  g_autoptr(GVariant) dirtree = NULL;
  if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_DIR_TREE, checksum,
                                 &dirtree, &local_error))
    {
      if (ignore_missing_dirs &&
          g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
        {
          g_debug ("Ignoring not-found dirmeta %s", checksum);
          return TRUE; /* Early return */
        }

      g_propagate_error (error, g_steal_pointer (&local_error));
      return FALSE;
    }

  g_debug ("Traversing dirtree %s", checksum);
  ostree_cleanup_repo_commit_traverse_iter
    OstreeRepoCommitTraverseIter iter = { 0, };
  if (!ostree_repo_commit_traverse_iter_init_dirtree (&iter, repo, dirtree,
                                                      OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE,
                                                      error))
    return FALSE;

  if (!traverse_iter (repo, &iter, parent_key, inout_reachable, inout_parents, ignore_missing_dirs, cancellable, error))
    return FALSE;

  return TRUE;
}

/**
 * ostree_repo_traverse_commit_union_with_parents: (skip)
 * @repo: Repo
 * @commit_checksum: ASCII SHA256 checksum
 * @maxdepth: Traverse this many parent commits, -1 for unlimited
 * @inout_reachable: Set of reachable objects
 * @inout_parents: Map from object to parent object
 * @cancellable: Cancellable
 * @error: Error
 *
 * Update the set @inout_reachable containing all objects reachable
 * from @commit_checksum, traversing @maxdepth parent commits.
 *
 * Additionally this constructs a mapping from each object to the parents
 * of the object, which can be used to track which commits an object
 * belongs to.
 *
 * Since: 2018.5
 */
gboolean
ostree_repo_traverse_commit_union_with_parents (OstreeRepo      *repo,
                                                const char      *commit_checksum,
                                                int              maxdepth,
                                                GHashTable      *inout_reachable,
                                                GHashTable      *inout_parents,
                                                GCancellable    *cancellable,
                                                GError         **error)
{
  g_autofree char *tmp_checksum = NULL;

  while (TRUE)
    {
      g_autoptr(GVariant) key =
        g_variant_ref_sink (ostree_object_name_serialize (commit_checksum, OSTREE_OBJECT_TYPE_COMMIT));

      if (g_hash_table_contains (inout_reachable, key))
        break;

      g_autoptr(GVariant) commit = NULL;
      if (!ostree_repo_load_variant_if_exists (repo, OSTREE_OBJECT_TYPE_COMMIT,
                                               commit_checksum, &commit,
                                               error))
        return FALSE;

      /* Just return if the parent isn't found; we do expect most
       * people to have partial repositories.
       */
      if (!commit)
        break;

      /* See if the commit is partial, if so it's not an error to lack objects */
      OstreeRepoCommitState commitstate;
      if (!ostree_repo_load_commit (repo, commit_checksum, NULL, &commitstate,
                                    error))
        return FALSE;

      gboolean ignore_missing_dirs = FALSE;
      if ((commitstate & OSTREE_REPO_COMMIT_STATE_PARTIAL) != 0)
        ignore_missing_dirs = TRUE;

      g_hash_table_add (inout_reachable, g_variant_ref (key));

      g_debug ("Traversing commit %s", commit_checksum);
      ostree_cleanup_repo_commit_traverse_iter
        OstreeRepoCommitTraverseIter iter = { 0, };
      if (!ostree_repo_commit_traverse_iter_init_commit (&iter, repo, commit,
                                                         OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE,
                                                         error))
        return FALSE;

      if (!traverse_iter (repo, &iter, key, inout_reachable, inout_parents, ignore_missing_dirs, cancellable, error))
        return FALSE;

      gboolean recurse = FALSE;
      if (maxdepth == -1 || maxdepth > 0)
        {
          g_free (tmp_checksum);
          tmp_checksum = ostree_commit_get_parent (commit);
          if (tmp_checksum)
            {
              commit_checksum = tmp_checksum;
              if (maxdepth > 0)
                maxdepth -= 1;
              recurse = TRUE;
            }
        }
      if (!recurse)
        break;
    }

  return TRUE;
}

/**
 * ostree_repo_traverse_commit_union: (skip)
 * @repo: Repo
 * @commit_checksum: ASCII SHA256 checksum
 * @maxdepth: Traverse this many parent commits, -1 for unlimited
 * @inout_reachable: Set of reachable objects
 * @cancellable: Cancellable
 * @error: Error
 *
 * Update the set @inout_reachable containing all objects reachable
 * from @commit_checksum, traversing @maxdepth parent commits.
 */
gboolean
ostree_repo_traverse_commit_union (OstreeRepo      *repo,
                                   const char      *commit_checksum,
                                   int              maxdepth,
                                   GHashTable      *inout_reachable,
                                   GCancellable    *cancellable,
                                   GError         **error)
{
  return
    ostree_repo_traverse_commit_union_with_parents (repo, commit_checksum, maxdepth,
                                                    inout_reachable, NULL,
                                                    cancellable, error);
}

/**
 * ostree_repo_traverse_commit:
 * @repo: Repo
 * @commit_checksum: ASCII SHA256 checksum
 * @maxdepth: Traverse this many parent commits, -1 for unlimited
 * @out_reachable: (out) (transfer container) (element-type GVariant GVariant): Set of reachable objects
 * @cancellable: Cancellable
 * @error: Error
 *
 * Create a new set @out_reachable containing all objects reachable
 * from @commit_checksum, traversing @maxdepth parent commits.
 */
gboolean
ostree_repo_traverse_commit (OstreeRepo      *repo,
                             const char      *commit_checksum,
                             int              maxdepth,
                             GHashTable     **out_reachable,
                             GCancellable    *cancellable,
                             GError         **error)
{
  g_autoptr(GHashTable) ret_reachable = ostree_repo_traverse_new_reachable ();
  if (!ostree_repo_traverse_commit_union (repo, commit_checksum, maxdepth,
                                          ret_reachable, cancellable, error))
    return FALSE;

  if (out_reachable)
    *out_reachable = g_steal_pointer (&ret_reachable);
  return TRUE;
}