/*

 * 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.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author: Ryan Lortie <desrt@desrt.ca>

 */

#include "gvdb-reader.h"

#include "gvdb-format.h"

#include <string.h>

struct _GvdbTable {

  gint ref_count;

  const gchar *data;

  gsize size;

  gpointer user_data;

  GvdbRefFunc ref_user_data;

  GDestroyNotify unref_user_data;

  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);

}

static GvdbTable *

new_from_data (const void    *data,

	       gsize          data_len,

	       gboolean       trusted,

	       gpointer       user_data,

	       GvdbRefFunc    ref,

	       GDestroyNotify unref,

	       const char    *filename,

	       GError       **error)

{

  GvdbTable *file;

  file = g_slice_new0 (GvdbTable);

  file->data = data;

  file->size = data_len;

  file->trusted = trusted;

  file->ref_count = 1;

  file->ref_user_data = ref;

  file->unref_user_data = unref;

  file->user_data = user_data;

  if (sizeof (struct gvdb_header) <= file->size)

    {

      const struct gvdb_header *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

        {

	  if (filename)

	    g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_INVAL,

			 "%s: invalid header", filename);

	  else

	    g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_INVAL,

			 "invalid gvdb header");

          g_slice_free (GvdbTable, file);

	  if (unref)

	    unref (user_data);

          return NULL;

        }

      gvdb_table_setup_root (file, &header->root);

    }

  return file;

}

/**

 * gvdb_table_new:

 * @filename: the path to the hash file

 * @trusted: if the contents of @filename are trusted

 * @error: %NULL, or a pointer to a %NULL #GError

 *

 * Creates a new #GvdbTable from the contents of the file found at

 * @filename.

 *

 * The only time this function fails is if the file cannot be opened.

 * In that case, the #GError that is returned will be an error from

 * g_mapped_file_new().

 *

 * An empty or otherwise corrupted file is considered to be a valid

 * #GvdbTable with no entries.

 *

 * You should call gvdb_table_unref() on the return result when you no

 * longer require it.

 *

 * Returns: a new #GvdbTable

 **/

GvdbTable *

gvdb_table_new (const gchar  *filename,

                gboolean      trusted,

                GError      **error)

{

  GMappedFile *mapped;

  if ((mapped = g_mapped_file_new (filename, FALSE, error)) == NULL)

    return NULL;

  return new_from_data (g_mapped_file_get_contents (mapped),

			g_mapped_file_get_length (mapped),

			trusted,

			mapped,

			(GvdbRefFunc)g_mapped_file_ref,

			(GDestroyNotify)g_mapped_file_unref,

			filename,

			error);

}

/**

 * gvdb_table_new_from_data:

 * @data: the data

 * @data_len: the length of @data in bytes

 * @trusted: if the contents of @data are trusted

 * @user_data: User supplied data that owns @data

 * @ref: Ref function for @user_data

 * @unref: Unref function for @user_data

 *

 * Creates a new #GvdbTable from the data in @data.

 *

 * An empty or otherwise corrupted data is considered to be a valid

 * #GvdbTable with no entries.

 *

 * You should call gvdb_table_unref() on the return result when you no

 * longer require it.

 *

 * Returns: a new #GvdbTable

 **/

GvdbTable *

gvdb_table_new_from_data (const void    *data,

			  gsize          data_len,

			  gboolean       trusted,

			  gpointer       user_data,

			  GvdbRefFunc    ref,

			  GDestroyNotify unref,

			  GError        **error)

{

  return new_from_data (data, data_len,

			trusted,

			user_data, ref, unref,

			NULL,

			error);

}

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 const struct gvdb_hash_item *

gvdb_table_get_item (GvdbTable  *table,

                     guint32_le  item_no)

{

  guint32 item_no_native = guint32_from_le (item_no);

  if G_LIKELY (item_no_native < table->n_hash_items)

    return table->hash_items + item_no_native;

  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_list:

 * @file: a #GvdbTable

 * @key: a string

 *

 * 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.

 *

 * Returns: a %NULL-terminated string array

 **/

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

 *

 * Checks for a value named @key in @file.

 *

 * Note: this function does not consider non-value nodes (other hash

 * tables, for example).

 *

 * Returns: %TRUE if @key is in the table

 **/

gboolean

gvdb_table_has_value (GvdbTable    *file,

                      const gchar  *key)

{

  return gvdb_table_lookup (file, key, 'v') != NULL;

}

static GVariant *

gvdb_table_value_from_item (GvdbTable                   *table,

                            const struct gvdb_hash_item *item)

{

  GVariant *variant, *value;

  gconstpointer data;

  gsize size;

  data = gvdb_table_dereference (table, &item->value.pointer, 8, &size);

  if G_UNLIKELY (data == NULL)

    return NULL;

  variant = g_variant_new_from_data (G_VARIANT_TYPE_VARIANT,

                                     data, size, table->trusted,

                                     table->unref_user_data,

                                     table->ref_user_data ? table->ref_user_data (table->user_data) : table->user_data);

  value = g_variant_get_variant (variant);

  g_variant_unref (variant);

  return value;

}

/**

 * gvdb_table_get_value:

 * @file: a #GvdbTable

 * @key: a string

 *

 * 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.

 *

 * Returns: a #GVariant, or %NULL

 **/

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

 *

 * Looks up a value named @key in @file.

 *

 * This call is equivalent to gvdb_table_get_value() except that it

 * never byteswaps the value.

 *

 * Returns: a #GVariant, or %NULL

 **/

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

 *

 * 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_unref() on the return result when you no

 * longer require it.

 *

 * Returns: a new #GvdbTable, or %NULL

 **/

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->user_data = file->ref_user_data ? file->ref_user_data (file->user_data) : file->user_data;

  new->ref_user_data = file->ref_user_data;

  new->unref_user_data = file->unref_user_data;

  new->byteswapped = file->byteswapped;

  new->trusted = file->trusted;

  new->data = file->data;

  new->size = file->size;

  new->ref_count = 1;

  gvdb_table_setup_root (new, &item->value.pointer);

  return new;

}

