luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-07 09:56:15 +01:00
Code Issues Packages Projects Releases Wiki Activity
1f9e44d623
glib/girepository/gitypelib.c
Philip Withnall 0fd99a9f16 gibaseinfo: Stop building GIBoxedInfo instances 
Instead, add a method on `GIRegisteredTypeInfo` which indicates whether
the registered type is a boxed type. This will return true for
`GIStructInfo` and `GIUnionInfo` instances which are boxed (not all
structs and unions are).

This makes `GIBoxedInfo` redundant, and it’ll be dropped in a following
commit.

---

There are several different things which typelibs need to be able to
represent:
 1. Plain old datatype (POD) structs
 2. POD unions
 3. Structs with a copy func and/or free func
 4. Unions with a copy func and/or free func
 5. Structs which are the ‘GType struct’ for an object or interface (i.e.
    the class or instance or interface struct)
 6. Structs with a copy func and free func *and* boxed GType
 7. Unions with a copy func and free func *and* boxed GType
 8. Boxed GTypes which represent something other than a struct or union

So there’s a lot going on here. In commit
e28078c70cbf4a57c7dbd39626f43f9bd2674145, a lot of this was reworked,
and support was added for boxed unions and boxed ‘others’ (the last item
on the list above).

Since then, support for boxed types other than structs seems to have
atrophied a bit, and the whole lot has got a bit confusing.

It was perhaps less confusing when all the `GIBaseInfo` subclasses were
actually aliases of each other, but now they have subtype relationships,
the position of `GIBoxedInfo` in that type hierarchy has become unclear.
How is it related to `GIStructInfo`, `GIUnionInfo` and
`GIRegisteredTypeInfo`?

Since a boxed type is necessarily a `GIRegisteredTypeInfo`, and the
methods of `GIRegisteredTypeInfo` are all written to allow a `GType` to
be optional, so that `GIStructInfo` and `GIUnionInfo` can safely derive
from it and still be used to represent plain old datatypes without
`GType`s, it makes sense to add a method to `GIRegisteredTypeInfo` to
indicate that the registered type is derived from `G_TYPE_BOXED`.

Accordingly, the things above are now represented in libgirepository’s
type system as:
 1. `GIStructInfo` instance, `GIRegisteredTypeInfo` methods return no
    `GType` info
 2. `GIUnionInfo` instance similarly
 3. `GIStructInfo` instance, `GIRegisteredTypeInfo` methods return no
    `GType` info, `gi_struct_info_get_{copy,free}_function_name()` return
    non-`NULL` values
 4. `GIUnionInfo` instance similarly
 5. `GIStructInfo` instance, `GIRegisteredTypeInfo` methods return no
    `GType` info, `gi_struct_info_is_gtype_struct()` returns true
 6. `GIStructInfo` instance, `GIRegisteredTypeInfo` methods return valid
    `GType` information, `gi_registered_type_info_is_boxed()` returns
    true, `gi_struct_info_get_{copy,free}_function_name()` return
    `NULL` values (because the copy/free functions are hidden inside the
    boxed type registration at runtime)
 7. `GIUnionInfo` instance similarly
 8. Not representable, but could be represented in future by re-adding a
    `GIBoxedInfo` type which derives from `GIRegisteredTypeInfo` and is
    used solely for boxed ‘other’ types, *not* boxed structs or unions

Signed-off-by: Philip Withnall <pwithnall@gnome.org>

Fixes: #3245
2024-02-12 13:16:07 +00:00

