luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-14 13:26:16 +01:00
Code Issues Packages Projects Releases Wiki Activity
d349902ce6
glib/gmetadata.c
Mark Doffman d349902ce6 girepository/ginvoke.c girepository/girepository.h 
2008-02-21  Mark Doffman  <mark.doffman@codethink.co.uk>

    * girepository/ginvoke.c
    * girepository/girepository.h
    * girepository/gmetadata.c
    * girepository/gmetadata.h
    * tools/generate.c
    * tools/gidlparser.c

      Modify TYPE_TAG_INTERFACE to TYPE_TAG_SYMBOL
      to avoid confusion with the interface blob.

    * tools/generate.c
    * tools/gidlparser.c

      Remove magic numbers and replace with type-tag
      enumeration symbols.

    * girepository/gmetadata.c
      Add validate declaration.

WARNING: This commit does not compile. It is a partial change.

svn path=/trunk/; revision=129
2008-03-10 17:44:06 +00:00

1882 lines
43 KiB
C
Raw Blame History

/* GObject introspection: metadata validation, auxiliary functions
* related to the binary metadata format
*
* Copyright (C) 2005 Matthias Clasen
*
* 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.
*/
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "gmetadata.h"
#define ALIGN_VALUE(this, boundary) \
(( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
static gboolean
validate_blob (GMetadata *metadata,
guint32 offset,
GError **error);
DirEntry *
g_metadata_get_dir_entry (GMetadata *metadata,
guint16 index)
{
Header *header = (Header *)metadata->data;
return (DirEntry *)&metadata->data[header->directory + (index - 1) * header->entry_blob_size];
}
void
g_metadata_check_sanity (void)
{
/* Check that struct layout is as we expect */
g_assert (sizeof (Header) == 100);
g_assert (sizeof (DirEntry) == 12);
g_assert (sizeof (SimpleTypeBlob) == 4);
g_assert (sizeof (ArgBlob) == 12);
g_assert (sizeof (SignatureBlob) == 8);
g_assert (sizeof (CommonBlob) == 8);
g_assert (sizeof (FunctionBlob) == 16);
g_assert (sizeof (InterfaceTypeBlob) == 4);
g_assert (sizeof (ArrayTypeBlob) == 8);
g_assert (sizeof (ParamTypeBlob) == 4);
g_assert (sizeof (ErrorTypeBlob) == 4);
g_assert (sizeof (ErrorDomainBlob) == 16);
g_assert (sizeof (ValueBlob) == 12);
g_assert (sizeof (FieldBlob) == 12);
g_assert (sizeof (RegisteredTypeBlob) == 16);
g_assert (sizeof (StructBlob) == 20);
g_assert (sizeof (EnumBlob) == 20);
g_assert (sizeof (PropertyBlob) == 12);
g_assert (sizeof (SignalBlob) == 12);
g_assert (sizeof (VFuncBlob) == 16);
g_assert (sizeof (ObjectBlob) == 32);
g_assert (sizeof (InterfaceBlob) == 28);
g_assert (sizeof (ConstantBlob) == 20);
g_assert (sizeof (AnnotationBlob) == 12);
g_assert (sizeof (UnionBlob) == 28);
}
static gboolean
is_aligned (guint32 offset)
{
return offset == ALIGN_VALUE (offset, 4);
}
#define MAX_NAME_LEN 200
static gboolean
is_name (const guchar *data, guint32 offset)
{
gchar *name;
name = (gchar*)&data[offset];
if (!memchr (name, '\0', MAX_NAME_LEN))
return FALSE;
if (strspn (name, G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "-_") < strlen (name))
return FALSE;
return TRUE;
}
static gboolean
validate_header (GMetadata *metadata,
GError **error)
{
Header *header;
if (metadata->len < sizeof (Header))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
header = (Header *)metadata->data;
if (strncmp (header->magic, G_IDL_MAGIC, 16) != 0)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Magic string not found");
return FALSE;
}
if (header->major_version != 1 || header->minor_version != 0)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Version mismatch");
return FALSE;
}
if (header->n_entries < header->n_local_entries)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Inconsistent entry counts");
return FALSE;
}
if (header->size != metadata->len)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Metadata size mismatch");
return FALSE;
}
if (header->entry_blob_size != 12 ||
header->function_blob_size != 16 ||
header->callback_blob_size != 12 ||
header->signal_blob_size != 12 ||
header->vfunc_blob_size != 16 ||
header->arg_blob_size != 12 ||
header->property_blob_size != 12 ||
header->field_blob_size != 12 ||
header->value_blob_size != 12 ||
header->constant_blob_size != 20 ||
header->error_domain_blob_size != 16 ||
header->annotation_blob_size != 12 ||
header->signature_blob_size != 8 ||
header->enum_blob_size != 20 ||
header->struct_blob_size != 20 ||
header->object_blob_size != 32 ||
header->interface_blob_size != 28 ||
header->union_blob_size != 28)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Blob size mismatch");
return FALSE;
}
if (!is_aligned (header->directory))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Misaligned directory");
return FALSE;
}
if (!is_aligned (header->annotations))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Misaligned annotations");
return FALSE;
}
if (header->annotations == 0 && header->n_annotations > 0)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Wrong number of annotations");
return FALSE;
}
if (!is_name (metadata->data, header->namespace))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_HEADER,
"Invalid namespace name");
return FALSE;
}
return TRUE;
}
static gboolean validate_type_blob (GMetadata *metadata,
guint32 offset,
guint32 signature_offset,
gboolean return_type,
GError **error);
static gboolean
validate_array_type_blob (GMetadata *metadata,
guint32 offset,
guint32 signature_offset,
gboolean return_type,
GError **error)
{
ArrayTypeBlob *blob;
blob = (ArrayTypeBlob*)&metadata->data[offset];
if (!blob->pointer)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Pointer type exected for tag %d", blob->tag);
return FALSE;
}
/* FIXME validate length */
if (!validate_type_blob (metadata,
offset + G_STRUCT_OFFSET (ArrayTypeBlob, type),
0, FALSE, error))
return FALSE;
return TRUE;
}
static gboolean
validate_iface_type_blob (GMetadata *metadata,
guint32 offset,
guint32 signature_offset,
gboolean return_type,
GError **error)
{
InterfaceTypeBlob *blob;
Header *header;
header = (Header *)metadata->data;
blob = (InterfaceTypeBlob*)&metadata->data[offset];
if (blob->interface == 0 || blob->interface > header->n_entries)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid directory index %d", blob->interface);
return FALSE;
}
return TRUE;
}
static gboolean
validate_param_type_blob (GMetadata *metadata,
guint32 offset,
guint32 signature_offset,
gboolean return_type,
gint n_params,
GError **error)
{
ParamTypeBlob *blob;
gint i;
blob = (ParamTypeBlob*)&metadata->data[offset];
if (!blob->pointer)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Pointer type exected for tag %d", blob->tag);
return FALSE;
}
if (blob->n_types != n_params)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Parameter type number mismatch");
return FALSE;
}
for (i = 0; i < n_params; i++)
{
if (!validate_type_blob (metadata,
offset + sizeof (ParamTypeBlob) +
i * sizeof (SimpleTypeBlob),
0, FALSE, error))
return FALSE;
}
return TRUE;
}
static gboolean
validate_error_type_blob (GMetadata *metadata,
guint32 offset,
guint32 signature_offset,
gboolean return_type,
GError **error)
{
ErrorTypeBlob *blob;
Header *header;
gint i;
DirEntry *entry;
blob = (ErrorTypeBlob*)&metadata->data[offset];
header = (Header *)metadata->data;
if (!blob->pointer)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Pointer type exected for tag %d", blob->tag);
return FALSE;
}
for (i = 0; i < blob->n_domains; i++)
{
if (blob->domains[i] == 0 || blob->domains[i] > header->n_entries)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid directory index %d", blob->domains[i]);
return FALSE;
}
entry = g_metadata_get_dir_entry (metadata, blob->domains[i]);
if (entry->blob_type != BLOB_TYPE_ERROR_DOMAIN &&
(entry->local || entry->blob_type != BLOB_TYPE_INVALID))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
}
return TRUE;
}
static gboolean
validate_type_blob (GMetadata *metadata,
guint32 offset,
guint32 signature_offset,
gboolean return_type,
GError **error)
{
SimpleTypeBlob *simple;
InterfaceTypeBlob *iface;
simple = (SimpleTypeBlob *)&metadata->data[offset];
if (simple->reserved == 0 &&
simple->reserved2 == 0)
{
if (simple->tag >= TYPE_TAG_ARRAY)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong tag in simple type");
return FALSE;
}
if (simple->tag >= TYPE_TAG_UTF8 &&
!simple->pointer)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Pointer type exected for tag %d", simple->tag);
return FALSE;
}
return TRUE;
}
iface = (InterfaceTypeBlob*)&metadata->data[simple->offset];
switch (iface->tag)
{
case TYPE_TAG_ARRAY:
if (!validate_array_type_blob (metadata, simple->offset,
signature_offset, return_type, error))
return FALSE;
break;
case TYPE_TAG_SYMBOL:
if (!validate_blob (metadata, simple->offset,
error))
return FALSE;
break;
case TYPE_TAG_LIST:
case TYPE_TAG_SLIST:
if (!validate_param_type_blob (metadata, simple->offset,
signature_offset, return_type, 1, error))
return FALSE;
break;
case TYPE_TAG_HASH:
if (!validate_param_type_blob (metadata, simple->offset,
signature_offset, return_type, 2, error))
return FALSE;
break;
case TYPE_TAG_ERROR:
if (!validate_error_type_blob (metadata, simple->offset,
signature_offset, return_type, error))
return FALSE;
break;
default:
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong tag in complex type");
return FALSE;
}
return TRUE;
}
static gboolean
validate_arg_blob (GMetadata *metadata,
guint32 offset,
guint32 signature_offset,
GError **error)
{
ArgBlob *blob;
if (metadata->len < offset + sizeof (ArgBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (ArgBlob*) &metadata->data[offset];
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid argument name");
return FALSE;
}
if (!validate_type_blob (metadata,
offset + G_STRUCT_OFFSET (ArgBlob, arg_type),
signature_offset, FALSE, error))
return FALSE;
return TRUE;
}
static gboolean
validate_signature_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
SignatureBlob *blob;
gint i;
if (metadata->len < offset + sizeof (SignatureBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (SignatureBlob*) &metadata->data[offset];
if (blob->return_type.offset != 0)
{
if (!validate_type_blob (metadata,
offset + G_STRUCT_OFFSET (SignatureBlob, return_type),
offset, TRUE, error))
return FALSE;
}
for (i = 0; i < blob->n_arguments; i++)
{
if (!validate_arg_blob (metadata,
offset + sizeof (SignatureBlob) +
i * sizeof (ArgBlob),
offset,
error))
return FALSE;
}
/* FIXME check constraints on return_value */
/* FIXME check array-length pairs */
return TRUE;
}
static gboolean
validate_function_blob (GMetadata *metadata,
guint32 offset,
guint16 container_type,
GError **error)
{
FunctionBlob *blob;
if (metadata->len < offset + sizeof (FunctionBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (FunctionBlob*) &metadata->data[offset];
if (blob->blob_type != BLOB_TYPE_FUNCTION)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid function name");
return FALSE;
}
if (!is_name (metadata->data, blob->symbol))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid function symbol");
return FALSE;
}
if (blob->constructor)
{
switch (container_type)
{
case BLOB_TYPE_BOXED:
case BLOB_TYPE_OBJECT:
case BLOB_TYPE_INTERFACE:
break;
default:
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Constructor not allowed");
return FALSE;
}
}
if (blob->setter || blob->getter || blob->wraps_vfunc)
{
switch (container_type)
{
case BLOB_TYPE_OBJECT:
case BLOB_TYPE_INTERFACE:
break;
default:
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Setter, getter or wrapper not allowed");
return FALSE;
}
}
if (blob->index)
{
if (!(blob->setter || blob->getter || blob->wraps_vfunc))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Must be setter, getter or wrapper");
return FALSE;
}
}
/* FIXME: validate index range */
/* FIXME: validate "this" argument for methods */
/* FIXME: validate return type for constructors */
if (!validate_signature_blob (metadata, blob->signature, error))
return FALSE;
return TRUE;
}
static gboolean
validate_callback_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
CallbackBlob *blob;
if (metadata->len < offset + sizeof (CallbackBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (CallbackBlob*) &metadata->data[offset];
if (blob->blob_type != BLOB_TYPE_CALLBACK)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid callback name");
return FALSE;
}
if (!validate_signature_blob (metadata, blob->signature, error))
return FALSE;
return TRUE;
}
static gboolean
validate_constant_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
gint value_size[] = {
0, 4, 1, 1, 2, 2, 4, 4, 8, 8,
sizeof (gint), sizeof (guint),
sizeof (glong), sizeof (gulong),
sizeof (gssize), sizeof (gsize),
sizeof (gfloat), sizeof (gdouble),
0, 0
};
ConstantBlob *blob;
SimpleTypeBlob *type;
if (metadata->len < offset + sizeof (ConstantBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (ConstantBlob*) &metadata->data[offset];
if (blob->blob_type != BLOB_TYPE_CONSTANT)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid constant name");
return FALSE;
}
if (!validate_type_blob (metadata, offset + G_STRUCT_OFFSET (ConstantBlob, type),
0, FALSE, error))
return FALSE;
if (!is_aligned (blob->offset))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Misaligned constant value");
return FALSE;
}
type = (SimpleTypeBlob *)&metadata->data[offset + G_STRUCT_OFFSET (ConstantBlob, type)];
if (type->reserved == 0)
{
if (type->tag == 0)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Constant value type void");
return FALSE;
}
if (value_size[type->tag] != 0 &&
blob->size != value_size[type->tag])
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Constant value size mismatch");
return FALSE;
}
/* FIXME check string values */
}
return TRUE;
}
static gboolean
validate_value_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
ValueBlob *blob;
if (metadata->len < offset + sizeof (ValueBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (ValueBlob*) &metadata->data[offset];
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid value name");
return FALSE;
}
return TRUE;
}
static gboolean
validate_field_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
FieldBlob *blob;
if (metadata->len < offset + sizeof (FieldBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (FieldBlob*) &metadata->data[offset];
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid field name");
return FALSE;
}
if (!validate_type_blob (metadata,
offset + G_STRUCT_OFFSET (FieldBlob, type),
0, FALSE, error))
return FALSE;
return TRUE;
}
static gboolean
validate_property_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
PropertyBlob *blob;
if (metadata->len < offset + sizeof (PropertyBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (PropertyBlob*) &metadata->data[offset];
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid property name");
return FALSE;
}
if (!validate_type_blob (metadata,
offset + G_STRUCT_OFFSET (PropertyBlob, type),
0, FALSE, error))
return FALSE;
return TRUE;
}
static gboolean
validate_signal_blob (GMetadata *metadata,
guint32 offset,
guint32 container_offset,
GError **error)
{
SignalBlob *blob;
gint n_signals;
if (metadata->len < offset + sizeof (SignalBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (SignalBlob*) &metadata->data[offset];
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid signal name");
return FALSE;
}
if ((blob->run_first != 0) +
(blob->run_last != 0) +
(blob->run_cleanup != 0) != 1)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid signal run flags");
return FALSE;
}
if (blob->has_class_closure)
{
if (((CommonBlob*)&metadata->data[container_offset])->blob_type == BLOB_TYPE_OBJECT)
{
ObjectBlob *object;
object = (ObjectBlob*)&metadata->data[container_offset];
n_signals = object->n_signals;
}
else
{
InterfaceBlob *iface;
iface = (InterfaceBlob*)&metadata->data[container_offset];
n_signals = iface->n_signals;
}
if (blob->class_closure >= n_signals)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid class closure index");
return FALSE;
}
}
if (!validate_signature_blob (metadata, blob->signature, error))
return FALSE;
return TRUE;
}
static gboolean
validate_vfunc_blob (GMetadata *metadata,
guint32 offset,
guint32 container_offset,
GError **error)
{
VFuncBlob *blob;
gint n_vfuncs;
if (metadata->len < offset + sizeof (VFuncBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (VFuncBlob*) &metadata->data[offset];
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid vfunc name");
return FALSE;
}
if (blob->class_closure)
{
if (((CommonBlob*)&metadata->data[container_offset])->blob_type == BLOB_TYPE_OBJECT)
{
ObjectBlob *object;
object = (ObjectBlob*)&metadata->data[container_offset];
n_vfuncs = object->n_vfuncs;
}
else
{
InterfaceBlob *iface;
iface = (InterfaceBlob*)&metadata->data[container_offset];
n_vfuncs = iface->n_vfuncs;
}
if (blob->class_closure >= n_vfuncs)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid class closure index");
return FALSE;
}
}
if (!validate_signature_blob (metadata, blob->signature, error))
return FALSE;
return TRUE;
}
static gboolean
validate_struct_blob (GMetadata *metadata,
guint32 offset,
guint16 blob_type,
GError **error)
{
StructBlob *blob;
gint i;
if (metadata->len < offset + sizeof (StructBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (StructBlob*) &metadata->data[offset];
if (blob->blob_type != blob_type)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
if ((blob->blob_type == BLOB_TYPE_BOXED && blob->unregistered) ||
(blob->blob_type == BLOB_TYPE_STRUCT && !blob->unregistered))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Registration/blob type mismatch");
return FALSE;
}
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid struct name");
return FALSE;
}
if (blob_type == BLOB_TYPE_BOXED)
{
if (!is_name (metadata->data, blob->gtype_name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid boxed type name");
return FALSE;
}
if (!is_name (metadata->data, blob->gtype_init))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid boxed type init");
return FALSE;
}
}
else
{
if (blob->gtype_name || blob->gtype_init)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Gtype data in struct");
return FALSE;
}
}
if (metadata->len < offset + sizeof (StructBlob) +
blob->n_fields * sizeof (FieldBlob) +
blob->n_methods * sizeof (FunctionBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
for (i = 0; i < blob->n_fields; i++)
{
if (!validate_field_blob (metadata,
offset + sizeof (StructBlob) +
i * sizeof (FieldBlob),
error))
return FALSE;
}
for (i = 0; i < blob->n_methods; i++)
{
if (!validate_function_blob (metadata,
offset + sizeof (StructBlob) +
blob->n_fields * sizeof (FieldBlob) +
i * sizeof (FunctionBlob),
blob_type,
error))
return FALSE;
}
return TRUE;
}
static gboolean
validate_enum_blob (GMetadata *metadata,
guint32 offset,
guint16 blob_type,
GError **error)
{
EnumBlob *blob;
ValueBlob *v1, *v2;
gint i, j;
if (metadata->len < offset + sizeof (EnumBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (EnumBlob*) &metadata->data[offset];
if (blob->blob_type != blob_type)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
if (!blob->unregistered)
{
if (!is_name (metadata->data, blob->gtype_name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid enum type name");
return FALSE;
}
if (!is_name (metadata->data, blob->gtype_init))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid enum type init");
return FALSE;
}
}
else
{
if (blob->gtype_name || blob->gtype_init)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Gtype data in unregistered enum");
return FALSE;
}
}
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid enum name");
return FALSE;
}
if (metadata->len < offset + sizeof (EnumBlob) +
blob->n_values * sizeof (ValueBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
for (i = 0; i < blob->n_values; i++)
{
if (!validate_value_blob (metadata,
offset + sizeof (EnumBlob) +
i * sizeof (ValueBlob),
error))
return FALSE;
v1 = (ValueBlob *)&metadata->data[offset + sizeof (EnumBlob) +
i * sizeof (ValueBlob)];
for (j = 0; j < i; j++)
{
v2 = (ValueBlob *)&metadata->data[offset + sizeof (EnumBlob) +
j * sizeof (ValueBlob)];
if (v1->value == v2->value)
{
/* FIXME should this be an error ? */
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Duplicate enum value");
return FALSE;
}
}
}
return TRUE;
}
static gboolean
validate_object_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
Header *header;
ObjectBlob *blob;
gint i;
guint32 offset2;
header = (Header *)metadata->data;
if (metadata->len < offset + sizeof (ObjectBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (ObjectBlob*) &metadata->data[offset];
if (blob->blob_type != BLOB_TYPE_OBJECT)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
if (!is_name (metadata->data, blob->gtype_name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid object type name");
return FALSE;
}
if (!is_name (metadata->data, blob->gtype_init))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid object type init");
return FALSE;
}
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid object name");
return FALSE;
}
if (blob->parent > header->n_entries)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid parent index");
return FALSE;
}
if (blob->parent != 0)
{
DirEntry *entry;
entry = g_metadata_get_dir_entry (metadata, blob->parent);
if (entry->blob_type != BLOB_TYPE_OBJECT &&
(entry->local || entry->blob_type != 0))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Parent not object");
return FALSE;
}
}
if (metadata->len < offset + sizeof (ObjectBlob) +
(blob->n_interfaces + blob->n_interfaces % 2) * 2 +
blob->n_fields * sizeof (FieldBlob) +
blob->n_properties * sizeof (PropertyBlob) +
blob->n_methods * sizeof (FunctionBlob) +
blob->n_signals * sizeof (SignalBlob) +
blob->n_vfuncs * sizeof (VFuncBlob) +
blob->n_constants * sizeof (ConstantBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
offset2 = offset + sizeof (ObjectBlob);
for (i = 0; i < blob->n_interfaces; i++, offset2 += 2)
{
guint16 iface;
DirEntry *entry;
iface = *(guint16*)&metadata->data[offset2];
if (iface == 0 || iface > header->n_entries)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid interface index");
return FALSE;
}
entry = g_metadata_get_dir_entry (metadata, iface);
if (entry->blob_type != BLOB_TYPE_INTERFACE &&
(entry->local || entry->blob_type != 0))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Not an interface");
return FALSE;
}
}
offset2 += 2 * (blob->n_interfaces %2);
for (i = 0; i < blob->n_fields; i++, offset2 += sizeof (FieldBlob))
{
if (!validate_field_blob (metadata, offset2, error))
return FALSE;
}
for (i = 0; i < blob->n_properties; i++, offset2 += sizeof (PropertyBlob))
{
if (!validate_property_blob (metadata, offset2, error))
return FALSE;
}
for (i = 0; i < blob->n_methods; i++, offset2 += sizeof (FunctionBlob))
{
if (!validate_function_blob (metadata, offset2, BLOB_TYPE_OBJECT, error))
return FALSE;
}
for (i = 0; i < blob->n_signals; i++, offset2 += sizeof (SignalBlob))
{
if (!validate_signal_blob (metadata, offset2, offset, error))
return FALSE;
}
for (i = 0; i < blob->n_vfuncs; i++, offset2 += sizeof (VFuncBlob))
{
if (!validate_vfunc_blob (metadata, offset2, offset, error))
return FALSE;
}
for (i = 0; i < blob->n_constants; i++, offset2 += sizeof (ConstantBlob))
{
if (!validate_constant_blob (metadata, offset2, error))
return FALSE;
}
return TRUE;
}
static gboolean
validate_interface_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
Header *header;
InterfaceBlob *blob;
gint i;
guint32 offset2;
header = (Header *)metadata->data;
if (metadata->len < offset + sizeof (InterfaceBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
blob = (InterfaceBlob*) &metadata->data[offset];
if (blob->blob_type != BLOB_TYPE_INTERFACE)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Wrong blob type");
return FALSE;
}
if (!is_name (metadata->data, blob->gtype_name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid interface type name");
return FALSE;
}
if (!is_name (metadata->data, blob->gtype_init))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid interface type init");
return FALSE;
}
if (!is_name (metadata->data, blob->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid interface name");
return FALSE;
}
if (metadata->len < offset + sizeof (InterfaceBlob) +
(blob->n_prerequisites + blob->n_prerequisites % 2) * 2 +
blob->n_properties * sizeof (PropertyBlob) +
blob->n_methods * sizeof (FunctionBlob) +
blob->n_signals * sizeof (SignalBlob) +
blob->n_vfuncs * sizeof (VFuncBlob) +
blob->n_constants * sizeof (ConstantBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
offset2 = offset + sizeof (InterfaceBlob);
for (i = 0; i < blob->n_prerequisites; i++, offset2 += 2)
{
DirEntry *entry;
guint16 req;
req = *(guint16*)&metadata->data[offset2];
if (req == 0 || req > header->n_entries)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Invalid prerequisite index");
return FALSE;
}
entry = g_metadata_get_dir_entry (metadata, req);
if (entry->blob_type != BLOB_TYPE_INTERFACE &&
entry->blob_type != BLOB_TYPE_OBJECT &&
(entry->local || entry->blob_type != 0))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_BLOB,
"Not an interface or object");
return FALSE;
}
}
offset2 += 2 * (blob->n_prerequisites % 2);
for (i = 0; i < blob->n_properties; i++, offset2 += sizeof (PropertyBlob))
{
if (!validate_property_blob (metadata, offset2, error))
return FALSE;
}
for (i = 0; i < blob->n_methods; i++, offset2 += sizeof (FunctionBlob))
{
if (!validate_function_blob (metadata, offset2, BLOB_TYPE_INTERFACE, error))
return FALSE;
}
for (i = 0; i < blob->n_signals; i++, offset2 += sizeof (SignalBlob))
{
if (!validate_signal_blob (metadata, offset2, offset, error))
return FALSE;
}
for (i = 0; i < blob->n_vfuncs; i++, offset2 += sizeof (VFuncBlob))
{
if (!validate_vfunc_blob (metadata, offset2, offset, error))
return FALSE;
}
for (i = 0; i < blob->n_constants; i++, offset2 += sizeof (ConstantBlob))
{
if (!validate_constant_blob (metadata, offset2, error))
return FALSE;
}
return TRUE;
}
static gboolean
validate_errordomain_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
return TRUE;
}
static gboolean
validate_union_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
return TRUE;
}
static gboolean
validate_blob (GMetadata *metadata,
guint32 offset,
GError **error)
{
CommonBlob *common;
if (metadata->len < offset + sizeof (CommonBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
common = (CommonBlob*)&metadata->data[offset];
switch (common->blob_type)
{
case BLOB_TYPE_FUNCTION:
if (!validate_function_blob (metadata, offset, 0, error))
return FALSE;
break;
case BLOB_TYPE_CALLBACK:
if (!validate_callback_blob (metadata, offset, error))
return FALSE;
break;
case BLOB_TYPE_STRUCT:
case BLOB_TYPE_BOXED:
if (!validate_struct_blob (metadata, offset, common->blob_type, error))
return FALSE;
break;
case BLOB_TYPE_ENUM:
case BLOB_TYPE_FLAGS:
if (!validate_enum_blob (metadata, offset, common->blob_type, error))
return FALSE;
break;
case BLOB_TYPE_OBJECT:
if (!validate_object_blob (metadata, offset, error))
return FALSE;
break;
case BLOB_TYPE_INTERFACE:
if (!validate_interface_blob (metadata, offset, error))
return FALSE;
break;
case BLOB_TYPE_CONSTANT:
if (!validate_constant_blob (metadata, offset, error))
return FALSE;
break;
case BLOB_TYPE_ERROR_DOMAIN:
if (!validate_errordomain_blob (metadata, offset, error))
return FALSE;
break;
case BLOB_TYPE_UNION:
if (!validate_union_blob (metadata, offset, error))
return FALSE;
break;
default:
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_ENTRY,
"Invalid blob type");
return FALSE;
}
return TRUE;
}
static gboolean
validate_directory (GMetadata *metadata,
GError **error)
{
Header *header = (Header *)metadata->data;
DirEntry *entry;
gint i;
if (metadata->len < header->directory + header->n_entries * sizeof (DirEntry))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
for (i = 0; i < header->n_entries; i++)
{
entry = g_metadata_get_dir_entry (metadata, i + 1);
if (!is_name (metadata->data, entry->name))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_DIRECTORY,
"Invalid entry name");
return FALSE;
}
if ((entry->local && entry->blob_type == BLOB_TYPE_INVALID) ||
entry->blob_type > BLOB_TYPE_UNION)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_DIRECTORY,
"Invalid entry type");
return FALSE;
}
if (i < header->n_local_entries)
{
if (!entry->local)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_DIRECTORY,
"Too few local directory entries");
return FALSE;
}
if (!is_aligned (entry->offset))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_DIRECTORY,
"Misaligned entry");
return FALSE;
}
if (!validate_blob (metadata, entry->offset, error))
return FALSE;
}
else
{
if (entry->local)
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_DIRECTORY,
"Too many local directory entries");
return FALSE;
}
if (!is_name (metadata->data, entry->offset))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID_DIRECTORY,
"Invalid namespace name");
return FALSE;
}
}
}
return TRUE;
}
static gboolean
validate_annotations (GMetadata *metadata,
GError **error)
{
Header *header = (Header *)metadata->data;
if (header->size < header->annotations + header->n_annotations * sizeof (AnnotationBlob))
{
g_set_error (error,
G_METADATA_ERROR,
G_METADATA_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
return TRUE;
}
gboolean
g_metadata_validate (GMetadata *metadata,
GError **error)
{
if (!validate_header (metadata, error))
return FALSE;
if (!validate_directory (metadata, error))
return FALSE;
if (!validate_annotations (metadata, error))
return FALSE;
return TRUE;
}
GQuark
g_metadata_error_quark (void)
{
static GQuark quark = 0;
if (quark == 0)
quark = g_quark_from_static_string ("g-metadata-error-quark");
return quark;
}
static inline void
_g_metadata_init (GMetadata *metadata)
{
Header *header;
header = (Header *) metadata->data;
if (header->shared_library)
{
const gchar *shlib;
shlib = g_metadata_get_string (metadata, header->shared_library);
metadata->module = g_module_open (shlib, G_MODULE_BIND_LAZY|G_MODULE_BIND_LOCAL);
if (metadata->module == NULL)
g_warning ("Failed to load shared library referenced by the metadata: %s",
g_module_error ());
}
}
/**
* g_metadata_new_from_memory:
* @memory: address of memory chunk containing the metadata
* @len: length of memory chunk containing the metadata
*
* Creates a new #GMetadata from a memory location. The memory block
* pointed to by @metadata will be automatically g_free()d when the
* repository is destroyed.
*
* Return value: the new #GMetadata
**/
GMetadata *
g_metadata_new_from_memory (guchar *memory, gsize len)
{
GMetadata *meta;
meta = g_new0 (GMetadata, 1);
meta->data = memory;
meta->len = len;
meta->owns_memory = TRUE;
_g_metadata_init (meta);
return meta;
}
/**
* g_metadata_new_from_const_memory:
* @memory: address of memory chunk containing the metadata
* @len: length of memory chunk containing the metadata
*
* Creates a new #GMetadata from a memory location.
*
* Return value: the new #GMetadata
**/
GMetadata *
g_metadata_new_from_const_memory (const guchar *memory, gsize len)
{
GMetadata *meta;
meta = g_new0 (GMetadata, 1);
meta->data = (guchar *) memory;
meta->len = len;
meta->owns_memory = FALSE;
_g_metadata_init (meta);
return meta;
}
/**
* g_metadata_new_from_mapped_file:
* @mfile: a #GMappedFile, that will be free'd when the repository is destroyed
*
* Creates a new #GMetadata from a #GMappedFile.
*
* Return value: the new #GMetadata
**/
GMetadata *
g_metadata_new_from_mapped_file (GMappedFile *mfile)
{
GMetadata *meta;
meta = g_new0 (GMetadata, 1);
meta->mfile = mfile;
meta->owns_memory = FALSE;
meta->data = (guchar *) g_mapped_file_get_contents (mfile);
meta->len = g_mapped_file_get_length (mfile);
_g_metadata_init (meta);
return meta;
}
/**
* g_metadata_free:
* @metadata: a #GMetadata
*
* Free a #GMetadata.
**/
void
g_metadata_free (GMetadata *metadata)
{
if (metadata->mfile)
g_mapped_file_free (metadata->mfile);
else
if (metadata->owns_memory)
g_free (metadata->data);
if (metadata->module)
g_module_close (metadata->module);
g_free (metadata);
}
/**
* g_metadata_set_module:
* @metadata: a #GMetadata instance
* @module: a #GModule; takes ownership of this module
*
* Sets the target module for all symbols referenced by the metadata.
**/
void
g_metadata_set_module (GMetadata *metadata, GModule *module)
{
if (metadata->module)
g_module_close (metadata->module);
metadata->module = module;
}
const gchar *
g_metadata_get_namespace(GMetadata *metadata)
{
return g_metadata_get_string (metadata, ((Header *) metadata->data)->namespace);
}
Reference in New Issue View Git Blame Copy Permalink