summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorCyrille Bagard <nocbos@gmail.com>2010-07-29 00:02:49 (GMT)
committerCyrille Bagard <nocbos@gmail.com>2010-07-29 00:02:49 (GMT)
commit73af1bd66e5d1a2e30d56151532710f2b28d12df (patch)
tree88f98194359accd8349193f4cbe3c4cabee24d23 /src
parentf150f36ee0297b4499a41bbbfc06699cd2f72db5 (diff)
Improved the GDB client.
git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@175 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a
Diffstat (limited to 'src')
-rw-r--r--src/analysis/binary.c211
-rw-r--r--src/analysis/binary.h15
-rwxr-xr-xsrc/common/Makefile.am1
-rw-r--r--src/common/cpp.h45
-rwxr-xr-xsrc/common/endianness.c197
-rwxr-xr-xsrc/common/endianness.h12
-rwxr-xr-xsrc/debug/Makefile.am3
-rw-r--r--src/debug/break.c440
-rw-r--r--src/debug/break.h105
-rw-r--r--src/debug/debugger-int.h4
-rw-r--r--src/debug/debugger.c212
-rw-r--r--src/debug/debugger.h92
-rw-r--r--src/debug/debuggers.c197
-rw-r--r--src/debug/debuggers.h91
-rw-r--r--src/debug/ptrace/ptrace.h2
-rw-r--r--src/debug/remgdb/Makefile.am1
-rw-r--r--src/debug/remgdb/gdb.c179
-rw-r--r--src/debug/remgdb/gdb.h12
-rw-r--r--src/debug/remgdb/helpers.c139
-rw-r--r--src/debug/remgdb/helpers.h61
-rw-r--r--src/debug/remgdb/packet.c2
-rw-r--r--src/debug/remgdb/packet.h2
-rw-r--r--src/debug/remgdb/stream.c48
-rw-r--r--src/editor.c65
-rw-r--r--src/glibext/Makefile.am3
-rw-r--r--src/glibext/proto.h42
-rw-r--r--src/gtkext/gtkblockview.c4
-rw-r--r--src/main.c11
-rwxr-xr-xsrc/panels/Makefile.am1
-rw-r--r--src/panels/breaks.c454
-rw-r--r--src/panels/breaks.h59
-rw-r--r--src/panels/panel-int.h4
-rw-r--r--src/panels/panel.c27
-rw-r--r--src/panels/panel.h3
-rw-r--r--src/panels/registers.h2
-rw-r--r--src/panels/symbols.c1
36 files changed, 2396 insertions, 351 deletions
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);
}
diff --git a/src/main.c b/src/main.c
index 544ce57..02ea961 100644
--- a/src/main.c
+++ b/src/main.c
@@ -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"