mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-02 15:46:17 +01:00
744 lines
20 KiB
C
744 lines
20 KiB
C
/*
|
|
* 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, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*
|
|
* 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
|
|
* @returns: a new #GvdbTable
|
|
*
|
|
* 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.
|
|
**/
|
|
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
|
|
* @returns: a new #GvdbTable
|
|
*
|
|
* 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.
|
|
**/
|
|
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
|
|
* @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)
|
|
{
|
|
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
|
|
* @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_unref() 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->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
|
|
* @returns: a new reference on @file
|
|
*
|
|
* Increases the reference count 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
|
|
* @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;
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|