diff options
Diffstat (limited to 'plugins/kaitai/records')
| -rw-r--r-- | plugins/kaitai/records/Makefile.am | 23 | ||||
| -rw-r--r-- | plugins/kaitai/records/bits-int.h | 59 | ||||
| -rw-r--r-- | plugins/kaitai/records/bits.c | 283 | ||||
| -rw-r--r-- | plugins/kaitai/records/bits.h | 62 | ||||
| -rw-r--r-- | plugins/kaitai/records/delayed-int.h | 60 | ||||
| -rw-r--r-- | plugins/kaitai/records/delayed.c | 352 | ||||
| -rw-r--r-- | plugins/kaitai/records/delayed.h | 65 | ||||
| -rw-r--r-- | plugins/kaitai/records/empty-int.h | 57 | ||||
| -rw-r--r-- | plugins/kaitai/records/empty.c | 236 | ||||
| -rw-r--r-- | plugins/kaitai/records/empty.h | 58 | ||||
| -rw-r--r-- | plugins/kaitai/records/group-int.h | 58 | ||||
| -rw-r--r-- | plugins/kaitai/records/group.c | 382 | ||||
| -rw-r--r-- | plugins/kaitai/records/group.h | 65 | ||||
| -rw-r--r-- | plugins/kaitai/records/item-int.h | 58 | ||||
| -rw-r--r-- | plugins/kaitai/records/item.c | 309 | ||||
| -rw-r--r-- | plugins/kaitai/records/item.h | 65 | ||||
| -rw-r--r-- | plugins/kaitai/records/list-int.h | 60 | ||||
| -rw-r--r-- | plugins/kaitai/records/list.c | 424 | ||||
| -rw-r--r-- | plugins/kaitai/records/list.h | 71 |
19 files changed, 2747 insertions, 0 deletions
diff --git a/plugins/kaitai/records/Makefile.am b/plugins/kaitai/records/Makefile.am new file mode 100644 index 0000000..3884bfb --- /dev/null +++ b/plugins/kaitai/records/Makefile.am @@ -0,0 +1,23 @@ + +noinst_LTLIBRARIES = libkaitairecords.la + +libkaitairecords_la_SOURCES = \ + bits-int.h \ + bits.h bits.c \ + delayed-int.h \ + delayed.h delayed.c \ + empty-int.h \ + empty.h empty.c \ + group-int.h \ + group.h group.c \ + item-int.h \ + item.h item.c \ + list-int.h \ + list.h list.c + +libkaitairecords_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBXML_CFLAGS) -I$(top_srcdir)/src + + +devdir = $(includedir)/chrysalide-$(subdir) + +dev_HEADERS = $(libkaitairecords_la_SOURCES:%c=) diff --git a/plugins/kaitai/records/bits-int.h b/plugins/kaitai/records/bits-int.h new file mode 100644 index 0000000..7b03911 --- /dev/null +++ b/plugins/kaitai/records/bits-int.h @@ -0,0 +1,59 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * bits-int.h - prototypes internes pour la conservation d'un champ de bits entre attribut et binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_BITS_INT_H +#define _PLUGINS_KAITAI_RECORDS_BITS_INT_H + + +#include "bits.h" + + +#include "../record-int.h" + + + +/* Correspondance de bits établie entre un attribut et du binaire (instance) */ +struct _GRecordBitField +{ + GMatchRecord parent; /* A laisser en premier */ + + ext_vmpa_t epos; /* Point de départ */ + uint8_t size; /* Quantité de bits concernés */ + SourceEndian endian; /* Boutisme des données imposé */ + +}; + +/* Correspondance de bits établie entre un attribut et du binaire (classe) */ +struct _GRecordBitFieldClass +{ + GMatchRecordClass parent; /* A laisser en premier */ + +}; + + +/* Met en place une correspondance entre attribut et binaire. */ +bool g_record_bit_field_create(GRecordBitField *, GKaitaiAttribute *, GBinContent *, const ext_vmpa_t *, uint8_t, SourceEndian); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_BITS_INT_H */ diff --git a/plugins/kaitai/records/bits.c b/plugins/kaitai/records/bits.c new file mode 100644 index 0000000..d224112 --- /dev/null +++ b/plugins/kaitai/records/bits.c @@ -0,0 +1,283 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * bits.c - conservation d'un champ de bits entre attribut et binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "bits.h" + + +#include <assert.h> +#include <string.h> + + +#include "bits-int.h" + + + +/* -------------------- DEFINITION D'UNE CORRESPONDANCE UNITAIRE -------------------- */ + + +/* Initialise la classe des correspondances attribut/binaire. */ +static void g_record_bit_field_class_init(GRecordBitFieldClass *); + +/* Initialise une correspondance entre attribut et binaire. */ +static void g_record_bit_field_init(GRecordBitField *); + +/* Supprime toutes les références externes. */ +static void g_record_bit_field_dispose(GRecordBitField *); + +/* Procède à la libération totale de la mémoire. */ +static void g_record_bit_field_finalize(GRecordBitField *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Calcule ou fournit la zone couverte par une correspondance. */ +static void g_record_bit_field_get_range(const GRecordBitField *, mrange_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DEFINITION D'UNE CORRESPONDANCE UNITAIRE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une correspondance entre un attribut et du binaire. */ +G_DEFINE_TYPE(GRecordBitField, g_record_bit_field, G_TYPE_MATCH_RECORD); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des correspondances attribut/binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_bit_field_class_init(GRecordBitFieldClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GMatchRecordClass *record; /* Version parente de la classe*/ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_record_bit_field_dispose; + object->finalize = (GObjectFinalizeFunc)g_record_bit_field_finalize; + + record = G_MATCH_RECORD_CLASS(klass); + + record->get_range = (get_record_range_fc)g_record_bit_field_get_range; + +} + + +/****************************************************************************** +* * +* Paramètres : field = instance à initialiser. * +* * +* Description : Initialise une correspondance entre attribut et binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_bit_field_init(GRecordBitField *field) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : field = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_bit_field_dispose(GRecordBitField *field) +{ + G_OBJECT_CLASS(g_record_bit_field_parent_class)->dispose(G_OBJECT(field)); + +} + + +/****************************************************************************** +* * +* Paramètres : field = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_bit_field_finalize(GRecordBitField *field) +{ + G_OBJECT_CLASS(g_record_bit_field_parent_class)->finalize(G_OBJECT(field)); + +} + + +/****************************************************************************** +* * +* Paramètres : attrib = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* epos = tête de lecture avec granularité en bits. * +* size = quantité de bits à prendre en compte. * +* endian = boustime des données à respecter. * +* * +* Description : Crée une nouvelle correspondance entre attribut et binaire. * +* * +* Retour : Instance mise en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GMatchRecord *g_record_bit_field_new(GKaitaiAttribute *attrib, GBinContent *content, const ext_vmpa_t *epos, uint8_t size, SourceEndian endian) +{ + GMatchRecord *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_RECORD_BIT_FIELD, NULL); + + if (!g_record_bit_field_create(G_RECORD_BIT_FIELD(result), attrib, content, epos, size, endian)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : field = correspondance à initialiser pleinement. * +* attrib = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* epos = tête de lecture avec granularité en bits. * +* size = quantité de bits à prendre en compte. * +* endian = boustime des données à respecter. * +* * +* Description : Met en place une correspondance entre attribut et binaire. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_bit_field_create(GRecordBitField *field, GKaitaiAttribute *attrib, GBinContent *content, const ext_vmpa_t *epos, uint8_t size, SourceEndian endian) +{ + bool result; /* Bilan à retourner */ + + result = g_match_record_create(G_MATCH_RECORD(field), G_KAITAI_PARSER(attrib), content); + + if (result) + { + copy_evmpa(&field->epos, epos); + field->size = size; + field->endian = endian; + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : field = correspondance à consulter. * +* out = valeur à sauvegarder sous une forme générique. [OUT] * +* * +* Description : Lit la valeur d'un élément Kaitai entier représenté. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_bit_field_get_value(const GRecordBitField *field, resolved_value_t *out) +{ + bool result; /* Bilan à retourner */ + GKaitaiParser *parser; /* Attribut associé à l'élément*/ + + parser = g_match_record_get_creator(G_MATCH_RECORD(field)); + assert(G_IS_KAITAI_ATTRIBUTE(parser)); + + result = g_kaitai_attribute_read_bit_field_value(G_KAITAI_ATTRIBUTE(parser), + G_MATCH_RECORD(field)->content, + &field->epos, field->size, + field->endian, out); + + g_object_unref(G_OBJECT(parser)); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : record = correspondance à consulter. * +* range = zone de couverture déterminée. [OUT] * +* * +* Description : Calcule ou fournit la zone couverte par une correspondance. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_bit_field_get_range(const GRecordBitField *record, mrange_t *range) +{ + phys_t len; /* Taille en octets */ + + len = record->size / 8; + + if (record->size % 8 > 0) + len ++; + + init_mrange(range, &record->epos.base, len); + +} diff --git a/plugins/kaitai/records/bits.h b/plugins/kaitai/records/bits.h new file mode 100644 index 0000000..923e8e3 --- /dev/null +++ b/plugins/kaitai/records/bits.h @@ -0,0 +1,62 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * bits.h - prototypes pour la conservation d'un champ de bits entre attribut et binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_BITS_H +#define _PLUGINS_KAITAI_RECORDS_BITS_H + + +#include <glib-object.h> + + +#include "../record.h" +#include "../parsers/attribute.h" + + + +#define G_TYPE_RECORD_BIT_FIELD g_record_bit_field_get_type() +#define G_RECORD_BIT_FIELD(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_BIT_FIELD, GRecordBitField)) +#define G_IS_RECORD_BIT_FIELD(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_BIT_FIELD)) +#define G_RECORD_BIT_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_BIT_FIELD, GRecordBitFieldClass)) +#define G_IS_RECORD_BIT_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_BIT_FIELD)) +#define G_RECORD_BIT_FIELD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_BIT_FIELD, GRecordBitFieldClass)) + + +/* Correspondance de bits établie entre un attribut et du binaire (instance) */ +typedef struct _GRecordBitField GRecordBitField; + +/* Correspondance de bits établie entre un attribut et du binaire (classe) */ +typedef struct _GRecordBitFieldClass GRecordBitFieldClass; + + +/* Indique le type défini pour une correspondance entre un attribut et du binaire. */ +GType g_record_bit_field_get_type(void); + +/* Crée une nouvelle correspondance entre attribut et binaire. */ +GMatchRecord *g_record_bit_field_new(GKaitaiAttribute *, GBinContent *, const ext_vmpa_t *, uint8_t, SourceEndian); + +/* Lit la valeur d'un élément Kaitai entier représenté. */ +bool g_record_bit_field_get_value(const GRecordBitField *, resolved_value_t *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_BITS_H */ diff --git a/plugins/kaitai/records/delayed-int.h b/plugins/kaitai/records/delayed-int.h new file mode 100644 index 0000000..9275500 --- /dev/null +++ b/plugins/kaitai/records/delayed-int.h @@ -0,0 +1,60 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * delayed-int.h - prototypes internes pour la conservation d'une instance virtuelle + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_DELAYED_INT_H +#define _PLUGINS_KAITAI_RECORDS_DELAYED_INT_H + + +#include "delayed.h" + + +#include "../record-int.h" + + + +/* Valeur calculée selon des correspondances parallèles (instance) */ +struct _GRecordDelayed +{ + GMatchRecord parent; /* A laisser en premier */ + + kaitai_scope_t locals; /* Sauvegarde de contexte */ + + bool has_value; /* Port d'une valeur directe ? */ + GMatchRecord *real_record; /* Enregistrement effectif */ + +}; + +/* Valeur calculée selon des correspondances parallèles (classe) */ +struct _GRecordDelayedClass +{ + GMatchRecordClass parent; /* A laisser en premier */ + +}; + + +/* Met en place une valeur calculée selon des correspondances. */ +bool g_record_delayed_create(GRecordDelayed *, GKaitaiInstance *, const kaitai_scope_t *, GBinContent *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_DELAYED_INT_H */ diff --git a/plugins/kaitai/records/delayed.c b/plugins/kaitai/records/delayed.c new file mode 100644 index 0000000..8c1395c --- /dev/null +++ b/plugins/kaitai/records/delayed.c @@ -0,0 +1,352 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * delayed.c - conservation d'une correspondance entre attribut et binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "delayed.h" + + +#include <assert.h> +#include <stdarg.h> +#include <string.h> + + +#include "delayed-int.h" +#include "item.h" +#include "../parsers/attribute.h" + + + +/* -------------------- DEFINITION D'UNE CORRESPONDANCE UNITAIRE -------------------- */ + + +/* Initialise la classe des valeurs purement calculées. */ +static void g_record_delayed_class_init(GRecordDelayedClass *); + +/* Initialise une correspondance entre attribut et binaire. */ +static void g_record_delayed_init(GRecordDelayed *); + +/* Supprime toutes les références externes. */ +static void g_record_delayed_dispose(GRecordDelayed *); + +/* Procède à la libération totale de la mémoire. */ +static void g_record_delayed_finalize(GRecordDelayed *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Calcule ou fournit la zone couverte par une correspondance. */ +static void g_record_delayed_get_range(const GRecordDelayed *, mrange_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DEFINITION D'UNE CORRESPONDANCE UNITAIRE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une valeur calculée selon des correspondances établies. */ +G_DEFINE_TYPE(GRecordDelayed, g_record_delayed, G_TYPE_MATCH_RECORD); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des valeurs purement calculées. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_delayed_class_init(GRecordDelayedClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GMatchRecordClass *record; /* Version parente de la classe*/ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_record_delayed_dispose; + object->finalize = (GObjectFinalizeFunc)g_record_delayed_finalize; + + record = G_MATCH_RECORD_CLASS(klass); + + record->get_range = (get_record_range_fc)g_record_delayed_get_range; + +} + + +/****************************************************************************** +* * +* Paramètres : delayed = instance à initialiser. * +* * +* Description : Initialise une correspondance entre attribut et binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_delayed_init(GRecordDelayed *delayed) +{ + init_record_scope(&delayed->locals, NULL); + + delayed->real_record = NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : delayed = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_delayed_dispose(GRecordDelayed *delayed) +{ + reset_record_scope(&delayed->locals); + + G_OBJECT_CLASS(g_record_delayed_parent_class)->dispose(G_OBJECT(delayed)); + +} + + +/****************************************************************************** +* * +* Paramètres : delayed = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_delayed_finalize(GRecordDelayed *delayed) +{ + G_OBJECT_CLASS(g_record_delayed_parent_class)->finalize(G_OBJECT(delayed)); + +} + + +/****************************************************************************** +* * +* Paramètres : inst = analyseur à l'origine de la correspondance. * +* locals = correspondances courantes pour résolutions. * +* content = contenu binaire lié à la correspondance. * +* * +* Description : Crée une nouvelle valeur calculée à partir d'une instance. * +* * +* Retour : Instance mise en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GRecordDelayed *g_record_delayed_new(GKaitaiInstance *inst, const kaitai_scope_t *locals, GBinContent *content) +{ + GRecordDelayed *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_RECORD_DELAYED, NULL); + + if (!g_record_delayed_create(result, inst, locals, content)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : delayed = correspondance à initialiser pleinement. * +* inst = analyseur à l'origine de la correspondance. * +* locals = correspondances courantes pour résolutions. * +* content = contenu binaire lié à la correspondance. * +* * +* Description : Met en place une valeur calculée à partir d'une instance. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_delayed_create(GRecordDelayed *delayed, GKaitaiInstance *inst, const kaitai_scope_t *locals, GBinContent *content) +{ + bool result; /* Bilan à retourner */ + + result = g_match_record_create(G_MATCH_RECORD(delayed), G_KAITAI_PARSER(inst), content); + + if (result) + copy_record_scope(&delayed->locals, locals); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : delayed = correspondance à consulter. * +* out = valeur à sauvegarder sous forme générique. [OUT] * +* * +* Description : Détermine la valeur d'un élément Kaitai calculé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_delayed_compute_value(GRecordDelayed *delayed, resolved_value_t *out) +{ + bool result; /* Bilan à retourner */ + GKaitaiParser *parser; /* Instance liée à l'élément */ + + parser = g_match_record_get_creator(G_MATCH_RECORD(delayed)); + assert(G_IS_KAITAI_ATTRIBUTE(parser)); + + if (G_MATCH_RECORD(delayed)->content == NULL) + result = g_kaitai_instance_compute_value(G_KAITAI_INSTANCE(parser), + &delayed->locals, + out); + + else + { + if (delayed->real_record == NULL) + delayed->real_record = g_kaitai_instance_compute_real_record(G_KAITAI_INSTANCE(parser), + &delayed->locals, + G_MATCH_RECORD(delayed)->content); + + if (delayed->real_record == NULL) + result = false; + + else + { + assert(G_IS_RECORD_ITEM(delayed->real_record)); + result = g_record_item_get_value(G_RECORD_ITEM(delayed->real_record), out); + } + + } + + g_object_unref(G_OBJECT(parser)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : delayed = correspondance à consulter. * +* out = valeur à sauvegarder sous forme générique. [OUT] * +* * +* Description : Détermine et ajuste la valeur d'un élément Kaitai calculé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_delayed_compute_and_aggregate_value(GRecordDelayed *delayed, resolved_value_t *out) +{ + bool result; /* Bilan à retourner */ + sized_string_t converted; /* Conversion finale ? */ + + result = g_record_delayed_compute_value(delayed, out); + + if (result) + { + /** + * Lorsque c'est possible, les tableaux Kaitai sont transformés en série + * d'octets. + * + * Même si les tableaux ont une grande portée en interne des règles + * Kaitai (par exemple pour constituer une table de constantes de + * référence), il en est différemment à l'extérieur du processus de + * traitement : les tableaux sont le plus souvent destinés à manipuler + * les octets représentés directement (par exemple : + * "contents: [0xca, 0xfe, 0xba, 0xbe]"). + * + * Pour les valeurs d'instance dont le type n'est pas explicite, + * le choix est fait de tenter de simplifier la vie de l'utilisateur + * en lui fournissant directement les octets qu'il attend probablement + * plutôt qu'un tableau contenant des octets à extraire. + */ + + if (out->type == GVT_ARRAY) + { + if (g_kaitai_array_convert_to_bytes(out->array, &converted)) + { + EXIT_RESOLVED_VALUE(*out); + + out->bytes = converted; + out->type = GVT_BYTES; + + } + + } + + } + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : delayed = correspondance à consulter. * +* range = zone de couverture déterminée. [OUT] * +* * +* Description : Calcule ou fournit la zone couverte par une correspondance. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_delayed_get_range(const GRecordDelayed *delayed, mrange_t *range) +{ + copy_mrange(range, UNUSED_MRANGE_PTR); + +} diff --git a/plugins/kaitai/records/delayed.h b/plugins/kaitai/records/delayed.h new file mode 100644 index 0000000..e88bb6c --- /dev/null +++ b/plugins/kaitai/records/delayed.h @@ -0,0 +1,65 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * delayed.h - prototypes pour la conservation d'une correspondance entre attribut et binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_DELAYED_H +#define _PLUGINS_KAITAI_RECORDS_DELAYED_H + + +#include <glib-object.h> + + +#include "../record.h" +#include "../parsers/instance.h" + + + +#define G_TYPE_RECORD_DELAYED g_record_delayed_get_type() +#define G_RECORD_DELAYED(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_DELAYED, GRecordDelayed)) +#define G_IS_RECORD_DELAYED(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_DELAYED)) +#define G_RECORD_DELAYED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_DELAYED, GRecordDelayedClass)) +#define G_IS_RECORD_DELAYED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_DELAYED)) +#define G_RECORD_DELAYED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_DELAYED, GRecordDelayedClass)) + + +/* Valeur calculée selon des correspondances parallèles (instance) */ +typedef struct _GRecordDelayed GRecordDelayed; + +/* Valeur calculée selon des correspondances parallèles (classe) */ +typedef struct _GRecordDelayedClass GRecordDelayedClass; + + +/* Indique le type défini pour une valeur calculée selon des correspondances établies. */ +GType g_record_delayed_get_type(void); + +/* Crée une nouvelle valeur calculée à partir d'une instance. */ +GRecordDelayed *g_record_delayed_new(GKaitaiInstance *, const kaitai_scope_t *, GBinContent *); + +/* Détermine la valeur d'un élément Kaitai entier calculé. */ +bool g_record_delayed_compute_value(GRecordDelayed *, resolved_value_t *); + +/* Détermine et ajuste la valeur d'un élément Kaitai calculé. */ +bool g_record_delayed_compute_and_aggregate_value(GRecordDelayed *, resolved_value_t *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_DELAYED_H */ diff --git a/plugins/kaitai/records/empty-int.h b/plugins/kaitai/records/empty-int.h new file mode 100644 index 0000000..2c6cefa --- /dev/null +++ b/plugins/kaitai/records/empty-int.h @@ -0,0 +1,57 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * empty-int.h - prototypes internes pour la notification d'une absence de correspondance attendue + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_EMPTY_INT_H +#define _PLUGINS_KAITAI_RECORDS_EMPTY_INT_H + + +#include "empty.h" + + +#include "../record-int.h" + + + +/* Marque d'une zone de correspondance vide (instance) */ +struct _GRecordEmpty +{ + GMatchRecord parent; /* A laisser en premier */ + + vmpa2t pos; /* Début d'une zone vide */ + +}; + +/* Marque d'une zone de correspondance vide (classe) */ +struct _GRecordEmptyClass +{ + GMatchRecordClass parent; /* A laisser en premier */ + +}; + + +/* Met en place une zone de correspondance vide. */ +bool g_record_empty_create(GRecordEmpty *, GKaitaiParser *, GBinContent *, const vmpa2t *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_EMPTY_INT_H */ diff --git a/plugins/kaitai/records/empty.c b/plugins/kaitai/records/empty.c new file mode 100644 index 0000000..e5121e1 --- /dev/null +++ b/plugins/kaitai/records/empty.c @@ -0,0 +1,236 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * empty.c - conservation d'une correspondance entre attribut et binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "empty.h" + + +#include <assert.h> +#include <stdarg.h> +#include <string.h> + + +#include "empty-int.h" + + + +/* ------------------ DEFINITION D'UNE ZONE DE CORRESPONDANCE VIDE ------------------ */ + + +/* Initialise la classe des zones de correspondance vides. */ +static void g_record_empty_class_init(GRecordEmptyClass *); + +/* Initialise une zone de correspondance vide. */ +static void g_record_empty_init(GRecordEmpty *); + +/* Supprime toutes les références externes. */ +static void g_record_empty_dispose(GRecordEmpty *); + +/* Procède à la libération totale de la mémoire. */ +static void g_record_empty_finalize(GRecordEmpty *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Calcule ou fournit la zone couverte par une correspondance. */ +static void g_record_empty_get_range(const GRecordEmpty *, mrange_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DEFINITION D'UNE ZONE DE CORRESPONDANCE VIDE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une zone de correspondance vide. */ +G_DEFINE_TYPE(GRecordEmpty, g_record_empty, G_TYPE_MATCH_RECORD); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des zones de correspondance vides. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_empty_class_init(GRecordEmptyClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GMatchRecordClass *record; /* Version parente de la classe*/ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_record_empty_dispose; + object->finalize = (GObjectFinalizeFunc)g_record_empty_finalize; + + record = G_MATCH_RECORD_CLASS(klass); + + record->get_range = (get_record_range_fc)g_record_empty_get_range; + +} + + +/****************************************************************************** +* * +* Paramètres : empty = instance à initialiser. * +* * +* Description : Initialise une zone de correspondance vide. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_empty_init(GRecordEmpty *empty) +{ + init_vmpa(&empty->pos, VMPA_NO_PHYSICAL, VMPA_NO_VIRTUAL); + +} + + +/****************************************************************************** +* * +* Paramètres : empty = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_empty_dispose(GRecordEmpty *empty) +{ + G_OBJECT_CLASS(g_record_empty_parent_class)->dispose(G_OBJECT(empty)); + +} + + +/****************************************************************************** +* * +* Paramètres : empty = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_empty_finalize(GRecordEmpty *empty) +{ + G_OBJECT_CLASS(g_record_empty_parent_class)->finalize(G_OBJECT(empty)); + +} + + +/****************************************************************************** +* * +* Paramètres : parser = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* pos = emplacement de la zone vide à construire. * +* * +* Description : Crée une zone de correspondance vide à une position donnée. * +* * +* Retour : Instance mise en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GRecordEmpty *g_record_empty_new(GKaitaiParser *parser, GBinContent *content, const vmpa2t *pos) +{ + GRecordEmpty *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_RECORD_EMPTY, NULL); + + if (!g_record_empty_create(result, parser, content, pos)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : empty = correspondance à initialiser pleinement. * +* parser = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* pos = emplacement de la zone vide à construire. * +* * +* Description : Met en place une zone de correspondance vide. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_empty_create(GRecordEmpty *empty, GKaitaiParser *parser, GBinContent *content, const vmpa2t *pos) +{ + bool result; /* Bilan à retourner */ + + result = g_match_record_create(G_MATCH_RECORD(empty), parser, content); + + if (result) + copy_vmpa(&empty->pos, pos); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : empty = correspondance à consulter. * +* range = zone de couverture déterminée. [OUT] * +* * +* Description : Calcule ou fournit la zone couverte par une correspondance. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_empty_get_range(const GRecordEmpty *empty, mrange_t *range) +{ + init_mrange(range, &empty->pos, 0); + +} diff --git a/plugins/kaitai/records/empty.h b/plugins/kaitai/records/empty.h new file mode 100644 index 0000000..4e89b62 --- /dev/null +++ b/plugins/kaitai/records/empty.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * empty.h - prototypes pour la notification d'une absence de correspondance attendue + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_EMPTY_H +#define _PLUGINS_KAITAI_RECORDS_EMPTY_H + + +#include <glib-object.h> + + +#include "../record.h" + + + +#define G_TYPE_RECORD_EMPTY g_record_empty_get_type() +#define G_RECORD_EMPTY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_EMPTY, GRecordEmpty)) +#define G_IS_RECORD_EMPTY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_EMPTY)) +#define G_RECORD_EMPTY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_EMPTY, GRecordEmptyClass)) +#define G_IS_RECORD_EMPTY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_EMPTY)) +#define G_RECORD_EMPTY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_EMPTY, GRecordEmptyClass)) + + +/* Marque d'une zone de correspondance vide (instance) */ +typedef struct _GRecordEmpty GRecordEmpty; + +/* Marque d'une zone de correspondance vide (classe) */ +typedef struct _GRecordEmptyClass GRecordEmptyClass; + + +/* Indique le type défini pour une zone de correspondance vide. */ +GType g_record_empty_get_type(void); + +/* Crée une zone de correspondance vide à une position donnée. */ +GRecordEmpty *g_record_empty_new(GKaitaiParser *, GBinContent *, const vmpa2t *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_EMPTY_H */ diff --git a/plugins/kaitai/records/group-int.h b/plugins/kaitai/records/group-int.h new file mode 100644 index 0000000..1fd0162 --- /dev/null +++ b/plugins/kaitai/records/group-int.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * group-int.h - prototypes internes pour la conservation d'un groupe de correspondance avec du binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_GROUP_INT_H +#define _PLUGINS_KAITAI_RECORDS_GROUP_INT_H + + +#include "group.h" + + +#include "../record-int.h" + + + +/* Groupe de correspondances établies entre attributs et binaire (instance) */ +struct _GRecordGroup +{ + GMatchRecord parent; /* A laisser en premier */ + + GMatchRecord **children; /* Sous-correspondances */ + size_t count; /* Taille de cette série */ + +}; + +/* Groupe de correspondances établies entre attributs et binaire (classe) */ +struct _GRecordGroupClass +{ + GMatchRecordClass parent; /* A laisser en premier */ + +}; + + +/* Met en place une série de correspondances attribut/binaire. */ +bool g_record_group_create(GRecordGroup *, GKaitaiStruct *, GBinContent *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_GROUP_INT_H */ diff --git a/plugins/kaitai/records/group.c b/plugins/kaitai/records/group.c new file mode 100644 index 0000000..13327c8 --- /dev/null +++ b/plugins/kaitai/records/group.c @@ -0,0 +1,382 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * group.c - conservation d'un groupe de correspondance avec du binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "group.h" + + +#include <malloc.h> + + +#include "group-int.h" +#include "../parsers/attribute.h" + + + +/* ------------------ DEFINITION D'UNE SEQUENCE DE CORRESPONDANCES ------------------ */ + + +/* Initialise la classe des groupes de correspondances. */ +static void g_record_group_class_init(GRecordGroupClass *); + +/* Initialise une série de correspondances attributs/binaire. */ +static void g_record_group_init(GRecordGroup *); + +/* Supprime toutes les références externes. */ +static void g_record_group_dispose(GRecordGroup *); + +/* Procède à la libération totale de la mémoire. */ +static void g_record_group_finalize(GRecordGroup *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Calcule ou fournit la zone couverte par une correspondance. */ +static void g_record_group_get_range(const GRecordGroup *, mrange_t *); + +/* Recherche la correspondance associée à un identifiant. */ +static GMatchRecord *g_record_group_find_by_name(GRecordGroup *, const char *, size_t, unsigned int); + +/* Transforme une énumération en constante entière. */ +static bool g_record_group_resolve_enum(const GRecordGroup *, const sized_string_t *, const sized_string_t *, resolved_value_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DEFINITION D'UNE SEQUENCE DE CORRESPONDANCES */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une série de correspondances entre attributes et binaire. */ +G_DEFINE_TYPE(GRecordGroup, g_record_group, G_TYPE_MATCH_RECORD); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des groupes de correspondances. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_group_class_init(GRecordGroupClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GMatchRecordClass *record; /* Version parente de la classe*/ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_record_group_dispose; + object->finalize = (GObjectFinalizeFunc)g_record_group_finalize; + + record = G_MATCH_RECORD_CLASS(klass); + + record->get_range = (get_record_range_fc)g_record_group_get_range; + record->find = (find_record_by_name_fc)g_record_group_find_by_name; + record->resolve = (resolve_record_enum_fc)g_record_group_resolve_enum; + +} + + +/****************************************************************************** +* * +* Paramètres : group = instance à initialiser. * +* * +* Description : Initialise une série de correspondances attributs/binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_group_init(GRecordGroup *group) +{ + group->children = NULL; + group->count = 0; + +} + + +/****************************************************************************** +* * +* Paramètres : group = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_group_dispose(GRecordGroup *group) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < group->count; i++) + g_clear_object(&group->children[i]); + + G_OBJECT_CLASS(g_record_group_parent_class)->dispose(G_OBJECT(group)); + +} + + +/****************************************************************************** +* * +* Paramètres : group = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_group_finalize(GRecordGroup *group) +{ + if (group->children != NULL) + free(group->children); + + G_OBJECT_CLASS(g_record_group_parent_class)->finalize(G_OBJECT(group)); + +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu binaire lié à la correspondance. * +* kstruct = analyseur à l'origine de la correspondance. * +* * +* Description : Crée une nouvelle série de correspondances attribut/binaire. * +* * +* Retour : Instance mise en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GRecordGroup *g_record_group_new(GKaitaiStruct *kstruct, GBinContent *content) +{ + GRecordGroup *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_RECORD_GROUP, NULL); + + if (!g_record_group_create(result, kstruct, content)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : group = correspondance à initialiser pleinement. * +* kstruct = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* * +* Description : Met en place une série de correspondances attribut/binaire. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_group_create(GRecordGroup *group, GKaitaiStruct *kstruct, GBinContent *content) +{ + bool result; /* Bilan à retourner */ + + result = g_match_record_create(G_MATCH_RECORD(group), G_KAITAI_PARSER(kstruct), content); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de correspondances attribut/binaire. * +* record = sous-corresponde à intégrer. * +* * +* Description : Ajoute une correspondance supplémentaire à une série. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_record_group_add_record(GRecordGroup *group, GMatchRecord *record) +{ + group->children = realloc(group->children, ++group->count * sizeof(GMatchRecord)); + + group->children[group->count - 1] = record; + g_object_ref(G_OBJECT(record)); + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : group = correspondance à consulter. * +* range = zone de couverture déterminée. [OUT] * +* * +* Description : Calcule ou fournit la zone couverte par une correspondance. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_group_get_range(const GRecordGroup *group, mrange_t *range) +{ + vmpa2t start; /* Position de départ */ + mrange_t range_0; /* Première zone couverte */ + mrange_t range_n; /* Dernière zone couverte */ + vmpa2t end; /* Position de d'arrivée */ + phys_t length; /* Taille de zone couverte */ + + if (group->count == 0) + { + init_vmpa(&start, VMPA_NO_PHYSICAL, VMPA_NO_VIRTUAL); + init_mrange(range, &start, VMPA_NO_PHYSICAL); + } + + else + { + g_match_record_get_range(group->children[0], &range_0); + g_match_record_get_range(group->children[group->count - 1], &range_n); + + copy_vmpa(&start, get_mrange_addr(&range_0)); + + compute_mrange_end_addr(&range_n, &end); + length = compute_vmpa_diff(&start, &end); + + init_mrange(range, &start, length); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de correspondances attribut/binaire. * +* name = désignation de l'élément recherché. * +* len = taille de cette désignation. * +* level = profondeur maximale à atteindre (fond : 0). * +* * +* Description : Recherche la correspondance associée à un identifiant. * +* * +* Retour : Correspondance trouvée ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GMatchRecord *g_record_group_find_by_name(GRecordGroup *group, const char *name, size_t len, unsigned int level) +{ + GMatchRecord *result; /* Correspondance à renvoyer */ + GMatchRecordClass *class; /* Classe parente normalisée */ + size_t i; /* Boucle de parcours */ + + class = G_MATCH_RECORD_CLASS(g_record_group_parent_class); + + /** + * Le cas d'un type utilisateur peut rattacher un attribut Kaitai à un groupe... + */ + result = class->find(G_MATCH_RECORD(group), name, len, level); + + if (level > 0) + { + level--; + + for (i = 0; i < group->count && result == NULL; i++) + result = g_match_record_find_by_name(group->children[i], name, len, level); + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de correspondances attribut/binaire. * +* name = désignation de l'élément recherché. * +* label = étiquette de l'élément constant à traduire. * +* value = valeur entière correspondante. [OUT] * +* * +* Description : Transforme une énumération en constante entière. * +* * +* Retour : Bilan de l'opération : true si la résolution est réalisée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_record_group_resolve_enum(const GRecordGroup *group, const sized_string_t *name, const sized_string_t *label, resolved_value_t *value) +{ + bool result; /* Bilan à retourner */ + GMatchRecord *base; /* Autre version du groupe */ + size_t i; /* Boucle de parcours */ + GKaitaiEnum *kenum; /* Enumération à consulter */ + + result = false; + + base = G_MATCH_RECORD(group); + + if (G_IS_KAITAI_STRUCT(base->creator)) + { + kenum = g_kaitai_structure_get_enum(G_KAITAI_STRUCT(base->creator), name); + + if (kenum != NULL) + { + result = g_kaitai_enum_find_value(kenum, label, value); + g_object_unref(G_OBJECT(kenum)); + } + + } + + for (i = 0; i < group->count && !result; i++) + result = g_match_record_resolve_enum(group->children[i], name, label, value); + + return result; + +} diff --git a/plugins/kaitai/records/group.h b/plugins/kaitai/records/group.h new file mode 100644 index 0000000..454dade --- /dev/null +++ b/plugins/kaitai/records/group.h @@ -0,0 +1,65 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * group.h - prototypes pour la conservation d'un groupe de correspondance avec du binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_GROUP_H +#define _PLUGINS_KAITAI_RECORDS_GROUP_H + + +#include <glib-object.h> + + +#include <analysis/content.h> + + +#include "../record.h" +#include "../parsers/struct.h" + + + +#define G_TYPE_RECORD_GROUP g_record_group_get_type() +#define G_RECORD_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_GROUP, GRecordGroup)) +#define G_IS_RECORD_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_GROUP)) +#define G_RECORD_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_GROUP, GRecordGroupClass)) +#define G_IS_RECORD_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_GROUP)) +#define G_RECORD_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_GROUP, GRecordGroupClass)) + + +/* Groupe de correspondances établies entre attributs et binaire (instance) */ +typedef struct _GRecordGroup GRecordGroup; + +/* Groupe de correspondances établies entre attributs et binaire (classe) */ +typedef struct _GRecordGroupClass GRecordGroupClass; + + +/* Indique le type défini pour une série de correspondances entre attributes et binaire. */ +GType g_record_group_get_type(void); + +/* Crée une nouvelle série de correspondances attribut/binaire. */ +GRecordGroup *g_record_group_new(GKaitaiStruct *, GBinContent *); + +/* Ajoute une correspondance supplémentaire à une série. */ +void g_record_group_add_record(GRecordGroup *, GMatchRecord *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_GROUP_H */ diff --git a/plugins/kaitai/records/item-int.h b/plugins/kaitai/records/item-int.h new file mode 100644 index 0000000..56e0a41 --- /dev/null +++ b/plugins/kaitai/records/item-int.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * item-int.h - prototypes internes pour la conservation d'une correspondance entre attribut et binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_ITEM_INT_H +#define _PLUGINS_KAITAI_RECORDS_ITEM_INT_H + + +#include "item.h" + + +#include "../record-int.h" + + + +/* Correspondance établie entre un attribut et du binaire (instance) */ +struct _GRecordItem +{ + GMatchRecord parent; /* A laisser en premier */ + + mrange_t range; /* Zone de binaire couverte */ + SourceEndian endian; /* Boutisme des données imposé */ + +}; + +/* Correspondance établie entre un attribut et du binaire (classe) */ +struct _GRecordItemClass +{ + GMatchRecordClass parent; /* A laisser en premier */ + +}; + + +/* Met en place une correspondance entre attribut et binaire. */ +bool g_record_item_create(GRecordItem *, GKaitaiAttribute *, GBinContent *, const mrange_t *, SourceEndian); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_ITEM_INT_H */ diff --git a/plugins/kaitai/records/item.c b/plugins/kaitai/records/item.c new file mode 100644 index 0000000..0bcf9f7 --- /dev/null +++ b/plugins/kaitai/records/item.c @@ -0,0 +1,309 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * item.c - conservation d'une correspondance entre attribut et binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "item.h" + + +#include <assert.h> +#include <string.h> + + +#include "item-int.h" + + + +/* -------------------- DEFINITION D'UNE CORRESPONDANCE UNITAIRE -------------------- */ + + +/* Initialise la classe des correspondances attribut/binaire. */ +static void g_record_item_class_init(GRecordItemClass *); + +/* Initialise une correspondance entre attribut et binaire. */ +static void g_record_item_init(GRecordItem *); + +/* Supprime toutes les références externes. */ +static void g_record_item_dispose(GRecordItem *); + +/* Procède à la libération totale de la mémoire. */ +static void g_record_item_finalize(GRecordItem *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Calcule ou fournit la zone couverte par une correspondance. */ +static void g_record_item_get_range(const GRecordItem *, mrange_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DEFINITION D'UNE CORRESPONDANCE UNITAIRE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une correspondance entre un attribut et du binaire. */ +G_DEFINE_TYPE(GRecordItem, g_record_item, G_TYPE_MATCH_RECORD); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des correspondances attribut/binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_item_class_init(GRecordItemClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GMatchRecordClass *record; /* Version parente de la classe*/ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_record_item_dispose; + object->finalize = (GObjectFinalizeFunc)g_record_item_finalize; + + record = G_MATCH_RECORD_CLASS(klass); + + record->get_range = (get_record_range_fc)g_record_item_get_range; + +} + + +/****************************************************************************** +* * +* Paramètres : item = instance à initialiser. * +* * +* Description : Initialise une correspondance entre attribut et binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_item_init(GRecordItem *item) +{ + copy_mrange(&item->range, UNUSED_MRANGE_PTR); + +} + + +/****************************************************************************** +* * +* Paramètres : item = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_item_dispose(GRecordItem *item) +{ + G_OBJECT_CLASS(g_record_item_parent_class)->dispose(G_OBJECT(item)); + +} + + +/****************************************************************************** +* * +* Paramètres : item = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_item_finalize(GRecordItem *item) +{ + G_OBJECT_CLASS(g_record_item_parent_class)->finalize(G_OBJECT(item)); + +} + + +/****************************************************************************** +* * +* Paramètres : attrib = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* range = zone couverture par la correspondance. * +* endian = boustime des données à respecter. * +* * +* Description : Crée une nouvelle correspondance entre attribut et binaire. * +* * +* Retour : Instance mise en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GRecordItem *g_record_item_new(GKaitaiAttribute *attrib, GBinContent *content, const mrange_t *range, SourceEndian endian) +{ + GRecordItem *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_RECORD_ITEM, NULL); + + if (!g_record_item_create(result, attrib, content, range, endian)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : item = correspondance à initialiser pleinement. * +* attrib = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* range = zone couverte par la correspondance. * +* endian = boustime des données à respecter. * +* * +* Description : Met en place une correspondance entre attribut et binaire. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_item_create(GRecordItem *item, GKaitaiAttribute *attrib, GBinContent *content, const mrange_t *range, SourceEndian endian) +{ + bool result; /* Bilan à retourner */ + + result = g_match_record_create(G_MATCH_RECORD(item), G_KAITAI_PARSER(attrib), content); + + if (result) + { + copy_mrange(&item->range, range); + + item->endian = endian; + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : item = correspondance à consulter. * +* out = tableau d'octets retournés. [OUT] * +* len = taille de ce tableau alloué. [OUT] * +* * +* Description : Lit la série d'octets d'un élément Kaitai entier représenté. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_item_get_truncated_bytes(const GRecordItem *item, bin_t **out, size_t *len) +{ + bool result; /* Bilan à retourner */ + GKaitaiParser *parser; /* Attribut associé à l'élément*/ + + parser = g_match_record_get_creator(G_MATCH_RECORD(item)); + assert(G_IS_KAITAI_ATTRIBUTE(parser)); + + result = g_kaitai_attribute_read_truncated_bytes(G_KAITAI_ATTRIBUTE(parser), + G_MATCH_RECORD(item)->content, + &item->range, + out, len); + + g_object_unref(G_OBJECT(parser)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : item = correspondance à consulter. * +* out = valeur à sauvegarder sous une forme générique. [OUT] * +* * +* Description : Lit la valeur d'un élément Kaitai entier représenté. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_item_get_value(const GRecordItem *item, resolved_value_t *out) +{ + bool result; /* Bilan à retourner */ + GKaitaiParser *parser; /* Attribut associé à l'élément*/ + + parser = g_match_record_get_creator(G_MATCH_RECORD(item)); + assert(G_IS_KAITAI_ATTRIBUTE(parser)); + + result = g_kaitai_attribute_read_value(G_KAITAI_ATTRIBUTE(parser), + G_MATCH_RECORD(item)->content, + &item->range, + item->endian, out); + + g_object_unref(G_OBJECT(parser)); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : item = correspondance à consulter. * +* range = zone de couverture déterminée. [OUT] * +* * +* Description : Calcule ou fournit la zone couverte par une correspondance. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_item_get_range(const GRecordItem *item, mrange_t *range) +{ + copy_mrange(range, &item->range); + +} diff --git a/plugins/kaitai/records/item.h b/plugins/kaitai/records/item.h new file mode 100644 index 0000000..1286a89 --- /dev/null +++ b/plugins/kaitai/records/item.h @@ -0,0 +1,65 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * item.h - prototypes pour la conservation d'une correspondance entre attribut et binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_ITEM_H +#define _PLUGINS_KAITAI_RECORDS_ITEM_H + + +#include <glib-object.h> + + +#include "../record.h" +#include "../parsers/attribute.h" + + + +#define G_TYPE_RECORD_ITEM g_record_item_get_type() +#define G_RECORD_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_ITEM, GRecordItem)) +#define G_IS_RECORD_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_ITEM)) +#define G_RECORD_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_ITEM, GRecordItemClass)) +#define G_IS_RECORD_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_ITEM)) +#define G_RECORD_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_ITEM, GRecordItemClass)) + + +/* Correspondance établie entre un attribut et du binaire (instance) */ +typedef struct _GRecordItem GRecordItem; + +/* Correspondance établie entre un attribut et du binaire (classe) */ +typedef struct _GRecordItemClass GRecordItemClass; + + +/* Indique le type défini pour une correspondance entre un attribut et du binaire. */ +GType g_record_item_get_type(void); + +/* Crée une nouvelle correspondance entre attribut et binaire. */ +GRecordItem *g_record_item_new(GKaitaiAttribute *, GBinContent *, const mrange_t *, SourceEndian); + +/* Lit la série d'octets d'un élément Kaitai entier représenté. */ +bool g_record_item_get_truncated_bytes(const GRecordItem *, bin_t **, size_t *); + +/* Lit la valeur d'un élément Kaitai entier représenté. */ +bool g_record_item_get_value(const GRecordItem *, resolved_value_t *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_ITEM_H */ diff --git a/plugins/kaitai/records/list-int.h b/plugins/kaitai/records/list-int.h new file mode 100644 index 0000000..88b411d --- /dev/null +++ b/plugins/kaitai/records/list-int.h @@ -0,0 +1,60 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * list-int.h - prototypes internes pour la conservation d'une liste de correspondance avec du binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_LIST_INT_H +#define _PLUGINS_KAITAI_RECORDS_LIST_INT_H + + +#include "list.h" + + +#include "../record-int.h" + + + +/* Liste de correspondances établies entre attributs et binaire (instance) */ +struct _GRecordList +{ + GMatchRecord parent; /* A laisser en premier */ + + vmpa2t pos; /* Début de zone */ + + GMatchRecord **children; /* Sous-correspondances */ + size_t count; /* Taille de cette série */ + +}; + +/* Liste de correspondances établies entre attributs et binaire (classe) */ +struct _GRecordListClass +{ + GMatchRecordClass parent; /* A laisser en premier */ + +}; + + +/* Met en place une série de correspondances attribut/binaire. */ +bool g_record_list_create(GRecordList *, GKaitaiAttribute *, GBinContent *, const vmpa2t *); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_LIST_INT_H */ diff --git a/plugins/kaitai/records/list.c b/plugins/kaitai/records/list.c new file mode 100644 index 0000000..1a36bf5 --- /dev/null +++ b/plugins/kaitai/records/list.c @@ -0,0 +1,424 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * list.c - conservation d'une liste de correspondance avec du binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "list.h" + + +#include <assert.h> +#include <malloc.h> + + +#include "list-int.h" + + + +/* ------------------ DEFINITION D'UNE SEQUENCE DE CORRESPONDANCES ------------------ */ + + +/* Initialise la classe des listes de correspondances. */ +static void g_record_list_class_init(GRecordListClass *); + +/* Initialise une série de correspondances attributs/binaire. */ +static void g_record_list_init(GRecordList *); + +/* Supprime toutes les références externes. */ +static void g_record_list_dispose(GRecordList *); + +/* Procède à la libération totale de la mémoire. */ +static void g_record_list_finalize(GRecordList *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Calcule ou fournit la zone couverte par une correspondance. */ +static void g_record_list_get_range(const GRecordList *, mrange_t *); + +/* Recherche la correspondance associée à un identifiant. */ +static GMatchRecord *g_record_list_find_by_name(GRecordList *, const char *, size_t, unsigned int); + +/* Transforme une énumération en constante entière. */ +static bool g_record_list_resolve_enum(const GRecordList *, const sized_string_t *, const sized_string_t *, resolved_value_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DEFINITION D'UNE SEQUENCE DE CORRESPONDANCES */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une série de correspondances entre attributes et binaire. */ +G_DEFINE_TYPE(GRecordList, g_record_list, G_TYPE_MATCH_RECORD); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des listes de correspondances. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_list_class_init(GRecordListClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GMatchRecordClass *record; /* Version parente de la classe*/ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_record_list_dispose; + object->finalize = (GObjectFinalizeFunc)g_record_list_finalize; + + record = G_MATCH_RECORD_CLASS(klass); + + record->get_range = (get_record_range_fc)g_record_list_get_range; + record->find = (find_record_by_name_fc)g_record_list_find_by_name; + record->resolve = (resolve_record_enum_fc)g_record_list_resolve_enum; + +} + + +/****************************************************************************** +* * +* Paramètres : list = instance à initialiser. * +* * +* Description : Initialise une série de correspondances attributs/binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_list_init(GRecordList *list) +{ + list->children = NULL; + list->count = 0; + +} + + +/****************************************************************************** +* * +* Paramètres : list = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_list_dispose(GRecordList *list) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < list->count; i++) + g_clear_object(&list->children[i]); + + G_OBJECT_CLASS(g_record_list_parent_class)->dispose(G_OBJECT(list)); + +} + + +/****************************************************************************** +* * +* Paramètres : list = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_list_finalize(GRecordList *list) +{ + if (list->children != NULL) + free(list->children); + + G_OBJECT_CLASS(g_record_list_parent_class)->finalize(G_OBJECT(list)); + +} + + +/****************************************************************************** +* * +* Paramètres : attrib = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* pos = début de la zone de couverture de la liste. * +* * +* Description : Crée une nouvelle série de correspondances attribut/binaire. * +* * +* Retour : Instance mise en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GRecordList *g_record_list_new(GKaitaiAttribute *attrib, GBinContent *content, const vmpa2t *pos) +{ + GRecordList *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_RECORD_LIST, NULL); + + if (!g_record_list_create(result, attrib, content, pos)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : list = correspondance à initialiser pleinement. * +* attrib = analyseur à l'origine de la correspondance. * +* content = contenu binaire lié à la correspondance. * +* * +* Description : Met en place une série de correspondances attribut/binaire. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_record_list_create(GRecordList *list, GKaitaiAttribute *attrib, GBinContent *content, const vmpa2t *pos) +{ + bool result; /* Bilan à retourner */ + + result = g_match_record_create(G_MATCH_RECORD(list), G_KAITAI_PARSER(attrib), content); + + if (result) + copy_vmpa(&list->pos, pos); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : list = ensemble de correspondances attribut/binaire. * +* * +* Description : Dénombre le nombre de correspondances enregistrées. * +* * +* Retour : Taille de la liste représentée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +size_t g_record_list_count_records(const GRecordList *list) +{ + size_t result; /* Quantité à retourner */ + + result = list->count; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : list = ensemble de correspondances attribut/binaire. * +* record = sous-corresponde à intégrer. * +* * +* Description : Ajoute une correspondance supplémentaire à une série. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_record_list_add_record(GRecordList *list, GMatchRecord *record) +{ + list->children = realloc(list->children, ++list->count * sizeof(GMatchRecord)); + + list->children[list->count - 1] = record; + g_object_ref(G_OBJECT(record)); + +} + + +/****************************************************************************** +* * +* Paramètres : list = ensemble de correspondances attribut/binaire. * +* index = indice de la correspondance visée. * +* * +* Description : Fournit un élément ciblé dans la liste de correspondances. * +* * +* Retour : Instance de correspondance particulière, voire NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GMatchRecord *g_record_list_get_record(const GRecordList *list, size_t index) +{ + GMatchRecord *result; /* Instance à retourner */ + + if (index < list->count) + { + result = list->children[index]; + g_object_ref(G_OBJECT(result)); + } + else + result = NULL; + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : list = correspondance à consulter. * +* range = zone de couverture déterminée. [OUT] * +* * +* Description : Calcule ou fournit la zone couverte par une correspondance. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_record_list_get_range(const GRecordList *list, mrange_t *range) +{ + vmpa2t start; /* Position de départ */ + mrange_t range_0; /* Première zone couverte */ + mrange_t range_n; /* Dernière zone couverte */ + vmpa2t end; /* Position de d'arrivée */ + phys_t length; /* Taille de zone couverte */ + + assert(list->count > 0); + + if (list->count == 0) + { + init_vmpa(&start, VMPA_NO_PHYSICAL, VMPA_NO_VIRTUAL); + init_mrange(range, &start, VMPA_NO_PHYSICAL); + } + + else + { + g_match_record_get_range(list->children[0], &range_0); + g_match_record_get_range(list->children[list->count - 1], &range_n); + + copy_vmpa(&start, get_mrange_addr(&range_0)); + + compute_mrange_end_addr(&range_n, &end); + length = compute_vmpa_diff(&start, &end); + + init_mrange(range, &start, length); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : list = ensemble de correspondances attribut/binaire. * +* name = désignation de l'élément recherché. * +* len = taille de cette désignation. * +* level = profondeur maximale à atteindre (fond : 0). * +* * +* Description : Recherche la correspondance associée à un identifiant. * +* * +* Retour : Correspondance trouvée ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GMatchRecord *g_record_list_find_by_name(GRecordList *list, const char *name, size_t len, unsigned int level) +{ + GMatchRecord *result; /* Correspondance à renvoyer */ + GMatchRecordClass *class; /* Classe parente normalisée */ + size_t i; /* Boucle de parcours */ + + class = G_MATCH_RECORD_CLASS(g_record_list_parent_class); + + result = class->find(G_MATCH_RECORD(list), name, len, level); + + if (level > 0) + { + for (i = 0; i < list->count && result == NULL; i++) + result = g_match_record_find_by_name(list->children[i], name, len, level); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : list = ensemble de correspondances attribut/binaire. * +* name = désignation de l'élément recherché. * +* label = étiquette de l'élément constant à traduire. * +* value = valeur entière correspondante. [OUT] * +* * +* Description : Transforme une énumération en constante entière. * +* * +* Retour : Bilan de l'opération : true si la résolution est réalisée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_record_list_resolve_enum(const GRecordList *list, const sized_string_t *name, const sized_string_t *label, resolved_value_t *value) +{ + bool result; /* Bilan à retourner */ + size_t i; /* Boucle de parcours */ + + /** + * Comme les types peuvent être sélectionnés dynamiquement, le parcours + * de l'ensemble des sous-noeuds doit être effectué. + */ + + result = false; + + for (i = 0; i < list->count && !result; i++) + result = g_match_record_resolve_enum(list->children[i], name, label, value); + + return result; + +} diff --git a/plugins/kaitai/records/list.h b/plugins/kaitai/records/list.h new file mode 100644 index 0000000..03e593e --- /dev/null +++ b/plugins/kaitai/records/list.h @@ -0,0 +1,71 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * list.h - prototypes pour la conservation d'une liste de correspondance avec du binaire + * + * Copyright (C) 2019 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_KAITAI_RECORDS_LIST_H +#define _PLUGINS_KAITAI_RECORDS_LIST_H + + +#include <glib-object.h> + + +#include <analysis/content.h> + + +#include "../record.h" +#include "../parsers/attribute.h" + + + +#define G_TYPE_RECORD_LIST g_record_list_get_type() +#define G_RECORD_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_LIST, GRecordList)) +#define G_IS_RECORD_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_LIST)) +#define G_RECORD_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_LIST, GRecordListClass)) +#define G_IS_RECORD_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_LIST)) +#define G_RECORD_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_LIST, GRecordListClass)) + + +/* Liste de correspondances établies entre attributs et binaire (instance) */ +typedef struct _GRecordList GRecordList; + +/* Liste de correspondances établies entre attributs et binaire (classe) */ +typedef struct _GRecordListClass GRecordListClass; + + +/* Indique le type défini pour une série de correspondances entre attributes et binaire. */ +GType g_record_list_get_type(void); + +/* Crée une nouvelle série de correspondances attribut/binaire. */ +GRecordList *g_record_list_new(GKaitaiAttribute *, GBinContent *, const vmpa2t *); + +/* Dénombre le nombre de correspondances enregistrées. */ +size_t g_record_list_count_records(const GRecordList *); + +/* Ajoute une correspondance supplémentaire à une série. */ +void g_record_list_add_record(GRecordList *, GMatchRecord *); + +/* Fournit un élément ciblé dans la liste de correspondances. */ +GMatchRecord *g_record_list_get_record(const GRecordList *, size_t); + + + +#endif /* _PLUGINS_KAITAI_RECORDS_LIST_H */ |