diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/format/executable-int.c | 155 | ||||
| -rw-r--r-- | src/format/executable-int.h | 48 | ||||
| -rw-r--r-- | src/format/executable.c | 402 | ||||
| -rw-r--r-- | src/format/executable.h | 74 | ||||
| -rw-r--r-- | src/format/flat-int.h | 2 | ||||
| -rw-r--r-- | src/format/flat.c | 38 | ||||
| -rw-r--r-- | src/format/known-int.h | 10 | ||||
| -rw-r--r-- | src/format/known.c | 48 | ||||
| -rw-r--r-- | src/format/known.h | 11 | ||||
| -rw-r--r-- | src/format/program-int.h | 6 | ||||
| -rw-r--r-- | src/format/program.c | 52 | ||||
| -rw-r--r-- | src/format/program.h | 8 | ||||
| -rw-r--r-- | src/glibext/Makefile.am | 4 | ||||
| -rw-r--r-- | src/glibext/portion-int.h | 37 | ||||
| -rw-r--r-- | src/glibext/portion.c | 963 | ||||
| -rw-r--r-- | src/glibext/portion.h | 141 |
16 files changed, 416 insertions, 1583 deletions
diff --git a/src/format/executable-int.c b/src/format/executable-int.c deleted file mode 100644 index 0e94e74..0000000 --- a/src/format/executable-int.c +++ /dev/null @@ -1,155 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * executable-int.c - code utile aux formats d'exécutables - * - * Copyright (C) 2015-2018 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 "executable-int.h" - - - -/****************************************************************************** -* * -* Paramètres : format = description de l'exécutable à consulter. * -* off = position physique à retrouver. * -* pos = position correspondante. [OUT] * -* * -* Description : Fournit l'emplacement correspondant à une position physique. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool g_exe_format_without_virt_translate_offset_into_vmpa(const GExeFormat *format, phys_t off, vmpa2t *pos) -{ - init_vmpa(pos, off, VMPA_NO_VIRTUAL); - - return true; - -} - - -/****************************************************************************** -* * -* Paramètres : format = description de l'exécutable à consulter. * -* addr = adresse virtuelle à retrouver. * -* pos = position correspondante. [OUT] * -* * -* Description : Fournit l'emplacement correspondant à une adresse virtuelle. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool g_exe_format_without_virt_translate_address_into_vmpa(const GExeFormat *format, virt_t addr, vmpa2t *pos) -{ - /** - * S'il n'y a pas de notion de mémoire virtuelle, positions physiques et - * adresses virtuelles se confondent. - * - * On reste néanmoins cohérent, et on n'utilise donc pas d'adresse virtuelle. - * - * Les sauts dans le code renvoient de façon transparente vers des positions - * physiques. - */ - - init_vmpa(pos, addr, VMPA_NO_VIRTUAL); - - return true; - -} - - -/****************************************************************************** -* * -* Paramètres : format = description de l'exécutable à consulter. * -* off = position physique à retrouver. * -* pos = position correspondante. [OUT] * -* * -* Description : Fournit l'emplacement correspondant à une position physique. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool g_exe_format_translate_offset_into_vmpa_using_portions(GExeFormat *format, phys_t off, vmpa2t *pos) -{ - bool result; /* Bilan à retourner */ - GBinPortion *portions; /* Liste de découpages */ - - portions = g_exe_format_get_portions(format); - - if (portions == NULL) - result = false; - - else - { - result = g_binary_portion_translate_offset_into_vmpa(portions, off, pos); - - g_object_unref(G_OBJECT(portions)); - - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : format = description de l'exécutable à consulter. * -* addr = adresse virtuelle à retrouver. * -* pos = position correspondante. [OUT] * -* * -* Description : Fournit l'emplacement correspondant à une adresse virtuelle. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool g_exe_format_translate_address_into_vmpa_using_portions(GExeFormat *format, virt_t addr, vmpa2t *pos) -{ - bool result; /* Bilan à retourner */ - GBinPortion *portions; /* Liste de découpages */ - - portions = g_exe_format_get_portions(format); - - if (portions == NULL) - result = false; - - else - { - result = g_binary_portion_translate_address_into_vmpa(portions, addr, pos); - - g_object_unref(G_OBJECT(portions)); - - } - - return result; - -} diff --git a/src/format/executable-int.h b/src/format/executable-int.h index 73b647c..1ca1bdb 100644 --- a/src/format/executable-int.h +++ b/src/format/executable-int.h @@ -35,12 +35,11 @@ /* Indique le type d'architecture visée par le format. */ typedef char * (* get_target_machine_fc) (const GExecutableFormat *); -#if 0 /* Fournit l'adresse principale associée à un format. */ typedef bool (* get_main_addr_fc) (GExecutableFormat *, vmpa2t *); /* Etend la définition des portions au sein d'un binaire. */ -typedef void (* refine_portions_fc) (GExecutableFormat *); +typedef bool (* refine_portions_fc) (GExecutableFormat *); /* Fournit l'emplacement correspondant à une position physique. */ typedef bool (* translate_phys_fc) (GExecutableFormat *, phys_t, vmpa2t *); @@ -48,28 +47,13 @@ typedef bool (* translate_phys_fc) (GExecutableFormat *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une adresse virtuelle. */ 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 GExecutableFormat *, const char *, mrange_t *); - -#endif - /* Format d'exécutable générique (instance) */ struct _GExecutableFormat { - GProgramFormat parent; /* A laisser en premier */ - -#if 0 + GProgramFormat parent; /* A laisser en premier */ - GDbgFormat **debugs; /* Informations de débogage */ - size_t debugs_count; /* Nombre de ces informations */ - - GBinPortion **user_portions; /* Couches de morceaux binaires*/ - size_t user_count; /* Nombre de ces portions */ - GBinPortion *portions; /* Couches de morceaux binaires*/ - GMutex mutex; /* Accès à l'arborescence */ - -#endif + GBinaryPortion *portions; /* Couches de morceaux binaires*/ }; @@ -80,41 +64,29 @@ struct _GExecutableFormatClass 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 */ - -#endif - }; -#if 0 - -/* Crée les portions potentiellement utiles aux traductions. */ -void g_executable_format_setup_portions(GExecutableFormat *, GtkStatusStack *); - -/* Effectue les ultimes opérations de chargement d'un binaire. */ -bool g_executable_format_complete_loading(GExecutableFormat *, wgroup_id_t, GtkStatusStack *); +/* Met en place un nouveau contenu binaire à analyser. */ +bool g_executable_format_create(GExecutableFormat *, GBinContent *); /* Fournit l'emplacement correspondant à une position physique. */ -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 GExecutableFormat *, virt_t, vmpa2t *); +bool g_executable_format_translate_offset_into_vmpa_without_virt(const GExecutableFormat *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une position physique. */ -bool g_exe_format_translate_offset_into_vmpa_using_portions(GExecutableFormat *, phys_t, vmpa2t *); +bool g_executable_format_translate_offset_into_vmpa_with_portions(GExecutableFormat *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une adresse virtuelle. */ -bool g_exe_format_translate_address_into_vmpa_using_portions(GExecutableFormat *, virt_t, vmpa2t *); +bool g_executable_format_translate_address_into_vmpa_without_virt(const GExecutableFormat *, virt_t, vmpa2t *); -#endif +/* Fournit l'emplacement correspondant à une adresse virtuelle. */ +bool g_executable_format_translate_address_into_vmpa_with_portions(GExecutableFormat *, virt_t, vmpa2t *); diff --git a/src/format/executable.c b/src/format/executable.c index 187bd4e..80bfc9d 100644 --- a/src/format/executable.c +++ b/src/format/executable.c @@ -25,19 +25,17 @@ #include <assert.h> -/* #include <malloc.h> #include <stdio.h> -#include <stdlib.h> +//#include <stdlib.h> #include <i18n.h> -*/ + #include "executable-int.h" -/* -#include "format.h" #include "../core/logs.h" +/* #include "../plugins/pglist.h" */ @@ -98,7 +96,7 @@ static void g_executable_format_class_init(GExecutableFormatClass *klass) static void g_executable_format_init(GExecutableFormat *format) { - //g_mutex_init(&format->mutex); + format->portions = NULL; } @@ -117,24 +115,8 @@ static void g_executable_format_init(GExecutableFormat *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++) - g_clear_object(&format->debugs[i]); - - for (i = 0; i < format->user_count; i++) - g_clear_object(&format->user_portions[i]); - g_clear_object(&format->portions); - g_mutex_clear(&format->mutex); - -#endif - - - G_OBJECT_CLASS(g_executable_format_parent_class)->dispose(G_OBJECT(format)); } @@ -154,108 +136,56 @@ static void g_executable_format_dispose(GExecutableFormat *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. * -* info = informations de débogage à lier. * +* Paramètres : format = description du format à initialiser pleinement. * +* content = contenu binaire à parcourir. * * * -* Description : Rajoute des informations de débogage à un exécutable. * +* Description : Met en place un nouveau contenu binaire à analyser. * * * -* Retour : - * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -void g_executable_format_add_debug_info(GExecutableFormat *format, GDbgFormat *info) +bool g_executable_format_create(GExecutableFormat *format, GBinContent *content) { - const char *desc; /* Description humaine associée*/ - - desc = g_known_format_get_description(G_KNOWN_FORMAT(info)); - - if (desc == NULL) - log_simple_message(LMT_WARNING, _("Unnamed debug information")); - else - log_variadic_message(LMT_INFO, _("Found debug information: %s"), desc); - - format->debugs = realloc(format->debugs, ++format->debugs_count * sizeof(GDbgFormat *)); - - format->debugs[format->debugs_count - 1] = info; - -} - + bool result; /* Bilan à retourner */ + vmpa2t addr; /* Emplacement vide de sens */ + phys_t length; /* Taille de portion globale */ + GExecutableFormatClass *class; /* Classe de l'instance */ -/****************************************************************************** -* * -* Paramètres : format = informations chargées à consulter. * -* * -* Description : Compte le nombre de formats de débogage liés à l'exécutable. * -* * -* Retour : Nombre de formats de débogage attachés. * -* * -* Remarques : - * -* * -******************************************************************************/ + result = g_program_format_create(G_PROGRAM_FORMAT(format), content); + if (!result) goto exit; -size_t g_executable_format_count_debug_info(const GExecutableFormat *format) -{ - return format->debugs_count; + /* Définition de portions */ -} + /** + * Avant de lire l'entête du format, on ne sait pas où on se trouve ! + */ + init_vmpa(&addr, 0, VMPA_NO_VIRTUAL); + length = g_binary_content_compute_size(G_KNOWN_FORMAT(format)->content); -/****************************************************************************** -* * -* Paramètres : format = informations chargées à consulter. * -* index = indice des informations à transmettre. * -* * -* Description : Fournit un format de débogage attaché à l'exécutable. * -* * -* Retour : Informations de débogage attachées. * -* * -* Remarques : - * -* * -******************************************************************************/ + format->portions = g_binary_portion_new(&addr, length); -GDbgFormat *g_executable_format_get_debug_info(const GExecutableFormat *format, size_t index) -{ - GDbgFormat *result; /* Format à retourner */ + class = G_EXECUTABLE_FORMAT_GET_CLASS(format); - if (index >= format->debugs_count) - result = NULL; + if (class->refine_portions != NULL) + result = class->refine_portions(format); - else - { - result = format->debugs[index]; - g_object_ref(G_OBJECT(result)); - } + exit: return result; } -#endif - /****************************************************************************** * * @@ -285,8 +215,6 @@ char *g_executable_format_get_target_machine(const GExecutableFormat *format) } -#if 0 - /****************************************************************************** * * * Paramètres : format = description de l'exécutable à consulter. * @@ -294,7 +222,7 @@ char *g_executable_format_get_target_machine(const GExecutableFormat *format) * * * Description : Fournit l'adresse principale associée à un format. * * * -* Retour : Bilan des recherches. * +* Retour : Validité de l'adresse transmise. * * * * Remarques : - * * * @@ -303,110 +231,11 @@ char *g_executable_format_get_target_machine(const GExecutableFormat *format) 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_EXECUTABLE_FORMAT_GET_CLASS(format)->get_main_addr != NULL) - result = G_EXECUTABLE_FORMAT_GET_CLASS(format)->get_main_addr(format, addr); - - if (!result) - { - base = G_BIN_FORMAT(format); - - g_rw_lock_reader_lock(&base->pt_lock); - - if (base->pt_count[DPL_ENTRY_POINT] > 0) - 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); - - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance à traiter. * -* status = barre de statut à tenir informée. * -* * -* Description : Crée les portions potentiellement utiles aux traductions. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_executable_format_setup_portions(GExecutableFormat *format, GtkStatusStack *status) -{ - vmpa2t addr; /* Emplacement vide de sens */ - phys_t length; /* Taille de portion globale */ - GExecutableFormatClass *class; /* Classe de l'instance */ - size_t i; /* Boucle de parcours */ - - /** - * Avant de lire l'entête du format, on ne sait pas où on se trouve ! - */ - init_vmpa(&addr, 0, VMPA_NO_VIRTUAL); - - length = g_binary_content_compute_size(G_KNOWN_FORMAT(format)->content); - - format->portions = g_binary_portion_new(BPC_RAW, &addr, length); + GExecutableFormatClass *class; /* Classe de l'instance */ class = G_EXECUTABLE_FORMAT_GET_CLASS(format); - if (class->refine_portions != NULL) - class->refine_portions(format); - - for (i = 0; i < format->user_count; i++) - { - g_object_ref(G_OBJECT(format->user_portions[i])); - g_executable_format_include_portion(format, format->user_portions[i], NULL); - } - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance à traiter. * -* gid = groupe de travail dédié. * -* status = barre de statut à tenir informée. * -* * -* Description : Effectue les ultimes opérations de chargement d'un binaire. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -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 */ - size_t i; /* Boucle de parcours */ - GDbgFormat *dbg; /* Informations de débogage */ - - result = true; - - attach_debug_format(format); - - count = g_executable_format_count_debug_info(format); - - for (i = 0; i < count && result; i++) - { - dbg = g_executable_format_get_debug_info(format, i); - - result = g_known_format_analyze(G_KNOWN_FORMAT(dbg), gid, status); - - g_object_unref(G_OBJECT(dbg)); - - } + result = class->get_main_addr(format, addr); return result; @@ -417,44 +246,19 @@ bool g_executable_format_complete_loading(GExecutableFormat *format, wgroup_id_t * * * Paramètres : format = description de l'exécutable à modifier. * * portion = portion à inclure dans les définitions du format. * -* * -* Description : Enregistre une portion artificielle pour le format. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_executable_format_register_user_portion(GExecutableFormat *format, GBinPortion *portion) -{ - g_mutex_lock(&format->mutex); - - format->user_portions = realloc(format->user_portions, ++format->user_count * sizeof(GBinPortion *)); - - format->user_portions[format->user_count - 1] = portion; - - g_mutex_unlock(&format->mutex); - -} - - -/****************************************************************************** -* * -* Paramètres : format = description de l'exécutable à modifier. * -* portion = portion à inclure dans les définitions du format. * * origin = source de définition de la portion fournie. * * * * Description : Procède à l'enregistrement d'une portion dans un format. * * * -* Retour : - * +* Retour : Bilan de l'opération : true si inclusion, false sinon. * * * * Remarques : - * * * ******************************************************************************/ -void g_executable_format_include_portion(GExecutableFormat *format, GBinPortion *portion, const vmpa2t *origin) +bool g_executable_format_include_portion(GExecutableFormat *format, GBinaryPortion *portion, const vmpa2t *origin) { + bool result; /* Bilan à retourner */ phys_t available; /* Taille totale du bianire */ const mrange_t *range; /* Emplacement de la portion */ phys_t start; /* Début de zone de la portion */ @@ -463,6 +267,8 @@ void g_executable_format_include_portion(GExecutableFormat *format, GBinPortion phys_t remaining; /* Taille maximale envisageable*/ bool truncated; /* Modification faite ? */ + result = false; + available = g_binary_content_compute_size(G_KNOWN_FORMAT(format)->content); range = g_binary_portion_get_range(portion); @@ -470,14 +276,9 @@ void g_executable_format_include_portion(GExecutableFormat *format, GBinPortion start = get_phy_addr(get_mrange_addr(range)); if (get_mrange_length(range) == 0) - { log_variadic_message(LMT_BAD_BINARY, _("The binary portion '%s' is empty and thus useless... Discarding!"), g_binary_portion_get_desc(portion)); - g_object_unref(G_OBJECT(portion)); - - } - else if (start >= available) { if (origin == NULL) @@ -489,12 +290,10 @@ void g_executable_format_include_portion(GExecutableFormat *format, GBinPortion asprintf(&msg, _("Defined binary portion '%s' is out of the file scope... Discarding!"), g_binary_portion_get_desc(portion)); - g_binary_format_add_error(G_BIN_FORMAT(format), BFE_STRUCTURE, origin, msg); + //g_binary_format_add_error(G_BIN_FORMAT(format), BFE_STRUCTURE, origin, msg); free(msg); - g_object_unref(G_OBJECT(portion)); - } else @@ -507,14 +306,12 @@ void g_executable_format_include_portion(GExecutableFormat *format, GBinPortion log_variadic_message(LMT_BAD_BINARY, _("Truncated binary portion '%s' to fit the binary content size!"), g_binary_portion_get_desc(portion)); - g_mutex_lock(&format->mutex); - - g_binary_portion_include(format->portions, portion); - - g_mutex_unlock(&format->mutex); + result = g_binary_portion_include(format->portions, portion); } + return result; + } @@ -531,18 +328,15 @@ void g_executable_format_include_portion(GExecutableFormat *format, GBinPortion * * ******************************************************************************/ -GBinPortion *g_executable_format_get_portions(GExecutableFormat *format) +GBinaryPortion *g_executable_format_get_portions(GExecutableFormat *format) { - GBinPortion *result; /* Instance à retourner */ - - g_mutex_lock(&format->mutex); + GBinaryPortion *result; /* Instance à retourner */ result = format->portions; - if (result != NULL) - g_object_ref(G_OBJECT(result)); + assert(result != NULL); - g_mutex_unlock(&format->mutex); + ref_object(result); return result; @@ -566,8 +360,11 @@ GBinPortion *g_executable_format_get_portions(GExecutableFormat *format) bool g_executable_format_translate_offset_into_vmpa(GExecutableFormat *format, phys_t off, vmpa2t *pos) { bool result; /* Bilan à retourner */ + GExecutableFormatClass *class; /* Classe de l'instance */ - result = G_EXECUTABLE_FORMAT_GET_CLASS(format)->translate_phys(format, off, pos); + class = G_EXECUTABLE_FORMAT_GET_CLASS(format); + + result = class->translate_phys(format, off, pos); return result; @@ -577,10 +374,10 @@ bool g_executable_format_translate_offset_into_vmpa(GExecutableFormat *format, p /****************************************************************************** * * * Paramètres : format = description de l'exécutable à consulter. * -* addr = adresse virtuelle à retrouver. * +* off = position physique à retrouver. * * pos = position correspondante. [OUT] * * * -* Description : Fournit l'emplacement correspondant à une adresse virtuelle. * +* Description : Fournit l'emplacement correspondant à une position physique. * * * * Retour : Bilan de l'opération. * * * @@ -588,11 +385,38 @@ bool g_executable_format_translate_offset_into_vmpa(GExecutableFormat *format, p * * ******************************************************************************/ -bool g_executable_format_translate_address_into_vmpa(GExecutableFormat *format, virt_t addr, vmpa2t *pos) +bool g_executable_format_translate_offset_into_vmpa_without_virt(const GExecutableFormat *format, phys_t off, vmpa2t *pos) +{ + init_vmpa(pos, off, VMPA_NO_VIRTUAL); + + return true; + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* off = position physique à retrouver. * +* pos = position correspondante. [OUT] * +* * +* Description : Fournit l'emplacement correspondant à une position physique. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_executable_format_translate_offset_into_vmpa_with_portions(GExecutableFormat *format, phys_t off, vmpa2t *pos) { bool result; /* Bilan à retourner */ - result = G_EXECUTABLE_FORMAT_GET_CLASS(format)->translate_virt(format, addr, pos); + if (format->portions == NULL) + result = false; + + else + result = g_binary_portion_translate_offset_into_vmpa(format->portions, off, pos); return result; @@ -602,10 +426,10 @@ bool g_executable_format_translate_address_into_vmpa(GExecutableFormat *format, /****************************************************************************** * * * Paramètres : format = description de l'exécutable à consulter. * -* name = nom de la section recherchée. * -* range = emplacement en mémoire à renseigner. [OUT] * +* addr = adresse virtuelle à retrouver. * +* pos = position correspondante. [OUT] * * * -* Description : Fournit l'emplacement d'une section donnée. * +* Description : Fournit l'emplacement correspondant à une adresse virtuelle. * * * * Retour : Bilan de l'opération. * * * @@ -613,21 +437,77 @@ bool g_executable_format_translate_address_into_vmpa(GExecutableFormat *format, * * ******************************************************************************/ -bool g_executable_format_get_section_range_by_name(const GExecutableFormat *format, const char *name, mrange_t *range) +bool g_executable_format_translate_address_into_vmpa(GExecutableFormat *format, virt_t addr, vmpa2t *pos) { bool result; /* Bilan à retourner */ GExecutableFormatClass *class; /* Classe de l'instance */ class = G_EXECUTABLE_FORMAT_GET_CLASS(format); - if (class->get_range_by_name == NULL) + result = class->translate_virt(format, addr, pos); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* addr = adresse virtuelle à retrouver. * +* pos = position correspondante. [OUT] * +* * +* Description : Fournit l'emplacement correspondant à une adresse virtuelle. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_executable_format_translate_address_into_vmpa_without_virt(const GExecutableFormat *format, virt_t addr, vmpa2t *pos) +{ + /** + * S'il n'y a pas de notion de mémoire virtuelle, positions physiques et + * adresses virtuelles se confondent. + * + * On reste néanmoins cohérent, et on n'utilise donc pas d'adresse virtuelle. + * + * Les sauts dans le code renvoient de façon transparente vers des positions + * physiques. + */ + + init_vmpa(pos, addr, VMPA_NO_VIRTUAL); + + return true; + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* addr = adresse virtuelle à retrouver. * +* pos = position correspondante. [OUT] * +* * +* Description : Fournit l'emplacement correspondant à une adresse virtuelle. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_executable_format_translate_address_into_vmpa_with_portions(GExecutableFormat *format, virt_t addr, vmpa2t *pos) +{ + bool result; /* Bilan à retourner */ + + if (format->portions == NULL) result = false; else - result = class->get_range_by_name(format, name, range); + result = g_binary_portion_translate_address_into_vmpa(format->portions, addr, pos); return result; } - -#endif diff --git a/src/format/executable.h b/src/format/executable.h index 6695b92..da71d66 100644 --- a/src/format/executable.h +++ b/src/format/executable.h @@ -25,7 +25,11 @@ #define _FORMAT_EXECUTABLE_H +#include <stdbool.h> + + #include "../glibext/helpers.h" +#include "../glibext/portion.h" @@ -37,46 +41,14 @@ DECLARE_GTYPE(GExecutableFormat, g_executable_format, G, EXECUTABLE_FORMAT); /* Indique le type d'architecture visée par le format. */ char *g_executable_format_get_target_machine(const GExecutableFormat *); - - - - -#if 0 - - -/* -#include "debuggable.h" -#include "../glibext/gbinportion.h" -*/ - - - -/* Rajoute des informations de débogage à un exécutable. */ -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_executable_format_count_debug_info(const GExecutableFormat *); - -/* Fournit un format de débogage attaché à l'exécutable. */ -GDbgFormat *g_executable_format_get_debug_info(const GExecutableFormat *, size_t); - -/* Indique le type d'architecture visée par le format. */ -//const char *g_executable_format_get_target_machine(const GExecutableFormat *); - /* Fournit l'adresse principale associée à un format. */ bool g_executable_format_get_main_address(GExecutableFormat *, vmpa2t *); -/* Enregistre une portion artificielle pour le format. */ -void g_executable_format_register_user_portion(GExecutableFormat *, GBinPortion *); - /* Procède à l'enregistrement d'une portion dans un format. */ -void g_executable_format_include_portion(GExecutableFormat *, GBinPortion *, const vmpa2t *); +bool g_executable_format_include_portion(GExecutableFormat *, GBinaryPortion *, const vmpa2t *); /* Fournit la première couche des portions composent le binaire. */ -GBinPortion *g_executable_format_get_portions(GExecutableFormat *); - -/* Fournit les espaces mémoires des portions exécutables. */ -mrange_t *g_executable_format_get_x_ranges(GExecutableFormat *, size_t *); +GBinaryPortion *g_executable_format_get_portions(GExecutableFormat *); /* Fournit l'emplacement correspondant à une position physique. */ bool g_executable_format_translate_offset_into_vmpa(GExecutableFormat *, phys_t, vmpa2t *); @@ -85,30 +57,24 @@ bool g_executable_format_translate_offset_into_vmpa(GExecutableFormat *, phys_t, bool g_executable_format_translate_address_into_vmpa(GExecutableFormat *, virt_t, vmpa2t *); -#define g_executable_format_translate_offset_into_address(fmt, off, addr) \ - ({ \ - bool __result; \ - vmpa2t __pos; \ - __result = g_executable_format_translate_offset_into_vmpa(fmt, off, &__pos); \ - *addr = get_virt_addr(&__pos); \ - __result; \ +#define g_executable_format_translate_offset_into_address(fmt, off, addr) \ + ({ \ + bool __result; \ + vmpa2t __pos; \ + __result = g_executable_format_translate_offset_into_vmpa(fmt, off, &__pos); \ + *addr = get_virt_addr(&__pos); \ + __result; \ }) -#define g_executable_format_translate_address_into_offset(fmt, addr, off) \ - ({ \ - bool __result; \ - vmpa2t __pos; \ - __result = g_executable_format_translate_address_into_vmpa(fmt, addr, &__pos); \ - *off = get_phy_addr(&__pos); \ - __result; \ +#define g_executable_format_translate_address_into_offset(fmt, addr, off) \ + ({ \ + bool __result; \ + vmpa2t __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_executable_format_get_section_range_by_name(const GExecutableFormat *, const char *, mrange_t *); - -#endif - - #endif /* _FORMAT_EXECUTABLE_H */ diff --git a/src/format/flat-int.h b/src/format/flat-int.h index 2630ef9..f858ba3 100644 --- a/src/format/flat-int.h +++ b/src/format/flat-int.h @@ -50,7 +50,7 @@ struct _GFlatFormatClass }; -/* Met en place une nouvelle instance de format de à plat. */ +/* Met en place une nouvelle instance de format à plat. */ bool g_flat_format_create(GFlatFormat *, GBinContent *, const char *, SourceEndian); diff --git a/src/format/flat.c b/src/format/flat.c index 26dd22b..c4e6edb 100644 --- a/src/format/flat.c +++ b/src/format/flat.c @@ -58,13 +58,8 @@ 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 +static bool g_flat_format_analyze(GFlatFormat *); /* Informe quant au boutisme utilisé. */ static SourceEndian g_flat_format_get_endianness(const GFlatFormat *); @@ -118,15 +113,8 @@ 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; -#endif - prgm = G_PROGRAM_FORMAT_CLASS(klass); prgm->get_endian = (program_get_endian_fc)g_flat_format_get_endianness; @@ -136,11 +124,9 @@ static void g_flat_format_class_init(GFlatFormatClass *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 + exe->translate_phys = g_executable_format_translate_offset_into_vmpa_with_portions; + exe->translate_virt = g_executable_format_translate_address_into_vmpa_with_portions; } @@ -238,8 +224,10 @@ GFlatFormat *g_flat_format_new(GBinContent *content, const char *machine, Source * * * Paramètres : format = description du format connu à consulter. * * content = contenu binaire à parcourir. * +* machine = architecture déterminée pour le code. * + endian = boutisme à observer pour les données. * * * -* Description : Met en place une nouvelle instance de format de à plat. * +* Description : Met en place une nouvelle instance de format à plat. * * * * Retour : Bilan de l'opération. * * * @@ -251,7 +239,7 @@ bool g_flat_format_create(GFlatFormat *format, GBinContent *content, const char { bool result; /* Bilan à retourner */ - result = g_known_format_create(G_KNOWN_FORMAT(format), content); + result = g_executable_format_create(G_EXECUTABLE_FORMAT(format), content); format->machine = strdup(machine); format->endian = endian; @@ -313,15 +301,9 @@ static char *g_flat_format_get_description(const GFlatFormat *format) } - - -#if 0 - /****************************************************************************** * * * Paramètres : format = format chargé dont l'analyse est lancée. * -* gid = groupe de travail dédié. * -* status = barre de statut à tenir informée. * * * * Description : Assure l'interprétation d'un format en différé. * * * @@ -331,20 +313,16 @@ static char *g_flat_format_get_description(const GFlatFormat *format) * * ******************************************************************************/ -static bool g_flat_format_analyze(GFlatFormat *format, wgroup_id_t gid, GtkStatusStack *status) +static bool g_flat_format_analyze(GFlatFormat *format) { bool result; /* Bilan à retourner */ result = true; - g_executable_format_setup_portions(G_EXECUTABLE_FORMAT(format), status); - return result; } -#endif - /****************************************************************************** * * diff --git a/src/format/known-int.h b/src/format/known-int.h index bac0c5c..75d0dab 100644 --- a/src/format/known-int.h +++ b/src/format/known-int.h @@ -36,13 +36,10 @@ 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 *); - -/* Réalise un traitement post-désassemblage. */ -typedef void (* known_complete_analysis_fc) (GKnownFormat *, wgroup_id_t, GtkStatusStack *); +typedef bool (* known_analyze_fc) (GKnownFormat *); +#if 0 /* Charge un format depuis une mémoire tampon. */ typedef bool (* load_known_fc) (GKnownFormat *, GObjectStorage *, packed_buffer_t *); @@ -68,10 +65,9 @@ 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 */ +#if 0 load_known_fc load; /* Chargement depuis un tampon */ store_known_fc store; /* Conservation dans un tampon */ #endif diff --git a/src/format/known.c b/src/format/known.c index c32a00b..bc03793 100644 --- a/src/format/known.c +++ b/src/format/known.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * format.c - support des différents formats binaires reconnus * - * Copyright (C) 2019 Cyrille Bagard + * Copyright (C) 2019-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -194,7 +194,7 @@ static void g_known_format_finalize(GKnownFormat *format) /****************************************************************************** * * -* Paramètres : format = description du format connu à consulter. * +* Paramètres : format = description du format à initialiser pleinement. * * content = contenu binaire à parcourir. * * * * Description : Met en place un nouveau contenu binaire à analyser. * @@ -301,13 +301,9 @@ char *g_known_format_get_description(const GKnownFormat *format) } -#if 0 - /****************************************************************************** * * * Paramètres : format = format chargé dont l'analyse est lancée. * -* gid = groupe de travail dédié. * -* status = barre de statut à tenir informée. * * * * Description : Assure l'interprétation d'un format en différé. * * * @@ -317,56 +313,24 @@ char *g_known_format_get_description(const GKnownFormat *format) * * ******************************************************************************/ -bool g_known_format_analyze(GKnownFormat *format, wgroup_id_t gid, GtkStatusStack *status) +bool g_known_format_analyze(GKnownFormat *format) { bool result; /* Bilan à retourner */ GKnownFormatClass *class; /* Classe de l'instance */ - handle_known_format_analysis(PGA_FORMAT_ANALYSIS_STARTED, format, gid, status); + //handle_known_format_analysis(PGA_FORMAT_ANALYSIS_STARTED, format, gid, status); class = G_KNOWN_FORMAT_GET_CLASS(format); - result = class->analyze(format, gid, status); + result = class->analyze(format); - handle_known_format_analysis(PGA_FORMAT_ANALYSIS_ENDED, format, gid, status); + //handle_known_format_analysis(PGA_FORMAT_ANALYSIS_ENDED, format, gid, status); return result; } -/****************************************************************************** -* * -* Paramètres : format = description de l'exécutable à manipuler. * -* gid = groupe de travail dédié. * -* status = barre de statut à tenir informée. * -* * -* Description : Réalise un traitement post-désassemblage. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_known_format_complete_analysis(GKnownFormat *format, wgroup_id_t gid, GtkStatusStack *status) -{ - GKnownFormatClass *class; /* Classe de l'instance */ - - handle_known_format_analysis(PGA_FORMAT_POST_ANALYSIS_STARTED, format, gid, status); - - class = G_KNOWN_FORMAT_GET_CLASS(format); - - if (class->complete != NULL) - class->complete(format, gid, status); - - handle_known_format_analysis(PGA_FORMAT_POST_ANALYSIS_ENDED, format, gid, status); - -} - -#endif - - /* ---------------------------------------------------------------------------------- */ /* CONSERVATION ET RECHARGEMENT DES DONNEES */ diff --git a/src/format/known.h b/src/format/known.h index 3da433a..41236df 100644 --- a/src/format/known.h +++ b/src/format/known.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * format.h - prototypes pour le support des différents formats binaires reconnus * - * Copyright (C) 2019 Cyrille Bagard + * Copyright (C) 2019-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -45,15 +45,8 @@ 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 +bool g_known_format_analyze(GKnownFormat *); diff --git a/src/format/program-int.h b/src/format/program-int.h index 958c6ff..1549a0a 100644 --- a/src/format/program-int.h +++ b/src/format/program-int.h @@ -35,6 +35,9 @@ /* Indique le boutisme employé par le format binaire analysé. */ typedef SourceEndian (* program_get_endian_fc) (const GProgramFormat *); +/* Fournit l'emplacement d'une section donnée. */ +typedef bool (* get_range_by_name_fc) (const GProgramFormat *, const char *, mrange_t *); + /* Format de programme générique (instance) */ struct _GProgramFormat @@ -49,10 +52,13 @@ struct _GProgramFormatClass GKnownFormatClass parent; /* A laisser en premier */ program_get_endian_fc get_endian; /* Boutisme employé */ + get_range_by_name_fc get_range_by_name; /* Emplacement de sections */ }; +/* Met en place un nouveau contenu binaire à analyser. */ +bool g_program_format_create(GProgramFormat *, GBinContent *); diff --git a/src/format/program.c b/src/format/program.c index 3624496..d44f988 100644 --- a/src/format/program.c +++ b/src/format/program.c @@ -285,8 +285,28 @@ static void g_program_format_finalize(GProgramFormat *format) } +/****************************************************************************** +* * +* Paramètres : format = description du format à initialiser pleinement. * +* content = contenu binaire à parcourir. * +* * +* Description : Met en place un nouveau contenu binaire à analyser. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_program_format_create(GProgramFormat *format, GBinContent *content) +{ + bool result; /* Bilan à retourner */ + result = g_known_format_create(G_KNOWN_FORMAT(format), content); + return result; + +} #if 0 @@ -446,6 +466,38 @@ SourceEndian g_program_format_get_endianness(const GProgramFormat *format) } +/****************************************************************************** +* * +* Paramètres : format = description du programme à consulter. * +* name = nom de la section recherchée. * +* range = emplacement en mémoire à renseigner. [OUT] * +* * +* Description : Fournit l'emplacement d'une section donnée. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_program_format_get_section_range_by_name(const GProgramFormat *format, const char *name, mrange_t *range) +{ + bool result; /* Bilan à retourner */ + GProgramFormatClass *class; /* Classe de l'instance */ + + class = G_PROGRAM_FORMAT_GET_CLASS(format); + + if (class->get_range_by_name == NULL) + result = false; + + else + result = class->get_range_by_name(format, name, range); + + return result; + +} + + #if 0 /****************************************************************************** diff --git a/src/format/program.h b/src/format/program.h index 51b7860..0eb26ae 100644 --- a/src/format/program.h +++ b/src/format/program.h @@ -25,6 +25,10 @@ #define _FORMAT_PROGRAM_H +#include <stdbool.h> + + +#include "../arch/vmpa.h" #include "../common/datatypes.h" #include "../glibext/helpers.h" @@ -38,14 +42,14 @@ 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 *); +/* Fournit l'emplacement d'une section donnée. */ +bool g_program_format_get_section_range_by_name(const GProgramFormat *, const char *, mrange_t *); #if 0 -#include <glib-object.h> -#include <stdbool.h> #include <sys/types.h> diff --git a/src/glibext/Makefile.am b/src/glibext/Makefile.am index 2d4abb8..adbec4c 100644 --- a/src/glibext/Makefile.am +++ b/src/glibext/Makefile.am @@ -9,8 +9,6 @@ noinst_LTLIBRARIES = libglibext.la libglibextui.la # configuration-int.h \ # configuration.h configuration.c \ # gbinarycursor.h gbinarycursor.c \ -# gbinportion-int.h \ -# gbinportion.h gbinportion.c \ # glinecursor-int.h \ # glinecursor.h glinecursor.c \ # gnhash.h gnhash.c \ @@ -43,6 +41,8 @@ noinst_LTLIBRARIES = libglibext.la libglibextui.la libglibext_la_SOURCES = \ chrysamarshal.h chrysamarshal.c \ helpers.h \ + portion-int.h \ + portion.h portion.c \ work-int.h \ work.h work.c \ workgroup-int.h \ diff --git a/src/glibext/portion-int.h b/src/glibext/portion-int.h index a29f53c..c044206 100644 --- a/src/glibext/portion-int.h +++ b/src/glibext/portion-int.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * binportion.h - prototypes pour la définition interne des portions de binaire + * portion-int.h - prototypes internes pour la définition interne des portions de binaire * - * Copyright (C) 2019 Cyrille Bagard + * Copyright (C) 2019-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,46 +21,49 @@ */ -#ifndef _GLIBEXT_BINPORTION_INT_H -#define _GLIBEXT_BINPORTION_INT_H +#ifndef GLIBEXT_PORTION_INT_H +#define GLIBEXT_PORTION_INT_H -#include "gbinportion.h" +#include "portion.h" /* Portion de données binaires quelconques (instance) */ -struct _GBinPortion +struct _GBinaryPortion { GObject parent; /* A laisser en premier */ - char *code; /* Code de la couleur de fond */ - -#ifdef INCLUDE_GTK_SUPPORT - cairo_surface_t *icon; /* Image de représentation */ -#endif - char *desc; /* Désignation humaine */ - char **text; /* Lignes brutes à représenter */ - size_t lcount; /* Quantité de ces lignes */ mrange_t range; /* Emplacement dans le code */ bool continued; /* Suite d'une découpe ? */ PortionAccessRights rights; /* Droits d'accès */ - GBinPortion **subs; /* Portions incluses */ + GBinaryPortion **subs; /* Portions incluses */ size_t count; /* Quantité d'inclusions */ }; /* Portion de données binaires quelconques (classe) */ -struct _GBinPortionClass +struct _GBinaryPortionClass { GObjectClass parent; /* A laisser en premier */ }; +/* Met en place une description de partie de code vierge. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_binary_portion_create(GBinaryPortion *, const vmpa2t *, phys_t); + + -#endif /* _GLIBEXT_BINPORTION_INT_H */ +#endif /* GLIBEXT_PORTION_INT_H */ diff --git a/src/glibext/portion.c b/src/glibext/portion.c index 12e12fb..e5604b6 100644 --- a/src/glibext/portion.c +++ b/src/glibext/portion.c @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * binportion.c - représentation graphique de portions de binaire + * portion.c - représentation graphique de portions de binaire * - * Copyright (C) 2013-2019 Cyrille Bagard + * Copyright (C) 2013-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,26 +21,26 @@ */ -#include "gbinportion.h" +#include "portion.h" #include <assert.h> #include <malloc.h> -#include <stdio.h> -#include <stdlib.h> +//#include <stdio.h> +//#include <stdlib.h> #include <string.h> #include <i18n.h> -#include "gbinportion-int.h" -#include "../analysis/human/asm/lang.h" +#include "portion-int.h" +//#include "../analysis/human/asm/lang.h" #include "../common/extstr.h" #include "../common/sort.h" -#include "../core/columns.h" -#include "../glibext/gbinarycursor.h" -#include "../glibext/linegen-int.h" +//#include "../core/columns.h" +//#include "../glibext/gbinarycursor.h" +//#include "../glibext/linegen-int.h" @@ -48,50 +48,16 @@ /* Initialise la classe des portions de données binaires. */ -static void g_binary_portion_class_init(GBinPortionClass *); +static void g_binary_portion_class_init(GBinaryPortionClass *); /* Initialise une instance de portion de données binaires. */ -static void g_binary_portion_init(GBinPortion *); - -/* Procède à l'initialisation de l'interface de génération. */ -static void g_binary_portion_interface_init(GLineGeneratorInterface *); +static void g_binary_portion_init(GBinaryPortion *); /* Supprime toutes les références externes. */ -static void g_binary_portion_dispose(GBinPortion *); +static void g_binary_portion_dispose(GBinaryPortion *); /* Procède à la libération totale de la mémoire. */ -static void g_binary_portion_finalize(GBinPortion *); - -#ifdef INCLUDE_GTK_SUPPORT - -/* Détermine l'aire d'une sous-portion. */ -static bool g_binary_portion_compute_sub_area(const GBinPortion *, phys_t, const GdkRectangle *, GdkRectangle *); - -#endif - - - -/* ------------------------ OFFRE DE CAPACITES DE GENERATION ------------------------ */ - - -/* Indique le nombre de ligne prêtes à être générées. */ -static size_t g_binary_portion_count_lines(const GBinPortion *); - -#ifdef INCLUDE_GTK_SUPPORT - -/* Retrouve l'emplacement correspondant à une position donnée. */ -static void g_binary_portion_compute_cursor(const GBinPortion *, gint, size_t, size_t, GLineCursor **); - -/* Détermine si le conteneur s'inscrit dans une plage donnée. */ -static int g_binary_portion_contain_cursor(const GBinPortion *, size_t, size_t, const GLineCursor *); - -#endif - -/* Renseigne sur les propriétés liées à un générateur. */ -static BufferLineFlags g_binary_portion_get_flags(const GBinPortion *, size_t, size_t); - -/* Imprime dans une ligne de rendu le contenu représenté. */ -static void g_binary_portion_print(GBinPortion *, GBufferLine *, size_t, size_t, const GBinContent *); +static void g_binary_portion_finalize(GBinaryPortion *); @@ -99,20 +65,7 @@ static void g_binary_portion_print(GBinPortion *, GBufferLine *, size_t, size_t, /* Détermine si une portion contient une adresse donnée. */ -static bool g_binary_portion_contains_vmpa(const GBinPortion *, const vmpa2t *); - -#ifdef INCLUDE_GTK_SUPPORT - -/* Recherche la portion présente à une adresse donnée. */ -static GBinPortion *g_binary_portion_find_with_area_at_addr(GBinPortion *, const vmpa2t *, GdkRectangle *); - -/* Détermine si une portion contient une position donnée. */ -static bool g_binary_portion_contains_physical(const GBinPortion *, phys_t); - -/* Détermine si une portion contient une adresse donnée. */ -static bool g_binary_portion_contains_virtual(const GBinPortion *, virt_t); - -#endif +static bool g_binary_portion_contains_vmpa(const GBinaryPortion *, const vmpa2t *); @@ -122,8 +75,7 @@ static bool g_binary_portion_contains_virtual(const GBinPortion *, virt_t); /* Indique le type défini par la GLib pour les portions de données binaires. */ -G_DEFINE_TYPE_WITH_CODE(GBinPortion, g_binary_portion, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE(G_TYPE_LINE_GENERATOR, g_binary_portion_interface_init)); +G_DEFINE_TYPE(GBinaryPortion, g_binary_portion, G_TYPE_OBJECT); /****************************************************************************** @@ -138,7 +90,7 @@ G_DEFINE_TYPE_WITH_CODE(GBinPortion, g_binary_portion, G_TYPE_OBJECT, * * ******************************************************************************/ -static void g_binary_portion_class_init(GBinPortionClass *klass) +static void g_binary_portion_class_init(GBinaryPortionClass *klass) { GObjectClass *object; /* Autre version de la classe */ @@ -163,49 +115,21 @@ static void g_binary_portion_class_init(GBinPortionClass *klass) * * ******************************************************************************/ -static void g_binary_portion_init(GBinPortion *portion) +static void g_binary_portion_init(GBinaryPortion *portion) { vmpa2t dummy; /* Coquille presque vide */ - portion->code = NULL; - -#ifdef INCLUDE_GTK_SUPPORT - portion->icon = NULL; -#endif - portion->desc = NULL; - portion->text = NULL; - portion->lcount = 0; init_vmpa(&dummy, VMPA_NO_PHYSICAL, VMPA_NO_VIRTUAL); init_mrange(&portion->range, &dummy, VMPA_NO_VIRTUAL); portion->continued = false; -} - - -/****************************************************************************** -* * -* Paramètres : iface = interface GLib à initialiser. * -* * -* Description : Procède à l'initialisation de l'interface de génération. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ + portion->rights = PAC_NONE; -static void g_binary_portion_interface_init(GLineGeneratorInterface *iface) -{ - iface->count = (linegen_count_lines_fc)g_binary_portion_count_lines; -#ifdef INCLUDE_GTK_SUPPORT - iface->compute = (linegen_compute_fc)g_binary_portion_compute_cursor; - iface->contain = (linegen_contain_fc)g_binary_portion_contain_cursor; -#endif - iface->get_flags = (linegen_get_flags_fc)g_binary_portion_get_flags; - iface->print = (linegen_print_fc)g_binary_portion_print; + portion->subs = NULL; + portion->count = 0; } @@ -222,7 +146,7 @@ static void g_binary_portion_interface_init(GLineGeneratorInterface *iface) * * ******************************************************************************/ -static void g_binary_portion_dispose(GBinPortion *portion) +static void g_binary_portion_dispose(GBinaryPortion *portion) { size_t i; /* Boucle de parcours */ @@ -246,27 +170,11 @@ static void g_binary_portion_dispose(GBinPortion *portion) * * ******************************************************************************/ -static void g_binary_portion_finalize(GBinPortion *portion) +static void g_binary_portion_finalize(GBinaryPortion *portion) { - size_t i; /* Boucle de parcours */ - - if (portion->code != NULL) - free(portion->code); - -#ifdef INCLUDE_GTK_SUPPORT - if (portion->icon != NULL) - cairo_surface_destroy(portion->icon); -#endif - if (portion->desc != NULL) free(portion->desc); - for (i = 0; i < portion->lcount; i++) - free(portion->text[i]); - - if (portion->text != NULL) - free(portion->text); - if (portion->subs != NULL) free(portion->subs); @@ -277,8 +185,7 @@ static void g_binary_portion_finalize(GBinPortion *portion) /****************************************************************************** * * -* Paramètres : code = désignation humaine de la couleur de fond. * -* addr = emplacement de la section à conserver. * +* Paramètres : addr = emplacement de la section à conserver. * * size = taille de la section à conserver. * * * * Description : Crée une description de partie de code vierge. * @@ -289,15 +196,11 @@ static void g_binary_portion_finalize(GBinPortion *portion) * * ******************************************************************************/ -GBinPortion *g_binary_portion_new(const char *code, const vmpa2t *addr, phys_t size) +GBinaryPortion *g_binary_portion_new(const vmpa2t *addr, phys_t size) { - GBinPortion *result; /* Structure à retourner */ - - result = g_object_new(G_TYPE_BIN_PORTION, NULL); + GBinaryPortion *result; /* Structure à retourner */ - result->code = strdup(code); - - init_mrange(&result->range, addr, size); + result = g_object_new(G_TYPE_BINARY_PORTION, NULL); return result; @@ -306,89 +209,60 @@ GBinPortion *g_binary_portion_new(const char *code, const vmpa2t *addr, phys_t s /****************************************************************************** * * -* Paramètres : a = premières informations à consulter. * -* b = secondes informations à consulter. * +* Paramètres : portion = instance à initialiser pleinement. * +* addr = emplacement de la section à conserver. * +* size = taille de la section à conserver. * * * -* Description : Etablit la comparaison ascendante entre deux portions. * +* Description : Met en place une description de partie de code vierge. * * * -* Retour : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b). * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -int g_binary_portion_compare(const GBinPortion **a, const GBinPortion **b) +bool g_binary_portion_create(GBinaryPortion *portion, const vmpa2t *addr, phys_t size) { - int result; /* Bilan à retourner */ - const vmpa2t *addr_a; /* Adresse de la portion 'a' */ - const vmpa2t *addr_b; /* Adresse de la portion 'b' */ + bool result; /* Bilan à retourner */ - addr_a = get_mrange_addr(&(*a)->range); - addr_b = get_mrange_addr(&(*b)->range); + result = true; - result = cmp_vmpa(addr_a, addr_b); + init_mrange(&portion->range, addr, size); return result; } -#ifdef INCLUDE_GTK_SUPPORT - - /****************************************************************************** * * -* Paramètres : portion = description de partie à mettre à jour. * -* icon = image miniature de représentation à associer. * -* * -* Description : Attribue à la portion une éventuelle image de représentation.* -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_binary_portion_set_icon(GBinPortion *portion, cairo_surface_t *icon) -{ - if (icon != NULL) - portion->icon = cairo_surface_reference(icon); - - else - portion->icon = NULL; - -} - - -/****************************************************************************** -* * -* Paramètres : portion = description de partie à consulter. * +* Paramètres : a = premières informations à consulter. * +* b = secondes informations à consulter. * * * -* Description : Fournit une éventuelle image de représentation de portion. * +* Description : Etablit la comparaison ascendante entre deux portions. * * * -* Retour : Image miniature de représentation associée. * +* Retour : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b). * * * * Remarques : - * * * ******************************************************************************/ -cairo_surface_t *g_binary_portion_get_icon(const GBinPortion *portion) +int g_binary_portion_compare(const GBinaryPortion **a, const GBinaryPortion **b) { - cairo_surface_t *result; + int result; /* Bilan à retourner */ + const vmpa2t *addr_a; /* Adresse de la portion 'a' */ + const vmpa2t *addr_b; /* Adresse de la portion 'b' */ - result = portion->icon; + addr_a = get_mrange_addr(&(*a)->range); + addr_b = get_mrange_addr(&(*b)->range); - if (result != NULL) - cairo_surface_reference(result); + result = cmp_vmpa(addr_a, addr_b); return result; } -#endif - - /****************************************************************************** * * * Paramètres : portion = description de partie à mettre à jour. * @@ -402,26 +276,11 @@ cairo_surface_t *g_binary_portion_get_icon(const GBinPortion *portion) * * ******************************************************************************/ -void g_binary_portion_set_desc(GBinPortion *portion, const char *desc) +void g_binary_portion_set_desc(GBinaryPortion *portion, const char *desc) { - size_t i; /* Boucle de parcours */ - GCodingLanguage *lang; /* Langage de sortie préféré */ - if (portion->desc != NULL) - { free(portion->desc); - for (i = 0; i < portion->lcount; i++) - free(portion->text[i]); - - if (portion->text != NULL) - { - free(portion->text); - portion->text = NULL; - } - - } - if (desc == NULL) portion->desc = NULL; @@ -432,40 +291,6 @@ void g_binary_portion_set_desc(GBinPortion *portion, const char *desc) if (portion->continued) portion->desc = stradd(portion->desc, _(" (continued)")); - /* Constitution du rendu */ - - portion->text = calloc(5, sizeof(char *)); - portion->lcount = 5; - - portion->text[0] = strdup("======================================================"); - portion->text[1] = strdup(""); - - asprintf(&portion->text[2], "%s (%s%s%s%s)", portion->desc, _("rights: "), - portion->rights & PAC_READ ? "r" : "-", - portion->rights & PAC_WRITE ? "w" : "-", - portion->rights & PAC_EXEC ? "x" : "-"); - - portion->text[3] = strdup(""); - portion->text[4] = strdup("======================================================"); - - /* Ajout de la touche "commentaires" */ - - lang = g_asm_language_new(); - - g_coding_language_encapsulate_comments(lang, &portion->text, &portion->lcount); - - g_object_unref(G_OBJECT(lang)); - - /* Ajout de deux bordures vides */ - - portion->lcount += 2; - portion->text = realloc(portion->text, portion->lcount * sizeof(char *)); - - memmove(&portion->text[1], &portion->text[0], (portion->lcount - 2) * sizeof(char *)); - - portion->text[0] = NULL; - portion->text[portion->lcount - 1] = NULL; - } } @@ -483,7 +308,7 @@ void g_binary_portion_set_desc(GBinPortion *portion, const char *desc) * * ******************************************************************************/ -const char *g_binary_portion_get_desc(const GBinPortion *portion) +const char *g_binary_portion_get_desc(const GBinaryPortion *portion) { return portion->desc; @@ -502,7 +327,7 @@ const char *g_binary_portion_get_desc(const GBinPortion *portion) * * ******************************************************************************/ -const mrange_t *g_binary_portion_get_range(const GBinPortion *portion) +const mrange_t *g_binary_portion_get_range(const GBinaryPortion *portion) { return &portion->range; @@ -521,7 +346,7 @@ const mrange_t *g_binary_portion_get_range(const GBinPortion *portion) * * ******************************************************************************/ -bool g_binary_portion_limit_range(GBinPortion *portion, phys_t max) +bool g_binary_portion_limit_range(GBinaryPortion *portion, phys_t max) { bool result; /* Bilan à retourner */ phys_t current; /* Taille courante */ @@ -552,7 +377,7 @@ bool g_binary_portion_limit_range(GBinPortion *portion, phys_t max) * * ******************************************************************************/ -void g_binary_portion_mark_as_continued(GBinPortion *portion, bool continued) +void g_binary_portion_mark_as_continued(GBinaryPortion *portion, bool continued) { portion->continued = continued; @@ -571,7 +396,7 @@ void g_binary_portion_mark_as_continued(GBinPortion *portion, bool continued) * * ******************************************************************************/ -bool g_binary_portion_is_continuation(const GBinPortion *portion) +bool g_binary_portion_is_continuation(const GBinaryPortion *portion) { return portion->continued; @@ -591,7 +416,7 @@ bool g_binary_portion_is_continuation(const GBinPortion *portion) * * ******************************************************************************/ -void g_binary_portion_set_rights(GBinPortion *portion, PortionAccessRights rights) +void g_binary_portion_set_rights(GBinaryPortion *portion, PortionAccessRights rights) { portion->rights = rights; @@ -610,199 +435,13 @@ void g_binary_portion_set_rights(GBinPortion *portion, PortionAccessRights right * * ******************************************************************************/ -PortionAccessRights g_binary_portion_get_rights(const GBinPortion *portion) +PortionAccessRights g_binary_portion_get_rights(const GBinaryPortion *portion) { return portion->rights; } -#ifdef INCLUDE_GTK_SUPPORT - - -/****************************************************************************** -* * -* Paramètres : portion = description de partie à mettre à jour. * -* tooltip = astuce à compléter. [OUT] * -* * -* Description : Prépare une astuce concernant une portion pour son affichage.* -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_binary_portion_query_tooltip(GBinPortion *portion, GtkTooltip *tooltip) -{ - char *markup; /* Description à construire */ - VMPA_BUFFER(value); /* Traduction en texte */ - - /* Nom */ - - if (portion->desc != NULL) - { - markup = strdup("<b>"); - markup = stradd(markup, portion->desc); - markup = stradd(markup, "</b>\n"); - markup = stradd(markup, "\n"); - - } - else markup = strdup(""); - - markup = stradd(markup, "taille : "); - mrange_length_to_string(&portion->range, MDS_UNDEFINED, value, NULL); - markup = stradd(markup, value); - markup = stradd(markup, "\n"); - - /* Localisation */ - - markup = stradd(markup, "<b>"); - markup = stradd(markup, _("Localisation")); - markup = stradd(markup, "</b>\n"); - - markup = stradd(markup, _("physical: from ")); - - mrange_phys_to_string(&portion->range, MDS_UNDEFINED, true, value, NULL); - markup = stradd(markup, value); - markup = stradd(markup, _(" to ")); - mrange_phys_to_string(&portion->range, MDS_UNDEFINED, false, value, NULL); - markup = stradd(markup, value); - markup = stradd(markup, "\n"); - - markup = stradd(markup, _("memory: from ")); - - mrange_virt_to_string(&portion->range, MDS_UNDEFINED, true, value, NULL); - markup = stradd(markup, value); - markup = stradd(markup, _(" to ")); - mrange_virt_to_string(&portion->range, MDS_UNDEFINED, false, value, NULL); - markup = stradd(markup, value); - - markup = stradd(markup, "\n\n"); - - /* Droits d'accès */ - - markup = stradd(markup, "<b>"); - markup = stradd(markup, _("Rights")); - markup = stradd(markup, "</b>\n"); - - snprintf(value, 2 * VMPA_MAX_SIZE, "%s%s%s", - portion->rights & PAC_READ ? "r" : "-", - portion->rights & PAC_WRITE ? "w" : "-", - portion->rights & PAC_EXEC ? "x" : "-"); - - markup = stradd(markup, value); - - /* Impression finale */ - - gtk_tooltip_set_markup(tooltip, markup); - free(markup); - -} - - -#ifdef INCLUDE_GTK_SUPPORT - - -/****************************************************************************** -* * -* Paramètres : portion = portion mère à consulter. * -* full = taille totale de la couche parente. * -* area = étendue de représentation de la portion mère. * -* sub_area = étendue de représentation de la portion fille. * -* * -* Description : Détermine l'aire d'une sous-portion. * -* * -* Retour : true si la sous-surface a été calculée correctement. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_binary_portion_compute_sub_area(const GBinPortion *portion, phys_t full, const GdkRectangle *area, GdkRectangle *sub_area) -{ - phys_t length; /* Taille de la portion */ - phys_t start; /* Position de départ */ - - length = get_mrange_length(&portion->range); - - /* On saute les portions comme le segment GNU_STACK... */ - if (length == 0) return false; - - start = get_phy_addr(get_mrange_addr(&portion->range)); - - sub_area->y = area->y; - sub_area->height = area->height; - - sub_area->x = area->x + (start * area->width) / full; - sub_area->width = (length * area->width) / full; - - return true; - -} - - -#endif - - -/****************************************************************************** -* * -* Paramètres : portion = description de partie à consulter. * -* context = contexte graphique associé à la procédure. * -* cr = contexte graphique pour le dessin. * -* area = étendue mise à disposition. * -* * -* Description : Représente la portion sur une bande dédiée. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_binary_portion_draw(const GBinPortion *portion, GtkStyleContext *context, cairo_t *cr, const GdkRectangle *area) -{ - phys_t full; /* Espace total représenté */ - size_t i; /* Boucle de parcours */ - GBinPortion *sub; /* Portion incluse à montrer */ - GdkRectangle sub_area; /* Etendue d'une sous-portion */ - - /* Dessin de la portion courante */ - - cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE); - - gtk_style_context_save(context); - - if (portion->code != NULL) - gtk_style_context_add_class(context, portion->code); - - gtk_render_background(context, cr, area->x, area->y, area->width, area->height); - - gtk_render_frame(context, cr, area->x, area->y, area->width, area->height); - - gtk_style_context_restore(context); - - /* Dessin des portions contenues */ - - full = get_mrange_length(&portion->range); - - for (i = 0; i < portion->count; i++) - { - sub = portion->subs[i]; - - if (!g_binary_portion_compute_sub_area(sub, full, area, &sub_area)) - continue; - - g_binary_portion_draw(sub, context, cr, &sub_area); - - } - -} - - -#endif - - /****************************************************************************** * * * Paramètres : portion = portion principale à compléter. * @@ -810,14 +449,15 @@ void g_binary_portion_draw(const GBinPortion *portion, GtkStyleContext *context, * * * Description : Procède à l'inclusion d'une portion dans une autre. * * * -* Retour : - * +* Retour : Bilan de l'opération : true si inclusion, false sinon. * * * * Remarques : - * * * ******************************************************************************/ -void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) +bool g_binary_portion_include(GBinaryPortion *portion, GBinaryPortion *sub) { + bool result; /* Bilan à retourner */ bool found; /* Zone d'accueil trouvée ? */ size_t best; /* Meilleur point d'insertion */ size_t missed; /* Indice de zone à déplacer */ @@ -825,11 +465,11 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) vmpa2t end; /* Fin de la zone commune */ phys_t overlapping; /* Taille de la zone commune */ bool continued; /* Suite d'une découpe ? */ - GBinPortion *left_part; /* Partie intégrable */ + GBinaryPortion *left_part; /* Partie intégrable */ vmpa2t start; /* Départ de la seconde partie */ - GBinPortion *right_part; /* Partie restante */ + GBinaryPortion *right_part; /* Partie restante */ - int g_binary_portion_is_included(const GBinPortion **a, const GBinPortion **b) + int g_binary_portion_is_included(const GBinaryPortion **a, const GBinaryPortion **b) { int result; /* Bilan à retourner */ @@ -839,7 +479,7 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) } - found = bsearch_index(&sub, portion->subs, portion->count, sizeof(GBinPortion *), + found = bsearch_index(&sub, portion->subs, portion->count, sizeof(GBinaryPortion *), (__compar_fn_t)g_binary_portion_is_included, &best); if (!found) @@ -879,7 +519,7 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) * */ - int g_binary_portion_track_missed_inclusion(const GBinPortion **a, const GBinPortion **b) + int g_binary_portion_track_missed_inclusion(const GBinaryPortion **a, const GBinaryPortion **b) { int result; /* Bilan à retourner */ @@ -891,14 +531,15 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) do { - found = bsearch_index(&sub, portion->subs, portion->count, sizeof(GBinPortion *), + found = bsearch_index(&sub, portion->subs, portion->count, sizeof(GBinaryPortion *), (__compar_fn_t)g_binary_portion_track_missed_inclusion, &missed); if (found) { - g_binary_portion_include(sub, portion->subs[missed]); + result = g_binary_portion_include(sub, portion->subs[missed]); + assert(result); - portion->subs = _qdelete(portion->subs, &portion->count, sizeof(GBinPortion *), missed); + portion->subs = _qdelete(portion->subs, &portion->count, sizeof(GBinaryPortion *), missed); } @@ -916,7 +557,7 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) * de découper la portion qui déborde. */ - int g_binary_portion_track_partial_inclusion(const GBinPortion **a, const GBinPortion **b) + int g_binary_portion_track_partial_inclusion(const GBinaryPortion **a, const GBinaryPortion **b) { int result; /* Bilan à retourner */ @@ -926,7 +567,7 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) } - found = bsearch_index(&sub, portion->subs, portion->count, sizeof(GBinPortion *), + found = bsearch_index(&sub, portion->subs, portion->count, sizeof(GBinaryPortion *), (__compar_fn_t)g_binary_portion_track_partial_inclusion, &best); if (found) @@ -940,7 +581,7 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) /* Partie contenue */ - left_part = g_binary_portion_new(sub->code, get_mrange_addr(&sub->range), overlapping); + left_part = g_binary_portion_new(get_mrange_addr(&sub->range), overlapping); g_binary_portion_set_desc(left_part, sub->desc); g_binary_portion_mark_as_continued(left_part, continued); @@ -958,7 +599,7 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) copy_vmpa(&start, get_mrange_addr(&sub->range)); advance_vmpa(&start, overlapping); - right_part = g_binary_portion_new(sub->code, &start, get_mrange_length(&sub->range) - overlapping); + right_part = g_binary_portion_new(&start, get_mrange_length(&sub->range) - overlapping); if (!continued) g_binary_portion_mark_as_continued(right_part, true); @@ -972,22 +613,34 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) /* Inclusions des parties */ - g_binary_portion_include(portion, left_part); - g_binary_portion_include(portion, right_part); + result = g_binary_portion_include(portion, left_part); - g_object_unref(G_OBJECT(sub)); + if (result) + result = g_binary_portion_include(portion, right_part); + + unref_object(left_part); + unref_object(right_part); } else - portion->subs = qinsert(portion->subs, &portion->count, sizeof(GBinPortion *), + { + ref_object(sub); + + portion->subs = qinsert(portion->subs, &portion->count, sizeof(GBinaryPortion *), (__compar_fn_t)g_binary_portion_compare, &sub); + result = true; + + } + } /* Poursuite de l'inclusion dans la sous-portion adaptée... */ else - g_binary_portion_include(portion->subs[best], sub); + result = g_binary_portion_include(portion->subs[best], sub); + + return result; } @@ -1006,11 +659,11 @@ void g_binary_portion_include(GBinPortion *portion, GBinPortion *sub) * * ******************************************************************************/ -bool g_binary_portion_visit(GBinPortion *portion, visit_portion_fc visitor, void *data) +bool g_binary_portion_visit(GBinaryPortion *portion, visit_portion_fc visitor, void *data) { bool result; /* Etat à retourner */ - bool visit_portion(GBinPortion *p, GBinPortion *pp) + bool visit_portion(GBinaryPortion *p, GBinaryPortion *pp) { bool ret; /* Etat à retourner */ size_t i; /* Boucle de parcours */ @@ -1043,253 +696,10 @@ bool g_binary_portion_visit(GBinPortion *portion, visit_portion_fc visitor, void /* ---------------------------------------------------------------------------------- */ -/* OFFRE DE CAPACITES DE GENERATION */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : portion = générateur à consulter. * -* * -* Description : Indique le nombre de ligne prêtes à être générées. * -* * -* Retour : Nombre de lignes devant apparaître au final. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static size_t g_binary_portion_count_lines(const GBinPortion *portion) -{ - return portion->lcount; - -} - - -#ifdef INCLUDE_GTK_SUPPORT - - -/****************************************************************************** -* * -* Paramètres : portion = générateur à consulter. * -* x = position géographique sur la ligne concernée. * -* index = indice de cette même ligne dans le tampon global. * -* repeat = indice d'utilisations successives du générateur. * -* cursor = emplacement à constituer. [OUT] * -* * -* Description : Retrouve l'emplacement correspondant à une position donnée. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_binary_portion_compute_cursor(const GBinPortion *portion, gint x, size_t index, size_t repeat, GLineCursor **cursor) -{ - *cursor = g_binary_cursor_new(); - - g_binary_cursor_update(G_BINARY_CURSOR(*cursor), get_mrange_addr(&portion->range)); - -} - - -/****************************************************************************** -* * -* Paramètres : portion = générateur à consulter. * -* index = indice de cette même ligne dans le tampon global. * -* repeat = indice d'utilisations successives du générateur. * -* cursor = emplacement à analyser. * -* * -* Description : Détermine si le conteneur s'inscrit dans une plage donnée. * -* * -* Retour : Bilan de la détermination, utilisable en comparaisons. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static int g_binary_portion_contain_cursor(const GBinPortion *portion, size_t index, size_t repeat, const GLineCursor *cursor) -{ - int result; /* Conclusion à retourner */ - vmpa2t addr; /* Autre emplacement à comparer*/ - - assert(G_IS_BINARY_CURSOR(cursor)); - - g_binary_cursor_retrieve(G_BINARY_CURSOR(cursor), &addr); - - result = cmp_vmpa(&addr, get_mrange_addr(&portion->range)); - - return result; - -} - - -#endif - - -/****************************************************************************** -* * -* Paramètres : portion = générateur à consulter. * -* index = indice de cette même ligne dans le tampon global. * -* repeat = indice d'utilisations successives du générateur. * -* * -* Description : Renseigne sur les propriétés liées à un générateur. * -* * -* Retour : Propriétés particulières associées. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static BufferLineFlags g_binary_portion_get_flags(const GBinPortion *portion, size_t index, size_t repeat) -{ - return (repeat == 0 ? BLF_WIDTH_MANAGER : BLF_NONE); - -} - - -/****************************************************************************** -* * -* Paramètres : portion = générateur à utiliser pour l'impression. * -* line = ligne de rendu à compléter. * -* index = indice de cette même ligne dans le tampon global. * -* repeat = indice d'utilisations successives du générateur. * -* content = éventuel contenu binaire brut à imprimer. * -* * -* Description : Imprime dans une ligne de rendu le contenu représenté. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_binary_portion_print(GBinPortion *portion, GBufferLine *line, size_t index, size_t repeat, const GBinContent *content) -{ - assert(repeat < portion->lcount); - - g_buffer_line_fill_phys(line, DLC_PHYSICAL, MDS_32_BITS_UNSIGNED, get_mrange_addr(&portion->range)); - - g_buffer_line_fill_virt(line, DLC_VIRTUAL, MDS_32_BITS_UNSIGNED, get_mrange_addr(&portion->range)); - - if (portion->text[repeat] != NULL) - { - g_buffer_line_start_merge_at(line, DLC_ASSEMBLY_LABEL); - - g_buffer_line_append_text(line, DLC_ASSEMBLY_LABEL, SL(portion->text[repeat]), RTT_COMMENT, NULL); - - } - -} - - - -/* ---------------------------------------------------------------------------------- */ /* PARCOURS D'ENSEMBLES DE PORTIONS */ /* ---------------------------------------------------------------------------------- */ -#ifdef INCLUDE_GTK_SUPPORT - - -/****************************************************************************** -* * -* Paramètres : portion = couche de portions à parcourir pour les recherches.* -* * -* Description : Compte le nombre de portions présentes dans une arborescence.* -* * -* Retour : Quantité de portions présentes. * -* * -* Remarques : - * -* * -******************************************************************************/ - -size_t g_binary_portion_count(const GBinPortion *portion) -{ - size_t result; /* Quantité à retourner */ - - - size_t measure_portion_size(const GBinPortion *root) - { - size_t count; /* Nombre de trouvailles */ - size_t i; /* Boucle de parcours */ - - count = 1; - - for (i = 0; i < root->count; i++) - count += measure_portion_size(root->subs[i]); - - return count; - - } - - - result = measure_portion_size(portion); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : portion = couche de portions à parcourir pour les recherches.* -* x = abscisse du point de recherche. * -* area = étendue de portion mère, puis celle trouvée. [OUT] * -* * -* Description : Recherche la portion présente à un point donné. * -* * -* Retour : Portion trouvée à l'endroit indiqué. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GBinPortion *g_binary_portion_find_at_pos(GBinPortion *portion, gint x, GdkRectangle *area) -{ - GBinPortion *result; /* Portion à retourner */ - phys_t full; /* Espace total représenté */ - size_t i; /* Boucle de parcours */ - GBinPortion *sub; /* Portion incluse à traiter */ - GdkRectangle sub_area; /* Etendue d'une sous-portion */ - - result = NULL; - - full = get_mrange_length(&portion->range); - - for (i = 0; i < portion->count && result == NULL; i++) - { - sub = portion->subs[i]; - - if (!g_binary_portion_compute_sub_area(sub, full, area, &sub_area)) - continue; - - if (sub_area.x <= x && x < (sub_area.x + sub_area.width)) - { - result = g_binary_portion_find_at_pos(sub, x, &sub_area); - - if (result != NULL) - *area = sub_area; - - } - - } - - if (result == NULL) - { - result = portion; - g_object_ref(G_OBJECT(result)); - } - - return result; - -} - - -#endif - - /****************************************************************************** * * * Paramètres : portion = portion mère à consulter. * @@ -1303,7 +713,7 @@ GBinPortion *g_binary_portion_find_at_pos(GBinPortion *portion, gint x, GdkRecta * * ******************************************************************************/ -static bool g_binary_portion_contains_vmpa(const GBinPortion *portion, const vmpa2t *addr) +static bool g_binary_portion_contains_vmpa(const GBinaryPortion *portion, const vmpa2t *addr) { bool result; /* Bilan à retourner */ const mrange_t *range; /* Emplacement de portion */ @@ -1338,16 +748,16 @@ static bool g_binary_portion_contains_vmpa(const GBinPortion *portion, const vmp * * ******************************************************************************/ -GBinPortion *g_binary_portion_find_at_addr(GBinPortion *portion, const vmpa2t *addr) +GBinaryPortion *g_binary_portion_find_at_addr(GBinaryPortion *portion, const vmpa2t *addr) { - GBinPortion *result; /* Portion à retourner */ - phys_t full; /* Espace total représenté */ - size_t i; /* Boucle de parcours #1 */ - GBinPortion *sub; /* Portion incluse à traiter */ + GBinaryPortion *result; /* Portion à retourner */ + size_t i; /* Boucle de parcours */ + GBinaryPortion *sub; /* Portion incluse à traiter */ result = NULL; - full = get_mrange_length(&portion->range); + if (!g_binary_portion_contains_vmpa(portion, addr)) + goto done; for (i = 0; i < portion->count && result == NULL; i++) { @@ -1363,65 +773,10 @@ GBinPortion *g_binary_portion_find_at_addr(GBinPortion *portion, const vmpa2t *a if (result == NULL) { result = portion; - g_object_ref(G_OBJECT(result)); + ref_object(result); } - return result; - -} - - -#ifdef INCLUDE_GTK_SUPPORT - - -/****************************************************************************** -* * -* Paramètres : portion = couche de portions à parcourir pour les recherches.* -* addr = adresse du point de recherche. * -* area = étendue de portion mère, puis celle trouvée. [OUT] * -* * -* Description : Recherche la portion présente à une adresse donnée. * -* * -* Retour : Portion trouvée à l'endroit indiqué. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GBinPortion *g_binary_portion_find_with_area_at_addr(GBinPortion *portion, const vmpa2t *addr, GdkRectangle *area) -{ - GBinPortion *result; /* Portion à retourner */ - phys_t full; /* Espace total représenté */ - size_t i; /* Boucle de parcours #1 */ - GBinPortion *sub; /* Portion incluse à traiter */ - GdkRectangle sub_area; /* Etendue d'une sous-portion */ - - result = NULL; - - full = get_mrange_length(&portion->range); - - for (i = 0; i < portion->count && result == NULL; i++) - { - sub = portion->subs[i]; - - if (!g_binary_portion_contains_vmpa(sub, addr)) - continue; - - if (!g_binary_portion_compute_sub_area(sub, full, area, &sub_area)) - continue; - - result = g_binary_portion_find_with_area_at_addr(sub, addr, &sub_area); - - if (result != NULL) - *area = sub_area; - - } - - if (result == NULL) - { - result = portion; - g_object_ref(G_OBJECT(result)); - } + done: return result; @@ -1430,114 +785,6 @@ static GBinPortion *g_binary_portion_find_with_area_at_addr(GBinPortion *portion /****************************************************************************** * * -* Paramètres : root = couche de portions à parcourir pour les recherches. * -* x = abscisse du point de recherche. * -* area = étendue de représentation de la portion mère. * -* addr = adresse correspondante. [OUT] * -* * -* Description : Fournit la position correspondant à une adresse donnée. * -* * -* Retour : Succès de la traduction. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool get_binary_portion_addr_from_pos(GBinPortion *root, gint x, const GdkRectangle *area, vmpa2t *addr) -{ - GdkRectangle owner_area; /* Aire de contenance */ - GBinPortion *owner; /* Conteneur propriétaire */ - - owner_area = *area; - - owner = g_binary_portion_find_at_pos(root, x, &owner_area); - if (owner == NULL) return false; - - copy_vmpa(addr, get_mrange_addr(&owner->range)); - - advance_vmpa(addr, (get_mrange_length(&owner->range) * (x - owner_area.x)) / owner_area.width); - - g_object_unref(G_OBJECT(owner)); - - return true; - -} - - -/****************************************************************************** -* * -* Paramètres : root = couche de portions à parcourir pour les recherches. * -* addr = adresse du point de recherche. * -* area = étendue de représentation de la portion mère. * -* x = position correspondante. [OUT] * -* * -* Description : Fournit l'adresse correspondant à une position donnée. * -* * -* Retour : Succès de la traduction. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool get_binary_portion_pos_from_addr(GBinPortion *root, const vmpa2t *addr, const GdkRectangle *area, gint *x) -{ - GdkRectangle owner_area; /* Aire de contenance */ - GBinPortion *owner; /* Conteneur propriétaire */ - phys_t diff; /* Décalage à appliquer */ - - owner_area = *area; - - owner = g_binary_portion_find_with_area_at_addr(root, addr, &owner_area); - if (owner == NULL) return false; - - diff = compute_vmpa_diff(addr, get_mrange_addr(&owner->range)); - - *x = owner_area.x + (diff * owner_area.width) / get_mrange_length(&owner->range); - - g_object_unref(G_OBJECT(owner)); - - return true; - -} - - -/****************************************************************************** -* * -* Paramètres : layer = couche de portions à consulter. * -* x = abscisse du point de recherche. * -* y = ordonnée du point de recherche. * -* area = étendue de représentation de la portion mère. * -* tooltip = astuce à compléter. [OUT] * -* * -* Description : Prépare une astuce concernant une portion pour son affichage.* -* * -* Retour : TRUE pour valider l'affichage. * -* * -* Remarques : - * -* * -******************************************************************************/ - -gboolean query_tooltip_for_binary_portion(GBinPortion *root, gint x, gint y, const GdkRectangle *area, GtkTooltip *tooltip) -{ - GBinPortion *selected; /* Portion à décrire ici */ - - selected = g_binary_portion_find_at_pos(root, x, (GdkRectangle []) { *area }); - if (selected == NULL) return FALSE; - - g_binary_portion_query_tooltip(selected, tooltip); - - g_object_unref(G_OBJECT(selected)); - - return TRUE; - -} - - -#endif - - -/****************************************************************************** -* * * Paramètres : portion = portion mère à consulter. * * off = position physique du point de recherche. * * * @@ -1549,7 +796,7 @@ gboolean query_tooltip_for_binary_portion(GBinPortion *root, gint x, gint y, con * * ******************************************************************************/ -static bool g_binary_portion_contains_physical(const GBinPortion *portion, phys_t off) +static bool g_binary_portion_contains_physical(const GBinaryPortion *portion, phys_t off) { bool result; /* Bilan à retourner */ const mrange_t *range; /* Emplacement de portion */ @@ -1583,11 +830,11 @@ static bool g_binary_portion_contains_physical(const GBinPortion *portion, phys_ * * ******************************************************************************/ -bool g_binary_portion_translate_offset_into_vmpa(const GBinPortion *portion, phys_t off, vmpa2t *pos) +bool g_binary_portion_translate_offset_into_vmpa(const GBinaryPortion *portion, phys_t off, vmpa2t *pos) { bool result; /* Bilan à retourner */ size_t i; /* Boucle de parcours #1 */ - GBinPortion *sub; /* Portion incluse à traiter */ + GBinaryPortion *sub; /* Portion incluse à traiter */ const mrange_t *range; /* Emplacement de portion */ const vmpa2t *addr; /* Départ de la portion */ @@ -1643,7 +890,7 @@ bool g_binary_portion_translate_offset_into_vmpa(const GBinPortion *portion, phy * * ******************************************************************************/ -static bool g_binary_portion_contains_virtual(const GBinPortion *portion, virt_t virt) +static bool g_binary_portion_contains_virtual(const GBinaryPortion *portion, virt_t virt) { bool result; /* Bilan à retourner */ const mrange_t *range; /* Emplacement de portion */ @@ -1677,11 +924,11 @@ static bool g_binary_portion_contains_virtual(const GBinPortion *portion, virt_t * * ******************************************************************************/ -bool g_binary_portion_translate_address_into_vmpa(const GBinPortion *portion, virt_t virt, vmpa2t *pos) +bool g_binary_portion_translate_address_into_vmpa(const GBinaryPortion *portion, virt_t virt, vmpa2t *pos) { bool result; /* Bilan à retourner */ size_t i; /* Boucle de parcours #1 */ - GBinPortion *sub; /* Portion incluse à traiter */ + GBinaryPortion *sub; /* Portion incluse à traiter */ const mrange_t *range; /* Emplacement de portion */ const vmpa2t *addr; /* Départ de la portion */ diff --git a/src/glibext/portion.h b/src/glibext/portion.h index ea4b4aa..88d69b6 100644 --- a/src/glibext/portion.h +++ b/src/glibext/portion.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * binportion.h - prototypes pour la représentation graphique de portions de binaire + * portion.h - prototypes pour la représentation graphique de portions de binaire * - * Copyright (C) 2013-2019 Cyrille Bagard + * Copyright (C) 2013-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,120 +21,70 @@ */ -#ifndef _GLIBEXT_BINPORTION_H -#define _GLIBEXT_BINPORTION_H +#ifndef _GLIBEXT_PORTION_H +#define _GLIBEXT_PORTION_H -#include <glib-object.h> #include <stdbool.h> -#ifdef INCLUDE_GTK_SUPPORT -# include <gtk/gtk.h> -#endif +#include "helpers.h" #include "../arch/vmpa.h" -#include "../common/fnv1a.h" /* ------------------------------- PORTION DE BINAIRE ------------------------------- */ -/** - * Couleurs de représentation. - */ - -#define BPC_RAW "binportion-raw" -#define BPC_CODE "binportion-code" -#define BPC_DATA "binportion-data" -#define BPC_DATA_RO "binportion-data-ro" -#define BPC_DISASS_ERROR "binportion-disassembly-error" - - -#define G_TYPE_BIN_PORTION (g_binary_portion_get_type()) -#define G_BIN_PORTION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BIN_PORTION, GBinPortion)) -#define G_IS_BIN_PORTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BIN_PORTION)) -#define G_BIN_PORTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BIN_PORTION, GBinPortionClass)) -#define G_IS_BIN_PORTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BIN_PORTION)) -#define G_BIN_PORTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BIN_PORTION, GBinPortionClass)) - - -/* Portion de données binaires quelconques (instance) */ -typedef struct _GBinPortion GBinPortion; - -/* Portion de données binaires quelconques (classe) */ -typedef struct _GBinPortionClass GBinPortionClass; - - -/* Droits d'accès à une portion */ -typedef enum _PortionAccessRights -{ - PAC_NONE = (0 << 0), /* Aucun */ - PAC_READ = (1 << 0), /* Lecture */ - PAC_WRITE = (1 << 1), /* Ecriture */ - PAC_EXEC = (1 << 2) /* Exécution */ - -} PortionAccessRights; +#define G_TYPE_BINARY_PORTION (g_binary_portion_get_type()) +DECLARE_GTYPE(GBinaryPortion, g_binary_portion, G, BINARY_PORTION); -#define PAC_ALL ((PortionAccessRights)(PAC_READ | PAC_WRITE | PAC_EXEC)) - - -/* Indique le type défini par la GLib pour les portions de données binaires. */ -GType g_binary_portion_get_type(void); /* Crée une description de partie de code vierge. */ -GBinPortion *g_binary_portion_new(const char *, const vmpa2t *, phys_t); +GBinaryPortion *g_binary_portion_new(const vmpa2t *, phys_t); /* Etablit la comparaison ascendante entre deux portions. */ -int g_binary_portion_compare(const GBinPortion **, const GBinPortion **); - -#ifdef INCLUDE_GTK_SUPPORT - -/* Attribue à la portion une éventuelle image de représentation. */ -void g_binary_portion_set_icon(GBinPortion *, cairo_surface_t *); - -/* Fournit une éventuelle image de représentation de portion. */ -cairo_surface_t *g_binary_portion_get_icon(const GBinPortion *); - -#endif +int g_binary_portion_compare(const GBinaryPortion **, const GBinaryPortion **); /* Attribue une description humaine à une partie de code. */ -void g_binary_portion_set_desc(GBinPortion *, const char *); +void g_binary_portion_set_desc(GBinaryPortion *, const char *); /* Fournit la description attribuée à une partie de code. */ -const char *g_binary_portion_get_desc(const GBinPortion *); +const char *g_binary_portion_get_desc(const GBinaryPortion *); /* Fournit l'emplacement d'une partie de code binaire. */ -const mrange_t *g_binary_portion_get_range(const GBinPortion *); +const mrange_t *g_binary_portion_get_range(const GBinaryPortion *); /* Assure qu'une portion ne dépasse pas une position donnée. */ -bool g_binary_portion_limit_range(GBinPortion *, phys_t); +bool g_binary_portion_limit_range(GBinaryPortion *, phys_t); /* Définit la nature de la portion en terme d'originalité. */ -void g_binary_portion_mark_as_continued(GBinPortion *, bool); +void g_binary_portion_mark_as_continued(GBinaryPortion *, bool); /* Indique la nature de la portion en terme d'originalité. */ -bool g_binary_portion_is_continuation(const GBinPortion *); - -/* Définit les droits associés à une partie de code. */ -void g_binary_portion_set_rights(GBinPortion *, PortionAccessRights); +bool g_binary_portion_is_continuation(const GBinaryPortion *); -/* Fournit les droits associés à une partie de code. */ -PortionAccessRights g_binary_portion_get_rights(const GBinPortion *); +/* Droits d'accès à une portion */ +typedef enum _PortionAccessRights +{ + PAC_NONE = (0 << 0), /* Aucun */ + PAC_READ = (1 << 0), /* Lecture */ + PAC_WRITE = (1 << 1), /* Ecriture */ + PAC_EXEC = (1 << 2) /* Exécution */ -#ifdef INCLUDE_GTK_SUPPORT +} PortionAccessRights; -/* Prépare une astuce concernant une portion pour son affichage. */ -void g_binary_portion_query_tooltip(GBinPortion *, GtkTooltip *); +#define PAC_ALL ((PortionAccessRights)(PAC_READ | PAC_WRITE | PAC_EXEC)) -/* Représente la portion sur une bande dédiée. */ -void g_binary_portion_draw(const GBinPortion *, GtkStyleContext *, cairo_t *, const GdkRectangle *); +/* Définit les droits associés à une partie de code. */ +void g_binary_portion_set_rights(GBinaryPortion *, PortionAccessRights); -#endif +/* Fournit les droits associés à une partie de code. */ +PortionAccessRights g_binary_portion_get_rights(const GBinaryPortion *); /* Procède à l'inclusion d'une portion dans une autre. */ -void g_binary_portion_include(GBinPortion *, GBinPortion *); +bool g_binary_portion_include(GBinaryPortion *, GBinaryPortion *); /* Sens des visites */ typedef enum _BinaryPortionVisit @@ -147,47 +97,24 @@ typedef enum _BinaryPortionVisit /* Fonction appelée à chaque visite de portion.*/ -typedef bool (* visit_portion_fc) (GBinPortion *, GBinPortion *, BinaryPortionVisit, void *); +typedef bool (* visit_portion_fc) (GBinaryPortion *, GBinaryPortion *, BinaryPortionVisit, void *); /* Parcourt un ensemble de portions binaires. */ -bool g_binary_portion_visit(GBinPortion *, visit_portion_fc, void *); +bool g_binary_portion_visit(GBinaryPortion *, visit_portion_fc, void *); /* ------------------------ PARCOURS D'ENSEMBLES DE PORTIONS ------------------------ */ -#ifdef INCLUDE_GTK_SUPPORT - -/* Compte le nombre de portions présentes dans une arborescence. */ -size_t g_binary_portion_count(const GBinPortion *); - -/* Recherche la portion présente à un point donné. */ -GBinPortion *g_binary_portion_find_at_pos(GBinPortion *, gint, GdkRectangle *); - -#endif - /* Recherche la portion présente à une adresse donnée. */ -GBinPortion *g_binary_portion_find_at_addr(GBinPortion *, const vmpa2t *); - -#ifdef INCLUDE_GTK_SUPPORT - -/* Fournit la position correspondant à une adresse donnée. */ -bool get_binary_portion_addr_from_pos(GBinPortion *, gint, const GdkRectangle *, vmpa2t *); - -/* Fournit l'adresse correspondant à une position donnée. */ -bool get_binary_portion_pos_from_addr(GBinPortion *, const vmpa2t *, const GdkRectangle *, gint *); - -/* Prépare une astuce concernant une portion pour son affichage. */ -gboolean query_tooltip_for_binary_portion(GBinPortion *, gint, gint, const GdkRectangle *, GtkTooltip *); - -#endif +GBinaryPortion *g_binary_portion_find_at_addr(GBinaryPortion *, const vmpa2t *); /* Fournit l'emplacement correspondant à une position physique. */ -bool g_binary_portion_translate_offset_into_vmpa(const GBinPortion *, phys_t, vmpa2t *); +bool g_binary_portion_translate_offset_into_vmpa(const GBinaryPortion *, phys_t, vmpa2t *); /* Fournit l'emplacement correspondant à une adresse virtuelle. */ -bool g_binary_portion_translate_address_into_vmpa(const GBinPortion *, virt_t, vmpa2t *); +bool g_binary_portion_translate_address_into_vmpa(const GBinaryPortion *, virt_t, vmpa2t *); |