2489 lines
67 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* -*- 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
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* 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 "config.h"
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "gitypelib-internal.h"
#include "gitypelib.h"
/**
* GITypelib:
*
* `GITypelib` represents a loaded `.typelib` file, which contains a description
* of a single module’s API.
*
* Since: 2.80
*/
G_DEFINE_BOXED_TYPE (GITypelib, gi_typelib, gi_typelib_ref, gi_typelib_unref)
GIInfoType
gi_typelib_blob_type_to_info_type (GITypelibBlobType blob_type)
{
switch (blob_type)
{
case BLOB_TYPE_BOXED:
/* `BLOB_TYPE_BOXED` now always refers to a `StructBlob`, and
* `GIRegisteredTypeInfo` (the parent type of `GIStructInfo`) has a method
* for distinguishing whether the struct is a boxed type. So presenting
* `BLOB_TYPE_BOXED` as its own `GIBaseInfo` subclass is not helpful.
* See commit e28078c70cbf4a57c7dbd39626f43f9bd2674145 and
* https://gitlab.gnome.org/GNOME/glib/-/issues/3245. */
return GI_INFO_TYPE_STRUCT;
default:
return (GIInfoType) blob_type;
}
}
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,
uint32_t offset,
GError **error);
static DirEntry *
get_dir_entry_checked (GITypelib *typelib,
uint16_t index,
GError **error)
{
Header *header = (Header *)typelib->data;
uint32_t offset;
if (index == 0 || index > header->n_entries)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
return (DirEntry *)&typelib->data[offset];
}
static CommonBlob *
get_blob (GITypelib *typelib,
uint32_t offset,
GError **error)
{
if (typelib->len < offset + sizeof (CommonBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"Expected blob for type");
return FALSE;
}
if (simple->flags.reserved == 0 && simple->flags.reserved2 == 0)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"Expected non-basic type but got %d",
simple->flags.tag);
return FALSE;
}
return (InterfaceTypeBlob*) get_blob (typelib, simple->offset, error);
}
/**
* gi_typelib_get_dir_entry:
* @typelib: a #GITypelib
* @index: index to retrieve
*
* Get the typelib directory entry at the given @index.
*
* Returns: (transfer none): a `DirEntry`
* Since: 2.80
*/
DirEntry *
gi_typelib_get_dir_entry (GITypelib *typelib,
uint16_t 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;
}
/**
* gi_typelib_get_dir_entry_by_name:
* @typelib: a #GITypelib
* @name: name to look up
*
* Get the typelib directory entry which has @name.
*
* Returns: (transfer none) (nullable): entry corresponding to @name, or `NULL`
* if none was found
* Since: 2.80
*/
DirEntry *
gi_typelib_get_dir_entry_by_name (GITypelib *typelib,
const char *name)
{
Section *dirindex;
size_t 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 = gi_typelib_get_dir_entry (typelib, i);
entry_name = gi_typelib_get_string (typelib, entry->name);
if (strcmp (name, entry_name) == 0)
return entry;
}
return NULL;
}
else
{
uint8_t *hash = (uint8_t *) &typelib->data[dirindex->offset];
uint16_t index;
index = gi_typelib_hash_search (hash, name, n_entries);
entry = gi_typelib_get_dir_entry (typelib, index + 1);
entry_name = gi_typelib_get_string (typelib, entry->name);
if (strcmp (name, entry_name) == 0)
return entry;
return NULL;
}
}
/**
* gi_typelib_get_dir_entry_by_gtype_name:
* @typelib: a #GITypelib
* @gtype_name: name of a [type@GObject.Type] to look up
*
* Get the typelib directory entry for the [type@GObject.Type] with the given
* @gtype_name.
*
* Returns: (transfer none) (nullable): entry corresponding to @gtype_name, or
* `NULL` if none was found
* Since: 2.80
*/
DirEntry *
gi_typelib_get_dir_entry_by_gtype_name (GITypelib *typelib,
const char *gtype_name)
{
Header *header = (Header *)typelib->data;
for (size_t i = 1; i <= header->n_local_entries; i++)
{
RegisteredTypeBlob *blob;
const char *type;
DirEntry *entry = gi_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 = gi_typelib_get_string (typelib, blob->gtype_name);
if (strcmp (type, gtype_name) == 0)
return entry;
}
return NULL;
}
typedef struct {
const char *s;
const char *separator;
size_t sep_len;
GString buf;
} StrSplitIter;
static void
strsplit_iter_init (StrSplitIter *iter,
const char *s,
const char *separator)
{
iter->s = s;
iter->separator = separator;
iter->sep_len = strlen (separator);
iter->buf.str = NULL;
iter->buf.len = 0;
iter->buf.allocated_len = 0;
}
static gboolean
strsplit_iter_next (StrSplitIter *iter,
const char **out_val)
{
const char *s = iter->s;
const char *next;
size_t len;
if (!s)
return FALSE;
next = strstr (s, iter->separator);
if (next)
{
iter->s = next + iter->sep_len;
len = next - s;
}
else
{
iter->s = NULL;
len = strlen (s);
}
if (len == 0)
{
*out_val = "";
}
else
{
g_string_overwrite_len (&iter->buf, 0, s, (gssize)len);
*out_val = iter->buf.str;
}
return TRUE;
}
static void
strsplit_iter_clear (StrSplitIter *iter)
{
g_free (iter->buf.str);
}
/**
* gi_typelib_matches_gtype_name_prefix:
* @typelib: a #GITypelib
* @gtype_name: name of a [type@GObject.Type]
*
* Check whether the symbol prefix for @typelib is a prefix of the given
* @gtype_name.
*
* Returns: `TRUE` if the prefix for @typelib prefixes @gtype_name
* Since: 2.80
*/
gboolean
gi_typelib_matches_gtype_name_prefix (GITypelib *typelib,
const char *gtype_name)
{
Header *header = (Header *)typelib->data;
const char *c_prefix;
const char *prefix;
gboolean ret = FALSE;
StrSplitIter split_iter;
size_t gtype_name_len;
c_prefix = gi_typelib_get_string (typelib, header->c_prefix);
if (c_prefix == NULL || strlen (c_prefix) == 0)
return FALSE;
gtype_name_len = strlen (gtype_name);
/* 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.
*/
strsplit_iter_init (&split_iter, c_prefix, ",");
while (strsplit_iter_next (&split_iter, &prefix))
{
size_t len = strlen (prefix);
if (gtype_name_len < len)
continue;
if (strncmp (prefix, gtype_name, len) != 0)
continue;
if (g_ascii_isupper (gtype_name[len]))
{
ret = TRUE;
break;
}
}
strsplit_iter_clear (&split_iter);
return ret;
}
/**
* gi_typelib_get_dir_entry_by_error_domain:
* @typelib: a #GITypelib
* @error_domain: name of a [type@GLib.Error] domain to look up
*
* Get the typelib directory entry for the [type@GLib.Error] domain with the
* given @error_domain name.
*
* Returns: (transfer none) (nullable): entry corresponding to @error_domain, or
* `NULL` if none was found
* Since: 2.80
*/
DirEntry *
gi_typelib_get_dir_entry_by_error_domain (GITypelib *typelib,
GQuark error_domain)
{
Header *header = (Header *)typelib->data;
size_t n_entries = header->n_local_entries;
const char *domain_string = g_quark_to_string (error_domain);
DirEntry *entry;
for (size_t i = 1; i <= n_entries; i++)
{
EnumBlob *blob;
const char *enum_domain_string;
entry = gi_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 = gi_typelib_get_string (typelib, blob->error_domain);
if (strcmp (domain_string, enum_domain_string) == 0)
return entry;
}
return NULL;
}
/* 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().
*/
G_STATIC_ASSERT (sizeof (Header) == 112);
G_STATIC_ASSERT (sizeof (DirEntry) == 12);
G_STATIC_ASSERT (sizeof (SimpleTypeBlob) == 4);
G_STATIC_ASSERT (sizeof (ArgBlob) == 16);
G_STATIC_ASSERT (sizeof (SignatureBlob) == 8);
G_STATIC_ASSERT (sizeof (CommonBlob) == 8);
G_STATIC_ASSERT (sizeof (FunctionBlob) == 20);
G_STATIC_ASSERT (sizeof (CallbackBlob) == 12);
G_STATIC_ASSERT (sizeof (InterfaceTypeBlob) == 4);
G_STATIC_ASSERT (sizeof (ArrayTypeBlob) == 8);
G_STATIC_ASSERT (sizeof (ParamTypeBlob) == 4);
G_STATIC_ASSERT (sizeof (ErrorTypeBlob) == 4);
G_STATIC_ASSERT (sizeof (ValueBlob) == 12);
G_STATIC_ASSERT (sizeof (FieldBlob) == 16);
G_STATIC_ASSERT (sizeof (RegisteredTypeBlob) == 16);
G_STATIC_ASSERT (sizeof (StructBlob) == 32);
G_STATIC_ASSERT (sizeof (EnumBlob) == 24);
G_STATIC_ASSERT (sizeof (PropertyBlob) == 16);
G_STATIC_ASSERT (sizeof (SignalBlob) == 16);
G_STATIC_ASSERT (sizeof (VFuncBlob) == 20);
G_STATIC_ASSERT (sizeof (ObjectBlob) == 60);
G_STATIC_ASSERT (sizeof (InterfaceBlob) == 40);
G_STATIC_ASSERT (sizeof (ConstantBlob) == 24);
G_STATIC_ASSERT (sizeof (AttributeBlob) == 12);
G_STATIC_ASSERT (sizeof (UnionBlob) == 40);
static gboolean
is_aligned (uint32_t offset)
{
return offset == ALIGN_VALUE (offset, 4);
}
#define MAX_NAME_LEN 2048
static const char *
get_string (GITypelib *typelib, uint32_t offset, GError **error)
{
if (typelib->len < offset)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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, uint32_t offset)
{
const char *ret = get_string (typelib, offset, NULL);
g_assert (ret);
return ret;
}
static gboolean
validate_name (GITypelib *typelib,
const char *msg,
const uint8_t *data,
uint32_t 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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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 uint8_t *memory,
size_t len,
GError **error)
{
Header *header = (Header *)memory;
if (len < sizeof (Header))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"The specified typelib length %zu is too short", len);
return FALSE;
}
if (strncmp (header->magic, GI_IR_MAGIC, 16) != 0)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_HEADER,
"Invalid magic header");
return FALSE;
}
if (header->major_version != 4)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_HEADER,
"Inconsistent entry counts");
return FALSE;
}
if (header->size != len)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_HEADER,
"Typelib size %zu does not match %zu",
(size_t) header->size, len);
return FALSE;
}
/* This is a sanity check for a specific typelib; it
* prevents us from loading an incompatible typelib.
*
* The hardcoded static checks 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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_HEADER,
"Blob size mismatch");
return FALSE;
}
if (!is_aligned (header->directory))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_HEADER,
"Misaligned directory");
return FALSE;
}
if (!is_aligned (header->attributes))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_HEADER,
"Misaligned attributes");
return FALSE;
}
if (header->attributes == 0 && header->n_attributes > 0)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
uint32_t signature_offset,
gboolean return_type,
GError **error);
static gboolean
validate_array_type_blob (GITypelib *typelib,
uint32_t offset,
uint32_t 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,
uint32_t offset,
uint32_t 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,
uint32_t offset,
uint32_t signature_offset,
gboolean return_type,
size_t n_params,
GError **error)
{
ParamTypeBlob *blob;
blob = (ParamTypeBlob*)&typelib->data[offset];
if (!blob->pointer)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Pointer type exected for tag %d", blob->tag);
return FALSE;
}
if (blob->n_types != n_params)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Parameter type number mismatch");
return FALSE;
}
for (size_t 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,
uint32_t offset,
uint32_t signature_offset,
gboolean return_type,
GError **error)
{
ErrorTypeBlob *blob;
blob = (ErrorTypeBlob*)&typelib->data[offset];
if (!blob->pointer)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Pointer type exected for tag %d", blob->tag);
return FALSE;
}
return TRUE;
}
static gboolean
validate_type_blob (GITypelib *typelib,
uint32_t offset,
uint32_t 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 (!GI_TYPE_TAG_IS_BASIC(simple->flags.tag))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Wrong tag in complex type");
return FALSE;
}
return TRUE;
}
static gboolean
validate_arg_blob (GITypelib *typelib,
uint32_t offset,
uint32_t signature_offset,
GError **error)
{
ArgBlob *blob;
if (typelib->len < offset + sizeof (ArgBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
GError **error)
{
SignatureBlob *blob;
if (typelib->len < offset + sizeof (SignatureBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
GError **error)
{
SignatureBlob *blob;
if (typelib->len < offset + sizeof (SignatureBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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 (size_t 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,
uint32_t offset,
uint16_t container_type,
GError **error)
{
GITypelib *typelib = ctx->typelib;
FunctionBlob *blob;
if (typelib->len < offset + sizeof (FunctionBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"Invalid return type '%s' for constructor '%s'",
gi_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,
uint32_t offset,
GError **error)
{
GITypelib *typelib = ctx->typelib;
CallbackBlob *blob;
if (typelib->len < offset + sizeof (CallbackBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
GError **error)
{
size_t value_size[] = {
0, /* VOID */
4, /* BOOLEAN */
1, /* INT8 */
1, /* UINT8 */
2, /* INT16 */
2, /* UINT16 */
4, /* INT32 */
4, /* UINT32 */
8, /* INT64 */
8, /* UINT64 */
sizeof (float),
sizeof (double),
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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Constant value size mismatch");
return FALSE;
}
/* FIXME check string values */
}
return TRUE;
}
static gboolean
validate_value_blob (GITypelib *typelib,
uint32_t offset,
GError **error)
{
ValueBlob *blob;
if (typelib->len < offset + sizeof (ValueBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
GError **error)
{
GITypelib *typelib = ctx->typelib;
Header *header = (Header *)typelib->data;
FieldBlob *blob;
if (typelib->len < offset + sizeof (FieldBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
GError **error)
{
PropertyBlob *blob;
if (typelib->len < offset + sizeof (PropertyBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
uint32_t container_offset,
GError **error)
{
SignalBlob *blob;
size_t n_signals;
if (typelib->len < offset + sizeof (SignalBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
uint32_t container_offset,
GError **error)
{
VFuncBlob *blob;
size_t n_vfuncs;
if (typelib->len < offset + sizeof (VFuncBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
uint16_t blob_type,
GError **error)
{
GITypelib *typelib = ctx->typelib;
StructBlob *blob;
size_t i;
uint32_t field_offset;
if (typelib->len < offset + sizeof (StructBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
field_offset = offset + sizeof (StructBlob);
for (i = 0; i < blob->n_fields; i++)
{
FieldBlob *field_blob = (FieldBlob*) &typelib->data[field_offset];
if (!validate_field_blob (ctx,
field_offset,
error))
return FALSE;
field_offset += sizeof (FieldBlob);
if (field_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,
uint32_t offset,
uint16_t blob_type,
GError **error)
{
GITypelib *typelib = ctx->typelib;
EnumBlob *blob;
uint32_t offset2;
if (typelib->len < offset + sizeof (EnumBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
offset2 = offset + sizeof (EnumBlob);
push_context (ctx, get_string_nofail (typelib, blob->name));
for (size_t 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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Duplicate enum value");
return FALSE;
}
}
#endif
}
for (size_t 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,
uint32_t offset,
GError **error)
{
GITypelib *typelib = ctx->typelib;
Header *header;
ObjectBlob *blob;
size_t i;
uint32_t offset2;
uint16_t n_field_callbacks;
header = (Header *)typelib->data;
if (typelib->len < offset + sizeof (ObjectBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
offset2 = offset + sizeof (ObjectBlob);
for (i = 0; i < blob->n_interfaces; i++, offset2 += 2)
{
uint16_t iface;
DirEntry *entry;
iface = *(uint16_t *)&typelib->data[offset2];
if (iface == 0 || iface > header->n_entries)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Not an interface");
return FALSE;
}
}
offset2 += 2 * (blob->n_interfaces %2);
push_context (ctx, get_string_nofail (typelib, blob->name));
n_field_callbacks = 0;
for (i = 0; i < blob->n_fields; i++)
{
FieldBlob *field_blob = (FieldBlob*) &typelib->data[offset2];
if (!validate_field_blob (ctx, offset2, error))
return FALSE;
offset2 += sizeof (FieldBlob);
/* Special case fields which are callbacks. */
if (field_blob->has_embedded_type) {
offset2 += sizeof (CallbackBlob);
n_field_callbacks++;
}
}
if (blob->n_field_callbacks != n_field_callbacks)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Incorrect number of field callbacks; expected "
"%" G_GUINT16_FORMAT ", got %" G_GUINT16_FORMAT,
blob->n_field_callbacks, n_field_callbacks);
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,
uint32_t offset,
GError **error)
{
GITypelib *typelib = ctx->typelib;
Header *header;
InterfaceBlob *blob;
size_t i;
uint32_t offset2;
header = (Header *)typelib->data;
if (typelib->len < offset + sizeof (InterfaceBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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;
uint16_t req;
req = *(uint16_t *)&typelib->data[offset2];
if (req == 0 || req > header->n_entries)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_BLOB,
"Invalid prerequisite index");
return FALSE;
}
entry = gi_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,
GI_TYPELIB_ERROR,
GI_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,
uint32_t offset,
GError **error)
{
return TRUE;
}
static gboolean
validate_blob (ValidateContext *ctx,
uint32_t offset,
GError **error)
{
GITypelib *typelib = ctx->typelib;
CommonBlob *common;
if (typelib->len < offset + sizeof (CommonBlob))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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;
size_t i;
if (typelib->len < header->directory + header->n_entries * sizeof (DirEntry))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID,
"The buffer is too short");
return FALSE;
}
for (i = 0; i < header->n_entries; i++)
{
entry = gi_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,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_DIRECTORY,
"Invalid entry type");
return FALSE;
}
if (i < header->n_local_entries)
{
if (!entry->local)
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_TYPELIB_ERROR_INVALID_DIRECTORY,
"Too few local directory entries");
return FALSE;
}
if (!is_aligned (entry->offset))
{
g_set_error (error,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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,
GI_TYPELIB_ERROR,
GI_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;
GSList *link;
char *buf;
link = ctx->context_stack;
if (!link)
{
g_prefix_error (error, "In %s:", section);
return;
}
str = g_string_new (NULL);
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);
}
/**
* gi_typelib_validate:
* @typelib: a #GITypelib
* @error: return location for a [type@GLib.Error], or `NULL`
*
* Check whether @typelib is well-formed, i.e. that the file is not corrupt or
* truncated.
*
* Returns: `TRUE` if @typelib is well-formed, `FALSE` otherwise
* Since: 2.80
*/
gboolean
gi_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;
}
/**
* gi_typelib_error_quark:
*
* Get the quark representing the [type@GIRepository.TypelibError] error domain.
*
* Returns: quark representing the error domain
* Since: 2.80
*/
GQuark
gi_typelib_error_quark (void)
{
static GQuark quark = 0;
if (quark == 0)
quark = g_quark_from_static_string ("gi-typelib-error-quark");
return quark;
}
/* 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 (GITypelib *typelib,
const char *shlib)
{
GModule *m;
#ifdef __APPLE__
/* On macOS, @-prefixed shlib paths (@rpath, @executable_path, @loader_path)
need to be treated as absolute; trying to combine them with a
configured library path produces a mangled path that is unresolvable
and may cause unintended side effects (such as loading the library
from a fall-back location on macOS 12.0.1).
*/
if (!g_path_is_absolute (shlib) && !g_str_has_prefix (shlib, "@"))
#else
if (!g_path_is_absolute (shlib))
#endif
{
/* First try in configured library paths */
for (unsigned int i = 0; typelib->library_paths != NULL && i < typelib->library_paths->len; i++)
{
char *path = g_build_filename (typelib->library_paths->pdata[i], 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
gi_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 = gi_typelib_get_string (typelib, header->shared_library);
else
shlib_str = NULL;
if (shlib_str != NULL && shlib_str[0] != '\0')
{
char **shlibs;
/* 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 (size_t i = 0; shlibs[i]; i++)
{
GModule *module;
module = load_one_shared_library (typelib, 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
gi_typelib_ensure_open (GITypelib *typelib)
{
if (typelib->open_attempted)
return;
typelib->open_attempted = TRUE;
gi_typelib_do_dlopen (typelib);
}
/**
* gi_typelib_new_from_bytes:
* @bytes: memory chunk containing the typelib
* @error: a [type@GLib.Error]
*
* Creates a new [type@GIRepository.Typelib] from a [type@GLib.Bytes].
*
* The [type@GLib.Bytes] can point to a memory location or a mapped file, and
* the typelib will hold a reference to it until the repository is destroyed.
*
* Returns: (transfer full): the new [type@GIRepository.Typelib]
* Since: 2.80
*/
GITypelib *
gi_typelib_new_from_bytes (GBytes *bytes,
GError **error)
{
GITypelib *meta;
size_t len;
const uint8_t *data = g_bytes_get_data (bytes, &len);
if (!validate_header_basic (data, len, error))
return NULL;
meta = g_slice_new0 (GITypelib);
g_atomic_ref_count_init (&meta->ref_count);
meta->bytes = g_bytes_ref (bytes);
meta->data = data;
meta->len = len;
meta->modules = NULL;
return meta;
}
/**
* gi_typelib_ref:
* @typelib: (transfer none): a #GITypelib
*
* Increment the reference count of a [type@GIRepository.Typelib].
*
* Returns: (transfer full): the same @typelib pointer
* Since: 2.80
*/
GITypelib *
gi_typelib_ref (GITypelib *typelib)
{
g_return_val_if_fail (typelib != NULL, NULL);
g_atomic_ref_count_inc (&typelib->ref_count);
return typelib;
}
/**
* gi_typelib_unref:
* @typelib: (transfer full): a #GITypelib
*
* Decrement the reference count of a [type@GIRepository.Typelib].
*
* Once the reference count reaches zero, the typelib is freed.
*
* Since: 2.80
*/
void
gi_typelib_unref (GITypelib *typelib)
{
g_return_if_fail (typelib != NULL);
if (g_atomic_ref_count_dec (&typelib->ref_count))
{
g_clear_pointer (&typelib->bytes, g_bytes_unref);
g_clear_pointer (&typelib->library_paths, g_ptr_array_unref);
if (typelib->modules)
{
g_list_foreach (typelib->modules, (GFunc) (void *) g_module_close, NULL);
g_list_free (typelib->modules);
}
g_slice_free (GITypelib, typelib);
}
}
/**
* gi_typelib_get_namespace:
* @typelib: a #GITypelib
*
* Get the name of the namespace represented by @typelib.
*
* Returns: name of the namespace represented by @typelib
* Since: 2.80
*/
const char *
gi_typelib_get_namespace (GITypelib *typelib)
{
return gi_typelib_get_string (typelib, ((Header *) typelib->data)->namespace);
}
/**
* gi_typelib_symbol:
* @typelib: the typelib
* @symbol_name: name of symbol to be loaded
* @symbol: (out) (nullable): returns a pointer to the symbol value, or `NULL`
* on failure
*
* Loads a symbol from a `GITypelib`.
*
* Returns: `TRUE` on success
* Since: 2.80
*/
gboolean
gi_typelib_symbol (GITypelib *typelib, const char *symbol_name, void **symbol)
{
GList *l;
gi_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;
}
Reference in New Issue View Git Blame Copy Permalink