diff options
Diffstat (limited to 'src/format')
| -rw-r--r-- | src/format/Makefile.am | 21 | ||||
| -rw-r--r-- | src/format/executable-int.h | 52 | ||||
| -rw-r--r-- | src/format/executable.c | 110 | ||||
| -rw-r--r-- | src/format/executable.h | 66 | ||||
| -rw-r--r-- | src/format/flat-int.h | 10 | ||||
| -rw-r--r-- | src/format/flat.c | 118 | ||||
| -rw-r--r-- | src/format/flat.h | 27 | ||||
| -rw-r--r-- | src/format/known-int.h | 12 | ||||
| -rw-r--r-- | src/format/known.c | 54 | ||||
| -rw-r--r-- | src/format/known.h | 30 | ||||
| -rw-r--r-- | src/format/program-int.h | 59 | ||||
| -rw-r--r-- | src/format/program.c | 266 | ||||
| -rw-r--r-- | src/format/program.h | 116 |
13 files changed, 576 insertions, 365 deletions
diff --git a/src/format/Makefile.am b/src/format/Makefile.am index dcd3567..3ffe24e 100644 --- a/src/format/Makefile.am +++ b/src/format/Makefile.am @@ -1,18 +1,9 @@ noinst_LTLIBRARIES = libformat.la -libformat_la_SOURCES = -# \ # debuggable-int.h \ # debuggable.h debuggable.c \ -# executable-int.h executable-int.c \ -# executable.h executable.c \ -# flat-int.h \ -# flat.h flat.c \ -# program-int.h \ -# program.h program.c \ -# known-int.h \ -# known.h known.c \ +# executable-int.c \ # preload-int.h \ # preload.h preload.c \ # strsym.h strsym.c \ @@ -20,6 +11,16 @@ libformat_la_SOURCES = # symbol-int.h \ # symbol.h symbol.c +libformat_la_SOURCES = \ + executable-int.h \ + executable.h executable.c \ + flat-int.h \ + flat.h flat.c \ + known-int.h \ + known.h known.c \ + program-int.h \ + program.h program.c + libformat_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBXML_CFLAGS) diff --git a/src/format/executable-int.h b/src/format/executable-int.h index 8722795..73b647c 100644 --- a/src/format/executable-int.h +++ b/src/format/executable-int.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * executable-int.h - prototypes de code utile aux formats d'exécutables * - * Copyright (C) 2009-2019 Cyrille Bagard + * Copyright (C) 2009-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -28,34 +28,38 @@ #include "executable.h" -#include "format-int.h" +#include "program-int.h" /* Indique le type d'architecture visée par le format. */ -typedef const char * (* get_target_machine_fc) (const GExeFormat *); +typedef char * (* get_target_machine_fc) (const GExecutableFormat *); +#if 0 /* Fournit l'adresse principale associée à un format. */ -typedef bool (* get_main_addr_fc) (GExeFormat *, vmpa2t *); +typedef bool (* get_main_addr_fc) (GExecutableFormat *, vmpa2t *); /* Etend la définition des portions au sein d'un binaire. */ -typedef void (* refine_portions_fc) (GExeFormat *); +typedef void (* refine_portions_fc) (GExecutableFormat *); /* Fournit l'emplacement correspondant à une position physique. */ -typedef bool (* translate_phys_fc) (GExeFormat *, phys_t, vmpa2t *); +typedef bool (* translate_phys_fc) (GExecutableFormat *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une adresse virtuelle. */ -typedef bool (* translate_virt_fc) (GExeFormat *, virt_t, vmpa2t *); +typedef bool (* translate_virt_fc) (GExecutableFormat *, virt_t, vmpa2t *); /* Fournit l'emplacement d'une section donnée. */ -typedef bool (* get_range_by_name_fc) (const GExeFormat *, const char *, mrange_t *); +typedef bool (* get_range_by_name_fc) (const GExecutableFormat *, const char *, mrange_t *); +#endif /* Format d'exécutable générique (instance) */ -struct _GExeFormat +struct _GExecutableFormat { - GBinFormat parent; /* A laisser en premier */ + GProgramFormat parent; /* A laisser en premier */ + +#if 0 GDbgFormat **debugs; /* Informations de débogage */ size_t debugs_count; /* Nombre de ces informations */ @@ -65,42 +69,52 @@ struct _GExeFormat GBinPortion *portions; /* Couches de morceaux binaires*/ GMutex mutex; /* Accès à l'arborescence */ +#endif + }; /* Format d'exécutable générique (classe) */ -struct _GExeFormatClass +struct _GExecutableFormatClass { - GBinFormatClass parent; /* A laisser en premier */ + GProgramFormatClass parent; /* A laisser en premier */ get_target_machine_fc get_machine; /* Architecture ciblée */ + +#if 0 get_main_addr_fc get_main_addr; /* Obtention d'adresse première*/ refine_portions_fc refine_portions; /* Décrit les portions binaires*/ translate_phys_fc translate_phys; /* Correspondance phys -> vmpa */ translate_virt_fc translate_virt; /* Correspondance virt -> vmpa */ - get_range_by_name_fc get_range_by_name; /* Emplacement de sections */ + get_range_by_name_fc get_range_by_name; /* Emplacement de sections */ + +#endif }; +#if 0 + /* Crée les portions potentiellement utiles aux traductions. */ -void g_executable_format_setup_portions(GExeFormat *, GtkStatusStack *); +void g_executable_format_setup_portions(GExecutableFormat *, GtkStatusStack *); /* Effectue les ultimes opérations de chargement d'un binaire. */ -bool g_executable_format_complete_loading(GExeFormat *, wgroup_id_t, GtkStatusStack *); +bool g_executable_format_complete_loading(GExecutableFormat *, wgroup_id_t, GtkStatusStack *); /* Fournit l'emplacement correspondant à une position physique. */ -bool g_exe_format_without_virt_translate_offset_into_vmpa(const GExeFormat *, phys_t, vmpa2t *); +bool g_exe_format_without_virt_translate_offset_into_vmpa(const GExecutableFormat *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une adresse virtuelle. */ -bool g_exe_format_without_virt_translate_address_into_vmpa(const GExeFormat *, virt_t, vmpa2t *); +bool g_exe_format_without_virt_translate_address_into_vmpa(const GExecutableFormat *, virt_t, vmpa2t *); /* Fournit l'emplacement correspondant à une position physique. */ -bool g_exe_format_translate_offset_into_vmpa_using_portions(GExeFormat *, phys_t, vmpa2t *); +bool g_exe_format_translate_offset_into_vmpa_using_portions(GExecutableFormat *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une adresse virtuelle. */ -bool g_exe_format_translate_address_into_vmpa_using_portions(GExeFormat *, virt_t, vmpa2t *); +bool g_exe_format_translate_address_into_vmpa_using_portions(GExecutableFormat *, virt_t, vmpa2t *); + +#endif diff --git a/src/format/executable.c b/src/format/executable.c index 26c418e..187bd4e 100644 --- a/src/format/executable.c +++ b/src/format/executable.c @@ -25,6 +25,7 @@ #include <assert.h> +/* #include <malloc.h> #include <stdio.h> #include <stdlib.h> @@ -32,30 +33,31 @@ #include <i18n.h> - +*/ #include "executable-int.h" +/* #include "format.h" #include "../core/logs.h" #include "../plugins/pglist.h" - +*/ /* Initialise la classe des formats d'exécutables génériques. */ -static void g_executable_format_class_init(GExeFormatClass *); +static void g_executable_format_class_init(GExecutableFormatClass *); /* Initialise une instance de format d'exécutable générique. */ -static void g_executable_format_init(GExeFormat *); +static void g_executable_format_init(GExecutableFormat *); /* Supprime toutes les références externes. */ -static void g_executable_format_dispose(GExeFormat *); +static void g_executable_format_dispose(GExecutableFormat *); /* Procède à la libération totale de la mémoire. */ -static void g_executable_format_finalize(GExeFormat *); +static void g_executable_format_finalize(GExecutableFormat *); /* Indique le type défini pour un format d'exécutable générique. */ -G_DEFINE_TYPE(GExeFormat, g_executable_format, G_TYPE_BIN_FORMAT); +G_DEFINE_TYPE(GExecutableFormat, g_executable_format, G_TYPE_PROGRAM_FORMAT); /****************************************************************************** @@ -70,7 +72,7 @@ G_DEFINE_TYPE(GExeFormat, g_executable_format, G_TYPE_BIN_FORMAT); * * ******************************************************************************/ -static void g_executable_format_class_init(GExeFormatClass *klass) +static void g_executable_format_class_init(GExecutableFormatClass *klass) { GObjectClass *object; /* Autre version de la classe */ @@ -94,9 +96,9 @@ static void g_executable_format_class_init(GExeFormatClass *klass) * * ******************************************************************************/ -static void g_executable_format_init(GExeFormat *format) +static void g_executable_format_init(GExecutableFormat *format) { - g_mutex_init(&format->mutex); + //g_mutex_init(&format->mutex); } @@ -113,8 +115,10 @@ static void g_executable_format_init(GExeFormat *format) * * ******************************************************************************/ -static void g_executable_format_dispose(GExeFormat *format) +static void g_executable_format_dispose(GExecutableFormat *format) { + +#if 0 size_t i; /* Boucle de parcours */ for (i = 0; i < format->debugs_count; i++) @@ -127,6 +131,10 @@ static void g_executable_format_dispose(GExeFormat *format) g_mutex_clear(&format->mutex); +#endif + + + G_OBJECT_CLASS(g_executable_format_parent_class)->dispose(G_OBJECT(format)); } @@ -144,19 +152,28 @@ static void g_executable_format_dispose(GExeFormat *format) * * ******************************************************************************/ -static void g_executable_format_finalize(GExeFormat *format) +static void g_executable_format_finalize(GExecutableFormat *format) { +#if 0 + if (format->debugs != NULL) free(format->debugs); if (format->user_portions != NULL) free(format->user_portions); +#endif + + + G_OBJECT_CLASS(g_executable_format_parent_class)->finalize(G_OBJECT(format)); } + +#if 0 + /****************************************************************************** * * * Paramètres : format = informations chargées à compléter. * @@ -170,7 +187,7 @@ static void g_executable_format_finalize(GExeFormat *format) * * ******************************************************************************/ -void g_exe_format_add_debug_info(GExeFormat *format, GDbgFormat *info) +void g_executable_format_add_debug_info(GExecutableFormat *format, GDbgFormat *info) { const char *desc; /* Description humaine associée*/ @@ -200,7 +217,7 @@ void g_exe_format_add_debug_info(GExeFormat *format, GDbgFormat *info) * * ******************************************************************************/ -size_t g_exe_format_count_debug_info(const GExeFormat *format) +size_t g_executable_format_count_debug_info(const GExecutableFormat *format) { return format->debugs_count; @@ -220,7 +237,7 @@ size_t g_exe_format_count_debug_info(const GExeFormat *format) * * ******************************************************************************/ -GDbgFormat *g_exe_format_get_debug_info(const GExeFormat *format, size_t index) +GDbgFormat *g_executable_format_get_debug_info(const GExecutableFormat *format, size_t index) { GDbgFormat *result; /* Format à retourner */ @@ -237,10 +254,12 @@ GDbgFormat *g_exe_format_get_debug_info(const GExeFormat *format, size_t index) } +#endif + /****************************************************************************** * * -* Paramètres : format = informations chargées à consulter. * +* Paramètres : format = description du format exécutable à consulter. * * * * Description : Indique le type d'architecture visée par le format. * * * @@ -250,13 +269,24 @@ GDbgFormat *g_exe_format_get_debug_info(const GExeFormat *format, size_t index) * * ******************************************************************************/ -const char *g_exe_format_get_target_machine(const GExeFormat *format) +char *g_executable_format_get_target_machine(const GExecutableFormat *format) { - return G_EXE_FORMAT_GET_CLASS(format)->get_machine(format); + char *result; /* Désignation à retourner */ + GExecutableFormatClass *class; /* Classe de l'instance */ + + class = G_EXECUTABLE_FORMAT_GET_CLASS(format); + + result = class->get_machine(format); + + //assert(result != NULL); + + return result; } +#if 0 + /****************************************************************************** * * * Paramètres : format = description de l'exécutable à consulter. * @@ -270,15 +300,15 @@ const char *g_exe_format_get_target_machine(const GExeFormat *format) * * ******************************************************************************/ -bool g_exe_format_get_main_address(GExeFormat *format, vmpa2t *addr) +bool g_executable_format_get_main_address(GExecutableFormat *format, vmpa2t *addr) { bool result; /* Bilan à retourner */ GBinFormat *base; /* Version d'instance parente */ result = false; - if (G_EXE_FORMAT_GET_CLASS(format)->get_main_addr != NULL) - result = G_EXE_FORMAT_GET_CLASS(format)->get_main_addr(format, addr); + if (G_EXECUTABLE_FORMAT_GET_CLASS(format)->get_main_addr != NULL) + result = G_EXECUTABLE_FORMAT_GET_CLASS(format)->get_main_addr(format, addr); if (!result) { @@ -287,7 +317,7 @@ bool g_exe_format_get_main_address(GExeFormat *format, vmpa2t *addr) g_rw_lock_reader_lock(&base->pt_lock); if (base->pt_count[DPL_ENTRY_POINT] > 0) - result = g_exe_format_translate_address_into_vmpa(format, base->start_points[DPL_ENTRY_POINT][0], addr); + result = g_executable_format_translate_address_into_vmpa(format, base->start_points[DPL_ENTRY_POINT][0], addr); g_rw_lock_reader_unlock(&base->pt_lock); @@ -311,11 +341,11 @@ bool g_exe_format_get_main_address(GExeFormat *format, vmpa2t *addr) * * ******************************************************************************/ -void g_executable_format_setup_portions(GExeFormat *format, GtkStatusStack *status) +void g_executable_format_setup_portions(GExecutableFormat *format, GtkStatusStack *status) { vmpa2t addr; /* Emplacement vide de sens */ phys_t length; /* Taille de portion globale */ - GExeFormatClass *class; /* Classe de l'instance */ + GExecutableFormatClass *class; /* Classe de l'instance */ size_t i; /* Boucle de parcours */ /** @@ -327,7 +357,7 @@ void g_executable_format_setup_portions(GExeFormat *format, GtkStatusStack *stat format->portions = g_binary_portion_new(BPC_RAW, &addr, length); - class = G_EXE_FORMAT_GET_CLASS(format); + class = G_EXECUTABLE_FORMAT_GET_CLASS(format); if (class->refine_portions != NULL) class->refine_portions(format); @@ -335,7 +365,7 @@ void g_executable_format_setup_portions(GExeFormat *format, GtkStatusStack *stat for (i = 0; i < format->user_count; i++) { g_object_ref(G_OBJECT(format->user_portions[i])); - g_exe_format_include_portion(format, format->user_portions[i], NULL); + g_executable_format_include_portion(format, format->user_portions[i], NULL); } } @@ -355,7 +385,7 @@ void g_executable_format_setup_portions(GExeFormat *format, GtkStatusStack *stat * * ******************************************************************************/ -bool g_executable_format_complete_loading(GExeFormat *format, wgroup_id_t gid, GtkStatusStack *status) +bool g_executable_format_complete_loading(GExecutableFormat *format, wgroup_id_t gid, GtkStatusStack *status) { bool result; /* Bilan à faire remonter */ size_t count; /* Qté d'infos supplémentaires */ @@ -366,11 +396,11 @@ bool g_executable_format_complete_loading(GExeFormat *format, wgroup_id_t gid, G attach_debug_format(format); - count = g_exe_format_count_debug_info(format); + count = g_executable_format_count_debug_info(format); for (i = 0; i < count && result; i++) { - dbg = g_exe_format_get_debug_info(format, i); + dbg = g_executable_format_get_debug_info(format, i); result = g_known_format_analyze(G_KNOWN_FORMAT(dbg), gid, status); @@ -396,7 +426,7 @@ bool g_executable_format_complete_loading(GExeFormat *format, wgroup_id_t gid, G * * ******************************************************************************/ -void g_exe_format_register_user_portion(GExeFormat *format, GBinPortion *portion) +void g_executable_format_register_user_portion(GExecutableFormat *format, GBinPortion *portion) { g_mutex_lock(&format->mutex); @@ -423,7 +453,7 @@ void g_exe_format_register_user_portion(GExeFormat *format, GBinPortion *portion * * ******************************************************************************/ -void g_exe_format_include_portion(GExeFormat *format, GBinPortion *portion, const vmpa2t *origin) +void g_executable_format_include_portion(GExecutableFormat *format, GBinPortion *portion, const vmpa2t *origin) { phys_t available; /* Taille totale du bianire */ const mrange_t *range; /* Emplacement de la portion */ @@ -501,7 +531,7 @@ void g_exe_format_include_portion(GExeFormat *format, GBinPortion *portion, cons * * ******************************************************************************/ -GBinPortion *g_exe_format_get_portions(GExeFormat *format) +GBinPortion *g_executable_format_get_portions(GExecutableFormat *format) { GBinPortion *result; /* Instance à retourner */ @@ -533,11 +563,11 @@ GBinPortion *g_exe_format_get_portions(GExeFormat *format) * * ******************************************************************************/ -bool g_exe_format_translate_offset_into_vmpa(GExeFormat *format, phys_t off, vmpa2t *pos) +bool g_executable_format_translate_offset_into_vmpa(GExecutableFormat *format, phys_t off, vmpa2t *pos) { bool result; /* Bilan à retourner */ - result = G_EXE_FORMAT_GET_CLASS(format)->translate_phys(format, off, pos); + result = G_EXECUTABLE_FORMAT_GET_CLASS(format)->translate_phys(format, off, pos); return result; @@ -558,11 +588,11 @@ bool g_exe_format_translate_offset_into_vmpa(GExeFormat *format, phys_t off, vmp * * ******************************************************************************/ -bool g_exe_format_translate_address_into_vmpa(GExeFormat *format, virt_t addr, vmpa2t *pos) +bool g_executable_format_translate_address_into_vmpa(GExecutableFormat *format, virt_t addr, vmpa2t *pos) { bool result; /* Bilan à retourner */ - result = G_EXE_FORMAT_GET_CLASS(format)->translate_virt(format, addr, pos); + result = G_EXECUTABLE_FORMAT_GET_CLASS(format)->translate_virt(format, addr, pos); return result; @@ -583,12 +613,12 @@ bool g_exe_format_translate_address_into_vmpa(GExeFormat *format, virt_t addr, v * * ******************************************************************************/ -bool g_exe_format_get_section_range_by_name(const GExeFormat *format, const char *name, mrange_t *range) +bool g_executable_format_get_section_range_by_name(const GExecutableFormat *format, const char *name, mrange_t *range) { bool result; /* Bilan à retourner */ - GExeFormatClass *class; /* Classe de l'instance */ + GExecutableFormatClass *class; /* Classe de l'instance */ - class = G_EXE_FORMAT_GET_CLASS(format); + class = G_EXECUTABLE_FORMAT_GET_CLASS(format); if (class->get_range_by_name == NULL) result = false; @@ -599,3 +629,5 @@ bool g_exe_format_get_section_range_by_name(const GExeFormat *format, const char return result; } + +#endif diff --git a/src/format/executable.h b/src/format/executable.h index 4f5abc7..6695b92 100644 --- a/src/format/executable.h +++ b/src/format/executable.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * executable.h - prototypes pour le support des formats d'exécutables * - * Copyright (C) 2009-2019 Cyrille Bagard + * Copyright (C) 2009-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -25,87 +25,89 @@ #define _FORMAT_EXECUTABLE_H -#include <glib-object.h> +#include "../glibext/helpers.h" -#include "debuggable.h" -#include "../glibext/gbinportion.h" +#define G_TYPE_EXECUTABLE_FORMAT (g_executable_format_get_type()) + +DECLARE_GTYPE(GExecutableFormat, g_executable_format, G, EXECUTABLE_FORMAT); -#define G_TYPE_EXE_FORMAT g_executable_format_get_type() -#define G_EXE_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_EXE_FORMAT, GExeFormat)) -#define G_IS_EXE_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_EXE_FORMAT)) -#define G_EXE_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_EXE_FORMAT, GExeFormatClass)) -#define G_IS_EXE_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_EXE_FORMAT)) -#define G_EXE_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_EXE_FORMAT, GExeFormatClass)) +/* Indique le type d'architecture visée par le format. */ +char *g_executable_format_get_target_machine(const GExecutableFormat *); + -/* Format d'exécutable générique (instance) */ -typedef struct _GExeFormat GExeFormat; -/* Format d'exécutable générique (classe) */ -typedef struct _GExeFormatClass GExeFormatClass; + +#if 0 + + +/* +#include "debuggable.h" +#include "../glibext/gbinportion.h" +*/ -/* Indique le type défini pour un format d'exécutable générique. */ -GType g_executable_format_get_type(void); /* Rajoute des informations de débogage à un exécutable. */ -void g_exe_format_add_debug_info(GExeFormat *, GDbgFormat *); +void g_executable_format_add_debug_info(GExecutableFormat *, GDbgFormat *); /* Compte le nombre de formats de débogage liés à l'exécutable. */ -size_t g_exe_format_count_debug_info(const GExeFormat *); +size_t g_executable_format_count_debug_info(const GExecutableFormat *); /* Fournit un format de débogage attaché à l'exécutable. */ -GDbgFormat *g_exe_format_get_debug_info(const GExeFormat *, size_t); +GDbgFormat *g_executable_format_get_debug_info(const GExecutableFormat *, size_t); /* Indique le type d'architecture visée par le format. */ -const char *g_exe_format_get_target_machine(const GExeFormat *); +//const char *g_executable_format_get_target_machine(const GExecutableFormat *); /* Fournit l'adresse principale associée à un format. */ -bool g_exe_format_get_main_address(GExeFormat *, vmpa2t *); +bool g_executable_format_get_main_address(GExecutableFormat *, vmpa2t *); /* Enregistre une portion artificielle pour le format. */ -void g_exe_format_register_user_portion(GExeFormat *, GBinPortion *); +void g_executable_format_register_user_portion(GExecutableFormat *, GBinPortion *); /* Procède à l'enregistrement d'une portion dans un format. */ -void g_exe_format_include_portion(GExeFormat *, GBinPortion *, const vmpa2t *); +void g_executable_format_include_portion(GExecutableFormat *, GBinPortion *, const vmpa2t *); /* Fournit la première couche des portions composent le binaire. */ -GBinPortion *g_exe_format_get_portions(GExeFormat *); +GBinPortion *g_executable_format_get_portions(GExecutableFormat *); /* Fournit les espaces mémoires des portions exécutables. */ -mrange_t *g_exe_format_get_x_ranges(GExeFormat *, size_t *); +mrange_t *g_executable_format_get_x_ranges(GExecutableFormat *, size_t *); /* Fournit l'emplacement correspondant à une position physique. */ -bool g_exe_format_translate_offset_into_vmpa(GExeFormat *, phys_t, vmpa2t *); +bool g_executable_format_translate_offset_into_vmpa(GExecutableFormat *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une position physique. */ -bool g_exe_format_translate_address_into_vmpa(GExeFormat *, virt_t, vmpa2t *); +bool g_executable_format_translate_address_into_vmpa(GExecutableFormat *, virt_t, vmpa2t *); -#define g_exe_format_translate_offset_into_address(fmt, off, addr) \ +#define g_executable_format_translate_offset_into_address(fmt, off, addr) \ ({ \ bool __result; \ vmpa2t __pos; \ - __result = g_exe_format_translate_offset_into_vmpa(fmt, off, &__pos); \ + __result = g_executable_format_translate_offset_into_vmpa(fmt, off, &__pos); \ *addr = get_virt_addr(&__pos); \ __result; \ }) -#define g_exe_format_translate_address_into_offset(fmt, addr, off) \ +#define g_executable_format_translate_address_into_offset(fmt, addr, off) \ ({ \ bool __result; \ vmpa2t __pos; \ - __result = g_exe_format_translate_address_into_vmpa(fmt, addr, &__pos); \ + __result = g_executable_format_translate_address_into_vmpa(fmt, addr, &__pos); \ *off = get_phy_addr(&__pos); \ __result; \ }) /* Fournit l'emplacement d'une section donnée. */ -bool g_exe_format_get_section_range_by_name(const GExeFormat *, const char *, mrange_t *); +bool g_executable_format_get_section_range_by_name(const GExecutableFormat *, const char *, mrange_t *); + +#endif diff --git a/src/format/flat-int.h b/src/format/flat-int.h index d785e5f..2630ef9 100644 --- a/src/format/flat-int.h +++ b/src/format/flat-int.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * flat-int.h - prototypes de code utile aux formats d'exécutables à plat * - * Copyright (C) 2018 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -35,7 +35,7 @@ /* Format d'exécutable à plat (instance) */ struct _GFlatFormat { - GExeFormat parent; /* A laisser en premier */ + GExecutableFormat parent; /* A laisser en premier */ char *machine; /* Architecture imposée */ SourceEndian endian; /* Boutisme imposé */ @@ -45,10 +45,14 @@ struct _GFlatFormat /* Format d'exécutable à plat (classe) */ struct _GFlatFormatClass { - GExeFormatClass parent; /* A laisser en premier */ + GExecutableFormatClass parent; /* A laisser en premier */ }; +/* Met en place une nouvelle instance de format de à plat. */ +bool g_flat_format_create(GFlatFormat *, GBinContent *, const char *, SourceEndian); + + #endif /* _FORMAT_FLAT_INT_H */ diff --git a/src/format/flat.c b/src/format/flat.c index 6b8b074..26dd22b 100644 --- a/src/format/flat.c +++ b/src/format/flat.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * flat.c - support des formats à plat * - * Copyright (C) 2018-2019 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -32,6 +32,9 @@ +/* ------------------------- DEFINITION D'UN NOUVEAU FORMAT ------------------------- */ + + /* Initialise la classe des formats d'exécutables à plat. */ static void g_flat_format_class_init(GFlatFormatClass *); @@ -44,28 +47,47 @@ static void g_flat_format_dispose(GFlatFormat *); /* Procède à la libération totale de la mémoire. */ static void g_flat_format_finalize(GFlatFormat *); + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + /* Indique la désignation interne du format. */ static char *g_flat_format_get_key(const GFlatFormat *); /* Fournit une description humaine du format. */ static char *g_flat_format_get_description(const GFlatFormat *); + +#if 0 + /* Assure l'interprétation d'un format en différé. */ static bool g_flat_format_analyze(GFlatFormat *, wgroup_id_t, GtkStatusStack *); +#endif + /* Informe quant au boutisme utilisé. */ static SourceEndian g_flat_format_get_endianness(const GFlatFormat *); /* Indique le type d'architecture visée par le format. */ -static const char *g_flat_format_get_target_machine(const GFlatFormat *); +static char *g_flat_format_get_target_machine(const GFlatFormat *); + +#if 0 /* Fournit l'adresse principale associée à un format à plat. */ static bool g_flat_format_get_main_address(GFlatFormat *, vmpa2t *); +#endif + + + +/* ---------------------------------------------------------------------------------- */ +/* DEFINITION D'UN NOUVEAU FORMAT */ +/* ---------------------------------------------------------------------------------- */ /* Indique le type défini pour un format d'exécutable à plat. */ -G_DEFINE_TYPE(GFlatFormat, g_flat_format, G_TYPE_EXE_FORMAT); +G_DEFINE_TYPE(GFlatFormat, g_flat_format, G_TYPE_EXECUTABLE_FORMAT); /****************************************************************************** @@ -84,8 +106,8 @@ static void g_flat_format_class_init(GFlatFormatClass *klass) { GObjectClass *object; /* Autre version de la classe */ GKnownFormatClass *known; /* Version de format connu */ - GBinFormatClass *fmt; /* Version en format basique */ - GExeFormatClass *exe; /* Version en exécutable */ + GProgramFormatClass *prgm; /* Version en format basique */ + GExecutableFormatClass *exe; /* Version en exécutable */ object = G_OBJECT_CLASS(klass); @@ -97,20 +119,29 @@ static void g_flat_format_class_init(GFlatFormatClass *klass) known->get_key = (known_get_key_fc)g_flat_format_get_key; known->get_desc = (known_get_desc_fc)g_flat_format_get_description; + + +#if 0 + known->analyze = (known_analyze_fc)g_flat_format_analyze; - fmt = G_BIN_FORMAT_CLASS(klass); +#endif + + prgm = G_PROGRAM_FORMAT_CLASS(klass); - fmt->get_endian = (format_get_endian_fc)g_flat_format_get_endianness; + prgm->get_endian = (program_get_endian_fc)g_flat_format_get_endianness; - exe = G_EXE_FORMAT_CLASS(klass); + exe = G_EXECUTABLE_FORMAT_CLASS(klass); exe->get_machine = (get_target_machine_fc)g_flat_format_get_target_machine; +#if 0 exe->get_main_addr = (get_main_addr_fc)g_flat_format_get_main_address; exe->translate_phys = (translate_phys_fc)g_exe_format_translate_offset_into_vmpa_using_portions; exe->translate_virt = (translate_virt_fc)g_exe_format_translate_address_into_vmpa_using_portions; +#endif + } @@ -178,8 +209,10 @@ static void g_flat_format_finalize(GFlatFormat *format) /****************************************************************************** * * * Paramètres : content = contenu binaire à parcourir. * +* machine = architecture déterminée pour le code. * + endian = boutisme à observer pour les données. * * * -* Description : Prend en charge un nouveau format à plat. * +* Description : Crée une nouvelle instance de format à plat. * * * * Retour : Adresse de la structure mise en place ou NULL en cas d'échec.* * * @@ -187,22 +220,53 @@ static void g_flat_format_finalize(GFlatFormat *format) * * ******************************************************************************/ -GExeFormat *g_flat_format_new(GBinContent *content, const char *machine, SourceEndian endian) +GFlatFormat *g_flat_format_new(GBinContent *content, const char *machine, SourceEndian endian) { GFlatFormat *result; /* Structure à retourner */ result = g_object_new(G_TYPE_FLAT_FORMAT, NULL); - g_known_format_set_content(G_KNOWN_FORMAT(result), content); + if (!g_flat_format_create(result, content, machine, endian)) + g_clear_object(&result); - result->machine = strdup(machine); - result->endian = endian; + return result; - return G_EXE_FORMAT(result); +} + + +/****************************************************************************** +* * +* Paramètres : format = description du format connu à consulter. * +* content = contenu binaire à parcourir. * +* * +* Description : Met en place une nouvelle instance de format de à plat. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_flat_format_create(GFlatFormat *format, GBinContent *content, const char *machine, SourceEndian endian) +{ + bool result; /* Bilan à retourner */ + + result = g_known_format_create(G_KNOWN_FORMAT(format), content); + + format->machine = strdup(machine); + format->endian = endian; + + return result; } + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + /****************************************************************************** * * * Paramètres : format = description de l'exécutable à consulter. * @@ -249,6 +313,10 @@ static char *g_flat_format_get_description(const GFlatFormat *format) } + + +#if 0 + /****************************************************************************** * * * Paramètres : format = format chargé dont l'analyse est lancée. * @@ -269,12 +337,14 @@ static bool g_flat_format_analyze(GFlatFormat *format, wgroup_id_t gid, GtkStatu result = true; - g_executable_format_setup_portions(G_EXE_FORMAT(format), status); + g_executable_format_setup_portions(G_EXECUTABLE_FORMAT(format), status); return result; } +#endif + /****************************************************************************** * * @@ -290,14 +360,18 @@ static bool g_flat_format_analyze(GFlatFormat *format, wgroup_id_t gid, GtkStatu static SourceEndian g_flat_format_get_endianness(const GFlatFormat *format) { - return format->endian; + SourceEndian result; /* Valeur à retourner */ + + result = format->endian; + + return result; } /****************************************************************************** * * -* Paramètres : format = informations chargées à consulter. * +* Paramètres : format = description du format exécutable à consulter. * * * * Description : Indique le type d'architecture visée par le format. * * * @@ -307,17 +381,17 @@ static SourceEndian g_flat_format_get_endianness(const GFlatFormat *format) * * ******************************************************************************/ -static const char *g_flat_format_get_target_machine(const GFlatFormat *format) +static char *g_flat_format_get_target_machine(const GFlatFormat *format) { - const char *result; /* Identifiant à retourner */ + char *result; /* Identifiant à retourner */ - result = format->machine; + result = strdup(format->machine); return result; } - +#if 0 /****************************************************************************** * * * Paramètres : format = description de l'exécutable à consulter. * @@ -350,3 +424,5 @@ static bool g_flat_format_get_main_address(GFlatFormat *format, vmpa2t *addr) return result; } + +#endif diff --git a/src/format/flat.h b/src/format/flat.h index 83c5e3c..2168221 100644 --- a/src/format/flat.h +++ b/src/format/flat.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * flat.h - prototypes pour le support des formats à plat * - * Copyright (C) 2018 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -25,34 +25,19 @@ #define _FORMAT_FLAT_H -#include <glib-object.h> - - -#include "executable.h" #include "../analysis/content.h" +#include "../glibext/helpers.h" -#define G_TYPE_FLAT_FORMAT g_flat_format_get_type() -#define G_FLAT_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_FLAT_FORMAT, GFlatFormat)) -#define G_IS_FLAT_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_FLAT_FORMAT)) -#define G_FLAT_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_FLAT_FORMAT, GFlatFormatClass)) -#define G_IS_FLAT_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_FLAT_FORMAT)) -#define G_FLAT_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_FLAT_FORMAT, GFlatFormatClass)) - - -/* Format d'exécutable à plat (instance) */ -typedef struct _GFlatFormat GFlatFormat; +#define G_TYPE_FLAT_FORMAT (g_flat_format_get_type()) -/* Format d'exécutable à plat (classe) */ -typedef struct _GFlatFormatClass GFlatFormatClass; +DECLARE_GTYPE(GFlatFormat, g_flat_format, G, FLAT_FORMAT); -/* Indique le type défini pour un format d'exécutable à plat. */ -GType g_flat_format_get_type(void); -/* Prend en charge un nouveau format à plat. */ -GExeFormat *g_flat_format_new(GBinContent *, const char *, SourceEndian); +/* Crée une nouvelle instance de format à plat. */ +GFlatFormat *g_flat_format_new(GBinContent *, const char *, SourceEndian); diff --git a/src/format/known-int.h b/src/format/known-int.h index 3328a96..bac0c5c 100644 --- a/src/format/known-int.h +++ b/src/format/known-int.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * known-int.h - prototypes utiles aux formats binaires reconnus * - * Copyright (C) 2019 Cyrille Bagard + * Copyright (C) 2019-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -26,7 +26,7 @@ #include "known.h" -#include "../analysis/storage/storage.h" +//#include "../analysis/storage/storage.h" @@ -36,6 +36,7 @@ typedef char * (* known_get_key_fc) (const GKnownFormat *); /* Fournit une description humaine du format. */ typedef char * (* known_get_desc_fc) (const GKnownFormat *); +#if 0 /*Assure l'interprétation d'un format en différé. */ typedef bool (* known_analyze_fc) (GKnownFormat *, wgroup_id_t, GtkStatusStack *); @@ -47,6 +48,7 @@ typedef bool (* load_known_fc) (GKnownFormat *, GObjectStorage *, packed_buffer_ /* Sauvegarde un format dans une mémoire tampon. */ typedef bool (* store_known_fc) (GKnownFormat *, GObjectStorage *, packed_buffer_t *); +#endif /* Format binaire générique (instance) */ @@ -66,14 +68,20 @@ struct _GKnownFormatClass known_get_key_fc get_key; /* Désignation interne */ known_get_desc_fc get_desc; /* Désignation humaine */ +#if 0 known_analyze_fc analyze; /* Interprétation du format */ known_complete_analysis_fc complete; /* Terminaison d'analyse */ load_known_fc load; /* Chargement depuis un tampon */ store_known_fc store; /* Conservation dans un tampon */ +#endif }; +/* Met en place un nouveau contenu binaire à analyser. */ +bool g_known_format_create(GKnownFormat *, GBinContent *); + + #endif /* _FORMAT_KNOWN_INT_H */ diff --git a/src/format/known.c b/src/format/known.c index 7512ae1..c32a00b 100644 --- a/src/format/known.c +++ b/src/format/known.c @@ -28,8 +28,8 @@ #include "known-int.h" -#include "../analysis/storage/serialize-int.h" -#include "../plugins/pglist.h" +//#include "../analysis/storage/serialize-int.h" +//#include "../plugins/pglist.h" @@ -43,7 +43,7 @@ static void g_known_format_class_init(GKnownFormatClass *); static void g_known_format_init(GKnownFormat *); /* Procède à l'initialisation de l'interface de sérialisation. */ -static void g_known_format_serializable_init(GSerializableObjectInterface *); +//static void g_known_format_serializable_init(GSerializableObjectInterface *); /* Supprime toutes les références externes. */ static void g_known_format_dispose(GKnownFormat *); @@ -56,6 +56,7 @@ static void g_known_format_finalize(GKnownFormat *); /* -------------------- CONSERVATION ET RECHARGEMENT DES DONNEES -------------------- */ +#if 0 /* Charge un format depuis une mémoire tampon. */ static bool _g_known_format_load(GKnownFormat *, GObjectStorage *, packed_buffer_t *); @@ -67,7 +68,7 @@ static bool _g_known_format_store(GKnownFormat *, GObjectStorage *, packed_buffe /* Sauvegarde un format dans une mémoire tampon. */ static bool g_known_format_store(GKnownFormat *, GObjectStorage *, packed_buffer_t *); - +#endif /* ---------------------------------------------------------------------------------- */ @@ -76,8 +77,9 @@ static bool g_known_format_store(GKnownFormat *, GObjectStorage *, packed_buffer /* Indique le type défini pour un format binaire générique. */ -G_DEFINE_TYPE_WITH_CODE(GKnownFormat, g_known_format, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_known_format_serializable_init)); +//G_DEFINE_TYPE_WITH_CODE(GKnownFormat, g_known_format, G_TYPE_OBJECT, +// G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_known_format_serializable_init)); +G_DEFINE_TYPE(GKnownFormat, g_known_format, G_TYPE_OBJECT); /****************************************************************************** @@ -101,8 +103,10 @@ static void g_known_format_class_init(GKnownFormatClass *klass) object->dispose = (GObjectFinalizeFunc/* ! */)g_known_format_dispose; object->finalize = (GObjectFinalizeFunc)g_known_format_finalize; + /* klass->load = (load_known_fc)_g_known_format_load; klass->store = (store_known_fc)_g_known_format_store; + */ } @@ -126,6 +130,7 @@ static void g_known_format_init(GKnownFormat *format) } +#if 0 /****************************************************************************** * * * Paramètres : iface = interface GLib à initialiser. * @@ -144,6 +149,7 @@ static void g_known_format_serializable_init(GSerializableObjectInterface *iface iface->store = (store_serializable_object_cb)g_known_format_store; } +#endif /****************************************************************************** @@ -188,24 +194,27 @@ static void g_known_format_finalize(GKnownFormat *format) /****************************************************************************** * * -* Paramètres : format = description du format connu à consulter. * +* Paramètres : format = description du format connu à consulter. * * content = contenu binaire à parcourir. * * * -* Description : Définit le contenu binaire à analyser. * +* Description : Met en place un nouveau contenu binaire à analyser. * * * -* Retour : - * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -void g_known_format_set_content(GKnownFormat *format, GBinContent *content) +bool g_known_format_create(GKnownFormat *format, GBinContent *content) { - assert(format->content == NULL); + bool result; /* Bilan à retourner */ - g_object_ref_sink(G_OBJECT(content)); + result = true; format->content = content; + ref_object(content); + + return result; } @@ -251,8 +260,13 @@ GBinContent *g_known_format_get_content(const GKnownFormat *format) char *g_known_format_get_key(const GKnownFormat *format) { char *result; /* Désignation à retourner */ + GKnownFormatClass *class; /* Classe de l'instance */ + + class = G_KNOWN_FORMAT_GET_CLASS(format); + + result = class->get_key(format); - result = G_KNOWN_FORMAT_GET_CLASS(format)->get_key(format); + //assert(result != NULL); return result; @@ -274,14 +288,21 @@ char *g_known_format_get_key(const GKnownFormat *format) char *g_known_format_get_description(const GKnownFormat *format) { char *result; /* Description à retourner */ + GKnownFormatClass *class; /* Classe de l'instance */ + + class = G_KNOWN_FORMAT_GET_CLASS(format); - result = G_KNOWN_FORMAT_GET_CLASS(format)->get_desc(format); + result = class->get_desc(format); + + //assert(result != NULL); return result; } +#if 0 + /****************************************************************************** * * * Paramètres : format = format chargé dont l'analyse est lancée. * @@ -343,13 +364,15 @@ void g_known_format_complete_analysis(GKnownFormat *format, wgroup_id_t gid, Gtk } +#endif + /* ---------------------------------------------------------------------------------- */ /* CONSERVATION ET RECHARGEMENT DES DONNEES */ /* ---------------------------------------------------------------------------------- */ - +#if 0 /****************************************************************************** * * * Paramètres : operand = élément GLib à constuire. * @@ -468,3 +491,4 @@ static bool g_known_format_store(GKnownFormat *format, GObjectStorage *storage, return result; } +#endif diff --git a/src/format/known.h b/src/format/known.h index dcc8669..3da433a 100644 --- a/src/format/known.h +++ b/src/format/known.h @@ -25,36 +25,16 @@ #define _FORMAT_KNOWN_H -#include <glib-object.h> -#include <stdbool.h> - - #include "../analysis/content.h" -#include "../glibext/delayed.h" -#include "../glibext/notifier.h" - - +#include "../glibext/helpers.h" -#define G_TYPE_KNOWN_FORMAT g_known_format_get_type() -#define G_KNOWN_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_KNOWN_FORMAT, GKnownFormat)) -#define G_IS_KNOWN_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_KNOWN_FORMAT)) -#define G_KNOWN_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_KNOWN_FORMAT, GKnownFormatClass)) -#define G_IS_KNOWN_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_KNOWN_FORMAT)) -#define G_KNOWN_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_KNOWN_FORMAT, GKnownFormatClass)) -/* Format binaire générique (instance) */ -typedef struct _GKnownFormat GKnownFormat; +#define G_TYPE_KNOWN_FORMAT (g_known_format_get_type()) -/* Format binaire générique (classe) */ -typedef struct _GKnownFormatClass GKnownFormatClass; +DECLARE_GTYPE(GKnownFormat, g_known_format, G, KNOWN_FORMAT); -/* Indique le type défini pour un format binaire générique. */ -GType g_known_format_get_type(void); - -/* Définit le contenu binaire à analyser. */ -void g_known_format_set_content(GKnownFormat *, GBinContent *); /* Fournit une référence vers le contenu binaire analysé. */ GBinContent *g_known_format_get_content(const GKnownFormat *); @@ -65,12 +45,16 @@ char *g_known_format_get_key(const GKnownFormat *); /* Fournit une description humaine du format. */ char *g_known_format_get_description(const GKnownFormat *); +#if 0 + /* Assure l'interprétation d'un format en différé. */ bool g_known_format_analyze(GKnownFormat *, wgroup_id_t, GtkStatusStack *); /* Réalise un traitement post-désassemblage. */ void g_known_format_complete_analysis(GKnownFormat *, wgroup_id_t, GtkStatusStack *); +#endif + #endif /* _FORMAT_KNOWN_H */ diff --git a/src/format/program-int.h b/src/format/program-int.h index f18bb24..958c6ff 100644 --- a/src/format/program-int.h +++ b/src/format/program-int.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * format-int.h - prototypes utiles aux formats binaires + * program-int.h - prototypes internes pour le support des différents formats de programmes * - * Copyright (C) 2009-2018 Cyrille Bagard + * Copyright (C) 2009-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,14 +21,53 @@ */ -#ifndef _FORMAT_FORMAT_INT_H -#define _FORMAT_FORMAT_INT_H +#ifndef _FORMAT_PROGRAM_INT_H +#define _FORMAT_PROGRAM_INT_H -#include "format.h" +#include "program.h" #include "known-int.h" + + + +/* Indique le boutisme employé par le format binaire analysé. */ +typedef SourceEndian (* program_get_endian_fc) (const GProgramFormat *); + + +/* Format de programme générique (instance) */ +struct _GProgramFormat +{ + GKnownFormat parent; /* A laisser en premier */ + +}; + +/* Format de programme générique (classe) */ +struct _GProgramFormatClass +{ + GKnownFormatClass parent; /* A laisser en premier */ + + program_get_endian_fc get_endian; /* Boutisme employé */ + +}; + + + + + + + + + + + + + + + +#if 0 + #include "preload.h" #include "../glibext/objhole.h" #include "../mangling/demangler.h" @@ -38,9 +77,6 @@ /* ------------------------ TRAITEMENT INDIVIDUEL DE FORMATS ------------------------ */ -/* Indique le boutisme employé par le format binaire analysé. */ -typedef SourceEndian (* format_get_endian_fc) (const GBinFormat *); - /* Rythme des allocations pour les entrées de code */ #define EXTRA_POINT_BLOCK 20 @@ -120,8 +156,6 @@ struct _GBinFormatClass { GKnownFormatClass parent; /* A laisser en premier */ - format_get_endian_fc get_endian; /* Boutisme employé */ - /* Signaux */ void (* symbol_added) (GBinFormat *, GBinSymbol *); @@ -156,5 +190,8 @@ GDataType *g_binary_format_decode_type(const GBinFormat *, const char *); GBinRoutine *g_binary_format_decode_routine(const GBinFormat *, const char *); +#endif + + -#endif /* _FORMAT_FORMAT_INT_H */ +#endif /* _FORMAT_PROGRAM_INT_H */ diff --git a/src/format/program.c b/src/format/program.c index d126236..3624496 100644 --- a/src/format/program.c +++ b/src/format/program.c @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * format.c - support des différents formats binaires + * program.c - support des différents formats de programmes * - * Copyright (C) 2009-2020 Cyrille Bagard + * Copyright (C) 2009-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,40 +21,45 @@ */ -#include "format.h" +#include "program.h" -#include <assert.h> -#include <malloc.h> -#include <string.h> +//#include <assert.h> +//#include <malloc.h> +//#include <string.h> -#include "format-int.h" +#include "program-int.h" + +/* #include "preload.h" #include "../arch/processor.h" #include "../common/sort.h" #include "../core/demanglers.h" #include "../plugins/pglist.h" +*/ /* Initialise la classe des formats binaires génériques. */ -static void g_binary_format_class_init(GBinFormatClass *); +static void g_program_format_class_init(GProgramFormatClass *); /* Initialise une instance de format binaire générique. */ -static void g_binary_format_init(GBinFormat *); +static void g_program_format_init(GProgramFormat *); /* Supprime toutes les références externes. */ -static void g_binary_format_dispose(GBinFormat *); +static void g_program_format_dispose(GProgramFormat *); /* Procède à la libération totale de la mémoire. */ -static void g_binary_format_finalize(GBinFormat *); +static void g_program_format_finalize(GProgramFormat *); + +#if 0 /* Charge les plages de couvertures depuis une mémoire tampon. */ -static bool g_binary_format_load_start_points(GBinFormat *, packed_buffer_t *); +static bool g_program_format_load_start_points(GProgramFormat *, packed_buffer_t *); /* Sauvegarde les points de départ enregistrés pour un format. */ -static bool g_binary_format_store_start_points(GBinFormat *, packed_buffer_t *); +static bool g_program_format_store_start_points(GProgramFormat *, packed_buffer_t *); @@ -62,13 +67,13 @@ static bool g_binary_format_store_start_points(GBinFormat *, packed_buffer_t *); /* Retire un symbole de la collection du format binaire. */ -static void _g_binary_format_remove_symbol(GBinFormat *, size_t); +static void _g_program_format_remove_symbol(GProgramFormat *, size_t); /* Recherche le symbole associé à une adresse. */ -static bool _g_binary_format_find_symbol(const GBinFormat *, const vmpa2t *, __compar_fn_t, size_t *, GBinSymbol **); +static bool _g_program_format_find_symbol(const GProgramFormat *, const vmpa2t *, __compar_fn_t, size_t *, GBinSymbol **); /* Recherche un symbole particulier. */ -static bool __g_binary_format_find_symbol(const GBinFormat *, const void *, __compar_fn_t, size_t *, GBinSymbol **); +static bool __g_program_format_find_symbol(const GProgramFormat *, const void *, __compar_fn_t, size_t *, GBinSymbol **); @@ -76,10 +81,10 @@ static bool __g_binary_format_find_symbol(const GBinFormat *, const void *, __co /* Charge les erreurs de chargement depuis une mémoire tampon. */ -static bool g_binary_format_load_errors(GBinFormat *, packed_buffer_t *); +static bool g_program_format_load_errors(GProgramFormat *, packed_buffer_t *); /* Sauvegarde les erreurs de chargement dans une mémoire tampon. */ -static bool g_binary_format_store_errors(GBinFormat *, packed_buffer_t *); +static bool g_program_format_store_errors(GProgramFormat *, packed_buffer_t *); @@ -87,17 +92,18 @@ static bool g_binary_format_store_errors(GBinFormat *, packed_buffer_t *); /* Charge un format depuis une mémoire tampon. */ -static bool g_binary_format_load(GBinFormat *, GObjectStorage *, packed_buffer_t *); +static bool g_program_format_load(GProgramFormat *, GObjectStorage *, packed_buffer_t *); /* Sauvegarde un format dans une mémoire tampon. */ -static bool g_binary_format_store(GBinFormat *, GObjectStorage *, packed_buffer_t *); +static bool g_program_format_store(GProgramFormat *, GObjectStorage *, packed_buffer_t *); +#endif /* Indique le type défini pour un format binaire générique. */ -G_DEFINE_TYPE(GBinFormat, g_binary_format, G_TYPE_KNOWN_FORMAT); +G_DEFINE_TYPE(GProgramFormat, g_program_format, G_TYPE_KNOWN_FORMAT); /****************************************************************************** @@ -112,25 +118,27 @@ G_DEFINE_TYPE(GBinFormat, g_binary_format, G_TYPE_KNOWN_FORMAT); * * ******************************************************************************/ -static void g_binary_format_class_init(GBinFormatClass *klass) +static void g_program_format_class_init(GProgramFormatClass *klass) { GObjectClass *object; /* Autre version de la classe */ - GKnownFormatClass *known; /* Version de classe parente */ + //GKnownFormatClass *known; /* Version de classe parente */ object = G_OBJECT_CLASS(klass); - object->dispose = (GObjectFinalizeFunc/* ! */)g_binary_format_dispose; - object->finalize = (GObjectFinalizeFunc)g_binary_format_finalize; + object->dispose = (GObjectFinalizeFunc/* ! */)g_program_format_dispose; + object->finalize = (GObjectFinalizeFunc)g_program_format_finalize; + +#if 0 known = G_KNOWN_FORMAT_CLASS(klass); - known->load = (load_known_fc)g_binary_format_load; - known->store = (load_known_fc)g_binary_format_store; + known->load = (load_known_fc)g_program_format_load; + known->store = (load_known_fc)g_program_format_store; g_signal_new("symbol-added", G_TYPE_BIN_FORMAT, G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET(GBinFormatClass, symbol_added), + G_STRUCT_OFFSET(GProgramFormatClass, symbol_added), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, G_TYPE_OBJECT); @@ -138,11 +146,13 @@ static void g_binary_format_class_init(GBinFormatClass *klass) g_signal_new("symbol-removed", G_TYPE_BIN_FORMAT, G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET(GBinFormatClass, symbol_removed), + G_STRUCT_OFFSET(GProgramFormatClass, symbol_removed), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, G_TYPE_OBJECT); +#endif + } @@ -158,8 +168,10 @@ static void g_binary_format_class_init(GBinFormatClass *klass) * * ******************************************************************************/ -static void g_binary_format_init(GBinFormat *format) +static void g_program_format_init(GProgramFormat *format) { + +#if 0 fmt_extra_data_t *extra; /* Données insérées à modifier */ extra = GET_BIN_FORMAT_EXTRA(format); @@ -184,6 +196,8 @@ static void g_binary_format_init(GBinFormat *format) g_atomic_int_set(&format->error_locked, 0); #endif +#endif + } @@ -199,8 +213,10 @@ static void g_binary_format_init(GBinFormat *format) * * ******************************************************************************/ -static void g_binary_format_dispose(GBinFormat *format) +static void g_program_format_dispose(GProgramFormat *format) { +#if 0 + size_t i; /* Boucle de parcours */ g_rw_lock_clear(&format->pt_lock); @@ -216,7 +232,10 @@ static void g_binary_format_dispose(GBinFormat *format) g_mutex_clear(&format->error_mutex); - G_OBJECT_CLASS(g_binary_format_parent_class)->dispose(G_OBJECT(format)); +#endif + + + G_OBJECT_CLASS(g_program_format_parent_class)->dispose(G_OBJECT(format)); } @@ -233,8 +252,10 @@ static void g_binary_format_dispose(GBinFormat *format) * * ******************************************************************************/ -static void g_binary_format_finalize(GBinFormat *format) +static void g_program_format_finalize(GProgramFormat *format) { +#if 0 + DisassPriorityLevel i; /* Boucle de parcours #1 */ size_t k; /* Boucle de parcours #2 */ @@ -255,11 +276,21 @@ static void g_binary_format_finalize(GBinFormat *format) } - G_OBJECT_CLASS(g_binary_format_parent_class)->finalize(G_OBJECT(format)); +#endif + + + + G_OBJECT_CLASS(g_program_format_parent_class)->finalize(G_OBJECT(format)); } + + + + +#if 0 + /****************************************************************************** * * * Paramètres : format = format à venir modifier. * @@ -273,7 +304,7 @@ static void g_binary_format_finalize(GBinFormat *format) * * ******************************************************************************/ -bool g_binary_format_set_flag(GBinFormat *format, FormatFlag flag) +bool g_program_format_set_flag(GProgramFormat *format, FormatFlag flag) { bool result; /* Bilan à retourner */ fmt_extra_data_t *extra; /* Données insérées à modifier */ @@ -306,7 +337,7 @@ bool g_binary_format_set_flag(GBinFormat *format, FormatFlag flag) * * ******************************************************************************/ -bool g_binary_format_unset_flag(GBinFormat *format, FormatFlag flag) +bool g_program_format_unset_flag(GProgramFormat *format, FormatFlag flag) { bool result; /* Bilan à retourner */ fmt_extra_data_t *extra; /* Données insérées à modifier */ @@ -339,7 +370,7 @@ bool g_binary_format_unset_flag(GBinFormat *format, FormatFlag flag) * * ******************************************************************************/ -bool g_binary_format_has_flag(const GBinFormat *format, FormatFlag flag) +bool g_program_format_has_flag(const GProgramFormat *format, FormatFlag flag) { bool result; /* Bilan à retourner */ fmt_extra_data_t *extra; /* Données insérées à modifier */ @@ -369,7 +400,7 @@ bool g_binary_format_has_flag(const GBinFormat *format, FormatFlag flag) * * ******************************************************************************/ -FormatFlag g_binary_format_get_flags(const GBinFormat *format) +FormatFlag g_program_format_get_flags(const GProgramFormat *format) { FormatFlag result; /* Fanions à retourner */ fmt_extra_data_t *extra; /* Données insérées à modifier */ @@ -386,6 +417,8 @@ FormatFlag g_binary_format_get_flags(const GBinFormat *format) } +#endif + /****************************************************************************** * * @@ -399,17 +432,22 @@ FormatFlag g_binary_format_get_flags(const GBinFormat *format) * * ******************************************************************************/ -SourceEndian g_binary_format_get_endianness(const GBinFormat *format) +SourceEndian g_program_format_get_endianness(const GProgramFormat *format) { SourceEndian result; /* Boutisme à retourner */ + GProgramFormatClass *class; /* Classe de l'instance */ + + class = G_PROGRAM_FORMAT_GET_CLASS(format); - result = G_BIN_FORMAT_GET_CLASS(format)->get_endian(format); + result = class->get_endian(format); return result; } +#if 0 + /****************************************************************************** * * * Paramètres : format = description de l'exécutable à compléter. * @@ -424,7 +462,7 @@ SourceEndian g_binary_format_get_endianness(const GBinFormat *format) * * ******************************************************************************/ -void g_binary_format_register_code_point(GBinFormat *format, virt_t pt, DisassPriorityLevel level) +void g_program_format_register_code_point(GProgramFormat *format, virt_t pt, DisassPriorityLevel level) { assert(level < DPL_COUNT); @@ -459,7 +497,7 @@ void g_binary_format_register_code_point(GBinFormat *format, virt_t pt, DisassPr * * ******************************************************************************/ -static bool g_binary_format_load_start_points(GBinFormat *format, packed_buffer_t *pbuf) +static bool g_program_format_load_start_points(GProgramFormat *format, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ DisassPriorityLevel i; /* Boucle de parcours #1 */ @@ -512,7 +550,7 @@ static bool g_binary_format_load_start_points(GBinFormat *format, packed_buffer_ * * ******************************************************************************/ -static bool g_binary_format_store_start_points(GBinFormat *format, packed_buffer_t *pbuf) +static bool g_program_format_store_start_points(GProgramFormat *format, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ DisassPriorityLevel i; /* Boucle de parcours #1 */ @@ -555,7 +593,7 @@ static bool g_binary_format_store_start_points(GBinFormat *format, packed_buffer * * ******************************************************************************/ -void g_binary_format_preload_disassembling_context(GBinFormat *format, GProcContext *ctx, GtkStatusStack *status) +void g_program_format_preload_disassembling_context(GProgramFormat *format, GProcContext *ctx, GtkStatusStack *status) { g_preload_info_copy(format->info, G_PRELOAD_INFO(ctx)); @@ -576,7 +614,7 @@ void g_binary_format_preload_disassembling_context(GBinFormat *format, GProcCont * * ******************************************************************************/ -void g_binary_format_activate_disassembling_context(GBinFormat *format, GProcContext *ctx, GtkStatusStack *status) +void g_program_format_activate_disassembling_context(GProgramFormat *format, GProcContext *ctx, GtkStatusStack *status) { DisassPriorityLevel i; /* Boucle de parcours #1 */ size_t k; /* Boucle de parcours #2 */ @@ -610,7 +648,7 @@ void g_binary_format_activate_disassembling_context(GBinFormat *format, GProcCon * * ******************************************************************************/ -GCompDemangler *g_binary_format_get_demangler(const GBinFormat *format) +GCompDemangler *g_program_format_get_demangler(const GProgramFormat *format) { GCompDemangler *result; /* Décodeur à retourner */ @@ -637,7 +675,7 @@ GCompDemangler *g_binary_format_get_demangler(const GBinFormat *format) * * ******************************************************************************/ -GDataType *g_binary_format_decode_type(const GBinFormat *format, const char *desc) +GDataType *g_program_format_decode_type(const GProgramFormat *format, const char *desc) { GDataType *result; /* Construction à remonter */ GCompDemangler *demangler; /* Accès plus lisible */ @@ -667,7 +705,7 @@ GDataType *g_binary_format_decode_type(const GBinFormat *format, const char *des * * ******************************************************************************/ -GBinRoutine *g_binary_format_decode_routine(const GBinFormat *format, const char *desc) +GBinRoutine *g_program_format_decode_routine(const GProgramFormat *format, const char *desc) { GBinRoutine *result; /* Construction à remonter */ GCompDemangler *demangler; /* Accès plus lisible */ @@ -708,7 +746,7 @@ GBinRoutine *g_binary_format_decode_routine(const GBinFormat *format, const char * * ******************************************************************************/ -void g_binary_format_lock_unlock_symbols_rd(GBinFormat *format, bool state) +void g_program_format_lock_unlock_symbols_rd(GProgramFormat *format, bool state) { #ifndef NDEBUG gint test; /* Test de valeur courante */ @@ -746,7 +784,7 @@ void g_binary_format_lock_unlock_symbols_rd(GBinFormat *format, bool state) * * ******************************************************************************/ -void g_binary_format_lock_unlock_symbols_wr(GBinFormat *format, bool state) +void g_program_format_lock_unlock_symbols_wr(GProgramFormat *format, bool state) { if (state) { @@ -778,7 +816,7 @@ void g_binary_format_lock_unlock_symbols_wr(GBinFormat *format, bool state) * * ******************************************************************************/ #ifndef NDEBUG -void g_binary_format_check_for_symbols_lock(const GBinFormat *format) +void g_program_format_check_for_symbols_lock(const GProgramFormat *format) { assert(g_atomic_int_get(&format->sym_locked) > 0); @@ -798,7 +836,7 @@ void g_binary_format_check_for_symbols_lock(const GBinFormat *format) * * ******************************************************************************/ -unsigned int g_binary_format_get_symbols_stamp(const GBinFormat *format) +unsigned int g_program_format_get_symbols_stamp(const GProgramFormat *format) { return format->sym_stamp; @@ -817,7 +855,7 @@ unsigned int g_binary_format_get_symbols_stamp(const GBinFormat *format) * * ******************************************************************************/ -size_t g_binary_format_count_symbols(const GBinFormat *format) +size_t g_program_format_count_symbols(const GProgramFormat *format) { assert(g_atomic_int_get(&format->sym_locked) > 0); @@ -839,7 +877,7 @@ size_t g_binary_format_count_symbols(const GBinFormat *format) * * ******************************************************************************/ -GBinSymbol *g_binary_format_get_symbol(const GBinFormat *format, size_t index) +GBinSymbol *g_program_format_get_symbol(const GProgramFormat *format, size_t index) { GBinSymbol *result; /* Symbole à retourner */ @@ -877,7 +915,7 @@ GBinSymbol *g_binary_format_get_symbol(const GBinFormat *format, size_t index) * * ******************************************************************************/ -bool g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol) +bool g_program_format_add_symbol(GProgramFormat *format, GBinSymbol *symbol) { bool result; /* Statut d'ajout à retourner */ #ifndef NDEBUG @@ -887,7 +925,7 @@ bool g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol) size_t index; /* Indice du point d'insertion */ /** - * Pour que les fonctions de recherche basées sur _g_binary_format_find_symbol() + * Pour que les fonctions de recherche basées sur _g_program_format_find_symbol() * fassent bien leur office, il faut que les symboles soient triés. * * Cependant, les localisations à satisfaire lors d'une recherche recontrent @@ -912,7 +950,7 @@ bool g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol) assert(has_phys_addr(addr) || g_binary_symbol_get_status(symbol) == SSS_DYNAMIC); #endif - g_binary_format_lock_unlock_symbols_wr(format, true); + g_program_format_lock_unlock_symbols_wr(format, true); /** * Avec tous les traitements parallèles, il est possible que plusieurs chemins d'exécution @@ -939,7 +977,7 @@ bool g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol) else g_object_unref(G_OBJECT(symbol)); - g_binary_format_lock_unlock_symbols_wr(format, false); + g_program_format_lock_unlock_symbols_wr(format, false); if (result) g_signal_emit_by_name(format, "symbol-added", symbol); @@ -963,7 +1001,7 @@ bool g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol) * * ******************************************************************************/ -bool g_binary_format_add_symbols(GBinFormat *format, GBinSymbol **symbols, size_t count) +bool g_program_format_add_symbols(GProgramFormat *format, GBinSymbol **symbols, size_t count) { bool result; /* Statut d'ajout à retourner */ #ifndef NDEBUG @@ -977,7 +1015,7 @@ bool g_binary_format_add_symbols(GBinFormat *format, GBinSymbol **symbols, size_ size_t index; /* Indice du point d'insertion */ /** - * Pour que les fonctions de recherche basées sur _g_binary_format_find_symbol() + * Pour que les fonctions de recherche basées sur _g_program_format_find_symbol() * fassent bien leur office, il faut que les symboles soient triés. * * Cependant, les localisations à satisfaire lors d'une recherche recontrent @@ -1014,7 +1052,7 @@ bool g_binary_format_add_symbols(GBinFormat *format, GBinSymbol **symbols, size_ } #endif - g_binary_format_lock_unlock_symbols_wr(format, true); + g_program_format_lock_unlock_symbols_wr(format, true); /** * Avec tous les traitements parallèles, il est possible que plusieurs chemins d'exécution @@ -1042,7 +1080,7 @@ bool g_binary_format_add_symbols(GBinFormat *format, GBinSymbol **symbols, size_ } - g_binary_format_lock_unlock_symbols_wr(format, false); + g_program_format_lock_unlock_symbols_wr(format, false); if (result) for (i = 0; i < count; i++) @@ -1066,7 +1104,7 @@ bool g_binary_format_add_symbols(GBinFormat *format, GBinSymbol **symbols, size_ * * ******************************************************************************/ -static void _g_binary_format_remove_symbol(GBinFormat *format, size_t index) +static void _g_program_format_remove_symbol(GProgramFormat *format, size_t index) { assert(g_atomic_int_get(&format->sym_locked) == 1); @@ -1096,22 +1134,22 @@ static void _g_binary_format_remove_symbol(GBinFormat *format, size_t index) * * ******************************************************************************/ -void g_binary_format_remove_symbol(GBinFormat *format, GBinSymbol *symbol) +void g_program_format_remove_symbol(GProgramFormat *format, GBinSymbol *symbol) { bool found; /* Jeton de présence */ size_t index; /* Indice du point de retrait */ g_object_ref(G_OBJECT(symbol)); - g_binary_format_lock_unlock_symbols_wr(format, true); + g_program_format_lock_unlock_symbols_wr(format, true); found = bsearch_index(&symbol, format->symbols, format->sym_count, sizeof(GBinSymbol *), (__compar_fn_t)g_binary_symbol_cmp, &index); if (found) - _g_binary_format_remove_symbol(format, index); + _g_program_format_remove_symbol(format, index); - g_binary_format_lock_unlock_symbols_wr(format, false); + g_program_format_lock_unlock_symbols_wr(format, false); if (found) g_signal_emit_by_name(format, "symbol-removed", symbol); @@ -1135,7 +1173,7 @@ void g_binary_format_remove_symbol(GBinFormat *format, GBinSymbol *symbol) * * ******************************************************************************/ -bool g_binary_format_find_symbol_by_label(GBinFormat *format, const char *label, GBinSymbol **symbol) +bool g_program_format_find_symbol_by_label(GProgramFormat *format, const char *label, GBinSymbol **symbol) { bool result; /* Bilan à retourner */ size_t i; /* Boucle de parcours */ @@ -1143,7 +1181,7 @@ bool g_binary_format_find_symbol_by_label(GBinFormat *format, const char *label, result = false; - g_binary_format_lock_symbols_rd(format); + g_program_format_lock_symbols_rd(format); for (i = 0; i < format->sym_count && !result; i++) { @@ -1163,7 +1201,7 @@ bool g_binary_format_find_symbol_by_label(GBinFormat *format, const char *label, } - g_binary_format_unlock_symbols_rd(format); + g_program_format_unlock_symbols_rd(format); return result; @@ -1186,16 +1224,16 @@ bool g_binary_format_find_symbol_by_label(GBinFormat *format, const char *label, * * ******************************************************************************/ -static bool _g_binary_format_find_symbol(const GBinFormat *format, const vmpa2t *addr, __compar_fn_t fn, size_t *index, GBinSymbol **symbol) +static bool _g_program_format_find_symbol(const GProgramFormat *format, const vmpa2t *addr, __compar_fn_t fn, size_t *index, GBinSymbol **symbol) { /** * Pour ce qui est des justifications quant à la vérification suivante, - * se référer aux commentaires placés dans g_binary_format_add_symbol(). + * se référer aux commentaires placés dans g_program_format_add_symbol(). */ assert(has_phys_addr(addr)); - return __g_binary_format_find_symbol(format, addr, fn, index, symbol); + return __g_program_format_find_symbol(format, addr, fn, index, symbol); } @@ -1216,7 +1254,7 @@ static bool _g_binary_format_find_symbol(const GBinFormat *format, const vmpa2t * * ******************************************************************************/ -static bool __g_binary_format_find_symbol(const GBinFormat *format, const void *key, __compar_fn_t fn, size_t *index, GBinSymbol **symbol) +static bool __g_program_format_find_symbol(const GProgramFormat *format, const void *key, __compar_fn_t fn, size_t *index, GBinSymbol **symbol) { bool result; /* Bilan à retourner */ void *found; /* Résultat de recherches */ @@ -1268,7 +1306,7 @@ static bool __g_binary_format_find_symbol(const GBinFormat *format, const void * * * ******************************************************************************/ -bool g_binary_format_find_symbol_index_at(GBinFormat *format, const vmpa2t *addr, size_t *index) +bool g_program_format_find_symbol_index_at(GProgramFormat *format, const vmpa2t *addr, size_t *index) { bool result; /* Bilan à retourner */ @@ -1282,11 +1320,11 @@ bool g_binary_format_find_symbol_index_at(GBinFormat *format, const vmpa2t *addr } - g_binary_format_lock_symbols_rd(format); + g_program_format_lock_symbols_rd(format); - result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, index, NULL); + result = _g_program_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, index, NULL); - g_binary_format_unlock_symbols_rd(format); + g_program_format_unlock_symbols_rd(format); return result; @@ -1307,7 +1345,7 @@ bool g_binary_format_find_symbol_index_at(GBinFormat *format, const vmpa2t *addr * * ******************************************************************************/ -bool g_binary_format_find_symbol_at(GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol) +bool g_program_format_find_symbol_at(GProgramFormat *format, const vmpa2t *addr, GBinSymbol **symbol) { bool result; /* Bilan à retourner */ @@ -1321,11 +1359,11 @@ bool g_binary_format_find_symbol_at(GBinFormat *format, const vmpa2t *addr, GBin } - g_binary_format_lock_symbols_rd(format); + g_program_format_lock_symbols_rd(format); - result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, NULL, symbol); + result = _g_program_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, NULL, symbol); - g_binary_format_unlock_symbols_rd(format); + g_program_format_unlock_symbols_rd(format); return result; @@ -1346,7 +1384,7 @@ bool g_binary_format_find_symbol_at(GBinFormat *format, const vmpa2t *addr, GBin * * ******************************************************************************/ -bool g_binary_format_find_symbol_for(GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol) +bool g_program_format_find_symbol_for(GProgramFormat *format, const vmpa2t *addr, GBinSymbol **symbol) { bool result; /* Bilan à retourner */ @@ -1360,11 +1398,11 @@ bool g_binary_format_find_symbol_for(GBinFormat *format, const vmpa2t *addr, GBi } - g_binary_format_lock_symbols_rd(format); + g_program_format_lock_symbols_rd(format); - result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, NULL, symbol); + result = _g_program_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, NULL, symbol); - g_binary_format_unlock_symbols_rd(format); + g_program_format_unlock_symbols_rd(format); return result; @@ -1385,7 +1423,7 @@ bool g_binary_format_find_symbol_for(GBinFormat *format, const vmpa2t *addr, GBi * * ******************************************************************************/ -bool g_binary_format_find_next_symbol_at(GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol) +bool g_program_format_find_next_symbol_at(GProgramFormat *format, const vmpa2t *addr, GBinSymbol **symbol) { bool result; /* Bilan à retourner */ size_t index; /* Indice à considérer */ @@ -1400,9 +1438,9 @@ bool g_binary_format_find_next_symbol_at(GBinFormat *format, const vmpa2t *addr, } - g_binary_format_lock_symbols_rd(format); + g_program_format_lock_symbols_rd(format); - result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, &index, NULL); + result = _g_program_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, &index, NULL); if (result && (index + 1) < format->sym_count) { @@ -1417,7 +1455,7 @@ bool g_binary_format_find_next_symbol_at(GBinFormat *format, const vmpa2t *addr, result = false; } - g_binary_format_unlock_symbols_rd(format); + g_program_format_unlock_symbols_rd(format); return result; @@ -1438,7 +1476,7 @@ bool g_binary_format_find_next_symbol_at(GBinFormat *format, const vmpa2t *addr, * * ******************************************************************************/ -bool g_binary_format_find_first_symbol_inside(GBinFormat *format, const mrange_t *range, size_t *index) +bool g_program_format_find_first_symbol_inside(GProgramFormat *format, const mrange_t *range, size_t *index) { bool result; /* Bilan à retourner */ const GBinSymbol *prev; /* Symbole précédent */ @@ -1463,7 +1501,7 @@ bool g_binary_format_find_first_symbol_inside(GBinFormat *format, const mrange_t g_rw_lock_reader_lock(&format->syms_lock); - result = __g_binary_format_find_symbol(format, range, (__compar_fn_t)find_symbol, index, NULL); + result = __g_program_format_find_symbol(format, range, (__compar_fn_t)find_symbol, index, NULL); if (result) while (*index > 0) @@ -1502,15 +1540,15 @@ bool g_binary_format_find_first_symbol_inside(GBinFormat *format, const mrange_t * * ******************************************************************************/ -bool g_binary_format_resolve_symbol(GBinFormat *format, const vmpa2t *addr, bool strict, GBinSymbol **symbol, phys_t *diff) +bool g_program_format_resolve_symbol(GProgramFormat *format, const vmpa2t *addr, bool strict, GBinSymbol **symbol, phys_t *diff) { bool result; /* Bilan à retourner */ const mrange_t *range; /* Espace mémoire parcouru */ if (strict) - result = g_binary_format_find_symbol_at(format, addr, symbol); + result = g_program_format_find_symbol_at(format, addr, symbol); else - result = g_binary_format_find_symbol_for(format, addr, symbol); + result = g_program_format_find_symbol_for(format, addr, symbol); if (result) { @@ -1548,7 +1586,7 @@ bool g_binary_format_resolve_symbol(GBinFormat *format, const vmpa2t *addr, bool * * ******************************************************************************/ -void g_binary_format_lock_unlock_errors(GBinFormat *format, bool state) +void g_program_format_lock_unlock_errors(GProgramFormat *format, bool state) { if (state) { @@ -1584,11 +1622,11 @@ void g_binary_format_lock_unlock_errors(GBinFormat *format, bool state) * * ******************************************************************************/ -void g_binary_format_add_error(GBinFormat *format, BinaryFormatError type, const vmpa2t *addr, const char *desc) +void g_program_format_add_error(GProgramFormat *format, BinaryFormatError type, const vmpa2t *addr, const char *desc) { fmt_error *error; /* Raccourci de confort */ - g_binary_format_lock_errors(format); + g_program_format_lock_errors(format); format->errors = realloc(format->errors, ++format->error_count * sizeof(fmt_error)); @@ -1603,7 +1641,7 @@ void g_binary_format_add_error(GBinFormat *format, BinaryFormatError type, const else error->desc = NULL; - g_binary_format_unlock_errors(format); + g_program_format_unlock_errors(format); } @@ -1620,7 +1658,7 @@ void g_binary_format_add_error(GBinFormat *format, BinaryFormatError type, const * * ******************************************************************************/ -size_t g_binary_format_count_errors(GBinFormat *format) +size_t g_program_format_count_errors(GProgramFormat *format) { size_t result; /* Quantité à retourner */ @@ -1649,7 +1687,7 @@ size_t g_binary_format_count_errors(GBinFormat *format) * * ******************************************************************************/ -bool g_binary_format_get_error(GBinFormat *format, size_t index, BinaryFormatError *type, vmpa2t *addr, char **desc) +bool g_program_format_get_error(GProgramFormat *format, size_t index, BinaryFormatError *type, vmpa2t *addr, char **desc) { bool result; /* Bilan à retourner */ fmt_error *error; /* Raccourci de confort */ @@ -1693,7 +1731,7 @@ bool g_binary_format_get_error(GBinFormat *format, size_t index, BinaryFormatErr * * ******************************************************************************/ -static bool g_binary_format_load_errors(GBinFormat *format, packed_buffer_t *pbuf) +static bool g_program_format_load_errors(GProgramFormat *format, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ uleb128_t value; /* Valeur ULEB128 à charger */ @@ -1701,7 +1739,7 @@ static bool g_binary_format_load_errors(GBinFormat *format, packed_buffer_t *pbu fmt_error *error; /* Raccourci de confort */ rle_string str; /* Chaîne à charger */ - g_binary_format_lock_errors(format); + g_program_format_lock_errors(format); result = unpack_uleb128(&value, pbuf); if (!result) goto exit; @@ -1736,7 +1774,7 @@ static bool g_binary_format_load_errors(GBinFormat *format, packed_buffer_t *pbu exit: - g_binary_format_unlock_errors(format); + g_program_format_unlock_errors(format); return result; @@ -1756,14 +1794,14 @@ static bool g_binary_format_load_errors(GBinFormat *format, packed_buffer_t *pbu * * ******************************************************************************/ -static bool g_binary_format_store_errors(GBinFormat *format, packed_buffer_t *pbuf) +static bool g_program_format_store_errors(GProgramFormat *format, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ size_t i; /* Boucle de parcours */ fmt_error *error; /* Raccourci de confort */ rle_string str; /* Chaîne à conserver */ - g_binary_format_lock_errors(format); + g_program_format_lock_errors(format); result = pack_uleb128((uleb128_t []){ format->error_count }, pbuf); @@ -1785,7 +1823,7 @@ static bool g_binary_format_store_errors(GBinFormat *format, packed_buffer_t *pb } - g_binary_format_unlock_errors(format); + g_program_format_unlock_errors(format); return result; @@ -1812,7 +1850,7 @@ static bool g_binary_format_store_errors(GBinFormat *format, packed_buffer_t *pb * * ******************************************************************************/ -static bool g_binary_format_load(GBinFormat *format, GObjectStorage *storage, packed_buffer_t *pbuf) +static bool g_program_format_load(GProgramFormat *format, GObjectStorage *storage, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ fmt_extra_data_t *extra; /* Données insérées à consulter*/ @@ -1831,7 +1869,7 @@ static bool g_binary_format_load(GBinFormat *format, GObjectStorage *storage, pa UNLOCK_GOBJECT_EXTRA(extra); if (result) - result = g_binary_format_load_start_points(format, pbuf); + result = g_program_format_load_start_points(format, pbuf); if (result) { @@ -1857,7 +1895,7 @@ static bool g_binary_format_load(GBinFormat *format, GObjectStorage *storage, pa if (result) - result = g_binary_format_load_errors(format, pbuf); + result = g_program_format_load_errors(format, pbuf); return result; @@ -1878,7 +1916,7 @@ static bool g_binary_format_load(GBinFormat *format, GObjectStorage *storage, pa * * ******************************************************************************/ -static bool g_binary_format_store(GBinFormat *format, GObjectStorage *storage, packed_buffer_t *pbuf) +static bool g_program_format_store(GProgramFormat *format, GObjectStorage *storage, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ fmt_extra_data_t *extra; /* Données insérées à consulter*/ @@ -1894,7 +1932,7 @@ static bool g_binary_format_store(GBinFormat *format, GObjectStorage *storage, p UNLOCK_GOBJECT_EXTRA(extra); if (result) - result = g_binary_format_store_start_points(format, pbuf); + result = g_program_format_store_start_points(format, pbuf); if (result) { @@ -1913,8 +1951,10 @@ static bool g_binary_format_store(GBinFormat *format, GObjectStorage *storage, p if (result) - result = g_binary_format_store_errors(format, pbuf); + result = g_program_format_store_errors(format, pbuf); return result; } + +#endif diff --git a/src/format/program.h b/src/format/program.h index f9aa430..51b7860 100644 --- a/src/format/program.h +++ b/src/format/program.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * format.h - prototypes pour le support des différents formats binaires + * program.h - prototypes pour le support des différents formats de programmes * - * Copyright (C) 2009-2020 Cyrille Bagard + * Copyright (C) 2009-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,10 +21,29 @@ */ -#ifndef _FORMAT_FORMAT_H -#define _FORMAT_FORMAT_H +#ifndef _FORMAT_PROGRAM_H +#define _FORMAT_PROGRAM_H +#include "../common/datatypes.h" +#include "../glibext/helpers.h" + + + +#define G_TYPE_PROGRAM_FORMAT (g_program_format_get_type()) + +DECLARE_GTYPE(GProgramFormat, g_program_format, G, PROGRAM_FORMAT); + + +/* Indique le boutisme employé par le format binaire analysé. */ +SourceEndian g_program_format_get_endianness(const GProgramFormat *); + + + + + +#if 0 + #include <glib-object.h> #include <stdbool.h> #include <sys/types.h> @@ -52,47 +71,31 @@ typedef enum _FormatFlag } FormatFlag; -#define G_TYPE_BIN_FORMAT g_binary_format_get_type() -#define G_BIN_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BIN_FORMAT, GBinFormat)) -#define G_IS_BIN_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BIN_FORMAT)) -#define G_BIN_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BIN_FORMAT, GBinFormatClass)) -#define G_IS_BIN_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BIN_FORMAT)) -#define G_BIN_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BIN_FORMAT, GBinFormatClass)) - -/* Format binaire générique (instance) */ -typedef struct _GBinFormat GBinFormat; - -/* Format binaire générique (classe) */ -typedef struct _GBinFormatClass GBinFormatClass; - - -/* Indique le type défini pour un format binaire générique. */ -GType g_binary_format_get_type(void); /* Ajoute une information complémentaire à un format. */ -bool g_binary_format_set_flag(GBinFormat *, FormatFlag); +bool g_program_format_set_flag(GProgramFormat *, FormatFlag); /* Retire une information complémentaire à un format. */ -bool g_binary_format_unset_flag(GBinFormat *, FormatFlag); +bool g_program_format_unset_flag(GProgramFormat *, FormatFlag); /* Détermine si un format possède un fanion particulier. */ -bool g_binary_format_has_flag(const GBinFormat *, FormatFlag); +bool g_program_format_has_flag(const GProgramFormat *, FormatFlag); /* Fournit les particularités du format. */ -FormatFlag g_binary_format_get_flags(const GBinFormat *); +FormatFlag g_program_format_get_flags(const GProgramFormat *); /* Indique le boutisme employé par le format binaire analysé. */ -SourceEndian g_binary_format_get_endianness(const GBinFormat *); +//SourceEndian g_program_format_get_endianness(const GProgramFormat *); /* Enregistre une adresse comme début d'une zone de code. */ -void g_binary_format_register_code_point(GBinFormat *, virt_t, DisassPriorityLevel); +void g_program_format_register_code_point(GProgramFormat *, virt_t, DisassPriorityLevel); /* Intègre dans un contexte les informations tirées d'un format. */ -void g_binary_format_preload_disassembling_context(GBinFormat *, GProcContext *, GtkStatusStack *); +void g_program_format_preload_disassembling_context(GProgramFormat *, GProcContext *, GtkStatusStack *); /* Définit les points de départ d'un contexte de désassemblage. */ -void g_binary_format_activate_disassembling_context(GBinFormat *, GProcContext *, GtkStatusStack *); +void g_program_format_activate_disassembling_context(GProgramFormat *, GProcContext *, GtkStatusStack *); @@ -100,7 +103,7 @@ void g_binary_format_activate_disassembling_context(GBinFormat *, GProcContext * /* Fournit le décodeur de symboles privilégié pour un format. */ -GCompDemangler *g_binary_format_get_demangler(const GBinFormat *); +GCompDemangler *g_program_format_get_demangler(const GProgramFormat *); @@ -108,60 +111,60 @@ GCompDemangler *g_binary_format_get_demangler(const GBinFormat *); /* Protège ou lève la protection de l'accès aux symboles. */ -void g_binary_format_lock_unlock_symbols_rd(GBinFormat *, bool); +void g_program_format_lock_unlock_symbols_rd(GProgramFormat *, bool); -#define g_binary_format_lock_symbols_rd(f) g_binary_format_lock_unlock_symbols_rd(f, true) -#define g_binary_format_unlock_symbols_rd(f) g_binary_format_lock_unlock_symbols_rd(f, false) +#define g_program_format_lock_symbols_rd(f) g_program_format_lock_unlock_symbols_rd(f, true) +#define g_program_format_unlock_symbols_rd(f) g_program_format_lock_unlock_symbols_rd(f, false) /* Protège ou lève la protection de l'accès aux symboles. */ -void g_binary_format_lock_unlock_symbols_wr(GBinFormat *, bool); +void g_program_format_lock_unlock_symbols_wr(GProgramFormat *, bool); -#define g_binary_format_lock_symbols_wr(f) g_binary_format_lock_unlock_symbols_wr(f, true) -#define g_binary_format_unlock_symbols_wr(f) g_binary_format_lock_unlock_symbols_wr(f, false) +#define g_program_format_lock_symbols_wr(f) g_program_format_lock_unlock_symbols_wr(f, true) +#define g_program_format_unlock_symbols_wr(f) g_program_format_lock_unlock_symbols_wr(f, false) /* Assure qu'un verrou est bien posé pour l'accès aux symboles. */ #ifndef NDEBUG -void g_binary_format_check_for_symbols_lock(const GBinFormat *); +void g_program_format_check_for_symbols_lock(const GProgramFormat *); #endif /* Fournit la marque de dernière modification des symboles. */ -unsigned int g_binary_format_get_symbols_stamp(const GBinFormat *); +unsigned int g_program_format_get_symbols_stamp(const GProgramFormat *); /* Compte le nombre de symboles représentés. */ -size_t g_binary_format_count_symbols(const GBinFormat *); +size_t g_program_format_count_symbols(const GProgramFormat *); /* Fournit un symbole lié à un format. */ -GBinSymbol *g_binary_format_get_symbol(const GBinFormat *, size_t); +GBinSymbol *g_program_format_get_symbol(const GProgramFormat *, size_t); /* Ajoute un symbole à la collection du format binaire. */ -bool g_binary_format_add_symbol(GBinFormat *, GBinSymbol *); +bool g_program_format_add_symbol(GProgramFormat *, GBinSymbol *); /* Ajoute plusieurs symboles à la collection du format binaire. */ -bool g_binary_format_add_symbols(GBinFormat *, GBinSymbol **, size_t); +bool g_program_format_add_symbols(GProgramFormat *, GBinSymbol **, size_t); /* Retire un symbole de la collection du format binaire. */ -void g_binary_format_remove_symbol(GBinFormat *, GBinSymbol *); +void g_program_format_remove_symbol(GProgramFormat *, GBinSymbol *); /* Recherche le symbole correspondant à une étiquette. */ -bool g_binary_format_find_symbol_by_label(GBinFormat *, const char *, GBinSymbol **); +bool g_program_format_find_symbol_by_label(GProgramFormat *, const char *, GBinSymbol **); /* Recherche l'indice du symbole correspondant à une adresse. */ -bool g_binary_format_find_symbol_index_at(GBinFormat *, const vmpa2t *, size_t *); +bool g_program_format_find_symbol_index_at(GProgramFormat *, const vmpa2t *, size_t *); /* Recherche le symbole correspondant à une adresse. */ -bool g_binary_format_find_symbol_at(GBinFormat *, const vmpa2t *, GBinSymbol **); +bool g_program_format_find_symbol_at(GProgramFormat *, const vmpa2t *, GBinSymbol **); /* Recherche le symbole contenant une adresse. */ -bool g_binary_format_find_symbol_for(GBinFormat *, const vmpa2t *, GBinSymbol **); +bool g_program_format_find_symbol_for(GProgramFormat *, const vmpa2t *, GBinSymbol **); /* Recherche le symbole suivant celui lié à une adresse. */ -bool g_binary_format_find_next_symbol_at(GBinFormat *, const vmpa2t *, GBinSymbol **); +bool g_program_format_find_next_symbol_at(GProgramFormat *, const vmpa2t *, GBinSymbol **); /* Recherche le premier symbole inclus dans une zone mémoire. */ -bool g_binary_format_find_first_symbol_inside(GBinFormat *, const mrange_t *, size_t *); +bool g_program_format_find_first_symbol_inside(GProgramFormat *, const mrange_t *, size_t *); /* Recherche le symbole correspondant à une adresse. */ -bool g_binary_format_resolve_symbol(GBinFormat *, const vmpa2t *, bool, GBinSymbol **, phys_t *); +bool g_program_format_resolve_symbol(GProgramFormat *, const vmpa2t *, bool, GBinSymbol **, phys_t *); @@ -181,20 +184,21 @@ typedef enum _BinaryFormatError /* Protège ou lève la protection de l'accès aux erreurs. */ -void g_binary_format_lock_unlock_errors(GBinFormat *, bool); +void g_program_format_lock_unlock_errors(GProgramFormat *, bool); -#define g_binary_format_lock_errors(f) g_binary_format_lock_unlock_errors(f, true) -#define g_binary_format_unlock_errors(f) g_binary_format_lock_unlock_errors(f, false) +#define g_program_format_lock_errors(f) g_program_format_lock_unlock_errors(f, true) +#define g_program_format_unlock_errors(f) g_program_format_lock_unlock_errors(f, false) /* Etend la liste des soucis détectés avec de nouvelles infos. */ -void g_binary_format_add_error(GBinFormat *, BinaryFormatError, const vmpa2t *, const char *); +void g_program_format_add_error(GProgramFormat *, BinaryFormatError, const vmpa2t *, const char *); /* Indique le nombre d'erreurs relevées au niveau assembleur. */ -size_t g_binary_format_count_errors(GBinFormat *); +size_t g_program_format_count_errors(GProgramFormat *); /* Fournit les éléments concernant un soucis détecté. */ -bool g_binary_format_get_error(GBinFormat *, size_t, BinaryFormatError *, vmpa2t *, char **); +bool g_program_format_get_error(GProgramFormat *, size_t, BinaryFormatError *, vmpa2t *, char **); +#endif -#endif /* _FORMAT_FORMAT_H */ +#endif /* _FORMAT_PROGRAM_H */ |