diff options
| -rw-r--r-- | ChangeLog | 30 | ||||
| -rw-r--r-- | configure.ac | 1 | ||||
| -rw-r--r-- | src/Makefile.am | 16 | ||||
| -rw-r--r-- | src/analysis/binary.c | 17 | ||||
| -rw-r--r-- | src/analysis/delayed.c | 299 | ||||
| -rw-r--r-- | src/analysis/delayed.h | 55 | ||||
| -rw-r--r-- | src/glibext/Makefile.am | 17 | ||||
| -rw-r--r-- | src/glibext/delayed-int.h | 82 | ||||
| -rw-r--r-- | src/glibext/delayed.c | 226 | ||||
| -rw-r--r-- | src/glibext/delayed.h | 81 | ||||
| -rw-r--r-- | src/gtkext/gtkblockview.c | 8 | ||||
| -rw-r--r-- | src/gtkext/gtkgraphview.c | 30 | ||||
| -rw-r--r-- | src/main.c | 2 |
13 files changed, 612 insertions, 252 deletions
@@ -1,5 +1,35 @@ 09-08-30 Cyrille Bagard <nocbos@gmail.com> + * configure.ac: + Add the new Makefile from the 'src/glibext' directory to AC_CONFIG_FILES. + + * src/analysis/binary.c: + Update code. + + * src/analysis/delayed.c: + * src/analysis/delayed.h: + Update/clean the code by using the generic delayed manager. + + * src/glibext/delayed.c: + * src/glibext/delayed.h: + * src/glibext/delayed-int.h: + * src/glibext/Makefile.am: + New entries: provide a clean way to run delayed tasks. + + * src/gtkext/gtkblockview.c: + Clean and improve the gtk_block_view_set_rendering_lines() function. + + * src/gtkext/gtkgraphview.c: + Clean the gtk_graph_view_set_rendering_lines() function. + + * src/main.c: + Update code. + + * src/Makefile.am: + Create the new liboidaglibext library. Add glibext to SUBDIRS. + +09-08-30 Cyrille Bagard <nocbos@gmail.com> + * src/editor.c: Quickly fix a bug in binary view lookup. diff --git a/configure.ac b/configure.ac index c483d47..81079a7 100644 --- a/configure.ac +++ b/configure.ac @@ -248,6 +248,7 @@ AC_CONFIG_FILES([Makefile src/format/java/Makefile src/format/mangling/Makefile src/format/pe/Makefile + src/glibext/Makefile src/graph/Makefile src/gtkext/Makefile src/panel/Makefile diff --git a/src/Makefile.am b/src/Makefile.am index 3685409..95eff37 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1,5 +1,5 @@ -lib_LTLIBRARIES = liboidadisass.la liboidagtkext.la liboidagui.la liboidaplugin.la +lib_LTLIBRARIES = liboidadisass.la liboidaglibext.la liboidagtkext.la liboidagui.la liboidaplugin.la bin_PROGRAMS=openida @@ -22,12 +22,22 @@ liboidadisass_la_LIBADD = \ format/libformat.la +#--- liboidaglibext + +liboidaglibext_la_SOURCES = + +liboidaglibext_la_LDFLAGS = $(LIBGTK_LIBS) $(LIBGRAPH_LIBS) + +liboidaglibext_la_LIBADD = \ + glibext/libglibext.la + + #--- liboidagtkext liboidagtkext_la_SOURCES = liboidagtkext_la_LDFLAGS = $(LIBGTK_LIBS) $(LIBGRAPH_LIBS) \ - -L.libs -loidadisass + -L.libs -loidadisass -loidaglibext liboidagtkext_la_LIBADD = \ graph/libgraph.la \ @@ -99,4 +109,4 @@ openida_LDADD = $(LIBINTL) \ # gtkext doit être traité en premier, à cause des marshals GLib -SUBDIRS = gtkext analysis arch format common debug graph panel plugins +SUBDIRS = glibext gtkext analysis arch format common debug graph panel plugins diff --git a/src/analysis/binary.c b/src/analysis/binary.c index c21b554..8cec72a 100644 --- a/src/analysis/binary.c +++ b/src/analysis/binary.c @@ -41,6 +41,7 @@ #include "line_prologue.h" #include "prototype.h" #include "../common/extstr.h" +#include "../glibext/delayed.h" #include "../format/format.h" #include "../panel/log.h" #include "../plugins/pglist.h" @@ -101,7 +102,7 @@ bin_t *map_binary_file(const char *, off_t *); GRenderingLine *build_binary_prologue(const char *, const uint8_t *, off_t); /* Acquitte la fin d'un désasemblage différé et complet. */ -void ack_completed_disassembly(GDelayedManager *, GOpenidaBinary *, GRenderingLine *, GOpenidaBinary *); +void ack_completed_disassembly(GDisassManager *, GOpenidaBinary *, GRenderingLine *, GOpenidaBinary *); @@ -312,24 +313,22 @@ bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPat void g_openida_binary_analyse(GOpenidaBinary *binary) { - GDelayedManager *manager; /* Gestionnaire de différés */ + GDisassManager *manager; /* Gestionnaire de différés */ GBinPart **parts; /* Parties d'élément binaire */ size_t parts_count; /* Nombre de ces parties */ + GDelayedDisassembly *disass; /* Désassemblage à mener */ - manager = get_delayed_manager(); + manager = get_disassembly_manager(); parts = g_exe_format_get_parts(binary->format, &parts_count); qsort(parts, parts_count, sizeof(GBinPart *), g_binary_part_compare); + disass = g_delayed_disassembly_new(binary, parts, parts_count); g_signal_connect(manager, "disassembly-completed", G_CALLBACK(ack_completed_disassembly), binary); - g_delayed_manager_schedule_disassembly(manager, binary, parts, parts_count); - - - - + g_delayed_queue_schedule_work(G_WORK_QUEUE(manager), G_DELAYED_WORK(disass)); } @@ -605,7 +604,7 @@ GRenderingLine *build_binary_prologue(const char *filename, const uint8_t *data, * * ******************************************************************************/ -void ack_completed_disassembly(GDelayedManager *manager, GOpenidaBinary *binary, GRenderingLine *lines, GOpenidaBinary *user) +void ack_completed_disassembly(GDisassManager *manager, GOpenidaBinary *binary, GRenderingLine *lines, GOpenidaBinary *user) { GRenderingLine *line; /* "Première" ligne de rendu */ GPluginModule **pglist; /* Liste de greffons */ diff --git a/src/analysis/delayed.c b/src/analysis/delayed.c index 6ec03e8..0d02d39 100644 --- a/src/analysis/delayed.c +++ b/src/analysis/delayed.c @@ -24,13 +24,11 @@ #include "delayed.h" -#include <malloc.h> - - #include "line_code.h" #include "line_comment.h" #include "../common/dllist.h" #include "../format/format.h" +#include "../glibext/delayed-int.h" #include "../gtkext/gtkextstatusbar.h" #include "../gtkext/iodamarshal.h" @@ -43,75 +41,75 @@ -/* Ensembles binaires à désassembler */ -typedef struct _disassembly_task +/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ + + +/* Ensembles binaires à désassembler (instance) */ +struct _GDelayedDisassembly { - GOpenidaBinary *owner; /* Destinataire final */ + GDelayedWork parent; /* A laisser en premier */ - DL_LIST_ITEM(link); /* Lien vers les maillons */ + GOpenidaBinary *binary; /* Destinataire final */ GBinPart **parts; /* Parties binaires à traiter */ size_t count; /* Nombre de ces parties */ -} disassembly_task; - +}; -#define disassembly_task_list_add_tail(new, head) dl_list_add_tail(new, head, disassembly_task, link) -#define disassembly_task_list_del(item, head) dl_list_del(item, head, disassembly_task, link) +/* Ensembles binaires à désassembler (classe) */ +struct _GDelayedDisassemblyClass +{ + GDelayedWorkClass parent; /* A laisser en premier */ +}; -/* Crée un tâche de désassemblage différé. */ -static disassembly_task *create_disassembly_task(GOpenidaBinary *, GBinPart **, size_t); -/* Efface une tâche de désassemblage de la mémoire. */ -static void delete_disassembly_task(disassembly_task *); +/* Initialise la classe des tâches de désassemblage différé. */ +static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *); +/* Initialise une tâche de désassemblage différé. */ +static void g_delayed_disassembly_init(GDelayedDisassembly *); +/* ------------------------- GESTION DES ANALYSES DIFFEREES ------------------------- */ /* Gestionnaire des analyses différées (instance) */ -struct _GDelayedManager +struct _GDisassManager { - GObject parent; /* A laisser en premier */ + GWorkQueue parent; /* A laisser en premier */ GtkExtStatusBar *statusbar; /* Barre de statut principale */ - disassembly_task *disassemblies; /* Binaires à désassembler */ - GMutex *disass_mutex; /* Verrou pour l'accès */ - GCond *disass_cond; /* Réveil pour un traitement */ - - GThread *disassemble; /* Procédures de désassemblage */ - }; /* Gestionnaire des analyses différées (classe) */ -struct _GDelayedManagerClass +struct _GDisassManagerClass { - GObjectClass parent; /* A laisser en premier */ + GWorkQueueClass parent; /* A laisser en premier */ /* Signaux */ - void (* disassembly_completed) (GDelayedManager *, GOpenidaBinary *, GRenderingLine *); + void (* disassembly_completed) (GDisassManager *, GOpenidaBinary *, GRenderingLine *); }; /* Initialise la classe des gestionnaires d'analyses différées. */ -static void g_delayed_manager_class_init(GDelayedManagerClass *); +static void g_disassembly_manager_class_init(GDisassManagerClass *); /* Initialise un gestionnaire d'analyses différées. */ -static void g_delayed_manager_init(GDelayedManager *); +static void g_disassembly_manager_init(GDisassManager *); /* Crée un gestionnaire d'analyses différées. */ -static GDelayedManager *g_delayed_manager_new(GObject *); +static GDisassManager *g_disassembly_manager_new(GObject *); /* Assure le désassemblage en différé. */ -static void *process_disassemblies(GDelayedManager *); +static void process_disassemblies(GDisassManager *, GDelayedDisassembly *); /* Procède au désassemblage basique d'un contenu binaire. */ -static GRenderingLine *disassemble_binary_parts(disassembly_task *, GBinRoutine **, size_t, GtkExtStatusBar *, guint); +static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *, GBinRoutine **, size_t, GtkExtStatusBar *, guint); /* Etablit les liens entres les différentes lignes de code. */ static void establish_links_between_lines(GRenderingLine *, GBinRoutine **, size_t, GtkExtStatusBar *, guint); @@ -124,48 +122,38 @@ static vmpa_t find_best_ending_address_for_routine(GRenderingLine *, size_t, con +/* ---------------------------------------------------------------------------------- */ +/* DESASSEMBLAGE DE BINAIRE DIFFERE */ +/* ---------------------------------------------------------------------------------- */ - +/* Indique le type défini pour les tâches de désassemblage différé. */ +G_DEFINE_TYPE(GDelayedDisassembly, g_delayed_disassembly, G_TYPE_DELAYED_WORK); /****************************************************************************** * * -* Paramètres : owner = binaire chargé en attente des résultats. * -* parts = parties binaires à désassembler. * -* count = nombre de parties à traiter. * +* Paramètres : klass = classe à initialiser. * * * -* Description : Crée un tâche de désassemblage différé. * +* Description : Initialise la classe des tâches de désassemblage différé. * * * -* Retour : Tâche créée. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -static disassembly_task *create_disassembly_task(GOpenidaBinary *owner, GBinPart **parts, size_t count) +static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *klass) { - disassembly_task *result; /* Tâche à retourner */ - - result = (disassembly_task *)calloc(1, sizeof(disassembly_task)); - - result->owner = owner; - - DL_LIST_ITEM_INIT(&result->link); - - result->parts = parts; - result->count = count; - - return result; } /****************************************************************************** * * -* Paramètres : task = tâche à libérer de la mémoire. * +* Paramètres : disass = instance à initialiser. * * * -* Description : Efface une tâche de désassemblage de la mémoire. * +* Description : Initialise une tâche de désassemblage différé. * * * * Retour : - * * * @@ -173,34 +161,50 @@ static disassembly_task *create_disassembly_task(GOpenidaBinary *owner, GBinPart * * ******************************************************************************/ -static void delete_disassembly_task(disassembly_task *task) +static void g_delayed_disassembly_init(GDelayedDisassembly *disass) { - /* TODO - result->parts = parts; - result->count = count; - */ - - free(task); } +/****************************************************************************** +* * +* Paramètres : binary = binaire chargé en attente des résultats. * +* parts = parties binaires à désassembler. * +* count = nombre de parties à traiter. * +* * +* Description : Crée une tâche de désassemblage différé. * +* * +* Retour : Tâche créée. * +* * +* Remarques : - * +* * +******************************************************************************/ +GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *binary, GBinPart **parts, size_t count) +{ + GDelayedDisassembly *result; /* Tâche à retourner */ + result = g_object_new(G_TYPE_DELAYED_DISASSEMBLY, NULL); + result->binary = binary; + result->parts = parts; + result->count = count; + return result; +} - - - +/* ---------------------------------------------------------------------------------- */ +/* GESTION DES ANALYSES DIFFEREES */ +/* ---------------------------------------------------------------------------------- */ /* Indique le type défini pour le gestionnaire des analyses différées. */ -G_DEFINE_TYPE(GDelayedManager, g_delayed_manager, G_TYPE_OBJECT); +G_DEFINE_TYPE(GDisassManager, g_disassembly_manager, G_TYPE_WORK_QUEUE); /****************************************************************************** @@ -215,12 +219,12 @@ G_DEFINE_TYPE(GDelayedManager, g_delayed_manager, G_TYPE_OBJECT); * * ******************************************************************************/ -static void g_delayed_manager_class_init(GDelayedManagerClass *klass) +static void g_disassembly_manager_class_init(GDisassManagerClass *klass) { g_signal_new("disassembly-completed", - G_TYPE_DELAYED_MANAGER, + G_TYPE_DISASS_MANAGER, G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET(GDelayedManagerClass, disassembly_completed), + G_STRUCT_OFFSET(GDisassManagerClass, disassembly_completed), NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2, G_TYPE_OPENIDA_BINARY, G_TYPE_RENDERING_LINE); @@ -240,8 +244,13 @@ static void g_delayed_manager_class_init(GDelayedManagerClass *klass) * * ******************************************************************************/ -static void g_delayed_manager_init(GDelayedManager *manager) +static void g_disassembly_manager_init(GDisassManager *manager) { + GWorkQueue *parent; /* Instance parente */ + + parent = G_WORK_QUEUE(manager); + + parent->process = (process_work_fc)process_disassemblies; } @@ -258,116 +267,76 @@ static void g_delayed_manager_init(GDelayedManager *manager) * * ******************************************************************************/ -static GDelayedManager *g_delayed_manager_new(GObject *ref) +static GDisassManager *g_disassembly_manager_new(GObject *ref) { - GDelayedManager *result; /* Adresse à retourner */ - GError *error; /* Bilan de création de thread */ + GDisassManager *result; /* Adresse à retourner */ - result = g_object_new(G_TYPE_DELAYED_MANAGER, NULL); + result = g_object_new(G_TYPE_DISASS_MANAGER, NULL); result->statusbar = g_object_get_data(ref, "statusbar"); - result->disass_mutex = g_mutex_new(); - if (result->disass_mutex == NULL) - goto dmn_error; - - result->disass_cond = g_cond_new(); - if (result->disass_cond == NULL) - goto dmn_error; - - result->disassemble = g_thread_create((GThreadFunc)process_disassemblies, result, FALSE, &error); - if (!result->disassemble) - goto dmn_error; - return result; - dmn_error: - - /* TODO */ - - return NULL; - } /****************************************************************************** * * * Paramètres : manager = gestionnaire des actions à mener. * +* disass = analyse à mener. * * * * Description : Assure le désassemblage en différé. * * * -* Retour : Bilan de l'opération. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -static void *process_disassemblies(GDelayedManager *manager) +static void process_disassemblies(GDisassManager *manager, GDelayedDisassembly *disass) { - disassembly_task *task; /* Désassemblage à effectuer */ GBinRoutine **routines; /* Liste des routines trouvées */ size_t routines_count; /* Nombre de ces routines */ guint id; /* Identifiant de statut */ GRenderingLine *lines; /* Nouvelles lignes de rendu */ - while (1) - { - g_mutex_lock(manager->disass_mutex); - - if (dl_list_empty(manager->disassemblies)) - g_cond_wait(manager->disass_cond, manager->disass_mutex); - - task = manager->disassemblies; - disassembly_task_list_del(task, &manager->disassemblies); - - g_mutex_unlock(manager->disass_mutex); + routines = g_binary_format_get_routines(G_BIN_FORMAT(g_openida_binary_get_format(disass->binary)), &routines_count); + qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare); - routines = g_binary_format_get_routines(G_BIN_FORMAT(g_openida_binary_get_format(task->owner)), &routines_count); - qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare); + /* Première étape */ - /* Première étape */ + id = gtk_extended_status_bar_push(manager->statusbar, _("Disassembling..."), true); - id = gtk_extended_status_bar_push(manager->statusbar, _("Disassembling..."), true); + lines = disassemble_binary_parts(disass, routines, routines_count, manager->statusbar, id); - lines = disassemble_binary_parts(task, routines, routines_count, - manager->statusbar, id); + gtk_extended_status_bar_remove(manager->statusbar, id); - gtk_extended_status_bar_remove(manager->statusbar, id); + /* Seconde étape */ - /* Seconde étape */ + id = gtk_extended_status_bar_push(manager->statusbar, _("Establishing links..."), true); - id = gtk_extended_status_bar_push(manager->statusbar, _("Establishing links..."), true); + establish_links_between_lines(lines, routines, routines_count, manager->statusbar, id); - establish_links_between_lines(lines, routines, routines_count, - manager->statusbar, id); + gtk_extended_status_bar_remove(manager->statusbar, id); - gtk_extended_status_bar_remove(manager->statusbar, id); + /* Troisième étape */ - /* Troisième étape */ + id = gtk_extended_status_bar_push(manager->statusbar, _("Finding remaining limits..."), true); - id = gtk_extended_status_bar_push(manager->statusbar, _("Finding remaining limits..."), true); + limit_all_routines(lines, routines, routines_count, manager->statusbar, id); - limit_all_routines(lines, routines, routines_count, - manager->statusbar, id); + gtk_extended_status_bar_remove(manager->statusbar, id); - gtk_extended_status_bar_remove(manager->statusbar, id); + /* Fin */ - /* Fin */ - - g_signal_emit_by_name(manager, "disassembly-completed", task->owner, lines); - - delete_disassembly_task(task); - - } - - return NULL; + g_signal_emit_by_name(manager, "disassembly-completed", disass->binary, lines); } /****************************************************************************** * * -* Paramètres : task = tâche à l'origine du traitement. * +* Paramètres : disass = tâche à l'origine du traitement. * * routines = prototypes existants à insérer. * * count = quantité de ces prototypes. * * statusbar = barre de statut avec progression à mettre à jour.* @@ -381,7 +350,7 @@ static void *process_disassemblies(GDelayedManager *manager) * * ******************************************************************************/ -static GRenderingLine *disassemble_binary_parts(disassembly_task *task, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id) +static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *disass, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id) { GRenderingLine *result; /* Ligne de rendu à retourner */ GArchProcessor *proc; /* Architecture du binaire */ @@ -403,25 +372,25 @@ static GRenderingLine *disassemble_binary_parts(disassembly_task *task, GBinRout result = NULL; - proc = get_arch_processor_from_format(g_openida_binary_get_format(task->owner)); - options = g_openida_binary_get_options(task->owner); - bin_data = g_openida_binary_get_data(task->owner, NULL); + proc = get_arch_processor_from_format(g_openida_binary_get_format(disass->binary)); + options = g_openida_binary_get_options(disass->binary); + bin_data = g_openida_binary_get_data(disass->binary, NULL); /* Préparation du suivi de la progression */ sum = 0; - for (i = 0; i < task->count; i++) + for (i = 0; i < disass->count; i++) { - g_binary_part_get_values(task->parts[i], NULL, &len, NULL); + g_binary_part_get_values(disass->parts[i], NULL, &len, NULL); sum += len; } done = 0; - for (i = 0; i < task->count; i++) + for (i = 0; i < disass->count; i++) { - g_binary_part_get_values(task->parts[i], &pos, &len, &base); + g_binary_part_get_values(disass->parts[i], &pos, &len, &base); /* Décodage des instructions */ @@ -695,48 +664,6 @@ static vmpa_t find_best_ending_address_for_routine(GRenderingLine *line, size_t } - - - - - - -/****************************************************************************** -* * -* Paramètres : manager = gestionnaire des actions à mener. * -* binary = élément binaire concerné par la procédure. * -* parts = blocs binaires à désassembler. * -* count = quantité de ces blocs binaires. * -* * -* Description : Place un nouveau désassemblage en attente. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_delayed_manager_schedule_disassembly(GDelayedManager *manager, GOpenidaBinary *binary, GBinPart **parts, size_t count) -{ - disassembly_task *task; /* Nouveau désassemblage */ - - task = create_disassembly_task(binary, parts, count); - - g_mutex_lock(manager->disass_mutex); - - disassembly_task_list_add_tail(task, &manager->disassemblies); - - g_cond_signal(manager->disass_cond); - - g_mutex_unlock(manager->disass_mutex); - -} - - - - - - /****************************************************************************** * * * Paramètres : manager = nouveau gestionnaire à mémoriser ou NULL. * @@ -749,9 +676,9 @@ void g_delayed_manager_schedule_disassembly(GDelayedManager *manager, GOpenidaBi * * ******************************************************************************/ -GDelayedManager *_get_delayed_manager(GDelayedManager *manager) +GDisassManager *_get_disassembly_manager(GDisassManager *manager) { - static GDelayedManager *result = NULL; /* Singleton à retourner */ + static GDisassManager *result = NULL; /* Singleton à retourner */ if (manager != NULL) result = manager; @@ -773,14 +700,14 @@ GDelayedManager *_get_delayed_manager(GDelayedManager *manager) * * ******************************************************************************/ -bool init_delayed_manager(GObject *ref) +bool init_disassembly_manager(GObject *ref) { - GDelayedManager *manager; /* Singleton à mettre en place */ + GDisassManager *manager; /* Singleton à mettre en place */ - manager = g_delayed_manager_new(ref); + manager = g_disassembly_manager_new(ref); if (manager != NULL) - _get_delayed_manager(manager); + _get_disassembly_manager(manager); return (manager != NULL); diff --git a/src/analysis/delayed.h b/src/analysis/delayed.h index 437f968..c543f0b 100644 --- a/src/analysis/delayed.h +++ b/src/analysis/delayed.h @@ -36,38 +36,61 @@ -#define G_TYPE_DELAYED_MANAGER g_delayed_manager_get_type() -#define G_DELAYED_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_manager_get_type(), GDelayedManager)) -#define G_IS_DELAYED_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_manager_get_type())) -#define G_DELAYED_MANAGER_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_delayed_manager_get_type(), GDelayedManagerIface)) -#define G_DELAYED_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_MANAGER, GDelayedManagerClass)) +/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ -/* Gestionnaire des analyses différées (instance) */ -typedef struct _GDelayedManager GDelayedManager; +#define G_TYPE_DELAYED_DISASSEMBLY g_delayed_disassembly_get_type() +#define G_DELAYED_DISASSEMBLY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_disassembly_get_type(), GDelayedDisassembly)) +#define G_IS_DELAYED_DISASSEMBLY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_disassembly_get_type())) +#define G_DELAYED_DISASSEMBLY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass)) +#define G_IS_DELAYED_DISASSEMBLY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_DISASSEMBLY)) +#define G_DELAYED_DISASSEMBLY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass)) -/* Gestionnaire des analyses différées (classe) */ -typedef struct _GDelayedManagerClass GDelayedManagerClass; +/* Ensembles binaires à désassembler (instance) */ +typedef struct _GDelayedDisassembly GDelayedDisassembly; + +/* Ensembles binaires à désassembler (classe) */ +typedef struct _GDelayedDisassemblyClass GDelayedDisassemblyClass; -/* Indique le type défini pour le gestionnaire des analyses différées. */ -GType g_delayed_manager_get_type(void); -/* Place un nouveau désassemblage en attente. */ -void g_delayed_manager_schedule_disassembly(GDelayedManager *, GOpenidaBinary *, GBinPart **, size_t); +/* Indique le type défini pour les tâches de désassemblage différé. */ +GType g_delayed_disassembly_get_type(void); +/* Crée une tâche de désassemblage différé. */ +GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *, GBinPart **, size_t); -#define get_delayed_manager() _get_delayed_manager(NULL) +/* ------------------------- GESTION DES ANALYSES DIFFEREES ------------------------- */ +#define G_TYPE_DISASS_MANAGER g_disassembly_manager_get_type() +#define G_DISASS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_disassembly_manager_get_type(), GDisassManager)) +#define G_IS_DISASS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_disassembly_manager_get_type())) +#define G_DISASS_MANAGER_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_disassembly_manager_get_type(), GDisassManagerIface)) +#define G_DISASS_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DISASS_MANAGER, GDisassManagerClass)) + + +/* Gestionnaire des analyses différées (instance) */ +typedef struct _GDisassManager GDisassManager; + +/* Gestionnaire des analyses différées (classe) */ +typedef struct _GDisassManagerClass GDisassManagerClass; + + +#define get_disassembly_manager() _get_disassembly_manager(NULL) + + +/* Indique le type défini pour le gestionnaire des analyses différées. */ +GType g_disassembly_manager_get_type(void); + /* Fournit le gestionnaire d'analyse en différé courant. */ -GDelayedManager *_get_delayed_manager(GDelayedManager *); +GDisassManager *_get_disassembly_manager(GDisassManager *); /* Procède au chargement du gestionnaire d'analyse différées. */ -bool init_delayed_manager(GObject *); +bool init_disassembly_manager(GObject *); diff --git a/src/glibext/Makefile.am b/src/glibext/Makefile.am new file mode 100644 index 0000000..334b49a --- /dev/null +++ b/src/glibext/Makefile.am @@ -0,0 +1,17 @@ + +noinst_LTLIBRARIES = libglibext.la + +libglibext_la_SOURCES = \ + delayed-int.h \ + delayed.h delayed.c + +libglibext_la_LDFLAGS = + + +INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) + +AM_CPPFLAGS = + +AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) + +SUBDIRS = diff --git a/src/glibext/delayed-int.h b/src/glibext/delayed-int.h new file mode 100644 index 0000000..7fb8f3a --- /dev/null +++ b/src/glibext/delayed-int.h @@ -0,0 +1,82 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * delayed-int.h - définitions internes pour la gestion des travaux différés + * + * Copyright (C) 2009 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 "delayed.h" + + +#include "../common/dllist.h" + + + +/* -------------------------- TACHE DIFFEREE DANS LE TEMPS -------------------------- */ + + +/* Travail différé (instance) */ +struct _GDelayedWork +{ + GObject parent; /* A laisser en premier */ + + DL_LIST_ITEM(link); /* Lien vers les maillons */ + +}; + +/* Travail différé (classe) */ +struct _GDelayedWorkClass +{ + GObjectClass parent; /* A laisser en premier */ + +}; + + +#define delayed_work_list_add_tail(new, head) dl_list_add_tail(new, head, GDelayedWork, link) +#define delayed_work_list_del(item, head) dl_list_del(item, head, GDelayedWork, link) + + + +/* ------------------------- TRAITEMENT DE TACHES DIFFEREES ------------------------- */ + + +/* Effectue le traitement d'une tâche donnée. */ +typedef void (* process_work_fc) (GWorkQueue *, GDelayedWork *); + + +/* Gestionnaire des travaux différés (instance) */ +struct _GWorkQueue +{ + GObject parent; /* A laisser en premier */ + + GDelayedWork *works; /* Tâches à mener à bien */ + GMutex *mutex; /* Verrou pour l'accès */ + GCond *cond; /* Réveil pour un traitement */ + + GThread *thread; /* Procédure de traitement */ + process_work_fc process; /* Coeur du traitement */ + +}; + +/* Gestionnaire des travaux différés (classe) */ +struct _GWorkQueueClass +{ + GObjectClass parent; /* A laisser en premier */ + +}; diff --git a/src/glibext/delayed.c b/src/glibext/delayed.c new file mode 100644 index 0000000..4388b2c --- /dev/null +++ b/src/glibext/delayed.c @@ -0,0 +1,226 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * delayed.c - gestion des travaux différés + * + * Copyright (C) 2009 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 "delayed.h" + + +#include "delayed-int.h" + + + +/* -------------------------- TACHE DIFFEREE DANS LE TEMPS -------------------------- */ + + +/* Initialise la classe des travaux différés. */ +static void g_delayed_work_class_init(GDelayedWorkClass *); + +/* Initialise une instance de travail différé. */ +static void g_delayed_work_init(GDelayedWork *); + + + +/* ------------------------- TRAITEMENT DE TACHES DIFFEREES ------------------------- */ + + +/* Initialise la classe des travaux différés. */ +static void g_work_queue_class_init(GWorkQueueClass *); + +/* Initialise une instance de gestionnaire de travaux différés. */ +static void g_work_queue_init(GWorkQueue *); + +/* Assure le traitement en différé. */ +static void *g_work_queue_process(GWorkQueue *); + + + +/* ---------------------------------------------------------------------------------- */ +/* TACHE DIFFEREE DANS LE TEMPS */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour les travaux différés. */ +G_DEFINE_TYPE(GDelayedWork, g_delayed_work, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des travaux différés. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_delayed_work_class_init(GDelayedWorkClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : work = instance à initialiser. * +* * +* Description : Initialise une instance de travail différé. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_delayed_work_init(GDelayedWork *work) +{ + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* TRAITEMENT DE TACHES DIFFEREES */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour le gestionnaire des travaux différés. */ +G_DEFINE_TYPE(GWorkQueue, g_work_queue, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des travaux différés. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_work_queue_class_init(GWorkQueueClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : queue = instance à initialiser. * +* * +* Description : Initialise une instance de gestionnaire de travaux différés. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_work_queue_init(GWorkQueue *queue) +{ + GError *error; /* Bilan de création de thread */ + + queue->mutex = g_mutex_new(); + if (queue->mutex == NULL) + goto gwqi_error; + + queue->cond = g_cond_new(); + if (queue->cond == NULL) + goto gwqi_error; + + queue->thread = g_thread_create((GThreadFunc)g_work_queue_process, queue, FALSE, &error); + if (!queue->thread) + goto gwqi_error; + + gwqi_error: + + /* TODO */ return; + +} + + +/****************************************************************************** +* * +* Paramètres : queue = gestionnaire des actions à mener. * +* * +* Description : Assure le traitement en différé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void *g_work_queue_process(GWorkQueue *queue) +{ + GDelayedWork *work; /* Traitement à mener */ + + while (1) + { + g_mutex_lock(queue->mutex); + + if (dl_list_empty(queue->works)) + g_cond_wait(queue->cond, queue->mutex); + + work = queue->works; + delayed_work_list_del(work, &queue->works); + + g_mutex_unlock(queue->mutex); + + queue->process(queue, work); + + /* TODO : delete work */ + + } + + return NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : queu = gestionnaire des actions à mener. * +* work = nouvelle tâche à programmer, puis effectuer. * +* * +* Description : Place une nouvelle tâche en attente. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_delayed_queue_schedule_work(GWorkQueue *queue, GDelayedWork *work) +{ + g_mutex_lock(queue->mutex); + + delayed_work_list_add_tail(work, &queue->works); + + g_cond_signal(queue->cond); + + g_mutex_unlock(queue->mutex); + +} diff --git a/src/glibext/delayed.h b/src/glibext/delayed.h new file mode 100644 index 0000000..d1e3967 --- /dev/null +++ b/src/glibext/delayed.h @@ -0,0 +1,81 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * delayed.h - prototypes pour la gestion des travaux différés + * + * Copyright (C) 2009 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_DELAYED_H +#define _GLIBEXT_DELAYED_H + + +#include <glib-object.h> + + + +/* -------------------------- TACHE DIFFEREE DANS LE TEMPS -------------------------- */ + + +#define G_TYPE_DELAYED_WORK g_delayed_work_get_type() +#define G_DELAYED_WORK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_work_get_type(), GDelayedWork)) +#define G_IS_DELAYED_WORK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_work_get_type())) +#define G_DELAYED_WORK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_WORK, GDelayedWorkClass)) +#define G_IS_DELAYED_WORK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_WORK)) +#define G_DELAYED_WORK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_WORK, GDelayedWorkClass)) + + +/* Travail différé (instance) */ +typedef struct _GDelayedWork GDelayedWork; + +/* Travail différé (classe) */ +typedef struct _GDelayedWorkClass GDelayedWorkClass; + + +/* Indique le type défini pour les travaux différés. */ +GType g_delayed_work_get_type(void); + + + +/* ------------------------- TRAITEMENT DE TACHES DIFFEREES ------------------------- */ + + +#define G_TYPE_WORK_QUEUE g_work_queue_get_type() +#define G_WORK_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_work_queue_get_type(), GWorkQueue)) +#define G_IS_WORK_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_work_queue_get_type())) +#define G_WORK_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_WORK_QUEUE, GWorkQueueClass)) +#define G_IS_WORK_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_WORK_QUEUE)) +#define G_WORK_QUEUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_WORK_QUEUE, GWorkQueueClass)) + + +/* Gestionnaire des travaux différés (instance) */ +typedef struct _GWorkQueue GWorkQueue; + +/* Gestionnaire des travaux différés (classe) */ +typedef struct _GWorkQueueClass GWorkQueueClass; + + +/* Indique le type défini pour le gestionnaire des travaux différés. */ +GType g_work_queue_get_type(void); + +/* Place une nouvelle tâche en attente. */ +void g_delayed_queue_schedule_work(GWorkQueue *, GDelayedWork *); + + + +#endif /* _GLIBEXT_DELAYED_H */ diff --git a/src/gtkext/gtkblockview.c b/src/gtkext/gtkblockview.c index 99825f0..7161762 100644 --- a/src/gtkext/gtkblockview.c +++ b/src/gtkext/gtkblockview.c @@ -628,15 +628,7 @@ static void gtk_block_view_set_rendering_lines(GtkBlockView *view, GRenderingLin { g_signal_connect(iter, "rendering-line-flags-changed", G_CALLBACK(gtk_block_view_update_margin), view); - } - - g_rendering_line_update_bin_len(GTK_BIN_VIEW(view)->lines, - GTK_BIN_VIEW(view)->last, view->rendering); - for (iter = GTK_BIN_VIEW(view)->lines; - iter != NULL; - iter = g_rendering_line_get_next_iter(GTK_BIN_VIEW(view)->lines, iter, GTK_BIN_VIEW(view)->last)) - { if (iter != GTK_BIN_VIEW(view)->lines) { gtk_text_buffer_get_end_iter(view->buffer, &pos); diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c index a6d4dd5..cc2d930 100644 --- a/src/gtkext/gtkgraphview.c +++ b/src/gtkext/gtkgraphview.c @@ -253,35 +253,7 @@ static void gtk_graph_view_reset(GtkGraphView *view) static void gtk_graph_view_set_rendering_lines(GtkGraphView *view, GRenderingLine *lines, GRenderingLine *last) { - GRenderingLine *mainl; - - view->childs = (GtkBinView **)calloc(2, sizeof(GtkBinView *)); - view->childs_count = 2; - - view->childs[0] = GTK_BIN_VIEW(gtk_block_view_new(MRD_GRAPH)); - - gtk_widget_show(GTK_WIDGET(view->childs[0])); - gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->childs[0]), 50, 50); - - - gtk_bin_view_set_rendering_lines(view->childs[0], GTK_BIN_VIEW(view)->binary, lines, lines); - - - - mainl = g_rendering_line_find_by_address(lines, last, 0x08048434); - - printf("mainl : %p\n", mainl); - - - view->childs[1] = GTK_BIN_VIEW(gtk_block_view_new(MRD_GRAPH)); - - gtk_widget_show(GTK_WIDGET(view->childs[1])); - gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->childs[1]), 100, 450); - - - gtk_bin_view_set_rendering_lines(view->childs[1], GTK_BIN_VIEW(view)->binary, mainl, mainl); - - + gtk_graph_view_reset(view); } @@ -99,7 +99,7 @@ int main(int argc, char **argv) editor = create_editor(); gtk_widget_show(editor); - init_delayed_manager(G_OBJECT(editor)); + init_disassembly_manager(G_OBJECT(editor)); init_all_plugins(G_OBJECT(editor)); |