diff options
41 files changed, 2494 insertions, 352 deletions
@@ -1,3 +1,98 @@ +10-07-29 Cyrille Bagard <nocbos@gmail.com> + + * configure.ac: + Add one extra definition to src/gtkext/iodamarshal.list. + + * pixmaps/breakpoint_disabled.png: + * pixmaps/breakpoint_normal.png: + New entries: add pictures for breakpoints. + + * pixmaps/Makefile.am: + Add breakpoint_disabled.png and breakpoint_normal.png to EXTRA_DIST. + + * src/analysis/binary.c: + * src/analysis/binary.h: + Manage breakpoints groups and breakpoint signals. + + * src/common/cpp.h: + New entry: define SIZE_T_MAXLEN. + + * src/common/endianness.c: + * src/common/endianness.h: + Read numbers from strings. + + * src/common/Makefile.am: + Add cpp.h to libcommon_la_SOURCES. + + * src/debug/break.c: + * src/debug/break.h: + New entries: define breakpoints and breakpoints groups. + + * src/debug/debugger.c: + * src/debug/debugger.h: + New entries: improve code. + + * src/debug/debugger-int.h: + Create a new signal for breakpoints. + + * src/debug/debuggers.c: + * src/debug/debuggers.h: + Deleted entries. + + * src/debug/Makefile.am: + Remove debuggers.[ch] from libdebug_la_SOURCES and add break.[ch] + and debugger.[ch]. + + * src/debug/ptrace/ptrace.h: + Update code. + + * src/debug/remgdb/gdb.c: + * src/debug/remgdb/gdb.h: + Improve the GDB client. + + * src/debug/remgdb/helpers.c: + * src/debug/remgdb/helpers.h: + New entries: decode one 'Stop Reply' GDB packet. + + * src/debug/remgdb/Makefile.am: + Add helpers.[ch] to libdebugremgdb_la_SOURCES. + + * src/debug/remgdb/packet.c: + * src/debug/remgdb/packet.h: + * src/debug/remgdb/stream.c: + Ack received GDB packets. + + * src/editor.c: + Update code. + + * src/glibext/Makefile.am: + Add proto.h to libglibext_la_SOURCES. + + * src/glibext/proto.h: + New entry: define GExtFunc prototype. + + * src/gtkext/gtkblockview.c: + Update code. + + * src/main.c: + Clean code. + + * src/panels/breaks.c: + * src/panels/breaks.h: + New entries: build a panel for breakpoints. + + * src/panels/Makefile.am: + Add breaks.[ch] to libpanels_la_SOURCES. + + * src/panels/panel.c: + * src/panels/panel.h: + * src/panels/panel-int.h: + Update panels on binary change. Load the new panel for breakpoints. + + * src/panels/registers.h: + * src/panels/symbols.c: + Update code. + 10-07-17 Cyrille Bagard <nocbos@gmail.com> * src/debug/Makefile.am: diff --git a/configure.ac b/configure.ac index 70c6c4e..64220ff 100644 --- a/configure.ac +++ b/configure.ac @@ -227,7 +227,7 @@ AC_SUBST(LIBGRAPH_LIBS) AC_CONFIG_FILES([stamp-h po/Makefile.in], [echo timestamp > stamp-h]) -AC_CONFIG_COMMANDS([marshal], [echo -e "VOID:UINT64,UINT64\nVOID:OBJECT\nVOID:OBJECT,OBJECT" > src/gtkext/iodamarshal.list]) +AC_CONFIG_COMMANDS([marshal], [echo -e "VOID:UINT64,UINT64\nVOID:INT,UINT64,INT\nVOID:OBJECT\nVOID:OBJECT,OBJECT" > src/gtkext/iodamarshal.list]) AC_CONFIG_FILES([Makefile pixmaps/Makefile diff --git a/pixmaps/Makefile.am b/pixmaps/Makefile.am index 8cf2b8a..479d9eb 100644 --- a/pixmaps/Makefile.am +++ b/pixmaps/Makefile.am @@ -25,6 +25,8 @@ LIST_ICONS = \ symbol_routine_classic.png EXTRA_DIST = \ + breakpoint_disabled.png \ + breakpoint_normal.png \ openida.xcf \ openida_text.xcf \ $(REVISION_PIX) \ diff --git a/pixmaps/breakpoint_disabled.png b/pixmaps/breakpoint_disabled.png Binary files differnew file mode 100644 index 0000000..f715828 --- /dev/null +++ b/pixmaps/breakpoint_disabled.png diff --git a/pixmaps/breakpoint_normal.png b/pixmaps/breakpoint_normal.png Binary files differnew file mode 100644 index 0000000..a2b889f --- /dev/null +++ b/pixmaps/breakpoint_normal.png diff --git a/src/analysis/binary.c b/src/analysis/binary.c index d8199c0..f6f56c7 100644 --- a/src/analysis/binary.c +++ b/src/analysis/binary.c @@ -39,7 +39,9 @@ #include "line_comment.h" /* TODO : supprimer ? */ #include "line_prologue.h" #include "routine.h" +#include "../common/cpp.h" #include "../common/extstr.h" +#include "../debug/break.h" #include "../glibext/delayed-int.h" #include "../format/format.h" #include "../panels/log.h" @@ -143,6 +145,10 @@ struct _GOpenidaBinary GRenderingLine *lines; /* Lignes de rendu en place */ GRenderingOptions *options; /* Options de désassemblage */ + GBreakGroup **brk_groups; /* Groupes de points d'arrêt */ + size_t brk_count; /* Taille de cette liste */ + GBreakGroup *brk_default; /* Groupe par défaut */ + }; /* Description de fichier binaire (classe) */ @@ -176,6 +182,16 @@ void ack_completed_disassembly(GDelayedDisassembly *, GOpenidaBinary *); +/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */ + + +/* Réagit à une nouvelle création de point d'arrêt. */ +static void g_openida_binary_breakpoint_added(GBreakGroup *, GBreakPoint *, GOpenidaBinary *); + +/* Réagit à une suppression de point d'arrêt. */ +static void g_openida_binary_breakpoint_removed(GBreakGroup *, GBreakPoint *, GOpenidaBinary *); + + /* ---------------------------------------------------------------------------------- */ /* DESASSEMBLAGE DE BINAIRE DIFFERE */ @@ -707,6 +723,8 @@ static void g_openida_binary_class_init(GOpenidaBinaryClass *klass) static void g_openida_binary_init(GOpenidaBinary *binary) { + /* FIXME : à replacer ailleurs */ + g_openida_binary_add_break_group(binary, _("default")); } @@ -1473,3 +1491,196 @@ void ack_completed_disassembly(GDelayedDisassembly *disass, GOpenidaBinary *bina g_signal_emit_by_name(binary, "disassembly-done"); } + + + +/* ---------------------------------------------------------------------------------- */ +/* ELEMENTS DE DEBOGAGE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : binary = représentation de binaire à modifier. * +* name = éventuel nom à associer au groupe. * +* * +* Description : Ajoute un nouveau groupe de points d'arrêt au binaire. * +* * +* Retour : true si l'opération s'est bien effectuée, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_openida_binary_add_break_group(GOpenidaBinary *binary, const char *name) +{ + bool result; /* Bilan à faire remonter */ + const char *used; /* Désignation à utiliser */ + size_t tmp_len; /* Longeur maximale à gérer */ + char *tmp; /* Construction temporaire */ + size_t i; /* Boucle de parcours */ + const char *test; /* Nom existant à tester */ + + result = true; + + /* Préparation du nom de scène */ + + if (name != NULL) used = name; + else + { + tmp_len = strlen(_("Group")) + 1 + SIZE_T_MAXLEN + 1; + tmp = (char *)calloc(tmp_len, sizeof(char)); + + snprintf(tmp, tmp_len, "%s %lu", _("Group"), binary->brk_count); + + used = tmp; + + } + + /* Vérification d'unicité */ + + for (i = 0; i < binary->brk_count && result; i++) + { + test = g_break_group_get_name(binary->brk_groups[i]); + + if (test != NULL) + result = (strcmp(used, test) != 0); + + } + + /* Mise en place finale */ + + if (result) + { + binary->brk_count++; + binary->brk_groups = (GBreakGroup **)realloc(binary->brk_groups, + binary->brk_count * sizeof(GBreakGroup *)); + + binary->brk_groups[i] = g_break_group_new(); + + g_break_group_set_name(binary->brk_groups[i], used); + + if (binary->brk_default == NULL) + binary->brk_default = binary->brk_groups[i]; + + g_signal_connect(binary->brk_groups[i], "added", + G_CALLBACK(g_openida_binary_breakpoint_added), binary); + + g_signal_connect(binary->brk_groups[i], "removed", + G_CALLBACK(g_openida_binary_breakpoint_removed), binary); + + } + + if (name == NULL) free(tmp); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de points d'arrêt intervenant. * +* point = point d'arrêt à l'origine de la procédure. * +* binary = représentation de binaire à modifier. * +* * +* Description : Réagit à une nouvelle création de point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_openida_binary_breakpoint_added(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary) +{ + GRenderingLine *line; /* Ligne à retrouver */ + + line = g_rendering_line_find_by_address(binary->lines, NULL, + g_break_point_get_address(point)); + + if (line != NULL) + g_rendering_line_toggle_flag(line, RLF_BREAK_POINT); + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de points d'arrêt intervenant. * +* point = point d'arrêt à l'origine de la procédure. * +* binary = représentation de binaire à modifier. * +* * +* Description : Réagit à une suppression de point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_openida_binary_breakpoint_removed(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary) +{ + GRenderingLine *line; /* Ligne à retrouver */ + + line = g_rendering_line_find_by_address(binary->lines, NULL, + g_break_point_get_address(point)); + + if (line != NULL) + g_rendering_line_toggle_flag(line, RLF_BREAK_POINT); + +} + + +/****************************************************************************** +* * +* Paramètres : binary = représentation de binaire à mettre à jour. * +* addr = adresse mémoire à faire basculer. * +* * +* Description : Ajoute ou supprime un point d'arrêt dans un binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_openida_binary_toggle_breakpoint(GOpenidaBinary *binary, vmpa_t addr) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < binary->brk_count; i++) + if (g_break_group_has_address(binary->brk_groups[i], addr)) + { + g_break_group_toggle_breakpoint(binary->brk_groups[i], addr); + break; + } + + if (i == binary->brk_count) + g_break_group_toggle_breakpoint(binary->brk_default, addr); + +} + + +/****************************************************************************** +* * +* Paramètres : binary = représentation de binaire à parcourir. * +* func = fonction à appeler à chaque point trouvé. * +* data = éventuelle donnée de l'utilisateur à joindre. * +* * +* Description : Parcourt l'ensemble des groupes de points d'arrêt du binaire.* +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_openida_binary_for_each_bp_group(GOpenidaBinary *binary, GExtFunc func, gpointer data) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < binary->brk_count; i++) + func(binary, binary->brk_groups[i], data); + +} diff --git a/src/analysis/binary.h b/src/analysis/binary.h index f556c4a..3869cae 100644 --- a/src/analysis/binary.h +++ b/src/analysis/binary.h @@ -31,6 +31,7 @@ #include "line.h" #include "../arch/processor.h" +#include "../debug/break.h" #include "../format/executable.h" #include "../common/xml.h" @@ -106,4 +107,18 @@ GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *); +/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */ + + +/* Ajoute un nouveau groupe de points d'arrêt au binaire. */ +bool g_openida_binary_add_break_group(GOpenidaBinary *, const char *); + +/* Ajoute ou supprime un point d'arrêt dans un binaire. */ +void g_openida_binary_toggle_breakpoint(GOpenidaBinary *, vmpa_t); + +/* Parcourt l'ensemble des groupes de points d'arrêt du binaire. */ +void g_openida_binary_for_each_bp_group(GOpenidaBinary *, GExtFunc, gpointer); + + + #endif /* _ANALYSIS_BINARY_H */ diff --git a/src/common/Makefile.am b/src/common/Makefile.am index f8e4f20..c883e02 100755 --- a/src/common/Makefile.am +++ b/src/common/Makefile.am @@ -2,6 +2,7 @@ lib_LTLIBRARIES = libcommon.la libcommon_la_SOURCES = \ + cpp.h \ dllist.h dllist.c \ endianness.h endianness.c \ environment.h environment.c \ diff --git a/src/common/cpp.h b/src/common/cpp.h new file mode 100644 index 0000000..b5e09c0 --- /dev/null +++ b/src/common/cpp.h @@ -0,0 +1,45 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * cpp.h - prototypes pour avoir à disposition un langage C plus plus mieux + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _COMMON_CPP_H +#define _COMMON_CPP_H + + +#include <limits.h> +#include <string.h> + + + +/** + * Détermine la taille de la plus longue chaîne de caractères + * correspondant à un type donné. + */ + +#define XSTR(e) STR(e) +#define STR(e) #e + +#define SIZE_T_MAXLEN strlen(XSTR(LONG_MAX)) + + + +#endif /* _COMMON_CPP_H */ diff --git a/src/common/endianness.c b/src/common/endianness.c index 5a14e1c..0b7e192 100755 --- a/src/common/endianness.c +++ b/src/common/endianness.c @@ -24,6 +24,9 @@ #include "endianness.h" +#include <stdarg.h> + + /****************************************************************************** * * @@ -318,3 +321,197 @@ bool read_u64(uint64_t *target, const bin_t *data, off_t *pos, off_t len, Source return true; } + + +/****************************************************************************** +* * +* Paramètres : target = lieu d'enregistrement de la lecture. [OUT] * +* data = flux de données à analyser. * +* pos = position courante dans ce flux. [OUT] * +* len = taille totale des données à analyser. * +* endian = ordre des bits dans la source. * +* * +* Description : Lit un nombre hexadécimal non signé sur deux octets. * +* * +* Retour : Bilan de l'opération : true en cas de succès, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool strtou8(uint8_t *target, const char *data, size_t *pos, size_t len, SourceEndian endian) +{ + size_t i; /* Boucle de parcours */ + + if (*pos < 0) return false; + if ((len - *pos) < 2) return false; + + *target = 0; + + for (i = 0; i < 2; i++) + switch (data[*pos + i]) + { + case '0' ... '9': + *target |= ((data[*pos + i] - '0') << (4 * (1 - i))); + break; + + case 'A' ... 'F': + *target |= ((data[*pos + i] + 10 - 'A') << (4 * (1 - i))); + break; + + case 'a' ... 'f': + *target |= ((data[*pos + i] + 10 - 'a') << (4 * (1 - i))); + break; + + } + + *pos += 2; + + return true; + +} + + + +/****************************************************************************** +* * +* Paramètres : n = nombre d'octets constituant le nombre à lire. * +* data = flux de données à analyser. * +* pos = position courante dans ce flux. [OUT] * +* len = taille totale des données à analyser. * +* endian = ordre des bits dans la source. * +* ... = lieu d'enregistrement de la lecture. [OUT] * +* * +* Description : Lit un nombre hexadécimal non signé sur n octets. * +* * +* Retour : Bilan de l'opération : true en cas de succès, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool _strtoun(uint8_t n, const char *data, size_t *pos, size_t len, SourceEndian endian, ...) +{ + bool result; /* Bilan à renvoyer */ + va_list ap; /* Arguments variables */ + uint8_t *target8; /* Enregistrement sur 8 bits */ + uint16_t *target16; /* Enregistrement sur 16 bits */ + uint32_t *target32; /* Enregistrement sur 32 bits */ + uint64_t *target64; /* Enregistrement sur 64 bits */ + uint8_t i; /* Boucle de parcours #1 */ + size_t j; /* Boucle de parcours #2 */ + uint8_t tmp; /* Valeur temporaire de 8 bits */ + + if (*pos < 0) return false; + if ((len - *pos) < (n * 2)) return false; + + /* Récupération de la destination */ + + va_start(ap, endian); + + switch (n) + { + case 1: + target8 = va_arg(ap, uint8_t *); + *target8 = 0; + target64 = (uint64_t *)target8; + break; + case 2: + target16 = va_arg(ap, uint16_t *); + *target16 = 0; + target64 = (uint64_t *)target16; + break; + case 4: + target32 = va_arg(ap, uint32_t *); + *target32 = 0; + target64 = (uint64_t *)target32; + break; + case 8: + target64 = va_arg(ap, uint64_t *); + *target64 = 0ull; + break; + default: + va_end(ap); + return false; + break; + } + + va_end(ap); + + /* Lecture des données */ + + result = true; + + for (i = 0; i < n && result; i++) + { + tmp = 0; + + for (j = 0; j < 2 && result; j++) + switch (data[*pos + j]) + { + case '0' ... '9': + tmp |= ((data[*pos + j] - '0') << (4 * (1 - j))); + break; + + case 'A' ... 'F': + tmp |= ((data[*pos + j] + 10 - 'A') << (4 * (1 - j))); + break; + + case 'a' ... 'f': + tmp |= ((data[*pos + j] + 10 - 'a') << (4 * (1 - j))); + break; + + default: + printf(" string :: '%s'\n", &data[*pos + j]); + result = false; + break; + + } + + *pos += 2; + + switch (endian) + { + case SRE_LITTLE: + +#if __BYTE_ORDER == __LITTLE_ENDIAN + + *target64 |= ((uint64_t)tmp) << (8 * i); + +#elif __BYTE_ORDER == __BIG_ENDIAN + + *target64 |= ((uint64_t)tmp) << (8 * (n - 1 - i)); + +#else + +# error "TODO : PDP !" + +#endif + + break; + + case SRE_BIG: + +#if __BYTE_ORDER == __LITTLE_ENDIAN + + *target64 |= ((uint64_t)tmp) << (8 * (n - 1 - i)); + +#elif __BYTE_ORDER == __BIG_ENDIAN + + *target64 |= ((uint64_t)tmp) << (8 * i); + +#else + +# error "TODO : PDP !" + +#endif + + break; + + } + + } + + return result; + +} diff --git a/src/common/endianness.h b/src/common/endianness.h index f729ac5..0664d6a 100755 --- a/src/common/endianness.h +++ b/src/common/endianness.h @@ -65,5 +65,17 @@ bool read_u64(uint64_t *, const bin_t *, off_t *, off_t, SourceEndian); #define read_s64(target, data, pos, len, endian) read_u64((uint64_t *)target, data, pos, len, endian) +/* Lit un nombre hexadécimal non signé sur deux octets. */ +bool strtou8(uint8_t *, const char *, size_t *, size_t, SourceEndian); + + + +/* Lit un nombre hexadécimal non signé sur n octets. */ +bool _strtoun(uint8_t, const char *, size_t *, size_t, SourceEndian, ...); + + +#define strtou32(target, data, pos, len, endian) _strtoun(4, data, pos, len, endian, target) + + #endif /* _COMMON_ENDIANNESS_H */ diff --git a/src/debug/Makefile.am b/src/debug/Makefile.am index 7a19221..ec3dde7 100755 --- a/src/debug/Makefile.am +++ b/src/debug/Makefile.am @@ -2,7 +2,8 @@ noinst_LTLIBRARIES = libdebug.la libdebug_la_SOURCES = \ - debuggers.h debuggers.c + break.h break.c \ + debugger.h debugger.c libdebug_la_CFLAGS = $(AM_CFLAGS) diff --git a/src/debug/break.c b/src/debug/break.c new file mode 100644 index 0000000..4a19f25 --- /dev/null +++ b/src/debug/break.c @@ -0,0 +1,440 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * break.c - manipulation des points d'arrêt + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "break.h" + + +#include <malloc.h> +#include <string.h> + + +#include "../common/dllist.h" + + + + +/* --------------------------- GESTION DES POINTS D'ARRET --------------------------- */ + + +/* Propriétés d'un point d'arrêt (instance) */ +struct _GBreakPoint +{ + GObject parent; /* A laisser en premier */ + + DL_LIST_ITEM(link); /* Maillon de liste chaînée */ + + vmpa_t address; /* Adresse où s'arrêter */ + + bool is_enabled; /* Statut d'activité */ + +}; + +/* Propriétés d'un point d'arrêt (classe) */ +struct _GBreakPointClass +{ + GObjectClass parent; /* A laisser en premier */ + + /* Signaux */ + + void (* changed) (GBreakPoint *); + +}; + + +#define bp_list_add_tail(new, head) dl_list_add_tail(new, head, GBreakPoint, link) +#define bp_list_del(item, head) dl_list_del(item, head, GBreakPoint, link) +#define bp_list_for_each(pos, head) dl_list_for_each(pos, head, GBreakPoint, link) +#define bp_list_for_each_safe(pos, head, next) dl_list_for_each_safe(pos, head, next, GBreakPoint, link) + + +/* Initialise la classe des propriétés d'un point d'arrêt. */ +static void g_break_point_class_init(GBreakPointClass *); + +/* Initialise des propriétés d'un point d'arrêt. */ +static void g_break_point_init(GBreakPoint *); + + + + + + +/* ---------------------------- GROUPE DE POINTS D'ARRET ---------------------------- */ + + +/* Propriétés d'un groupe de points d'arrêt (instance) */ +struct _GBreakGroup +{ + GObject parent; /* A laisser en premier */ + + char *name; /* Désignation humaine */ + + GBreakPoint *points; /* Liste de points d'arrêt */ + +}; + +/* Propriétés d'un groupe de points d'arrêt (classe) */ +struct _GBreakGroupClass +{ + GObjectClass parent; /* A laisser en premier */ + + /* Signaux */ + + void (* added) (GBreakGroup *, GBreakPoint *); + void (* removed) (GBreakGroup *, GBreakPoint *); + +}; + + +/* Initialise la classe des groupes de points d'arrêt. */ +static void g_break_group_class_init(GBreakGroupClass *); + +/* Initialise un groupe de points d'arrêt. */ +static void g_break_group_init(GBreakGroup *); + + + + + + + + +/* ---------------------------------------------------------------------------------- */ +/* GESTION DES POINTS D'ARRET */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour des propriétés d'un point d'arrêt. */ +G_DEFINE_TYPE(GBreakPoint, g_break_point, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des propriétés d'un point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_break_point_class_init(GBreakPointClass *klass) +{ + g_signal_new("changed", + G_TYPE_BREAK_POINT, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GBreakPointClass, changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + +} + + +/****************************************************************************** +* * +* Paramètres : point = instance à initialiser. * +* * +* Description : Initialise des propriétés d'un point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_break_point_init(GBreakPoint *point) +{ + DL_LIST_ITEM_INIT(&point->link); + +} + + +/****************************************************************************** +* * +* Paramètres : address = adresse à laquelle s'arrêter. * +* * +* Description : Construit un nouveau point d'arrêt. * +* * +* Retour : Point d'arrêt mis en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GBreakPoint *g_break_point_new(vmpa_t address) +{ + GBreakPoint *result; /* Adresse à retourner */ + + result = g_object_new(G_TYPE_BREAK_POINT, NULL); + + result->address = address; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : point = instance à consulter. * +* * +* Description : Fournit l'adresse associée à un point d'arrêt. * +* * +* Retour : Adresse associée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +vmpa_t g_break_point_get_address(const GBreakPoint *point) +{ + return point->address; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* GROUPE DE POINTS D'ARRET */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour les groupes de points d'errêt. */ +G_DEFINE_TYPE(GBreakGroup, g_break_group, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des groupes de points d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_break_group_class_init(GBreakGroupClass *klass) +{ + g_signal_new("added", + G_TYPE_BREAK_GROUP, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GBreakGroupClass, added), + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, 1, G_TYPE_BREAK_POINT); + + g_signal_new("removed", + G_TYPE_BREAK_GROUP, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GBreakGroupClass, removed), + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, 1, G_TYPE_BREAK_POINT); + +} + + +/****************************************************************************** +* * +* Paramètres : group = instance à initialiser. * +* * +* Description : Initialise un groupe de point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_break_group_init(GBreakGroup *group) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Construit un nouveau groupe de points d'arrêt. * +* * +* Retour : Groupe de points d'arrêt mis en place ou NULL en cas d'échec.* +* * +* Remarques : - * +* * +******************************************************************************/ + +GBreakGroup *g_break_group_new(void) +{ + GBreakGroup *result; /* Adresse à retourner */ + + result = g_object_new(G_TYPE_BREAK_GROUP, NULL); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : group = groupe de points d'arrêt à consulter. * +* * +* Description : Fournit la désignation humaine associée à un groupe. * +* * +* Retour : Désignation humaine associée, jamais NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const char *g_break_group_get_name(const GBreakGroup *group) +{ + return group->name; + +} + + +/****************************************************************************** +* * +* Paramètres : group = groupe de points d'arrêt à modifier. * +* name = nouveau nom de scène. * +* * +* Description : Définit la désignation humaine à associer à un groupe. * +* * +* Retour : Désignation humaine associée, voire NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_break_group_set_name(GBreakGroup *group, const char *name) +{ + if (group->name != NULL) + free(group->name); + + if (name == NULL) + group->name = NULL; + + else + group->name = strdup(name); + +} + + +/****************************************************************************** +* * +* Paramètres : group = groupe de points d'arrêt à consulter. * +* addr = adresse recherchée dans les points d'arrêt. * +* * +* Description : Indique si une adresse donnée est gérée dans un groupe. * +* * +* Retour : true si l'adresse est gérée ici, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_break_group_has_address(const GBreakGroup *group, vmpa_t addr) +{ + GBreakPoint *iter; /* Boucle de parcours */ + + bp_list_for_each(iter, group->points) + if (g_break_point_get_address(iter) == addr) + return true; + + return false; + +} + + +/****************************************************************************** +* * +* Paramètres : group = groupe de points d'arrêt à modifier. * +* addr = adresse mémoire à faire basculer. * +* * +* Description : Ajoute ou supprime un point d'arrêt dans un groupe. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_break_group_toggle_breakpoint(GBreakGroup *group, vmpa_t addr) +{ + GBreakPoint *iter; /* Boucle de parcours */ + GBreakPoint *next; /* Prochain point de passage */ + + /* Suppression d'un éventuel existant */ + + bp_list_for_each_safe(iter, &group->points, next) + if (g_break_point_get_address(iter) == addr) + { + g_signal_emit_by_name(group, "removed", iter); + + bp_list_del(iter, &group->points); + g_object_unref(G_OBJECT(iter)); + + return; + + } + + /* Si non trouvé, ajout du nouveau point */ + + iter = g_break_point_new(addr); + + bp_list_add_tail(iter, &group->points); + + g_signal_emit_by_name(group, "added", iter); + +} + + +/****************************************************************************** +* * +* Paramètres : group = groupe de points d'arrêt à parcourir. * +* func = fonction à appeler à chaque point trouvé. * +* data = éventuelle donnée de l'utilisateur à joindre. * +* * +* Description : Parcourt l'ensemble des points d'arrêt d'un groupe donné. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_break_group_for_each(GBreakGroup *group, GExtFunc func, gpointer data) +{ + GBreakPoint *iter; /* Boucle de parcours */ + + /* Suppression d'un éventuel existant */ + + bp_list_for_each(iter, group->points) + func(group, iter, data); + +} diff --git a/src/debug/break.h b/src/debug/break.h new file mode 100644 index 0000000..76b537a --- /dev/null +++ b/src/debug/break.h @@ -0,0 +1,105 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * break.h - prototypes pour la manipulation des points d'arrêt + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _DEBUG_BREAK_H +#define _DEBUG_BREAK_H + + +#include <glib-object.h> +#include <stdbool.h> + + +#include "../arch/archbase.h" +#include "../glibext/proto.h" + + + +/* --------------------------- GESTION DES POINTS D'ARRET --------------------------- */ + + +#define G_TYPE_BREAK_POINT g_break_point_get_type() +#define G_BREAK_POINT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_break_point_get_type(), GBreakPoint)) +#define G_IS_BREAK_POINT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_break_point_get_type())) +#define G_BREAK_POINT_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_break_point_get_type(), GBreakPointIface)) +#define G_BREAK_POINT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BREAK_POINT, GBreakPointClass)) + + +/* Propriétés d'un point d'arrêt (instance) */ +typedef struct _GBreakPoint GBreakPoint; + +/* Propriétés d'un point d'arrêt (classe) */ +typedef struct _GBreakPointClass GBreakPointClass; + + +/* Indique le type défini pour des propriétés d'un point d'arrêt. */ +GType g_break_point_get_type(void); + +/* Construit un nouveau point d'arrêt. */ +GBreakPoint *g_break_point_new(vmpa_t); + +/* Fournit l'adresse associée à un point d'arrêt. */ +vmpa_t g_break_point_get_address(const GBreakPoint *); + + + +/* ---------------------------- GROUPE DE POINTS D'ARRET ---------------------------- */ + + +#define G_TYPE_BREAK_GROUP g_break_group_get_type() +#define G_BREAK_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_break_group_get_type(), GBreakGroup)) +#define G_IS_BREAK_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_break_group_get_type())) +#define G_BREAK_GROUP_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_break_group_get_type(), GBreakGroupIface)) +#define G_BREAK_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BREAK_GROUP, GBreakGroupClass)) + + +/* Propriétés d'un groupe de points d'arrêt (instance) */ +typedef struct _GBreakGroup GBreakGroup; + +/* Propriétés d'un groupe de points d'arrêt (classe) */ +typedef struct _GBreakGroupClass GBreakGroupClass; + + +/* Indique le type défini pour les groupes de points d'errêt. */ +GType g_break_group_get_type(void); + +/* Construit un nouveau groupe de points d'arrêt. */ +GBreakGroup *g_break_group_new(void); + +/* Fournit la désignation humaine associée à un groupe. */ +const char *g_break_group_get_name(const GBreakGroup *); + +/* Définit la désignation humaine à associer à un groupe. */ +void g_break_group_set_name(GBreakGroup *, const char *); + +/* Indique si une adresse donnée est gérée dans un groupe. */ +bool g_break_group_has_address(const GBreakGroup *, vmpa_t); + +/* Ajoute ou supprime un point d'arrêt dans un groupe. */ +void g_break_group_toggle_breakpoint(GBreakGroup *, vmpa_t); + +/* Parcourt l'ensemble des points d'arrêt d'un groupe donné. */ +void g_break_group_for_each(GBreakGroup *, GExtFunc, gpointer); + + + +#endif /* _DEBUG_BREAK_H */ diff --git a/src/debug/debugger-int.h b/src/debug/debugger-int.h index 3ba594a..642efd7 100644 --- a/src/debug/debugger-int.h +++ b/src/debug/debugger-int.h @@ -25,7 +25,7 @@ #define _DEBUG_DEBUGGER_INT_H -#include "debuggers.h" +#include "debugger.h" #include <gtk/gtk.h> @@ -68,6 +68,8 @@ struct _GBinaryDebuggerClass void (* debugger_stopped) (GBinaryDebugger *, uint64_t, uint64_t); + void (* debugger_halted) (GBinaryDebugger *, int, vmpa_t, pid_t); + }; diff --git a/src/debug/debugger.c b/src/debug/debugger.c new file mode 100644 index 0000000..a7d7470 --- /dev/null +++ b/src/debug/debugger.c @@ -0,0 +1,212 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * debugger.c - gestion des différents débogueurs + * + * Copyright (C) 2008 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "debugger.h" + +#include "debugger-int.h" +#include "remgdb/gdb.h" +#include "ptrace/ptrace.h" +#include "../gtkext/iodamarshal.h" + + + +/* Initialise la classe de base des débogueurs. */ +static void g_binary_debugger_class_init(GBinaryDebuggerClass *); + +/* Initialise une instance de base d'un débogueur. */ +static void g_binary_debugger_init(GBinaryDebugger *); + + + +/* Indique le type définit pour une ligne de représentation. */ +G_DEFINE_TYPE(GBinaryDebugger, g_binary_debugger, G_TYPE_OBJECT); + + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe de base des débogueurs. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_binary_debugger_class_init(GBinaryDebuggerClass *klass) +{ + g_signal_new("debugger-stopped", + G_TYPE_BINARY_DEBUGGER, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GBinaryDebuggerClass, debugger_stopped), + NULL, NULL, + g_cclosure_user_marshal_VOID__UINT64_UINT64, + G_TYPE_NONE, 2, G_TYPE_UINT64, G_TYPE_UINT64); + + g_signal_new("halted", + G_TYPE_BINARY_DEBUGGER, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GBinaryDebuggerClass, debugger_halted), + NULL, NULL, + g_cclosure_user_marshal_VOID__INT_UINT64_INT, + G_TYPE_NONE, 3, G_TYPE_INT, G_TYPE_UINT64, G_TYPE_INT); + +} + + +/****************************************************************************** +* * +* Paramètres : debugger = instance à initialiser. * +* * +* Description : Initialise une instance de base d'un débogueur. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_binary_debugger_init(GBinaryDebugger *debugger) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : type = type de débigueur choisi pour l'opération. * +* binary = binaire devant être débogué. * +* * +* Description : Crée un nouveau débogueur. * +* * +* Retour : Composant GObject mis en place ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GBinaryDebugger *g_new_binary_debugger(DebuggerType type, GOpenidaBinary *binary) +{ + GBinaryDebugger *result; + + switch (type) + { + case DGT_REMOTE_GDB: + result = g_gdb_debugger_new(binary, NULL); + break; + + case DGT_PTRACE: + result = g_object_new(G_TYPE_PTRACE_DEBUGGER, NULL); + break; + + default: + result = NULL; + break; + + } + + if (result != NULL) + result->binary = binary; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : debugger = débogueur à manipuler ici. * +* * +* Description : Démarre une procédure de débogage. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_binary_debugger_run(GBinaryDebugger *debugger) +{ + debugger->run(debugger); + +} + + +/****************************************************************************** +* * +* Paramètres : debugger = débogueur à manipuler ici. * +* * +* Description : Reprend une procédure de débogage. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_binary_debugger_resume(GBinaryDebugger *debugger) +{ + debugger->resume(debugger); + +} + + +/****************************************************************************** +* * +* Paramètres : debugger = débogueur à manipuler ici. * +* * +* Description : Tue une procédure de débogage. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_binary_debugger_kill(GBinaryDebugger *debugger) +{ + debugger->kill(debugger); + +} + + +/****************************************************************************** +* * +* Paramètres : debugger = débogueur à manipuler ici. * +* count = nombre de transmissions effetuées. * +* * +* Description : Fournit la valeur des registres de l'architecture. * +* * +* Retour : Tableau de valeurs transmises à libérer de la mémoire / NULL.* +* * +* Remarques : - * +* * +******************************************************************************/ + +register_value *g_binary_debugger_get_registers(GBinaryDebugger *debugger, size_t *count) +{ + return debugger->get_reg_values(debugger, count); + +} diff --git a/src/debug/debugger.h b/src/debug/debugger.h new file mode 100644 index 0000000..d6163cf --- /dev/null +++ b/src/debug/debugger.h @@ -0,0 +1,92 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * debugger.h - prototypes pour la gestion des différents débogueurs + * + * Copyright (C) 2008 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _DEBUG_DEBUGGER_H +#define _DEBUG_DEBUGGER_H + + +#include <glib-object.h> +#include <stdint.h> +#include <sys/types.h> + + +#include "../analysis/binary.h" + + + +/* Liste de tous les débogueurs */ +typedef enum _DebuggerType +{ + DGT_REMOTE_GDB, /* Utilisation de GDB */ + DGT_PTRACE, /* Utilisation de ptrace() */ + + DGT_COUNT + +} DebuggerType; + + +/* Transmission des valeurs des registres */ +typedef struct _register_value +{ + const char *name; /* Nom à ne pas libérer */ + uint64_t value; /* Valeur (taille maximale) */ + +} register_value; + + +#define G_TYPE_BINARY_DEBUGGER g_binary_debugger_get_type() +#define G_BINARY_DEBUGGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_binary_debugger_get_type(), GBinaryDebugger)) +#define G_IS_BINARY_DEBUGGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_binary_debugger_get_type())) +#define G_BINARY_DEBUGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BINARY_DEBUGGER, GGBinaryDebuggerClass)) +#define G_IS_BINARY_DEBUGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BINARY_DEBUGGER)) +#define G_BINARY_DEBUGGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BINARY_DEBUGGER, GGBinaryDebuggerClass)) + + +/* Définition des fonctionnalités d'un débogueur (instance) */ +typedef struct _GBinaryDebugger GBinaryDebugger; + +/* Définition des fonctionnalités d'un débogueur (classe) */ +typedef struct _GBinaryDebuggerClass GBinaryDebuggerClass; + + +/* Indique le type définit par la GLib pour le débogueur ptrace(). */ +GType g_binary_debugger_get_type(void); + +/* Crée un nouveau débogueur. */ +GBinaryDebugger *g_new_binary_debugger(DebuggerType, GOpenidaBinary *); + +/* Démarre une procédure de débogage. */ +void g_binary_debugger_run(GBinaryDebugger *); + +/* Reprend une procédure de débogage. */ +void g_binary_debugger_resume(GBinaryDebugger *); + +/* Tue une procédure de débogage. */ +void g_binary_debugger_kill(GBinaryDebugger *); + +/* Fournit la valeur des registres de l'architecture. */ +register_value *g_binary_debugger_get_registers(GBinaryDebugger *, size_t *); + + + +#endif /* _DEBUG_DEBUGGER_H */ diff --git a/src/debug/debuggers.c b/src/debug/debuggers.c index c9af67a..e69de29 100644 --- a/src/debug/debuggers.c +++ b/src/debug/debuggers.c @@ -1,197 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * debugger.sc - gestion des différents débogueurs - * - * Copyright (C) 2008 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA 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. - * - * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#include "debuggers.h" - -#include "debugger-int.h" -#include "ptrace/ptrace.h" -#include "../gtkext/iodamarshal.h" - - - -/* Initialise la classe de base des débogueurs. */ -static void g_binary_debugger_class_init(GBinaryDebuggerClass *); - -/* Initialise une instance de base d'un débogueur. */ -static void g_binary_debugger_init(GBinaryDebugger *); - - - -/* Indique le type définit pour une ligne de représentation. */ -G_DEFINE_TYPE(GBinaryDebugger, g_binary_debugger, G_TYPE_OBJECT); - - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe de base des débogueurs. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_binary_debugger_class_init(GBinaryDebuggerClass *klass) -{ - g_signal_new("debugger-stopped", - G_TYPE_BINARY_DEBUGGER, - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET(GBinaryDebuggerClass, debugger_stopped), - NULL, NULL, - g_cclosure_user_marshal_VOID__UINT64_UINT64, - G_TYPE_NONE, 2, G_TYPE_UINT64, G_TYPE_UINT64); - -} - - -/****************************************************************************** -* * -* Paramètres : debugger = instance à initialiser. * -* * -* Description : Initialise une instance de base d'un débogueur. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_binary_debugger_init(GBinaryDebugger *debugger) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : type = type de débigueur choisi pour l'opération. * -* binary = binaire devant être débogué. * -* * -* Description : Crée un nouveau débogueur. * -* * -* Retour : Composant GObject mis en place ou NULL. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GBinaryDebugger *g_new_binary_debugger(DebuggerType type, GOpenidaBinary *binary) -{ - GBinaryDebugger *result; - - switch (type) - { - case DGT_PTRACE: - result = g_object_new(G_TYPE_PTRACE_DEBUGGER, NULL); - break; - default: - result = NULL; - break; - } - - if (result != NULL) - result->binary = binary; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : debugger = débogueur à manipuler ici. * -* * -* Description : Démarre une procédure de débogage. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_binary_debugger_run(GBinaryDebugger *debugger) -{ - debugger->run(debugger); - -} - - -/****************************************************************************** -* * -* Paramètres : debugger = débogueur à manipuler ici. * -* * -* Description : Reprend une procédure de débogage. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_binary_debugger_resume(GBinaryDebugger *debugger) -{ - debugger->resume(debugger); - -} - - -/****************************************************************************** -* * -* Paramètres : debugger = débogueur à manipuler ici. * -* * -* Description : Tue une procédure de débogage. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_binary_debugger_kill(GBinaryDebugger *debugger) -{ - debugger->kill(debugger); - -} - - -/****************************************************************************** -* * -* Paramètres : debugger = débogueur à manipuler ici. * -* count = nombre de transmissions effetuées. * -* * -* Description : Fournit la valeur des registres de l'architecture. * -* * -* Retour : Tableau de valeurs transmises à libérer de la mémoire / NULL.* -* * -* Remarques : - * -* * -******************************************************************************/ - -register_value *g_binary_debugger_get_registers(GBinaryDebugger *debugger, size_t *count) -{ - return debugger->get_reg_values(debugger, count); - -} diff --git a/src/debug/debuggers.h b/src/debug/debuggers.h index 90db12f..e69de29 100644 --- a/src/debug/debuggers.h +++ b/src/debug/debuggers.h @@ -1,91 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * debuggers.h - prototypes pour la gestion des différents débogueurs - * - * Copyright (C) 2008 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA 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. - * - * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. - */ - - -#ifndef _DEBUG_DEBUGGER_H -#define _DEBUG_DEBUGGER_H - - -#include <glib-object.h> -#include <stdint.h> -#include <sys/types.h> - - -#include "../analysis/binary.h" - - - -/* Liste de tous les débogueurs */ -typedef enum _DebuggerType -{ - DGT_PTRACE, /* Utilisation de ptrace() */ - - DGT_COUNT - -} DebuggerType; - - -/* Transmission des valeurs des registres */ -typedef struct _register_value -{ - const char *name; /* Nom à ne pas libérer */ - uint64_t value; /* Valeur (taille maximale) */ - -} register_value; - - -#define G_TYPE_BINARY_DEBUGGER g_binary_debugger_get_type() -#define G_BINARY_DEBUGGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_binary_debugger_get_type(), GBinaryDebugger)) -#define G_IS_BINARY_DEBUGGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_binary_debugger_get_type())) -#define G_BINARY_DEBUGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BINARY_DEBUGGER, GGBinaryDebuggerClass)) -#define G_IS_BINARY_DEBUGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BINARY_DEBUGGER)) -#define G_BINARY_DEBUGGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BINARY_DEBUGGER, GGBinaryDebuggerClass)) - - -/* Définition des fonctionnalités d'un débogueur (instance) */ -typedef struct _GBinaryDebugger GBinaryDebugger; - -/* Définition des fonctionnalités d'un débogueur (classe) */ -typedef struct _GBinaryDebuggerClass GBinaryDebuggerClass; - - -/* Indique le type définit par la GLib pour le débogueur ptrace(). */ -GType g_binary_debugger_get_type(void); - -/* Crée un nouveau débogueur. */ -GBinaryDebugger *g_new_binary_debugger(DebuggerType, GOpenidaBinary *); - -/* Démarre une procédure de débogage. */ -void g_binary_debugger_run(GBinaryDebugger *); - -/* Reprend une procédure de débogage. */ -void g_binary_debugger_resume(GBinaryDebugger *); - -/* Tue une procédure de débogage. */ -void g_binary_debugger_kill(GBinaryDebugger *); - -/* Fournit la valeur des registres de l'architecture. */ -register_value *g_binary_debugger_get_registers(GBinaryDebugger *, size_t *); - - - -#endif /* _DEBUG_DEBUGGER_H */ diff --git a/src/debug/ptrace/ptrace.h b/src/debug/ptrace/ptrace.h index f0e2c2b..e309fb2 100644 --- a/src/debug/ptrace/ptrace.h +++ b/src/debug/ptrace/ptrace.h @@ -28,7 +28,7 @@ #include <glib-object.h> -#include "../debuggers.h" +#include "../debugger.h" diff --git a/src/debug/remgdb/Makefile.am b/src/debug/remgdb/Makefile.am index b2829c9..7ed26b0 100644 --- a/src/debug/remgdb/Makefile.am +++ b/src/debug/remgdb/Makefile.am @@ -3,6 +3,7 @@ noinst_LTLIBRARIES = libdebugremgdb.la libdebugremgdb_la_SOURCES = \ gdb.h gdb.c \ + helpers.h helpers.c \ packet.h packet.c \ stream-int.h \ stream.h stream.c \ diff --git a/src/debug/remgdb/gdb.c b/src/debug/remgdb/gdb.c index 068cf26..ea8e48e 100644 --- a/src/debug/remgdb/gdb.c +++ b/src/debug/remgdb/gdb.c @@ -23,7 +23,46 @@ #include "gdb.h" + +#include "../debugger-int.h" + + + +#include "helpers.h" +#include "tcp.h" + + + + +/* Débogueur utilisant un serveur GDB (instance) */ +struct _GGdbDebugger +{ + GBinaryDebugger parent; /* A laisser en premier */ + + GGdbStream *stream; /* Flux de communication */ + + #if 0 + GCond *cond; /* Poursuite du déroulement */ + GMutex *mutex; /* Accès à la condition */ + + ptrace_options *options; /* Configuration du débogage */ + + pid_t child; /* Processus suivi lancé */ + + gboolean run_again; /* Reprise du débogage */ +#endif +}; + +/* Débogueur utilisant un serveur GDB (classe) */ +struct _GGdbDebuggerClass +{ + GBinaryDebuggerClass parent; /* A laisser en premier */ + +}; + + + /* Initialise la classe du débogueur utilisant gdb. */ @@ -33,6 +72,16 @@ static void g_gdb_debugger_class_init(GGdbDebuggerClass *); static void g_gdb_debugger_init(GGdbDebugger *); +/* Met en marche le débogueur utilisant un serveur GDB. */ +static bool g_gdb_debugger_run(GGdbDebugger *); + +/* Remet en marche le débogueur utilisant un serveur GDB. */ +static bool g_gdb_debugger_resume(GGdbDebugger *); + +/* Tue le débogueur utilisant un serveur GDB. */ +static bool g_gdb_debugger_kill(GGdbDebugger *); + + /* Indique le type défini par la GLib pour le débogueur gdb. */ G_DEFINE_TYPE(GGdbDebugger, g_gdb_debugger, G_TYPE_BINARY_DEBUGGER); @@ -79,19 +128,49 @@ static void g_gdb_debugger_init(GGdbDebugger *debugger) parent->resume = (resume_debugger_fc)g_gdb_debugger_resume; parent->kill = (basic_debugger_fc)g_gdb_debugger_kill; - parent->get_reg_values = (get_register_values_fc)get_register_values_using_gdb_debugger; + //parent->get_reg_values = (get_register_values_fc)get_register_values_using_gdb_debugger; - debugger->cond = g_cond_new(); - debugger->mutex = g_mutex_new(); + //debugger->cond = g_cond_new(); + //debugger->mutex = g_mutex_new(); } /****************************************************************************** * * +* Paramètres : binary = binaire représenter à déboguer. * +* options = paramètres destinés au débogage. * +* * +* Description : Crée un débogueur utilisant un serveur GDB distant. * +* * +* Retour : Instance de débogueur mise en place ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GBinaryDebugger *g_gdb_debugger_new(GOpenidaBinary *binary, void *options) +{ + GBinaryDebugger *result; /* Débogueur à retourner */ + + result = g_object_new(G_TYPE_GDB_DEBUGGER, NULL); + + return result; + +} + + + + + + + + +/****************************************************************************** +* * * Paramètres : debugger = débogueur à lancer. * * * -* Description : Met en marche le débogueur utilisant gdb. * +* Description : Met en marche le débogueur utilisant un serveur GDB. * * * * Retour : Bilan de l'opération. * * * @@ -99,30 +178,68 @@ static void g_gdb_debugger_init(GGdbDebugger *debugger) * * ******************************************************************************/ -bool g_gdb_debugger_run(GGdbDebugger *debugger) +static bool g_gdb_debugger_run(GGdbDebugger *debugger) { - GError *error; /* Bilan de création de thread */ - if (debugger->options == NULL) - debugger->options = create_gdb_options_from_binary(G_BINARY_DEBUGGER(debugger)->binary); - if (debugger->options == NULL) - return false; + GGdbPacket *packet; + bool test; + + const char *data; + size_t len; + + + int sig; + vmpa_t addr; + pid_t thread; + + + debugger->stream = g_gdb_tcp_client_new("127.0.0.1", "6666"); + if (debugger->stream == NULL) return false; + + + printf("Connection done !\n"); + + + + packet = g_gdb_stream_get_free_packet(debugger->stream); + + g_gdb_packet_start_new_command(packet); + g_gdb_packet_append(packet, "?"); + + + test = g_gdb_stream_send_packet(debugger->stream, packet); + + + + printf(" >> Paquet '%s' bien envoyé ? %s\n", "?", test ? "oui" : "non"); + + + + g_gdb_stream_mark_packet_as_free(debugger->stream, packet); + + packet = g_gdb_stream_recv_packet(debugger->stream); + + g_gdb_packet_get_data(packet, &data, &len, NULL); + + printf(" << Réception de '%s'\n", data); + + + + + + get_stop_reply_sig_info(packet, &sig, &addr, &thread, SRE_LITTLE); + + g_signal_emit_by_name(debugger, "halted", sig, addr, thread); + + - if (!g_thread_create((GThreadFunc)gdb_thread, debugger, FALSE, &error)) - { - printf ("Failed to create the thread: %s\n", error->message); - } - /* - printf("Start Debugger with bin :: %p\n", G_BINARY_DEBUGGER_GET_IFACE(debugger)->binary); - g_signal_emit_by_name(debugger, "debugger-stopped", (uint64_t)0xdeadbeaf); - */ return true; } @@ -132,7 +249,7 @@ bool g_gdb_debugger_run(GGdbDebugger *debugger) * * * Paramètres : debugger = débogueur à relancer. * * * -* Description : Remet en marche le débogueur utilisant gdb(). * +* Description : Remet en marche le débogueur utilisant un serveur GDB. * * * * Retour : Bilan de l'opération. * * * @@ -140,13 +257,16 @@ bool g_gdb_debugger_run(GGdbDebugger *debugger) * * ******************************************************************************/ -bool g_gdb_debugger_resume(GGdbDebugger *debugger) +static bool g_gdb_debugger_resume(GGdbDebugger *debugger) { + + + /* g_mutex_lock(debugger->mutex); debugger->run_again = TRUE; g_cond_signal(debugger->cond); g_mutex_unlock(debugger->mutex); - + */ return true; } @@ -156,7 +276,7 @@ bool g_gdb_debugger_resume(GGdbDebugger *debugger) * * * Paramètres : debugger = débogueur à relancer. * * * -* Description : Tue le débogueur utilisant gdb(). * +* Description : Tue le débogueur utilisant un serveur GDB. * * * * Retour : Bilan de l'opération. * * * @@ -164,8 +284,11 @@ bool g_gdb_debugger_resume(GGdbDebugger *debugger) * * ******************************************************************************/ -bool g_gdb_debugger_kill(GGdbDebugger *debugger) +static bool g_gdb_debugger_kill(GGdbDebugger *debugger) { + + +#if 0 int ret; /* Bilan de l'appel système */ ret = kill(debugger->child, SIGKILL); @@ -177,19 +300,11 @@ bool g_gdb_debugger_kill(GGdbDebugger *debugger) debugger->run_again = TRUE; g_cond_signal(debugger->cond); g_mutex_unlock(debugger->mutex); - +#endif return true; } -#endif - - - - - - -#include "tcp.h" diff --git a/src/debug/remgdb/gdb.h b/src/debug/remgdb/gdb.h index 2812afd..dfd2f69 100644 --- a/src/debug/remgdb/gdb.h +++ b/src/debug/remgdb/gdb.h @@ -28,9 +28,9 @@ #include <glib-object.h> -#include "../debuggers.h" +#include "../debugger.h" + -#if 0 #define G_TYPE_GDB_DEBUGGER (g_gdb_debugger_get_type()) #define G_GDB_DEBUGGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_GDB_DEBUGGER, GGdbDebugger)) @@ -40,18 +40,18 @@ #define G_GDB_DEBUGGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GDB_DEBUGGER, GGdbDebuggerClass)) -/* Débogueur utilisant gdb (instance) */ +/* Débogueur utilisant un serveur GDB (instance) */ typedef struct _GGdbDebugger GGdbDebugger; -/* Débogueur utilisant gdb (classe) */ +/* Débogueur utilisant un serveur GDB (classe) */ typedef struct _GGdbDebuggerClass GGdbDebuggerClass; /* Indique le type défini par la GLib pour le débogueur gdb. */ GType g_gdb_debugger_get_type(void); -#endif - +/* Crée un débogueur utilisant un serveur GDB distant. */ +GBinaryDebugger *g_gdb_debugger_new(GOpenidaBinary *, void *); void test_gdb(void); diff --git a/src/debug/remgdb/helpers.c b/src/debug/remgdb/helpers.c new file mode 100644 index 0000000..9451b08 --- /dev/null +++ b/src/debug/remgdb/helpers.c @@ -0,0 +1,139 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * helpers.c - assistanat dans la manipulation des paquets GDB + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "helpers.h" + + +#include <regex.h> +#include <string.h> + + + + + + + + + + + + + + + + +/* -------------------------- PAQUETS DES REPONSES D'ARRET -------------------------- */ + + + + + + +/****************************************************************************** +* * +* Paramètres : packet = paquet de deonnées à interpréter. * +* sig = identifiant du signal source. [OUT] * +* addr = adresse de l'instruction courante. [OUT] * +* thread = identifiant du thread concerné. [OUT] * +* endian = boutisme de la plateforme ciblée. * +* * +* Description : Récupère les informations liées à un arrêt suite à signal. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : Les données sont la forme : * +* T0505:00000000;04:a08de6bf;08:505878b7;thread:50dc; * +* * +******************************************************************************/ + +bool get_stop_reply_sig_info(const GGdbPacket *packet, int *sig, vmpa_t *addr, pid_t *thread, SourceEndian endian) +{ + const char *data; /* Données brutes du paquet */ + size_t length; /* Quantité de ces données */ + uint8_t index; /* Indice de 8 bits quelconque */ + size_t pos; /* Tête de lecture courante */ + regex_t preg; /* Expression régulière */ + int ret; /* Bilan d'un appel */ + regmatch_t pmatch[3]; /* Zones remarquées */ + size_t key_len; /* Taille de l'indicatif */ + + *addr = 0ull; + + g_gdb_packet_get_data(packet, &data, &length, NULL); + + pos = 1; + + /* Lecture du numéro du signal */ + + if (!strtou8(&index, data, &pos, length, SRE_LITTLE)) + return false; + + *sig = index; + + /* Reste des informations */ + + ret = regcomp(&preg, "([^:]+):([^;]+);", REG_EXTENDED | REG_ICASE); + if (ret != 0) return false; + + for (ret = regexec(&preg, &data[pos], 3, pmatch, 0); + ret != REG_NOMATCH; + ret = regexec(&preg, &data[pos], 3, pmatch, 0)) + { + key_len = pmatch[1].rm_eo - pmatch[1].rm_so; + + /* Indication sur le thread */ + if (key_len == strlen("thread") + && strncmp(&data[pos + pmatch[1].rm_so], "thread", key_len) == 0) + { + + /* TODO printf("Thread found !\n"); */ + + } + + /* Valeur de registre ? */ + else if (key_len == 2) + { + if (!strtou8(&index, data, (size_t []) { pos + pmatch[1].rm_so }, length, SRE_LITTLE)) + return false; + + if (index != 8 /* FIXME */) + goto next_field; + + if (!strtou32(addr, data, (size_t []) { pos + pmatch[2].rm_so }, length, SRE_LITTLE/* FIXME */)) + return false; + + } + + next_field: + pos += pmatch[0].rm_eo; + + } + + regfree(&preg); + + return (*addr != 0ull); + +} + + + diff --git a/src/debug/remgdb/helpers.h b/src/debug/remgdb/helpers.h new file mode 100644 index 0000000..d6888d0 --- /dev/null +++ b/src/debug/remgdb/helpers.h @@ -0,0 +1,61 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * helpers.h - prototypes pour un assistanat dans la manipulation des paquets GDB + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _DEBUG_REMGDB_HELPERS_H +#define _DEBUG_REMGDB_HELPERS_H + + +#include "packet.h" + + +#include "../../arch/archbase.h" +#include "../../common/endianness.h" + + + + + + + +/* -------------------------- PAQUETS DES REPONSES D'ARRET -------------------------- */ + + +/* Récupère les informations liées à un arrêt suite à signal. */ +bool get_stop_reply_sig_info(const GGdbPacket *, int *, vmpa_t *, pid_t *, SourceEndian); + + + +/* ---------------------------------------------------------------------------------- */ +/* PAQUETS DES REPONSES D'ARRET */ +/* ---------------------------------------------------------------------------------- */ + + + + + + + + + + +#endif /* _DEBUG_REMGDB_HELPERS_H */ diff --git a/src/debug/remgdb/packet.c b/src/debug/remgdb/packet.c index 3fd3cba..acdec1d 100644 --- a/src/debug/remgdb/packet.c +++ b/src/debug/remgdb/packet.c @@ -333,7 +333,7 @@ bool g_gdb_packet_decode(GGdbPacket *packet) * * ******************************************************************************/ -void g_gdb_packet_get_data(GGdbPacket *packet, const char **data, size_t *len, uint8_t *checksum) +void g_gdb_packet_get_data(const GGdbPacket *packet, const char **data, size_t *len, uint8_t *checksum) { *data = packet->buffer; *len = packet->len; diff --git a/src/debug/remgdb/packet.h b/src/debug/remgdb/packet.h index 30be43e..9276e62 100644 --- a/src/debug/remgdb/packet.h +++ b/src/debug/remgdb/packet.h @@ -69,7 +69,7 @@ bool g_gdb_packet_verify_checksum(GGdbPacket *, uint8_t); bool g_gdb_packet_decode(GGdbPacket *); /* Fournit le contenu du paquet. */ -void g_gdb_packet_get_data(GGdbPacket *, const char **, size_t *, uint8_t *); +void g_gdb_packet_get_data(const GGdbPacket *, const char **, size_t *, uint8_t *); /* Ajoute un paquet à une liste de paquets. */ void g_gdb_packet_push(GGdbPacket **, GGdbPacket *); diff --git a/src/debug/remgdb/stream.c b/src/debug/remgdb/stream.c index 2b487ad..0f17930 100644 --- a/src/debug/remgdb/stream.c +++ b/src/debug/remgdb/stream.c @@ -41,6 +41,9 @@ static void g_gdb_stream_class_init(GGdbStreamClass *); /* Initialise une instance de flux de communication avec GDB. */ static void g_gdb_stream_init(GGdbStream *); +/* Envoie un acquittement pour la dernière réception. */ +static bool gdb_stream_ack(GGdbStream *); + /* Ecoute une connexion à un serveur GDB. */ static void *gdb_stream_thread(GGdbStream *); @@ -124,6 +127,37 @@ bool g_gdb_stream_listen(GGdbStream *stream) * * * Paramètres : stream = encadrement associée à l'opération. * * * +* Description : Envoie un acquittement pour la dernière réception. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool gdb_stream_ack(GGdbStream *stream) +{ + bool result; /* Bilan à retourner */ + GGdbPacket *packet; /* Paquet à envoyer */ + + packet = g_gdb_stream_get_free_packet(stream); + + g_gdb_packet_start_new_command(packet); + g_gdb_packet_append(packet, "+"); + + result = g_gdb_stream_send_packet(stream, packet); + + g_gdb_stream_mark_packet_as_free(stream, packet); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : stream = encadrement associée à l'opération. * +* * * Description : Ecoute une connexion à un serveur GDB. * * * * Retour : ??? * @@ -145,6 +179,8 @@ static void *gdb_stream_thread(GGdbStream *stream) ret = select(stream->fd + 1, &rfds, NULL, NULL, NULL); + printf("ret :: %d\n", ret); + switch (ret) { case -1: @@ -162,6 +198,11 @@ static void *gdb_stream_thread(GGdbStream *stream) if (g_gdb_stream_read_packet(stream, packet)) { + /* Acquittement */ + if (!gdb_stream_ack(stream)) goto bad_recv; + + /* On conserve le résultat */ + g_mutex_lock(stream->recv_mutex); g_gdb_packet_push(&stream->recv_packets, packet); g_mutex_unlock(stream->recv_mutex); @@ -169,7 +210,12 @@ static void *gdb_stream_thread(GGdbStream *stream) g_cond_signal(stream->recv_cond); } - else g_gdb_stream_mark_packet_as_free(stream, packet); + + bad_recv: + + printf("bad things happend...\n"); + + g_gdb_stream_mark_packet_as_free(stream, packet); break; diff --git a/src/editor.c b/src/editor.c index f038de6..c446234 100644 --- a/src/editor.c +++ b/src/editor.c @@ -48,7 +48,7 @@ #include "gtkext/gtkblockview.h" #include "gtkext/gtkdockpanel.h" -#include "debug/debuggers.h" +#include "debug/debugger.h" #include "dialogs/about.h" #include "dialogs/binparts.h" #include "dialogs/export.h" @@ -126,7 +126,7 @@ static void mcb_binary_select_plugins(GtkMenuItem *, GObject *); static void mcb_binary_export(GtkMenuItem *, GObject *); -/*Réagit avec le menu "Débogage -> Démarrer". */ +/* Réagit avec le menu "Débogage -> Démarrer". */ void mcb_debug_start(GtkCheckMenuItem *, gpointer); /* Réagit avec le menu "Débogage -> Mettre en pause". */ @@ -162,6 +162,12 @@ static void refresh_editor_menus(GObject *, GOpenidaBinary *, GtkBinView *); +/* ------------------------- PARTIE DEDIEE AU MODE DEBOGAGE ------------------------- */ + + +/* Prend note d'une pause dans le débogage. */ +static void on_debugger_halted(GBinaryDebugger *, int, vmpa_t, pid_t, GObject *); + @@ -1271,12 +1277,14 @@ void mcb_debug_start(GtkCheckMenuItem *menuitem, gpointer data) - debugger = g_new_binary_debugger(DGT_PTRACE, binary); + debugger = g_new_binary_debugger(DGT_REMOTE_GDB, binary); g_object_set_data(G_OBJECT(data), "current_debugger", debugger); g_signal_connect(debugger, "debugger-stopped", G_CALLBACK(debugger_stopped_cb), data); + g_signal_connect(debugger, "halted", G_CALLBACK(on_debugger_halted), data); + g_binary_debugger_run(debugger); @@ -1450,6 +1458,7 @@ static void mcb_help_about(GtkMenuItem *menuitem, GObject *ref) static void on_dock_item_switch(GtkDockPanel *panel, GDockItem *item, GObject *ref) { GtkWidget *widget; /* Support réel à traiter */ + GOpenidaBinary *old_binary; /* Ancien binaire édité */ GOpenidaBinary *binary; /* Binaire en cours d'édition */ widget = g_dock_item_get_panel(item); @@ -1462,9 +1471,17 @@ static void on_dock_item_switch(GtkDockPanel *panel, GDockItem *item, GObject *r if (GTK_IS_BIN_VIEW(widget)) { + /* Changement de binaire ? */ + + old_binary = G_OPENIDA_BINARY(g_object_get_data(ref, "current_binary")); binary = gtk_bin_view_get_binary(GTK_BIN_VIEW(widget)); - g_object_set_data(ref, "current_binary", binary); + if (old_binary != binary) + { + g_object_set_data(ref, "current_binary", binary); + notify_panels_of_binary_change(binary); + } + g_object_set_data(ref, "binview", widget); refresh_editor_menus(ref, binary, GTK_BIN_VIEW(widget)); @@ -1520,3 +1537,43 @@ static void refresh_editor_menus(GObject *ref, GOpenidaBinary *binary, GtkBinVie g_signal_connect(menuitem, "toggled", G_CALLBACK(mcb_view_change_support), ref); } + + + + + + + + + + +/* ---------------------------------------------------------------------------------- */ +/* PARTIE DEDIEE AU MODE DEBOGAGE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : debugger = débogueur intervenant dans l'action. * +* sig = identifiant du signal source (nul si indéterminé).* +* addr = adresse de l'instruction courante. * +* thread = identifiant du thread concerné. * +* ref = espace de référencement global. * +* * +* Description : Prend note d'une pause dans le débogage. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void on_debugger_halted(GBinaryDebugger *debugger, int sig, vmpa_t addr, pid_t thread, GObject *ref) +{ + + printf("HALT (sig=%d) at 0x%016llx\n", sig, addr); + + + + +} diff --git a/src/glibext/Makefile.am b/src/glibext/Makefile.am index 7712965..1e21b58 100644 --- a/src/glibext/Makefile.am +++ b/src/glibext/Makefile.am @@ -6,7 +6,8 @@ libglibext_la_SOURCES = \ delayed.h delayed.c \ gbufferline.h gbufferline.c \ gbuffersegment.h gbuffersegment.c \ - gcodebuffer.h gcodebuffer.c + gcodebuffer.h gcodebuffer.c \ + proto.h libglibext_la_LDFLAGS = diff --git a/src/glibext/proto.h b/src/glibext/proto.h new file mode 100644 index 0000000..5831e11 --- /dev/null +++ b/src/glibext/proto.h @@ -0,0 +1,42 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * proto.h - prototypes supplémentaires pour les fonctions GLib + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _GLIBEXT_PROTO_H +#define _GLIBEXT_PROTO_H + + +#include <glib-object.h> + + + +/** + * Boucle de parcours avec plusieurs arguments : + * - #1 : conteneur. + * - #2 : élément parcouru. + * - #3 : éventuelle donnée de l'utilisateur. + */ +typedef void (* GExtFunc) (gpointer container, gpointer item, gpointer data); + + + +#endif /* _GLIBEXT_PROTO_H */ diff --git a/src/gtkext/gtkblockview.c b/src/gtkext/gtkblockview.c index 5c5d0f6..a19c17a 100644 --- a/src/gtkext/gtkblockview.c +++ b/src/gtkext/gtkblockview.c @@ -663,8 +663,10 @@ static gboolean gtk_block_view_button_press(GtkWidget *widget, GdkEventButton *e { line = G_RENDERING_LINE(g_object_get_data(G_OBJECT(bline), "line")); + g_openida_binary_toggle_breakpoint(GTK_BIN_VIEW(view)->binary, + get_rendering_line_address(line)); + result = TRUE; - g_rendering_line_toggle_flag(line, RLF_BREAK_POINT); } @@ -38,7 +38,6 @@ #include "plugins/pglist.h" -/////void test_gdb(void); //extern test_itanium_demangling(name_demangler *); @@ -80,16 +79,6 @@ int main(int argc, char **argv) gtk_set_locale(); gtk_init(&argc, &argv); - - /* - test_gdb(); - gdk_threads_enter(); - gtk_main(); - gdk_threads_leave(); - */ - - - /* * this initialize the library and check potential ABI mismatches * between the version it was compiled for and the actual shared diff --git a/src/panels/Makefile.am b/src/panels/Makefile.am index 2ab4bad..0db863a 100755 --- a/src/panels/Makefile.am +++ b/src/panels/Makefile.am @@ -2,6 +2,7 @@ noinst_LTLIBRARIES = libpanels.la libpanels_la_SOURCES = \ + breaks.h breaks.c \ glimpse.h glimpse.c \ log.h log.c \ panel-int.h \ diff --git a/src/panels/breaks.c b/src/panels/breaks.c new file mode 100644 index 0000000..5455aed --- /dev/null +++ b/src/panels/breaks.c @@ -0,0 +1,454 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * breaks.c - panneau d'affichage des points d'arrêt + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "breaks.h" + + +#include "panel-int.h" +#include "../gtkext/easygtk.h" +#include "../gtkext/support.h" + + + +#define _(str) str + + +/* Panneau d'affichage des points d'arrêt (instance) */ +struct _GBreaksPanel +{ + GEditorPanel parent; /* A laisser en premier */ + + GtkTreeView *treeview; /* Composant d'affichage */ + GtkTreeStore *store; /* Modèle de gestion */ + + GOpenidaBinary *binary; /* Binaire en cours d'étude */ + +}; + + +/* Panneau d'affichage des points d'arrêt (classe) */ +struct _GBreaksPanelClass +{ + GEditorPanelClass parent; /* A laisser en premier */ + +}; + + +/* Colonnes de la liste des symboles */ +typedef enum _BreaksColumn +{ + BKC_POINT, /* Point d'arrêt de référence */ + BKC_ICON, /* Statut du point d'arrêt */ + BKC_ADDRESS, /* Adresse mémoire du symbole */ + BKC_STRING, /* Désignation humaine */ + + BKC_COUNT /* Nombre de colonnes */ + +} BreaksColumn; + + +/* Initialise la classe des panneaux de points d'arrêt. */ +static void g_breaks_panel_class_init(GBreaksPanelClass *); + +/* Initialise une instance de panneau de points d'arrêt. */ +static void g_breaks_panel_init(GBreaksPanel *); + +/* Réagit à un changement du binaire courant. */ +static void reload_breaks_for_new_binary(GBreaksPanel *, GOpenidaBinary *); + + + + +/* Intègre à l'affichage un groupe de points d'arrêt. */ +static void add_bp_group_to_breaks_panel(GOpenidaBinary *, GBreakGroup *, GBreaksPanel *); + +/* Réagit à une nouvelle création de point d'arrêt. */ +static void refresh_breaks_panel_on_bp_added(GBreakGroup *, GBreakPoint *, GBreaksPanel *); + +/* Réagit à une suppression de point d'arrêt. */ +static void refresh_breaks_panel_on_bp_removed(GBreakGroup *, GBreakPoint *, GBreaksPanel *); + +/* Réagit à une modification de point d'arrêt. */ +static void refresh_breaks_panel_on_bp_changed(GBreakGroup *, GBreakPoint *, GBreaksPanel *); + + + + +/* Retrouve un point d'arrêt dans la liste affichée. */ +static bool find_breakpoint_in_breaks_panel(GBreaksPanel *, GBreakPoint *, GtkTreeIter *); + + + +/* Indique le type définit pour un panneau d'affichage des points d'arrêt. */ +G_DEFINE_TYPE(GBreaksPanel, g_breaks_panel, G_TYPE_EDITOR_PANEL); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des panneaux de points d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_breaks_panel_class_init(GBreaksPanelClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : panel = instance à initialiser. * +* * +* Description : Initialise une instance de panneau de points d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_breaks_panel_init(GBreaksPanel *panel) +{ + GEditorPanel *base; /* Version basique d'instance */ + GObject *ref; /* Espace de référencement */ + GtkTooltips *tooltips; /* Affichage des bulles d'aide */ + GtkWidget *toolbar; /* Barre d'outils */ + GtkWidget *button; /* Bouton de cette même barre */ + GtkWidget *separator; /* Barre de séparation vert. */ + GtkWidget *scrollwnd; /* Support défilant */ + GtkWidget *treeview; /* Affichage de la liste */ + GtkCellRenderer *renderer; /* Moteur de rendu de colonne */ + GtkTreeViewColumn *column; /* Colonne de la liste */ + GtkTreeSelection *select; /* Sélection dans la liste */ + + + + + base = G_EDITOR_PANEL(panel); + + base->name = _("Breakpoints"); + base->reload_binary = (reload_for_new_binary_fc)reload_breaks_for_new_binary; + + base->widget = gtk_vbox_new(FALSE, 0); + gtk_widget_show(base->widget); + + ref = G_OBJECT(base->widget); + g_object_set_data(ref, "panel", panel); + + scrollwnd = gtk_scrolled_window_new(NULL, NULL); + gtk_widget_show(scrollwnd); + gtk_box_pack_start(GTK_BOX(base->widget), scrollwnd, TRUE, TRUE, 0); + + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwnd), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwnd), GTK_SHADOW_IN); + + panel->store = gtk_tree_store_new(BKC_COUNT, G_TYPE_OBJECT, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); + + treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(panel->store)); + gtk_widget_show(treeview); + gtk_container_add(GTK_CONTAINER(scrollwnd), treeview); + + panel->treeview = GTK_TREE_VIEW(treeview); + + g_object_unref(G_OBJECT(panel->store)); + + column = gtk_tree_view_column_new(); + gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); + gtk_tree_view_set_expander_column(GTK_TREE_VIEW(treeview), column); + + + + column = gtk_tree_view_column_new(); + gtk_tree_view_column_set_title(column, _("Address")); + + renderer = gtk_cell_renderer_pixbuf_new(); + gtk_tree_view_column_pack_start(column, renderer, FALSE); + gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", BKC_ICON); + + renderer = gtk_cell_renderer_text_new(); + gtk_tree_view_column_pack_start(column, renderer, TRUE); + gtk_tree_view_column_add_attribute(column, renderer, "text", BKC_ADDRESS); + + gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); + + + + + //renderer = gtk_cell_renderer_text_new(); + //column = gtk_tree_view_column_new_with_attributes(_("Address"), renderer, "text", BKC_ADDRESS, NULL); + //gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); + + renderer = gtk_cell_renderer_text_new(); + column = gtk_tree_view_column_new_with_attributes(_("String"), renderer, "text", BKC_STRING, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); + + + + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Crée un panneau d'aperçu de graphiques. * +* * +* Retour : Adresse de la structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GEditorPanel *g_breaks_panel_new(void) +{ + GEditorPanel *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_BREAKS_PANEL, NULL); + + return G_EDITOR_PANEL(result); + +} + + +/****************************************************************************** +* * +* Paramètres : panel = panneau à mettre à jour. * +* binary = nouvelle instance de binaire analysé. * +* * +* Description : Réagit à un changement du binaire courant. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void reload_breaks_for_new_binary(GBreaksPanel *panel, GOpenidaBinary *binary) +{ + + printf("CHNAGE BINARY !\n"); + + panel->binary = binary; + + g_openida_binary_for_each_bp_group(binary, (GExtFunc)add_bp_group_to_breaks_panel, panel); + + +} + + + + + + + + + + + + + + +/****************************************************************************** +* * +* Paramètres : binary = instance active du binaire analysé. * +* group = groupe de points d'arrêt présent dans le binaire. * +* panel = panneau à mettre à jour. * +* * +* Description : Intègre à l'affichage un groupe de points d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void add_bp_group_to_breaks_panel(GOpenidaBinary *binary, GBreakGroup *group, GBreaksPanel *panel) +{ + /* FIXME : bloquer toute émission de signal tant que les ajouts ne sont pas terminés. */ + + g_signal_connect(group, "added", + G_CALLBACK(refresh_breaks_panel_on_bp_added), panel); + + g_signal_connect(group, "removed", + G_CALLBACK(refresh_breaks_panel_on_bp_removed), panel); + + g_break_group_for_each(group, (GExtFunc)refresh_breaks_panel_on_bp_added, panel); + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de points d'arrêt intervenant. * +* point = point d'arrêt à l'origine de la procédure. * +* panel = panneau à mettre à jour. * +* * +* Description : Réagit à une nouvelle création de point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void refresh_breaks_panel_on_bp_added(GBreakGroup *group, GBreakPoint *point, GBreaksPanel *panel) +{ + GExeFormat *format; /* Format associé au binaire */ + GArchProcessor *proc; /* Architecture utilisée */ + char address[VMPA_MAX_SIZE]; /* Conversion de l'adresse */ + GtkTreeIter iter; /* Point d'insertion */ + + format = g_openida_binary_get_format(panel->binary); + proc = get_arch_processor_from_format(format); + + vmpa_to_string(g_break_point_get_address(point), + g_arch_processor_get_memory_size(proc), + address); + + gtk_tree_store_append(panel->store, &iter, NULL); + gtk_tree_store_set(panel->store, &iter, + BKC_POINT, point, + BKC_ADDRESS, address, + BKC_STRING, "???", + -1); + + /* Pour le reste... */ + refresh_breaks_panel_on_bp_changed(group, point, panel); + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de points d'arrêt intervenant. * +* point = point d'arrêt à l'origine de la procédure. * +* panel = panneau à mettre à jour. * +* * +* Description : Réagit à une suppression de point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void refresh_breaks_panel_on_bp_removed(GBreakGroup *group, GBreakPoint *point, GBreaksPanel *panel) +{ + GtkTreeIter iter; /* Point de modification */ + + if (!find_breakpoint_in_breaks_panel(panel, point, &iter)) + return; + + gtk_tree_store_remove(panel->store, &iter); + +} + + +/****************************************************************************** +* * +* Paramètres : group = ensemble de points d'arrêt intervenant. * +* point = point d'arrêt à l'origine de la procédure. * +* panel = panneau à mettre à jour. * +* * +* Description : Réagit à une modification de point d'arrêt. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void refresh_breaks_panel_on_bp_changed(GBreakGroup *group, GBreakPoint *point, GBreaksPanel *panel) +{ + GtkTreeIter iter; /* Point de modification */ + GdkPixbuf *pixbuf; /* Tampon d'image chargé */ + + if (!find_breakpoint_in_breaks_panel(panel, point, &iter)) + return; + + pixbuf = get_pixbuf_from_file("breakpoint_normal.png"); + if (pixbuf == NULL) return; + + gtk_tree_store_set(panel->store, &iter, + BKC_ICON, pixbuf, + -1); + +} + + + + + + + + + + +/****************************************************************************** +* * +* Paramètres : panel = panneau d'affichage à consulter. * +* point = point d'arrêt lié à la procédure. * +* * +* Description : Retrouve un point d'arrêt dans la liste affichée. * +* * +* Retour : Bilan de la recherche. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool find_breakpoint_in_breaks_panel(GBreaksPanel *panel, GBreakPoint *point, GtkTreeIter *iter) +{ + bool result; /* Bilan à retourner */ + GtkTreeIter tmp; /* Sauvegarde temporaire */ + bool test; /* Valide la poursuite */ + GBreakPoint *bp; /* Adresse à comparer */ + + result = false; + + for (test = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(panel->store), &tmp); + test && !result; + test = gtk_tree_model_iter_next(GTK_TREE_MODEL(panel->store), &tmp)) + { + gtk_tree_model_get(GTK_TREE_MODEL(panel->store), + &tmp, BKC_POINT, &bp, -1); + + if (bp == point) + { + *iter = tmp; + result = true; + } + + } + + return result; + +} diff --git a/src/panels/breaks.h b/src/panels/breaks.h new file mode 100644 index 0000000..7a32e31 --- /dev/null +++ b/src/panels/breaks.h @@ -0,0 +1,59 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * breaks.h - prototypes pour le panneau d'affichage des points d'arrêt + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA 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. + * + * OpenIDA 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _PANELS_BREAKS_H +#define _PANELS_BREAKS_H + + +#include <glib-object.h> + + +#include "panel.h" + + + +#define G_TYPE_BREAKS_PANEL g_breaks_panel_get_type() +#define G_BREAKS_PANEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_breaks_panel_get_type(), GBreaksPanel)) +#define G_IS_BREAKS_PANEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_breaks_panel_get_type())) +#define G_BREAKS_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BREAKS_PANEL, GBreaksPanelClass)) +#define G_IS_BREAKS_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BREAKS_PANEL)) +#define G_BREAKS_PANEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BREAKS_PANEL, GBreaksPanelClass)) + + +/* Panneau d'affichage des points d'arrêt (instance) */ +typedef struct _GBreaksPanel GBreaksPanel; + +/* Panneau d'affichage des points d'arrêt (classe) */ +typedef struct _GBreaksPanelClass GBreaksPanelClass; + + +/* Indique le type définit pour un panneau d'affichage des points d'arrêt. */ +GType g_breaks_panel_get_type(void); + +/* Crée un panneau d'affichage des points d'arrêt. */ +GEditorPanel *g_breaks_panel_new(void); + + + +#endif /* _PANELS_BREAKS_H */ diff --git a/src/panels/panel-int.h b/src/panels/panel-int.h index 417665f..0048d19 100644 --- a/src/panels/panel-int.h +++ b/src/panels/panel-int.h @@ -34,6 +34,9 @@ +/* Réagit à un changement du binaire courant. */ +typedef void (* reload_for_new_binary_fc) (GEditorPanel *, GOpenidaBinary *); + /* Réagit à un changement d'affichage principal de contenu. */ typedef void (* reload_for_new_view_fc) (GEditorPanel *, GtkBinView *, bool); @@ -47,6 +50,7 @@ struct _GEditorPanel const char *name; /* Nom du panneau */ + reload_for_new_binary_fc reload_binary; /* Changement de binaire */ reload_for_new_view_fc reload_view; /* Rechargement dû à une vue */ GtkWidget *widget; /* Composant GTK d'affichage */ diff --git a/src/panels/panel.c b/src/panels/panel.c index 9cf3f98..c9acac9 100644 --- a/src/panels/panel.c +++ b/src/panels/panel.c @@ -25,6 +25,7 @@ #include "panel.h" +#include "breaks.h" #include "glimpse.h" #include "panel-int.h" #include "symbols.h" @@ -143,6 +144,9 @@ void init_internal_panels(void) { GEditorPanel *panel; /* Nouveau panneau chargé */ + panel = g_breaks_panel_new(); + panels_list_add_tail(panel, &panels_list); + panel = g_symbols_panel_new(); panels_list_add_tail(panel, &panels_list); @@ -180,6 +184,29 @@ void place_all_panels_in_editor(GtkWidget *top) /****************************************************************************** * * +* Paramètres : binary = nouvelle instance de binaire analysé. * +* * +* Description : Lance une actualisation du fait d'un changement de binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void notify_panels_of_binary_change(GOpenidaBinary *binary) +{ + GEditorPanel *iter; /* Boucle de parcours */ + + panels_list_for_each(iter, panels_list) + if (iter->reload_binary != NULL) + iter->reload_binary(iter, binary); + +} + + +/****************************************************************************** +* * * Paramètres : view = nouvelle visualisation de désassemblage. * * same = changement de binaire ou de vue ? * * * diff --git a/src/panels/panel.h b/src/panels/panel.h index 1a94ebc..38eeb79 100644 --- a/src/panels/panel.h +++ b/src/panels/panel.h @@ -76,6 +76,9 @@ void init_internal_panels(void); /* Incruste tous les panneaux dans la fenêtre de l'éditeur. */ void place_all_panels_in_editor(GtkWidget *); +/* Lance une actualisation du fait d'un changement de binaire. */ +void notify_panels_of_binary_change(GOpenidaBinary *); + /* Lance une actualisation du fait d'un changement de vue. */ void notify_panels_of_view_change(GtkBinView *, bool); diff --git a/src/panels/registers.h b/src/panels/registers.h index 7110414..0abf849 100644 --- a/src/panels/registers.h +++ b/src/panels/registers.h @@ -29,7 +29,7 @@ #include <gtk/gtk.h> -#include "../debug/debuggers.h" +#include "../debug/debugger.h" diff --git a/src/panels/symbols.c b/src/panels/symbols.c index d24bedf..e3c9bd4 100644 --- a/src/panels/symbols.c +++ b/src/panels/symbols.c @@ -26,7 +26,6 @@ #include <string.h> -#include <gtk/gtk.h> #include "panel-int.h" |