/**

 * gvdb_table_ref:

 * @file: a #GvdbTable

 *

 * Increases the reference count on @file.

 *

 * Returns: a new reference on @file

 **/

GvdbTable *

gvdb_table_ref (GvdbTable *file)

{

  g_atomic_int_inc (&file->ref_count);

  return file;

}

/**

 * gvdb_table_unref:

 * @file: a #GvdbTable

 *

 * Decreases the reference count on @file, possibly freeing it.

 *

 * Since: 2.26

 **/

void

gvdb_table_unref (GvdbTable *file)

{

  if (g_atomic_int_dec_and_test (&file->ref_count))

    {

      if (file->unref_user_data)

	file->unref_user_data (file->user_data);

      g_slice_free (GvdbTable, file);

    }

}

/**

 * gvdb_table_is_valid:

 * @table: a #GvdbTable

 *

 * 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.

 *

 * Returns: %TRUE if @table is still valid

 **/

gboolean

gvdb_table_is_valid (GvdbTable *table)

{

  return !!*table->data;

}

/**

 * gvdb_table_walk:

 * @table: a #GvdbTable

 * @key: a key corresponding to a list

 * @open_func: the #GvdbWalkOpenFunc

 * @value_func: the #GvdbWalkValueFunc

 * @close_func: the #GvdbWalkCloseFunc

 * @user_data: data to pass to the callbacks

 *

 * Looks up the list at @key and iterate over the items in it.

 *

 * First, @open_func is called to signal that we are starting to iterate over

 * the list.  Then the list is iterated.  When all items in the list have been

 * iterated over, the @close_func is called.

 *

 * When iterating, if a given item in the list is a value then @value_func is

 * called.

 *

 * If a given item in the list is itself a list then @open_func is called.  If

 * that function returns %TRUE then the walk begins iterating the items in the

 * sublist, until there are no more items, at which point a matching

 * @close_func call is made.  If @open_func returns %FALSE then no iteration of

 * the sublist occurs and no corresponding @close_func call is made.

 **/

void

gvdb_table_walk (GvdbTable         *table,

                 const gchar       *key,

                 GvdbWalkOpenFunc   open_func,

                 GvdbWalkValueFunc  value_func,

                 GvdbWalkCloseFunc  close_func,

                 gpointer           user_data)

{

  const struct gvdb_hash_item *item;

  const guint32_le *pointers[64];

  const guint32_le *enders[64];

  gsize name_lengths[64];

  gint index = 0;

  item = gvdb_table_lookup (table, key, 'L');

  name_lengths[0] = 0;

  pointers[0] = NULL;

  enders[0] = NULL;

  goto start_here;

  while (index)

    {

      close_func (name_lengths[index], user_data);

      index--;

      while (pointers[index] < enders[index])

        {

          const gchar *name;

          gsize name_len;

          item = gvdb_table_get_item (table, *pointers[index]++);

 start_here:

          if (item != NULL &&

              (name = gvdb_table_item_get_key (table, item, &name_len)))

            {

              if (item->type == 'L')

                {

                  if (open_func (name, name_len, user_data))

                    {

                      guint length = 0;

                      index++;

                      g_assert (index < 64);

                      gvdb_table_list_from_item (table, item,

                                                 &pointers[index],

                                                 &length);

                      enders[index] = pointers[index] + length;

                      name_lengths[index] = name_len;

                    }

                }

              else if (item->type == 'v')

                {

                  GVariant *value;

                  value = gvdb_table_value_from_item (table, item);

                  if (value != NULL)

                    {

                      if (table->byteswapped)

                        {

                          GVariant *tmp;

                          tmp = g_variant_byteswap (value);

                          g_variant_unref (value);

                          value = tmp;

                        }

                      value_func (name, name_len, value, user_data);

                      g_variant_unref (value);

                    }

                }

            }

        }

    }

}