mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-10-31 03:26:19 +01:00
33afebb2d7
When g_irepository_find_by_gtype() doesn't succeed on a simple prefix match (the current 'fastpass' mechanism), it ends up taking a considerable amount of CPU time, traversing the contents of all typelibs. I imagine that the reasons to have the exhaustive search fallback are not as strong as they used to be. For example, the case mentioned (Clutter including Cogl) no longer seems to be true. Also, typelibs (as generated by g-ir-scanner) now provide comma-separated C prefix info for cases when the typelib includes introspection info for multiple prefixes. For example, the Sugar typelib has a c_prefix string of Sugar,EggSM,Gsm,Acme. So I imagine there are not many remaining justified cases where the exhaustive search is needed. With that in mind, I found two ways to optimize this function: 1. Support comma-separated C prefixes 2. Don't bother with an exhaustive search if we did find a typelib claiming support for the prefix. For example, if we're looking for GdkDeviceManagerXI2 (currently non-introspectable) and we already found typelib files providing the 'Gdk' prefix that didn't offer this, lets not bother with the exhaustive search, we aren't going to find anything.
2354 lines
56 KiB
C
2354 lines
56 KiB
C
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
|
|
* GObject introspection: typelib validation, auxiliary functions
|
|
* related to the binary typelib 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 "config.h"
|
|
#include "gitypelib-internal.h"
|
|
#include "glib-compat.h"
|
|
|
|
typedef struct {
|
|
GITypelib *typelib;
|
|
GSList *context_stack;
|
|
} ValidateContext;
|
|
|
|
#define ALIGN_VALUE(this, boundary) \
|
|
(( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
|
|
|
|
static void
|
|
push_context (ValidateContext *ctx, const char *name)
|
|
{
|
|
ctx->context_stack = g_slist_prepend (ctx->context_stack, (char*)name);
|
|
}
|
|
|
|
static void
|
|
pop_context (ValidateContext *ctx)
|
|
{
|
|
g_assert (ctx->context_stack != NULL);
|
|
ctx->context_stack = g_slist_delete_link (ctx->context_stack,
|
|
ctx->context_stack);
|
|
}
|
|
|
|
static gboolean
|
|
validate_interface_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
GError **error);
|
|
|
|
static DirEntry *
|
|
get_dir_entry_checked (GITypelib *typelib,
|
|
guint16 index,
|
|
GError **error)
|
|
{
|
|
Header *header = (Header *)typelib->data;
|
|
guint32 offset;
|
|
|
|
if (index == 0 || index > header->n_entries)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid directory index %d", index);
|
|
return FALSE;
|
|
}
|
|
|
|
offset = header->directory + (index - 1) * header->entry_blob_size;
|
|
|
|
if (typelib->len < offset + sizeof (DirEntry))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
return (DirEntry *)&typelib->data[offset];
|
|
}
|
|
|
|
|
|
static CommonBlob *
|
|
get_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
if (typelib->len < offset + sizeof (CommonBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
return (CommonBlob *)&typelib->data[offset];
|
|
}
|
|
|
|
static InterfaceTypeBlob *
|
|
get_type_blob (GITypelib *typelib,
|
|
SimpleTypeBlob *simple,
|
|
GError **error)
|
|
{
|
|
if (simple->offset == 0)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"Expected blob for type");
|
|
return FALSE;
|
|
}
|
|
|
|
if (simple->flags.reserved == 0 && simple->flags.reserved2 == 0)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"Expected non-basic type but got %d",
|
|
simple->flags.tag);
|
|
return FALSE;
|
|
}
|
|
|
|
return (InterfaceTypeBlob*) get_blob (typelib, simple->offset, error);
|
|
}
|
|
|
|
DirEntry *
|
|
g_typelib_get_dir_entry (GITypelib *typelib,
|
|
guint16 index)
|
|
{
|
|
Header *header = (Header *)typelib->data;
|
|
|
|
return (DirEntry *)&typelib->data[header->directory + (index - 1) * header->entry_blob_size];
|
|
}
|
|
|
|
static Section *
|
|
get_section_by_id (GITypelib *typelib,
|
|
SectionType section_type)
|
|
{
|
|
Header *header = (Header *)typelib->data;
|
|
Section *section;
|
|
|
|
if (header->sections == 0)
|
|
return NULL;
|
|
|
|
for (section = (Section*)&typelib->data[header->sections];
|
|
section->id != GI_SECTION_END;
|
|
section++)
|
|
{
|
|
if (section->id == section_type)
|
|
return section;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
DirEntry *
|
|
g_typelib_get_dir_entry_by_name (GITypelib *typelib,
|
|
const char *name)
|
|
{
|
|
Section *dirindex;
|
|
gint i, n_entries;
|
|
const char *entry_name;
|
|
DirEntry *entry;
|
|
|
|
dirindex = get_section_by_id (typelib, GI_SECTION_DIRECTORY_INDEX);
|
|
n_entries = ((Header *)typelib->data)->n_local_entries;
|
|
|
|
if (dirindex == NULL)
|
|
{
|
|
for (i = 1; i <= n_entries; i++)
|
|
{
|
|
entry = g_typelib_get_dir_entry (typelib, i);
|
|
entry_name = g_typelib_get_string (typelib, entry->name);
|
|
if (strcmp (name, entry_name) == 0)
|
|
return entry;
|
|
}
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
guint8 *hash = (guint8*) &typelib->data[dirindex->offset];
|
|
guint16 index;
|
|
|
|
index = _gi_typelib_hash_search (hash, name, n_entries);
|
|
entry = g_typelib_get_dir_entry (typelib, index + 1);
|
|
entry_name = g_typelib_get_string (typelib, entry->name);
|
|
if (strcmp (name, entry_name) == 0)
|
|
return entry;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
DirEntry *
|
|
g_typelib_get_dir_entry_by_gtype_name (GITypelib *typelib,
|
|
const gchar *gtype_name)
|
|
{
|
|
Header *header = (Header *)typelib->data;
|
|
guint i;
|
|
|
|
for (i = 1; i <= header->n_local_entries; i++)
|
|
{
|
|
RegisteredTypeBlob *blob;
|
|
const char *type;
|
|
DirEntry *entry = g_typelib_get_dir_entry (typelib, i);
|
|
if (!BLOB_IS_REGISTERED_TYPE (entry))
|
|
continue;
|
|
|
|
blob = (RegisteredTypeBlob *)(&typelib->data[entry->offset]);
|
|
if (!blob->gtype_name)
|
|
continue;
|
|
|
|
type = g_typelib_get_string (typelib, blob->gtype_name);
|
|
if (strcmp (type, gtype_name) == 0)
|
|
return entry;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
gboolean
|
|
g_typelib_matches_gtype_name_prefix (GITypelib *typelib,
|
|
const gchar *gtype_name)
|
|
{
|
|
Header *header = (Header *)typelib->data;
|
|
const char *c_prefix;
|
|
gchar **prefixes;
|
|
gchar **prefix;
|
|
gboolean ret = FALSE;
|
|
|
|
c_prefix = g_typelib_get_string (typelib, header->c_prefix);
|
|
if (c_prefix == NULL)
|
|
return FALSE;
|
|
|
|
/* c_prefix is a comma separated string of supported prefixes
|
|
* in the typelib.
|
|
* We match the specified gtype_name if the gtype_name starts
|
|
* with the prefix, and is followed by a capital letter.
|
|
* For example, a typelib offering the 'Gdk' prefix does match
|
|
* GdkX11Cursor, however a typelib offering the 'G' prefix does not.
|
|
*/
|
|
prefixes = g_strsplit (c_prefix, ",", 0);
|
|
for (prefix = prefixes; *prefix; prefix++)
|
|
{
|
|
size_t len = strlen (*prefix);
|
|
if (strncmp (*prefix, gtype_name, len))
|
|
continue;
|
|
|
|
if (strlen (gtype_name) > len && g_ascii_isupper (gtype_name[len]))
|
|
{
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
g_strfreev(prefixes);
|
|
return ret;
|
|
}
|
|
|
|
DirEntry *
|
|
g_typelib_get_dir_entry_by_error_domain (GITypelib *typelib,
|
|
GQuark error_domain)
|
|
{
|
|
Header *header = (Header *)typelib->data;
|
|
guint n_entries = header->n_local_entries;
|
|
const char *domain_string = g_quark_to_string (error_domain);
|
|
DirEntry *entry;
|
|
guint i;
|
|
|
|
for (i = 1; i <= n_entries; i++)
|
|
{
|
|
EnumBlob *blob;
|
|
const char *enum_domain_string;
|
|
|
|
entry = g_typelib_get_dir_entry (typelib, i);
|
|
if (entry->blob_type != BLOB_TYPE_ENUM)
|
|
continue;
|
|
|
|
blob = (EnumBlob *)(&typelib->data[entry->offset]);
|
|
if (!blob->error_domain)
|
|
continue;
|
|
|
|
enum_domain_string = g_typelib_get_string (typelib, blob->error_domain);
|
|
if (strcmp (domain_string, enum_domain_string) == 0)
|
|
return entry;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
g_typelib_check_sanity (void)
|
|
{
|
|
/* Check that struct layout is as we expect */
|
|
|
|
gboolean size_check_ok = TRUE;
|
|
|
|
#define CHECK_SIZE(s,n) \
|
|
if (sizeof(s) != n) \
|
|
{ \
|
|
g_printerr ("sizeof("#s") is expected to be %d but is %"G_GSIZE_FORMAT".\n", \
|
|
n, sizeof (s)); \
|
|
size_check_ok = FALSE; \
|
|
}
|
|
|
|
/* When changing the size of a typelib structure, you are required to update
|
|
* the hardcoded size here. Do NOT change these to use sizeof(); these
|
|
* should match whatever is defined in the text specification and serve as
|
|
* a sanity check on structure modifications.
|
|
*
|
|
* Everything else in the code however should be using sizeof().
|
|
*/
|
|
|
|
CHECK_SIZE (Header, 112);
|
|
CHECK_SIZE (DirEntry, 12);
|
|
CHECK_SIZE (SimpleTypeBlob, 4);
|
|
CHECK_SIZE (ArgBlob, 16);
|
|
CHECK_SIZE (SignatureBlob, 8);
|
|
CHECK_SIZE (CommonBlob, 8);
|
|
CHECK_SIZE (FunctionBlob, 20);
|
|
CHECK_SIZE (CallbackBlob, 12);
|
|
CHECK_SIZE (InterfaceTypeBlob, 4);
|
|
CHECK_SIZE (ArrayTypeBlob, 8);
|
|
CHECK_SIZE (ParamTypeBlob, 4);
|
|
CHECK_SIZE (ErrorTypeBlob, 4);
|
|
CHECK_SIZE (ValueBlob, 12);
|
|
CHECK_SIZE (FieldBlob, 16);
|
|
CHECK_SIZE (RegisteredTypeBlob, 16);
|
|
CHECK_SIZE (StructBlob, 32);
|
|
CHECK_SIZE (EnumBlob, 24);
|
|
CHECK_SIZE (PropertyBlob, 16);
|
|
CHECK_SIZE (SignalBlob, 16);
|
|
CHECK_SIZE (VFuncBlob, 20);
|
|
CHECK_SIZE (ObjectBlob, 60);
|
|
CHECK_SIZE (InterfaceBlob, 40);
|
|
CHECK_SIZE (ConstantBlob, 24);
|
|
CHECK_SIZE (AttributeBlob, 12);
|
|
CHECK_SIZE (UnionBlob, 40);
|
|
#undef CHECK_SIZE
|
|
|
|
g_assert (size_check_ok);
|
|
}
|
|
|
|
|
|
static gboolean
|
|
is_aligned (guint32 offset)
|
|
{
|
|
return offset == ALIGN_VALUE (offset, 4);
|
|
}
|
|
|
|
#define MAX_NAME_LEN 200
|
|
|
|
static const char *
|
|
get_string (GITypelib *typelib, guint32 offset, GError **error)
|
|
{
|
|
if (typelib->len < offset)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"Buffer is too short while looking up name");
|
|
return NULL;
|
|
}
|
|
|
|
return (const char*)&typelib->data[offset];
|
|
}
|
|
|
|
static const char *
|
|
get_string_nofail (GITypelib *typelib, guint32 offset)
|
|
{
|
|
const char *ret = get_string (typelib, offset, NULL);
|
|
g_assert (ret);
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
validate_name (GITypelib *typelib,
|
|
const char *msg,
|
|
const guchar *data, guint32 offset,
|
|
GError **error)
|
|
{
|
|
const char *name;
|
|
|
|
name = get_string (typelib, offset, error);
|
|
if (!name)
|
|
return FALSE;
|
|
|
|
if (!memchr (name, '\0', MAX_NAME_LEN))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The %s is too long: %s",
|
|
msg, name);
|
|
return FALSE;
|
|
}
|
|
|
|
if (strspn (name, G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "-_") < strlen (name))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The %s contains invalid characters: '%s'",
|
|
msg, name);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* Fast path sanity check, operates on a memory blob */
|
|
static gboolean
|
|
validate_header_basic (const guint8 *memory,
|
|
gsize len,
|
|
GError **error)
|
|
{
|
|
Header *header = (Header *)memory;
|
|
|
|
if (len < sizeof (Header))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The specified typelib length %" G_GSIZE_FORMAT " is too short",
|
|
len);
|
|
return FALSE;
|
|
}
|
|
|
|
if (strncmp (header->magic, G_IR_MAGIC, 16) != 0)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Invalid magic header");
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (header->major_version != 4)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Typelib version mismatch; expected 4, found %d",
|
|
header->major_version);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (header->n_entries < header->n_local_entries)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Inconsistent entry counts");
|
|
return FALSE;
|
|
}
|
|
|
|
if (header->size != len)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Typelib size %" G_GSIZE_FORMAT " does not match %" G_GSIZE_FORMAT,
|
|
(gsize) header->size, len);
|
|
return FALSE;
|
|
}
|
|
|
|
/* This is a sanity check for a specific typelib; it
|
|
* prevents us from loading an incompatible typelib.
|
|
*
|
|
* The hardcoded checks in g_typelib_check_sanity to
|
|
* protect against inadvertent or buggy changes to the typelib format
|
|
* itself.
|
|
*/
|
|
|
|
if (header->entry_blob_size != sizeof (DirEntry) ||
|
|
header->function_blob_size != sizeof (FunctionBlob) ||
|
|
header->callback_blob_size != sizeof (CallbackBlob) ||
|
|
header->signal_blob_size != sizeof (SignalBlob) ||
|
|
header->vfunc_blob_size != sizeof (VFuncBlob) ||
|
|
header->arg_blob_size != sizeof (ArgBlob) ||
|
|
header->property_blob_size != sizeof (PropertyBlob) ||
|
|
header->field_blob_size != sizeof (FieldBlob) ||
|
|
header->value_blob_size != sizeof (ValueBlob) ||
|
|
header->constant_blob_size != sizeof (ConstantBlob) ||
|
|
header->attribute_blob_size != sizeof (AttributeBlob) ||
|
|
header->signature_blob_size != sizeof (SignatureBlob) ||
|
|
header->enum_blob_size != sizeof (EnumBlob) ||
|
|
header->struct_blob_size != sizeof (StructBlob) ||
|
|
header->object_blob_size != sizeof(ObjectBlob) ||
|
|
header->interface_blob_size != sizeof (InterfaceBlob) ||
|
|
header->union_blob_size != sizeof (UnionBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Blob size mismatch");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!is_aligned (header->directory))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Misaligned directory");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!is_aligned (header->attributes))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Misaligned attributes");
|
|
return FALSE;
|
|
}
|
|
|
|
if (header->attributes == 0 && header->n_attributes > 0)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_HEADER,
|
|
"Wrong number of attributes");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_header (ValidateContext *ctx,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
|
|
if (!validate_header_basic (typelib->data, typelib->len, error))
|
|
return FALSE;
|
|
|
|
{
|
|
Header *header = (Header*)typelib->data;
|
|
if (!validate_name (typelib, "namespace", typelib->data, header->namespace, error))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean validate_type_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 signature_offset,
|
|
gboolean return_type,
|
|
GError **error);
|
|
|
|
static gboolean
|
|
validate_array_type_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 signature_offset,
|
|
gboolean return_type,
|
|
GError **error)
|
|
{
|
|
/* FIXME validate length */
|
|
|
|
if (!validate_type_blob (typelib,
|
|
offset + G_STRUCT_OFFSET (ArrayTypeBlob, type),
|
|
0, FALSE, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_iface_type_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 signature_offset,
|
|
gboolean return_type,
|
|
GError **error)
|
|
{
|
|
InterfaceTypeBlob *blob;
|
|
InterfaceBlob *target;
|
|
|
|
blob = (InterfaceTypeBlob*)&typelib->data[offset];
|
|
|
|
target = (InterfaceBlob*) get_dir_entry_checked (typelib, blob->interface, error);
|
|
|
|
if (!target)
|
|
return FALSE;
|
|
if (target->blob_type == 0) /* non-local */
|
|
return TRUE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_param_type_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 signature_offset,
|
|
gboolean return_type,
|
|
gint n_params,
|
|
GError **error)
|
|
{
|
|
ParamTypeBlob *blob;
|
|
gint i;
|
|
|
|
blob = (ParamTypeBlob*)&typelib->data[offset];
|
|
|
|
if (!blob->pointer)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Pointer type exected for tag %d", blob->tag);
|
|
return FALSE;
|
|
}
|
|
|
|
if (blob->n_types != n_params)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Parameter type number mismatch");
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < n_params; i++)
|
|
{
|
|
if (!validate_type_blob (typelib,
|
|
offset + sizeof (ParamTypeBlob) +
|
|
i * sizeof (SimpleTypeBlob),
|
|
0, FALSE, error))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_error_type_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 signature_offset,
|
|
gboolean return_type,
|
|
GError **error)
|
|
{
|
|
ErrorTypeBlob *blob;
|
|
|
|
blob = (ErrorTypeBlob*)&typelib->data[offset];
|
|
|
|
if (!blob->pointer)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Pointer type exected for tag %d", blob->tag);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_type_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 signature_offset,
|
|
gboolean return_type,
|
|
GError **error)
|
|
{
|
|
SimpleTypeBlob *simple;
|
|
InterfaceTypeBlob *iface;
|
|
|
|
simple = (SimpleTypeBlob *)&typelib->data[offset];
|
|
|
|
if (simple->flags.reserved == 0 &&
|
|
simple->flags.reserved2 == 0)
|
|
{
|
|
if (!G_TYPE_TAG_IS_BASIC(simple->flags.tag))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid non-basic tag %d in simple type", simple->flags.tag);
|
|
return FALSE;
|
|
}
|
|
|
|
if (simple->flags.tag >= GI_TYPE_TAG_UTF8 &&
|
|
simple->flags.tag != GI_TYPE_TAG_UNICHAR &&
|
|
!simple->flags.pointer)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Pointer type exected for tag %d", simple->flags.tag);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
iface = (InterfaceTypeBlob*)&typelib->data[simple->offset];
|
|
|
|
switch (iface->tag)
|
|
{
|
|
case GI_TYPE_TAG_ARRAY:
|
|
if (!validate_array_type_blob (typelib, simple->offset,
|
|
signature_offset, return_type, error))
|
|
return FALSE;
|
|
break;
|
|
case GI_TYPE_TAG_INTERFACE:
|
|
if (!validate_iface_type_blob (typelib, simple->offset,
|
|
signature_offset, return_type, error))
|
|
return FALSE;
|
|
break;
|
|
case GI_TYPE_TAG_GLIST:
|
|
case GI_TYPE_TAG_GSLIST:
|
|
if (!validate_param_type_blob (typelib, simple->offset,
|
|
signature_offset, return_type, 1, error))
|
|
return FALSE;
|
|
break;
|
|
case GI_TYPE_TAG_GHASH:
|
|
if (!validate_param_type_blob (typelib, simple->offset,
|
|
signature_offset, return_type, 2, error))
|
|
return FALSE;
|
|
break;
|
|
case GI_TYPE_TAG_ERROR:
|
|
if (!validate_error_type_blob (typelib, simple->offset,
|
|
signature_offset, return_type, error))
|
|
return FALSE;
|
|
break;
|
|
default:
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong tag in complex type");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_arg_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 signature_offset,
|
|
GError **error)
|
|
{
|
|
ArgBlob *blob;
|
|
|
|
if (typelib->len < offset + sizeof (ArgBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (ArgBlob*) &typelib->data[offset];
|
|
|
|
if (!validate_name (typelib, "argument", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (!validate_type_blob (typelib,
|
|
offset + G_STRUCT_OFFSET (ArgBlob, arg_type),
|
|
signature_offset, FALSE, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static SimpleTypeBlob *
|
|
return_type_from_signature (GITypelib *typelib,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
SignatureBlob *blob;
|
|
if (typelib->len < offset + sizeof (SignatureBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return NULL;
|
|
}
|
|
|
|
blob = (SignatureBlob*) &typelib->data[offset];
|
|
if (blob->return_type.offset == 0)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"No return type found in signature");
|
|
return NULL;
|
|
}
|
|
|
|
return (SimpleTypeBlob *)&typelib->data[offset + G_STRUCT_OFFSET (SignatureBlob, return_type)];
|
|
}
|
|
|
|
static gboolean
|
|
validate_signature_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
SignatureBlob *blob;
|
|
gint i;
|
|
|
|
if (typelib->len < offset + sizeof (SignatureBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (SignatureBlob*) &typelib->data[offset];
|
|
|
|
if (blob->return_type.offset != 0)
|
|
{
|
|
if (!validate_type_blob (typelib,
|
|
offset + G_STRUCT_OFFSET (SignatureBlob, return_type),
|
|
offset, TRUE, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_arguments; i++)
|
|
{
|
|
if (!validate_arg_blob (typelib,
|
|
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 (ValidateContext *ctx,
|
|
guint32 offset,
|
|
guint16 container_type,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
FunctionBlob *blob;
|
|
|
|
if (typelib->len < offset + sizeof (FunctionBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (FunctionBlob*) &typelib->data[offset];
|
|
|
|
if (blob->blob_type != BLOB_TYPE_FUNCTION)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong blob type %d, expected function", blob->blob_type);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_name (typelib, "function", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
push_context (ctx, get_string_nofail (typelib, blob->name));
|
|
|
|
if (!validate_name (typelib, "function symbol", typelib->data, blob->symbol, error))
|
|
return FALSE;
|
|
|
|
if (blob->constructor)
|
|
{
|
|
switch (container_type)
|
|
{
|
|
case BLOB_TYPE_BOXED:
|
|
case BLOB_TYPE_STRUCT:
|
|
case BLOB_TYPE_UNION:
|
|
case BLOB_TYPE_OBJECT:
|
|
case BLOB_TYPE_INTERFACE:
|
|
break;
|
|
default:
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_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_TYPELIB_ERROR,
|
|
G_TYPELIB_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_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Must be setter, getter or wrapper");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* FIXME: validate index range */
|
|
|
|
if (!validate_signature_blob (typelib, blob->signature, error))
|
|
return FALSE;
|
|
|
|
if (blob->constructor)
|
|
{
|
|
SimpleTypeBlob *simple = return_type_from_signature (typelib,
|
|
blob->signature,
|
|
error);
|
|
InterfaceTypeBlob *iface_type;
|
|
|
|
if (!simple)
|
|
return FALSE;
|
|
iface_type = get_type_blob (typelib, simple, error);
|
|
if (!iface_type)
|
|
return FALSE;
|
|
if (iface_type->tag != GI_TYPE_TAG_INTERFACE &&
|
|
(container_type == BLOB_TYPE_OBJECT ||
|
|
container_type == BLOB_TYPE_INTERFACE))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"Invalid return type '%s' for constructor '%s'",
|
|
g_type_tag_to_string (iface_type->tag),
|
|
get_string_nofail (typelib, blob->symbol));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
pop_context (ctx);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_callback_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
CallbackBlob *blob;
|
|
|
|
if (typelib->len < offset + sizeof (CallbackBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (CallbackBlob*) &typelib->data[offset];
|
|
|
|
if (blob->blob_type != BLOB_TYPE_CALLBACK)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong blob type");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_name (typelib, "callback", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
push_context (ctx, get_string_nofail (typelib, blob->name));
|
|
|
|
if (!validate_signature_blob (typelib, blob->signature, error))
|
|
return FALSE;
|
|
|
|
pop_context (ctx);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_constant_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
guint value_size[] = {
|
|
0, /* VOID */
|
|
4, /* BOOLEAN */
|
|
1, /* INT8 */
|
|
1, /* UINT8 */
|
|
2, /* INT16 */
|
|
2, /* UINT16 */
|
|
4, /* INT32 */
|
|
4, /* UINT32 */
|
|
8, /* INT64 */
|
|
8, /* UINT64 */
|
|
sizeof (gfloat),
|
|
sizeof (gdouble),
|
|
0, /* GTYPE */
|
|
0, /* UTF8 */
|
|
0, /* FILENAME */
|
|
0, /* ARRAY */
|
|
0, /* INTERFACE */
|
|
0, /* GLIST */
|
|
0, /* GSLIST */
|
|
0, /* GHASH */
|
|
0, /* ERROR */
|
|
4 /* UNICHAR */
|
|
};
|
|
ConstantBlob *blob;
|
|
SimpleTypeBlob *type;
|
|
|
|
g_assert (G_N_ELEMENTS (value_size) == GI_TYPE_TAG_N_TYPES);
|
|
|
|
if (typelib->len < offset + sizeof (ConstantBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (ConstantBlob*) &typelib->data[offset];
|
|
|
|
if (blob->blob_type != BLOB_TYPE_CONSTANT)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong blob type");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_name (typelib, "constant", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (!validate_type_blob (typelib, offset + G_STRUCT_OFFSET (ConstantBlob, type),
|
|
0, FALSE, error))
|
|
return FALSE;
|
|
|
|
if (!is_aligned (blob->offset))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Misaligned constant value");
|
|
return FALSE;
|
|
}
|
|
|
|
type = (SimpleTypeBlob *)&typelib->data[offset + G_STRUCT_OFFSET (ConstantBlob, type)];
|
|
if (type->flags.reserved == 0 && type->flags.reserved2 == 0)
|
|
{
|
|
if (type->flags.tag == 0)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Constant value type void");
|
|
return FALSE;
|
|
}
|
|
|
|
if (value_size[type->flags.tag] != 0 &&
|
|
blob->size != value_size[type->flags.tag])
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Constant value size mismatch");
|
|
return FALSE;
|
|
}
|
|
/* FIXME check string values */
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_value_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
ValueBlob *blob;
|
|
|
|
if (typelib->len < offset + sizeof (ValueBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (ValueBlob*) &typelib->data[offset];
|
|
|
|
if (!validate_name (typelib, "value", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_field_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
Header *header = (Header *)typelib->data;
|
|
FieldBlob *blob;
|
|
|
|
if (typelib->len < offset + sizeof (FieldBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (FieldBlob*) &typelib->data[offset];
|
|
|
|
if (!validate_name (typelib, "field", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (blob->has_embedded_type)
|
|
{
|
|
if (!validate_callback_blob (ctx, offset + header->field_blob_size, error))
|
|
return FALSE;
|
|
}
|
|
else if (!validate_type_blob (typelib,
|
|
offset + G_STRUCT_OFFSET (FieldBlob, type),
|
|
0, FALSE, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_property_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
PropertyBlob *blob;
|
|
|
|
if (typelib->len < offset + sizeof (PropertyBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (PropertyBlob*) &typelib->data[offset];
|
|
|
|
if (!validate_name (typelib, "property", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (!validate_type_blob (typelib,
|
|
offset + G_STRUCT_OFFSET (PropertyBlob, type),
|
|
0, FALSE, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_signal_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 container_offset,
|
|
GError **error)
|
|
{
|
|
SignalBlob *blob;
|
|
gint n_signals;
|
|
|
|
if (typelib->len < offset + sizeof (SignalBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (SignalBlob*) &typelib->data[offset];
|
|
|
|
if (!validate_name (typelib, "signal", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if ((blob->run_first != 0) +
|
|
(blob->run_last != 0) +
|
|
(blob->run_cleanup != 0) != 1)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid signal run flags");
|
|
return FALSE;
|
|
}
|
|
|
|
if (blob->has_class_closure)
|
|
{
|
|
if (((CommonBlob*)&typelib->data[container_offset])->blob_type == BLOB_TYPE_OBJECT)
|
|
{
|
|
ObjectBlob *object;
|
|
|
|
object = (ObjectBlob*)&typelib->data[container_offset];
|
|
|
|
n_signals = object->n_signals;
|
|
}
|
|
else
|
|
{
|
|
InterfaceBlob *iface;
|
|
|
|
iface = (InterfaceBlob*)&typelib->data[container_offset];
|
|
|
|
n_signals = iface->n_signals;
|
|
}
|
|
|
|
if (blob->class_closure >= n_signals)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid class closure index");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!validate_signature_blob (typelib, blob->signature, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_vfunc_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
guint32 container_offset,
|
|
GError **error)
|
|
{
|
|
VFuncBlob *blob;
|
|
gint n_vfuncs;
|
|
|
|
if (typelib->len < offset + sizeof (VFuncBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (VFuncBlob*) &typelib->data[offset];
|
|
|
|
if (!validate_name (typelib, "vfunc", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (blob->class_closure)
|
|
{
|
|
if (((CommonBlob*)&typelib->data[container_offset])->blob_type == BLOB_TYPE_OBJECT)
|
|
{
|
|
ObjectBlob *object;
|
|
|
|
object = (ObjectBlob*)&typelib->data[container_offset];
|
|
|
|
n_vfuncs = object->n_vfuncs;
|
|
}
|
|
else
|
|
{
|
|
InterfaceBlob *iface;
|
|
|
|
iface = (InterfaceBlob*)&typelib->data[container_offset];
|
|
|
|
n_vfuncs = iface->n_vfuncs;
|
|
}
|
|
|
|
if (blob->class_closure >= n_vfuncs)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid class closure index");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!validate_signature_blob (typelib, blob->signature, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_struct_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
guint16 blob_type,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
StructBlob *blob;
|
|
gint i;
|
|
guint32 field_offset;
|
|
|
|
if (typelib->len < offset + sizeof (StructBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (StructBlob*) &typelib->data[offset];
|
|
|
|
if (blob->blob_type != blob_type)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong blob type");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_name (typelib, "struct", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
push_context (ctx, get_string_nofail (typelib, blob->name));
|
|
|
|
if (!blob->unregistered)
|
|
{
|
|
if (!validate_name (typelib, "boxed", typelib->data, blob->gtype_name, error))
|
|
return FALSE;
|
|
|
|
if (!validate_name (typelib, "boxed", typelib->data, blob->gtype_init, error))
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (blob->gtype_name || blob->gtype_init)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Gtype data in struct");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (typelib->len < offset + sizeof (StructBlob) +
|
|
blob->n_fields * sizeof (FieldBlob) +
|
|
blob->n_methods * sizeof (FunctionBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
field_offset = offset + sizeof (StructBlob);
|
|
for (i = 0; i < blob->n_fields; i++)
|
|
{
|
|
FieldBlob *blob = (FieldBlob*) &typelib->data[field_offset];
|
|
|
|
if (!validate_field_blob (ctx,
|
|
field_offset,
|
|
error))
|
|
return FALSE;
|
|
|
|
field_offset += sizeof (FieldBlob);
|
|
if (blob->has_embedded_type)
|
|
field_offset += sizeof (CallbackBlob);
|
|
}
|
|
|
|
for (i = 0; i < blob->n_methods; i++)
|
|
{
|
|
if (!validate_function_blob (ctx,
|
|
field_offset +
|
|
i * sizeof (FunctionBlob),
|
|
blob_type,
|
|
error))
|
|
return FALSE;
|
|
}
|
|
|
|
pop_context (ctx);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_enum_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
guint16 blob_type,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
EnumBlob *blob;
|
|
gint i;
|
|
guint32 offset2;
|
|
|
|
if (typelib->len < offset + sizeof (EnumBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (EnumBlob*) &typelib->data[offset];
|
|
|
|
if (blob->blob_type != blob_type)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong blob type");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!blob->unregistered)
|
|
{
|
|
if (!validate_name (typelib, "enum", typelib->data, blob->gtype_name, error))
|
|
return FALSE;
|
|
|
|
if (!validate_name (typelib, "enum", typelib->data, blob->gtype_init, error))
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (blob->gtype_name || blob->gtype_init)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Gtype data in unregistered enum");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!validate_name (typelib, "enum", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (typelib->len < offset + sizeof (EnumBlob) +
|
|
blob->n_values * sizeof (ValueBlob) +
|
|
blob->n_methods * sizeof (FunctionBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
offset2 = offset + sizeof (EnumBlob);
|
|
|
|
push_context (ctx, get_string_nofail (typelib, blob->name));
|
|
|
|
for (i = 0; i < blob->n_values; i++, offset2 += sizeof (ValueBlob))
|
|
{
|
|
if (!validate_value_blob (typelib,
|
|
offset2,
|
|
error))
|
|
return FALSE;
|
|
|
|
#if 0
|
|
v1 = (ValueBlob *)&typelib->data[offset2];
|
|
for (j = 0; j < i; j++)
|
|
{
|
|
v2 = (ValueBlob *)&typelib->data[offset2 +
|
|
j * sizeof (ValueBlob)];
|
|
|
|
if (v1->value == v2->value)
|
|
{
|
|
|
|
/* FIXME should this be an error ? */
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Duplicate enum value");
|
|
return FALSE;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
for (i = 0; i < blob->n_methods; i++, offset2 += sizeof (FunctionBlob))
|
|
{
|
|
if (!validate_function_blob (ctx, offset2, BLOB_TYPE_ENUM, error))
|
|
return FALSE;
|
|
}
|
|
|
|
pop_context (ctx);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_object_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
Header *header;
|
|
ObjectBlob *blob;
|
|
gint i;
|
|
guint32 offset2;
|
|
|
|
header = (Header *)typelib->data;
|
|
|
|
if (typelib->len < offset + sizeof (ObjectBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (ObjectBlob*) &typelib->data[offset];
|
|
|
|
if (blob->blob_type != BLOB_TYPE_OBJECT)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong blob type");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_name (typelib, "object", typelib->data, blob->gtype_name, error))
|
|
return FALSE;
|
|
|
|
if (!validate_name (typelib, "object", typelib->data, blob->gtype_init, error))
|
|
return FALSE;
|
|
|
|
if (!validate_name (typelib, "object", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (blob->parent > header->n_entries)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid parent index");
|
|
return FALSE;
|
|
}
|
|
|
|
if (blob->parent != 0)
|
|
{
|
|
DirEntry *entry;
|
|
|
|
entry = get_dir_entry_checked (typelib, blob->parent, error);
|
|
if (!entry)
|
|
return FALSE;
|
|
if (entry->blob_type != BLOB_TYPE_OBJECT &&
|
|
(entry->local || entry->blob_type != 0))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Parent not object");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (blob->gtype_struct != 0)
|
|
{
|
|
DirEntry *entry;
|
|
|
|
entry = get_dir_entry_checked (typelib, blob->gtype_struct, error);
|
|
if (!entry)
|
|
return FALSE;
|
|
if (entry->blob_type != BLOB_TYPE_STRUCT && entry->local)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Class struct invalid type or not local");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (typelib->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_TYPELIB_ERROR,
|
|
G_TYPELIB_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*)&typelib->data[offset2];
|
|
if (iface == 0 || iface > header->n_entries)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid interface index");
|
|
return FALSE;
|
|
}
|
|
|
|
entry = get_dir_entry_checked (typelib, iface, error);
|
|
if (!entry)
|
|
return FALSE;
|
|
|
|
if (entry->blob_type != BLOB_TYPE_INTERFACE &&
|
|
(entry->local || entry->blob_type != 0))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Not an interface");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
offset2 += 2 * (blob->n_interfaces %2);
|
|
|
|
push_context (ctx, get_string_nofail (typelib, blob->name));
|
|
|
|
for (i = 0; i < blob->n_fields; i++, offset2 += sizeof (FieldBlob))
|
|
{
|
|
if (!validate_field_blob (ctx, offset2, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_properties; i++, offset2 += sizeof (PropertyBlob))
|
|
{
|
|
if (!validate_property_blob (typelib, offset2, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_methods; i++, offset2 += sizeof (FunctionBlob))
|
|
{
|
|
if (!validate_function_blob (ctx, offset2, BLOB_TYPE_OBJECT, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_signals; i++, offset2 += sizeof (SignalBlob))
|
|
{
|
|
if (!validate_signal_blob (typelib, offset2, offset, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_vfuncs; i++, offset2 += sizeof (VFuncBlob))
|
|
{
|
|
if (!validate_vfunc_blob (typelib, offset2, offset, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_constants; i++, offset2 += sizeof (ConstantBlob))
|
|
{
|
|
if (!validate_constant_blob (typelib, offset2, error))
|
|
return FALSE;
|
|
}
|
|
|
|
pop_context (ctx);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_interface_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
Header *header;
|
|
InterfaceBlob *blob;
|
|
gint i;
|
|
guint32 offset2;
|
|
|
|
header = (Header *)typelib->data;
|
|
|
|
if (typelib->len < offset + sizeof (InterfaceBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
blob = (InterfaceBlob*) &typelib->data[offset];
|
|
|
|
if (blob->blob_type != BLOB_TYPE_INTERFACE)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Wrong blob type; expected interface, got %d", blob->blob_type);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_name (typelib, "interface", typelib->data, blob->gtype_name, error))
|
|
return FALSE;
|
|
|
|
if (!validate_name (typelib, "interface", typelib->data, blob->gtype_init, error))
|
|
return FALSE;
|
|
|
|
if (!validate_name (typelib, "interface", typelib->data, blob->name, error))
|
|
return FALSE;
|
|
|
|
if (typelib->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_TYPELIB_ERROR,
|
|
G_TYPELIB_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*)&typelib->data[offset2];
|
|
if (req == 0 || req > header->n_entries)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Invalid prerequisite index");
|
|
return FALSE;
|
|
}
|
|
|
|
entry = g_typelib_get_dir_entry (typelib, 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_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_BLOB,
|
|
"Not an interface or object");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
offset2 += 2 * (blob->n_prerequisites % 2);
|
|
|
|
push_context (ctx, get_string_nofail (typelib, blob->name));
|
|
|
|
for (i = 0; i < blob->n_properties; i++, offset2 += sizeof (PropertyBlob))
|
|
{
|
|
if (!validate_property_blob (typelib, offset2, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_methods; i++, offset2 += sizeof (FunctionBlob))
|
|
{
|
|
if (!validate_function_blob (ctx, offset2, BLOB_TYPE_INTERFACE, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_signals; i++, offset2 += sizeof (SignalBlob))
|
|
{
|
|
if (!validate_signal_blob (typelib, offset2, offset, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_vfuncs; i++, offset2 += sizeof (VFuncBlob))
|
|
{
|
|
if (!validate_vfunc_blob (typelib, offset2, offset, error))
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < blob->n_constants; i++, offset2 += sizeof (ConstantBlob))
|
|
{
|
|
if (!validate_constant_blob (typelib, offset2, error))
|
|
return FALSE;
|
|
}
|
|
|
|
pop_context (ctx);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_union_blob (GITypelib *typelib,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_blob (ValidateContext *ctx,
|
|
guint32 offset,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
CommonBlob *common;
|
|
|
|
if (typelib->len < offset + sizeof (CommonBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
common = (CommonBlob*)&typelib->data[offset];
|
|
|
|
switch (common->blob_type)
|
|
{
|
|
case BLOB_TYPE_FUNCTION:
|
|
if (!validate_function_blob (ctx, offset, 0, error))
|
|
return FALSE;
|
|
break;
|
|
case BLOB_TYPE_CALLBACK:
|
|
if (!validate_callback_blob (ctx, offset, error))
|
|
return FALSE;
|
|
break;
|
|
case BLOB_TYPE_STRUCT:
|
|
case BLOB_TYPE_BOXED:
|
|
if (!validate_struct_blob (ctx, offset, common->blob_type, error))
|
|
return FALSE;
|
|
break;
|
|
case BLOB_TYPE_ENUM:
|
|
case BLOB_TYPE_FLAGS:
|
|
if (!validate_enum_blob (ctx, offset, common->blob_type, error))
|
|
return FALSE;
|
|
break;
|
|
case BLOB_TYPE_OBJECT:
|
|
if (!validate_object_blob (ctx, offset, error))
|
|
return FALSE;
|
|
break;
|
|
case BLOB_TYPE_INTERFACE:
|
|
if (!validate_interface_blob (ctx, offset, error))
|
|
return FALSE;
|
|
break;
|
|
case BLOB_TYPE_CONSTANT:
|
|
if (!validate_constant_blob (typelib, offset, error))
|
|
return FALSE;
|
|
break;
|
|
case BLOB_TYPE_UNION:
|
|
if (!validate_union_blob (typelib, offset, error))
|
|
return FALSE;
|
|
break;
|
|
default:
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_ENTRY,
|
|
"Invalid blob type");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_directory (ValidateContext *ctx,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
Header *header = (Header *)typelib->data;
|
|
DirEntry *entry;
|
|
gint i;
|
|
|
|
if (typelib->len < header->directory + header->n_entries * sizeof (DirEntry))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < header->n_entries; i++)
|
|
{
|
|
entry = g_typelib_get_dir_entry (typelib, i + 1);
|
|
|
|
if (!validate_name (typelib, "entry", typelib->data, entry->name, error))
|
|
return FALSE;
|
|
|
|
if ((entry->local && entry->blob_type == BLOB_TYPE_INVALID) ||
|
|
entry->blob_type > BLOB_TYPE_UNION)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_DIRECTORY,
|
|
"Invalid entry type");
|
|
return FALSE;
|
|
}
|
|
|
|
if (i < header->n_local_entries)
|
|
{
|
|
if (!entry->local)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_DIRECTORY,
|
|
"Too few local directory entries");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!is_aligned (entry->offset))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_DIRECTORY,
|
|
"Misaligned entry");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_blob (ctx, entry->offset, error))
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (entry->local)
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID_DIRECTORY,
|
|
"Too many local directory entries");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_name (typelib, "namespace", typelib->data, entry->offset, error))
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_attributes (ValidateContext *ctx,
|
|
GError **error)
|
|
{
|
|
GITypelib *typelib = ctx->typelib;
|
|
Header *header = (Header *)typelib->data;
|
|
|
|
if (header->size < header->attributes + header->n_attributes * sizeof (AttributeBlob))
|
|
{
|
|
g_set_error (error,
|
|
G_TYPELIB_ERROR,
|
|
G_TYPELIB_ERROR_INVALID,
|
|
"The buffer is too short");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
prefix_with_context (GError **error,
|
|
const char *section,
|
|
ValidateContext *ctx)
|
|
{
|
|
GString *str = g_string_new (NULL);
|
|
GSList *link;
|
|
char *buf;
|
|
|
|
link = ctx->context_stack;
|
|
if (!link)
|
|
{
|
|
g_prefix_error (error, "In %s:", section);
|
|
return;
|
|
}
|
|
|
|
for (; link; link = link->next)
|
|
{
|
|
g_string_append (str, link->data);
|
|
if (link->next)
|
|
g_string_append_c (str, '/');
|
|
}
|
|
g_string_append_c (str, ')');
|
|
buf = g_string_free (str, FALSE);
|
|
g_prefix_error (error, "In %s (Context: %s): ", section, buf);
|
|
g_free (buf);
|
|
}
|
|
|
|
gboolean
|
|
g_typelib_validate (GITypelib *typelib,
|
|
GError **error)
|
|
{
|
|
ValidateContext ctx;
|
|
ctx.typelib = typelib;
|
|
ctx.context_stack = NULL;
|
|
|
|
if (!validate_header (&ctx, error))
|
|
{
|
|
prefix_with_context (error, "In header", &ctx);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_directory (&ctx, error))
|
|
{
|
|
prefix_with_context (error, "directory", &ctx);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!validate_attributes (&ctx, error))
|
|
{
|
|
prefix_with_context (error, "attributes", &ctx);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GQuark
|
|
g_typelib_error_quark (void)
|
|
{
|
|
static GQuark quark = 0;
|
|
if (quark == 0)
|
|
quark = g_quark_from_static_string ("g-typelib-error-quark");
|
|
return quark;
|
|
}
|
|
|
|
static GSList *library_paths;
|
|
|
|
/**
|
|
* g_irepository_prepend_library_path:
|
|
* @directory: (type filename): a single directory to scan for shared libraries
|
|
*
|
|
* Prepends @directory to the search path that is used to
|
|
* search shared libraries referenced by imported namespaces.
|
|
* Multiple calls to this function all contribute to the final
|
|
* list of paths.
|
|
* The list of paths is unique and shared for all #GIRepository
|
|
* instances across the process, but it doesn't affect namespaces
|
|
* imported before the call.
|
|
*
|
|
* If the library is not found in the directories configured
|
|
* in this way, loading will fall back to the system library
|
|
* path (ie. LD_LIBRARY_PATH and DT_RPATH in ELF systems).
|
|
* See the documentation of your dynamic linker for full details.
|
|
*
|
|
* Since: 1.35.8
|
|
*/
|
|
void
|
|
g_irepository_prepend_library_path (const char *directory)
|
|
{
|
|
library_paths = g_slist_prepend (library_paths,
|
|
g_strdup (directory));
|
|
}
|
|
|
|
/* Note on the GModule flags used by this function:
|
|
|
|
* Glade's autoconnect feature and OpenGL's extension mechanism
|
|
* as used by Clutter rely on g_module_open(NULL) to work as a means of
|
|
* accessing the app's symbols. This keeps us from using
|
|
* G_MODULE_BIND_LOCAL. BIND_LOCAL may have other issues as well;
|
|
* in general libraries are not expecting multiple copies of
|
|
* themselves and are not expecting to be unloaded. So we just
|
|
* load modules globally for now.
|
|
*/
|
|
static GModule *
|
|
load_one_shared_library (const char *shlib)
|
|
{
|
|
GSList *p;
|
|
GModule *m;
|
|
|
|
if (!g_path_is_absolute (shlib))
|
|
{
|
|
/* First try in configured library paths */
|
|
for (p = library_paths; p; p = p->next)
|
|
{
|
|
char *path = g_build_filename (p->data, shlib, NULL);
|
|
|
|
m = g_module_open (path, G_MODULE_BIND_LAZY);
|
|
|
|
g_free (path);
|
|
if (m != NULL)
|
|
return m;
|
|
}
|
|
}
|
|
|
|
/* Then try loading from standard paths */
|
|
/* Do not attempt to fix up shlib to replace .la with .so:
|
|
it's done by GModule anyway.
|
|
*/
|
|
return g_module_open (shlib, G_MODULE_BIND_LAZY);
|
|
}
|
|
|
|
static void
|
|
_g_typelib_do_dlopen (GITypelib *typelib)
|
|
{
|
|
Header *header;
|
|
const char *shlib_str;
|
|
|
|
header = (Header *) typelib->data;
|
|
/* note that NULL shlib means to open the main app, which is allowed */
|
|
if (header->shared_library)
|
|
shlib_str = g_typelib_get_string (typelib, header->shared_library);
|
|
else
|
|
shlib_str = NULL;
|
|
|
|
if (shlib_str != NULL && shlib_str[0] != '\0')
|
|
{
|
|
gchar **shlibs;
|
|
gint i;
|
|
|
|
/* shared-library is a comma-separated list of libraries */
|
|
shlibs = g_strsplit (shlib_str, ",", 0);
|
|
|
|
/* We load all passed libs unconditionally as if the same library is loaded
|
|
* again with g_module_open(), the same file handle will be returned. See bug:
|
|
* http://bugzilla.gnome.org/show_bug.cgi?id=555294
|
|
*/
|
|
for (i = 0; shlibs[i]; i++)
|
|
{
|
|
GModule *module;
|
|
|
|
module = load_one_shared_library (shlibs[i]);
|
|
|
|
if (module == NULL)
|
|
{
|
|
g_warning ("Failed to load shared library '%s' referenced by the typelib: %s",
|
|
shlibs[i], g_module_error ());
|
|
}
|
|
else
|
|
{
|
|
typelib->modules = g_list_append (typelib->modules, module);
|
|
}
|
|
}
|
|
|
|
g_strfreev (shlibs);
|
|
}
|
|
else
|
|
{
|
|
/* If there's no shared-library entry for this module, assume that
|
|
* the module is for the application. Some of the hand-written .gir files
|
|
* in gobject-introspection don't have shared-library entries, but no one
|
|
* is really going to be calling g_module_symbol on them either.
|
|
*/
|
|
GModule *module = g_module_open (NULL, 0);
|
|
if (module == NULL)
|
|
g_warning ("gtypelib.c: Failed to g_module_open (NULL): %s", g_module_error ());
|
|
else
|
|
typelib->modules = g_list_prepend (typelib->modules, module);
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
_g_typelib_ensure_open (GITypelib *typelib)
|
|
{
|
|
if (typelib->open_attempted)
|
|
return;
|
|
typelib->open_attempted = TRUE;
|
|
_g_typelib_do_dlopen (typelib);
|
|
}
|
|
|
|
/**
|
|
* g_typelib_new_from_memory: (skip)
|
|
* @memory: address of memory chunk containing the typelib
|
|
* @len: length of memory chunk containing the typelib
|
|
* @error: a #GError
|
|
*
|
|
* Creates a new #GITypelib from a memory location. The memory block
|
|
* pointed to by @typelib will be automatically g_free()d when the
|
|
* repository is destroyed.
|
|
*
|
|
* Return value: the new #GITypelib
|
|
**/
|
|
GITypelib *
|
|
g_typelib_new_from_memory (guint8 *memory,
|
|
gsize len,
|
|
GError **error)
|
|
{
|
|
GITypelib *meta;
|
|
|
|
if (!validate_header_basic (memory, len, error))
|
|
return NULL;
|
|
|
|
meta = g_slice_new0 (GITypelib);
|
|
meta->data = memory;
|
|
meta->len = len;
|
|
meta->owns_memory = TRUE;
|
|
meta->modules = NULL;
|
|
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* g_typelib_new_from_const_memory: (skip)
|
|
* @memory: address of memory chunk containing the typelib
|
|
* @len: length of memory chunk containing the typelib
|
|
* @error: A #GError
|
|
*
|
|
* Creates a new #GITypelib from a memory location.
|
|
*
|
|
* Return value: the new #GITypelib
|
|
**/
|
|
GITypelib *
|
|
g_typelib_new_from_const_memory (const guchar *memory,
|
|
gsize len,
|
|
GError **error)
|
|
{
|
|
GITypelib *meta;
|
|
|
|
if (!validate_header_basic (memory, len, error))
|
|
return NULL;
|
|
|
|
meta = g_slice_new0 (GITypelib);
|
|
meta->data = (guchar *) memory;
|
|
meta->len = len;
|
|
meta->owns_memory = FALSE;
|
|
meta->modules = NULL;
|
|
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* g_typelib_new_from_mapped_file: (skip)
|
|
* @mfile: a #GMappedFile, that will be free'd when the repository is destroyed
|
|
* @error: a #GError
|
|
*
|
|
* Creates a new #GITypelib from a #GMappedFile.
|
|
*
|
|
* Return value: the new #GITypelib
|
|
**/
|
|
GITypelib *
|
|
g_typelib_new_from_mapped_file (GMappedFile *mfile,
|
|
GError **error)
|
|
{
|
|
GITypelib *meta;
|
|
guint8 *data = (guint8 *) g_mapped_file_get_contents (mfile);
|
|
gsize len = g_mapped_file_get_length (mfile);
|
|
|
|
if (!validate_header_basic (data, len, error))
|
|
return NULL;
|
|
|
|
meta = g_slice_new0 (GITypelib);
|
|
meta->mfile = mfile;
|
|
meta->owns_memory = FALSE;
|
|
meta->data = data;
|
|
meta->len = len;
|
|
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* g_typelib_free:
|
|
* @typelib: a #GITypelib
|
|
*
|
|
* Free a #GITypelib.
|
|
**/
|
|
void
|
|
g_typelib_free (GITypelib *typelib)
|
|
{
|
|
if (typelib->mfile)
|
|
g_mapped_file_unref (typelib->mfile);
|
|
else
|
|
if (typelib->owns_memory)
|
|
g_free (typelib->data);
|
|
if (typelib->modules)
|
|
{
|
|
g_list_foreach (typelib->modules, (GFunc) g_module_close, NULL);
|
|
g_list_free (typelib->modules);
|
|
}
|
|
g_slice_free (GITypelib, typelib);
|
|
}
|
|
|
|
const gchar *
|
|
g_typelib_get_namespace (GITypelib *typelib)
|
|
{
|
|
return g_typelib_get_string (typelib, ((Header *) typelib->data)->namespace);
|
|
}
|
|
|
|
/**
|
|
* g_typelib_symbol:
|
|
* @typelib: the typelib
|
|
* @symbol_name: name of symbol to be loaded
|
|
* @symbol: returns a pointer to the symbol value
|
|
*
|
|
* Loads a symbol from #GITypelib.
|
|
*
|
|
* Return value: #TRUE on success
|
|
**/
|
|
gboolean
|
|
g_typelib_symbol (GITypelib *typelib, const char *symbol_name, gpointer *symbol)
|
|
{
|
|
GList *l;
|
|
|
|
_g_typelib_ensure_open (typelib);
|
|
|
|
/*
|
|
* The reason for having multiple modules dates from gir-repository
|
|
* when it was desired to inject code (accessors, etc.) into an
|
|
* existing library. In that situation, the first module listed
|
|
* will be the custom one, which overrides the main one. A bit
|
|
* inefficient, but the problem will go away when gir-repository
|
|
* does.
|
|
*
|
|
* For modules with no shared library, we dlopen'd the current
|
|
* process above.
|
|
*/
|
|
for (l = typelib->modules; l; l = l->next)
|
|
{
|
|
GModule *module = l->data;
|
|
|
|
if (g_module_symbol (module, symbol_name, symbol))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|