From 8eb95d316f7b6fbad0ff798abfe7f70f89e812d2 Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Sun, 22 Apr 2018 00:00:00 +0200 Subject: Improved the way file formats are detected and loaded. --- plugins/dex/core.c | 55 +- plugins/dex/core.h | 3 + plugins/dex/format.c | 150 ++-- plugins/dex/format.h | 5 +- plugins/dex/python/format.c | 59 +- plugins/elf/core.c | 50 +- plugins/elf/core.h | 3 + plugins/elf/elf_def.h | 5 + plugins/elf/format.c | 129 ++- plugins/elf/format.h | 2 +- plugins/elf/python/format.c | 58 +- plugins/pychrysalide/analysis/Makefile.am | 1 + plugins/pychrysalide/analysis/binary.c | 91 +- plugins/pychrysalide/analysis/loaded.c | 77 +- plugins/pychrysalide/analysis/loading.c | 196 ++++ plugins/pychrysalide/analysis/loading.h | 56 ++ plugins/pychrysalide/analysis/module.c | 3 + plugins/pychrysalide/analysis/project.c | 93 +- plugins/pychrysalide/core/Makefile.am | 1 + plugins/pychrysalide/core/global.c | 280 ++++++ plugins/pychrysalide/core/global.h | 42 + plugins/pychrysalide/core/module.c | 2 + plugins/pychrysalide/format/executable.c | 2 +- plugins/pychrysalide/plugin.c | 66 +- src/analysis/binary.c | 511 ++++------- src/analysis/binary.h | 22 +- src/analysis/content-int.h | 5 + src/analysis/content.c | 28 + src/analysis/content.h | 3 + src/analysis/contents/encapsulated.c | 28 + src/analysis/contents/file.c | 28 + src/analysis/contents/memory.c | 28 + src/analysis/contents/restricted.c | 28 + src/analysis/disass/disassembler.c | 534 +++-------- src/analysis/disass/disassembler.h | 34 +- src/analysis/disass/fetch.c | 2 +- src/analysis/loaded-int.h | 26 + src/analysis/loaded.c | 425 +++++++++ src/analysis/loaded.h | 20 + src/analysis/loading.c | 1379 +++++++++++++++++++++++------ src/analysis/loading.h | 96 +- src/analysis/project.c | 846 ++++++++++++++---- src/analysis/project.h | 33 +- src/core/core.c | 8 + src/core/global.c | 98 +- src/core/global.h | 13 + src/format/format-int.h | 10 + src/format/format.c | 48 + src/format/format.h | 8 +- src/glibext/delayed-int.h | 8 + src/glibext/delayed.c | 90 +- src/glibext/delayed.h | 3 + src/gui/editem-int.h | 1 + src/gui/editor.c | 10 +- src/gui/menus/project.c | 6 +- src/main.c | 7 +- src/plugins/pglist.h | 14 +- src/plugins/plugin-def.h | 15 +- src/plugins/plugin-int.h | 6 +- src/plugins/plugin.c | 45 + src/plugins/plugin.h | 3 +- 61 files changed, 4289 insertions(+), 1609 deletions(-) create mode 100644 plugins/pychrysalide/analysis/loading.c create mode 100644 plugins/pychrysalide/analysis/loading.h create mode 100644 plugins/pychrysalide/core/global.c create mode 100644 plugins/pychrysalide/core/global.h diff --git a/plugins/dex/core.c b/plugins/dex/core.c index 05130a6..869ef4b 100644 --- a/plugins/dex/core.c +++ b/plugins/dex/core.c @@ -24,7 +24,7 @@ #include "core.h" -#include +#include #include @@ -34,7 +34,7 @@ DEFINE_CHRYSALIDE_PLUGIN("dex", "Add support for the DEX format", "0.1.0", - RL("PyChrysalide", "dexbnf"), AL(PGA_PLUGIN_INIT)); + RL("PyChrysalide", "dexbnf"), AL(PGA_PLUGIN_INIT, PGA_CONTENT_RESOLVER)); @@ -54,10 +54,7 @@ G_MODULE_EXPORT bool chrysalide_plugin_init(GPluginModule *plugin) { bool result; /* Bilan à retourner */ - result = register_format_matcher(dex_is_matching, NULL); - - if (result) - result = register_format_loader("dex", "Dalvik Executable format", g_dex_format_new); + result = register_format_loader("dex", "Dalvik Executable format", g_dex_format_new); if (result) result = add_format_dex_module_to_python_module(); @@ -65,3 +62,49 @@ G_MODULE_EXPORT bool chrysalide_plugin_init(GPluginModule *plugin) return result; } + + +/****************************************************************************** +* * +* Paramètres : plugin = greffon à manipuler. * +* action = type d'action attendue. * +* content = contenu binaire à traiter. * +* gid = identifiant du groupe de traitement. * +* status = barre de statut à tenir informée. * +* * +* Description : Procède à une opération liée à un contenu binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +G_MODULE_EXPORT void chrysalide_plugin_handle_binary_content(const GPluginModule *plugin, PluginAction action, GBinContent *content, gid_t gid, GtkStatusStack *status) +{ + vmpa2t addr; /* Tête de lecture initiale */ + bool test; /* Bilan des accès mémoire */ + char magic[DEX_FILE_MAGIC_LEN]; /* Idenfiant standard */ + GExeFormat *format; /* Format DEX reconnu */ + GLoadedContent *loaded; /* Représentation chargée */ + GContentResolver *resolver; /* Resolveur de contenus */ + + init_vmpa(&addr, 0, VMPA_NO_VIRTUAL); + + test = g_binary_content_read_raw(content, &addr, DEX_FILE_MAGIC_LEN, (bin_t *)magic); + + if (test) + test = (memcmp(magic, DEX_FILE_MAGIC, DEX_FILE_MAGIC_LEN) == 0); + + if (test) + { + format = g_dex_format_new(content); + loaded = g_loaded_binary_new(format); + + resolver = get_current_content_resolver(); + g_content_resolver_add_detected(resolver, gid, loaded); + g_object_unref(G_OBJECT(resolver)); + + } + +} diff --git a/plugins/dex/core.h b/plugins/dex/core.h index bc1a444..8a07f84 100644 --- a/plugins/dex/core.h +++ b/plugins/dex/core.h @@ -33,6 +33,9 @@ /* Prend acte du chargement du greffon. */ G_MODULE_EXPORT bool chrysalide_plugin_init(GPluginModule *); +/* Procède à une opération liée à un contenu binaire. */ +G_MODULE_EXPORT void chrysalide_plugin_handle_binary_content(const GPluginModule *, PluginAction, GBinContent *, gid_t, GtkStatusStack *); + #endif /* _PLUGINS_DEX_CORE_H */ diff --git a/plugins/dex/format.c b/plugins/dex/format.c index f4cfdc9..d3e18da 100755 --- a/plugins/dex/format.c +++ b/plugins/dex/format.c @@ -51,6 +51,12 @@ static void g_dex_format_dispose(GDexFormat *); /* Procède à la libération totale de la mémoire. */ static void g_dex_format_finalize(GDexFormat *); +/* Indique la désignation interne du format. */ +static const char *g_dex_format_get_name(const GDexFormat *); + +/* Assure l'interprétation d'un format en différé. */ +static bool g_dex_format_analyze(GDexFormat *, wgroup_id_t, GtkStatusStack *); + /* Informe quant au boutisme utilisé. */ static SourceEndian g_dex_format_get_endianness(const GDexFormat *); @@ -83,52 +89,6 @@ static void g_dex_format_decompile(const GDexFormat *, void/*GCodeBuffer*/ *, co -/****************************************************************************** -* * -* Paramètres : content = contenu binaire à parcourir. * -* parent = éventuel format exécutable déjà chargé. * -* unused = adresse non utilisée ici. * -* key = identifiant de format trouvé ou NULL. [OUT] * -* * -* Description : Indique si le format peut être pris en charge ici. * -* * -* Retour : Conclusion de haut niveau sur la reconnaissance effectuée. * -* * -* Remarques : - * -* * -******************************************************************************/ - -FormatMatchStatus dex_is_matching(GBinContent *content, GExeFormat *parent, void *unused, char **key) -{ - FormatMatchStatus result; /* Bilan à renvoyer */ - vmpa2t addr; /* Tête de lecture initiale */ - bool status; /* Bilan des accès mémoire */ - char magic[DEX_FILE_MAGIC_LEN]; /* Idenfiant standard */ - - - /* REMME */ - if (parent != NULL) return FMS_UNKNOWN; - - - init_vmpa(&addr, 0, VMPA_NO_VIRTUAL); - - status = g_binary_content_read_raw(content, &addr, DEX_FILE_MAGIC_LEN, (bin_t *)magic); - - status &= (memcmp(magic, DEX_FILE_MAGIC, DEX_FILE_MAGIC_LEN) == 0); - - if (status) - { - result = FMS_MATCHED; - *key = strdup(parent == NULL ? "dex" : "dexdbg"); - } - else - result = FMS_UNKNOWN; - - return result; - -} - - /* Indique le type défini pour un format d'exécutable DEX. */ G_DEFINE_TYPE(GDexFormat, g_dex_format, G_TYPE_EXE_FORMAT); @@ -158,6 +118,8 @@ static void g_dex_format_class_init(GDexFormatClass *klass) fmt = G_BIN_FORMAT_CLASS(klass); + fmt->get_name = (format_get_name_fc)g_dex_format_get_name; + fmt->analyze = (format_analyze_fc)g_dex_format_analyze; fmt->get_endian = (format_get_endian_fc)g_dex_format_get_endianness; exe = G_EXE_FORMAT_CLASS(klass); @@ -240,8 +202,6 @@ static void g_dex_format_finalize(GDexFormat *format) /****************************************************************************** * * * Paramètres : content = contenu binaire à parcourir. * -* parent = éventuel format exécutable déjà chargé. * - status = barre de statut à tenir informée. * * * * Description : Prend en charge un nouveau format Dex. * * * @@ -251,54 +211,96 @@ static void g_dex_format_finalize(GDexFormat *format) * * ******************************************************************************/ -GBinFormat *g_dex_format_new(GBinContent *content, GExeFormat *parent, GtkStatusStack *status) +GExeFormat *g_dex_format_new(GBinContent *content) { GDexFormat *result; /* Structure à retourner */ - GBinFormat *base; /* Version basique du format */ - GExeFormat *exe_format; /* Autre version du format */ - vmpa2t pos; /* Position de tête de lecture */ - wgroup_id_t gid; /* Identifiant pour les tâches */ result = g_object_new(G_TYPE_DEX_FORMAT, NULL); - base = G_BIN_FORMAT(result); - exe_format = G_EXE_FORMAT(result); + g_binary_format_set_content(G_BIN_FORMAT(result), content); - g_binary_format_set_content(base, content); + return G_EXE_FORMAT(result); - init_vmpa(&pos, 0, VMPA_NO_VIRTUAL); +} - if (!read_dex_header(result, &pos, &result->header)) - goto gdfn_error; +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* * +* Description : Indique la désignation interne du format. * +* * +* Retour : Description du format. * +* * +* Remarques : - * +* * +******************************************************************************/ +static const char *g_dex_format_get_name(const GDexFormat *format) +{ + const char *result; /* Désignation à retourner */ - /* TODO : vérifier que les *_id ne se chevauchent pas */ + result = "dex"; + return result; - gid = g_work_queue_define_work_group(get_work_queue()); +} - if (!load_all_dex_types(result, gid, status)) - goto gdfn_error; - if (!load_all_dex_fields(result, gid, status)) - goto gdfn_error; +/****************************************************************************** +* * +* Paramètres : format = format chargé dont l'analyse est lancée. * +* gid = groupe de travail dédié. * +* status = barre de statut à tenir informée. * +* * +* Description : Assure l'interprétation d'un format en différé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ - if (!load_all_dex_classes(result, gid, status)) - goto gdfn_error; +static bool g_dex_format_analyze(GDexFormat *format, wgroup_id_t gid, GtkStatusStack *status) +{ + bool result; /* Bilan à retourner */ + GBinFormat *base; /* Version basique du format */ + GExeFormat *exe; /* Autre version du format */ + vmpa2t pos; /* Position de tête de lecture */ - preload_binary_format(PGA_FORMAT_PRELOAD, base, base->info, status); + result = false; - if (!g_executable_format_complete_loading(exe_format, status)) - goto gdfn_error; + base = G_BIN_FORMAT(format); + exe = G_EXE_FORMAT(format); - return base; + init_vmpa(&pos, 0, VMPA_NO_VIRTUAL); - gdfn_error: + if (!read_dex_header(format, &pos, &format->header)) + goto gdfa_error; - g_object_unref(G_OBJECT(result)); - return NULL; + /* TODO : vérifier que les *_id ne se chevauchent pas */ + + + if (!load_all_dex_types(format, gid, status)) + goto gdfa_error; + + if (!load_all_dex_fields(format, gid, status)) + goto gdfa_error; + + if (!load_all_dex_classes(format, gid, status)) + goto gdfa_error; + + preload_binary_format(PGA_FORMAT_PRELOAD, base, base->info, status); + + if (!g_executable_format_complete_loading(exe, status)) + goto gdfa_error; + + result = true; + + gdfa_error: + + return result; } diff --git a/plugins/dex/format.h b/plugins/dex/format.h index 81a4b0f..6850ed1 100755 --- a/plugins/dex/format.h +++ b/plugins/dex/format.h @@ -52,14 +52,11 @@ typedef struct _GDexFormat GDexFormat; typedef struct _GDexFormatClass GDexFormatClass; -/* Indique si le format peut être pris en charge ici. */ -FormatMatchStatus dex_is_matching(GBinContent *, GExeFormat *, void *, char **); - /* Indique le type défini pour un format d'exécutable DEX. */ GType g_dex_format_get_type(void); /* Prend en charge un nouveau format DEX. */ -GBinFormat *g_dex_format_new(GBinContent *, GExeFormat *, GtkStatusStack *); +GExeFormat *g_dex_format_new(GBinContent *); /* Présente l'en-tête DEX du format chargé. */ const dex_header *g_dex_format_get_header(const GDexFormat *); diff --git a/plugins/dex/python/format.c b/plugins/dex/python/format.c index a406f62..a421549 100644 --- a/plugins/dex/python/format.c +++ b/plugins/dex/python/format.c @@ -25,6 +25,7 @@ #include "format.h" +#include #include @@ -69,67 +70,17 @@ static PyObject *py_dex_format_new(PyTypeObject *type, PyObject *args, PyObject { PyObject *result; /* Instance à retourner */ PyObject *content_obj; /* Objet pour le contenu */ - PyObject *parent_obj; /* Objet pour le parent */ - PyObject *status_obj; /* Objet pour la progression */ int ret; /* Bilan de lecture des args. */ GBinContent *content; /* Instance GLib du contenu */ - GExeFormat *parent; /* Instance GLib du parent */ - GtkStatusStack *status; /* Instance GTK de suivi */ - GBinFormat *format; /* Création GLib à transmettre */ + GExeFormat *format; /* Création GLib à transmettre */ - parent_obj = Py_None; - status_obj = Py_None; - - ret = PyArg_ParseTuple(args, "O|OO", &content_obj, &parent_obj, &status_obj); + ret = PyArg_ParseTuple(args, "O!", get_python_binary_content_type(), &content_obj); if (!ret) return NULL; - ret = PyObject_IsInstance(content_obj, (PyObject *)get_python_binary_content_type()); - if (!ret) - { - PyErr_SetString(PyExc_TypeError, _("The first argument must be an instance of BinContent.")); - return NULL; - } - content = G_BIN_CONTENT(pygobject_get(content_obj)); - if (parent_obj == Py_None) - parent = NULL; - - else - { - ret = PyObject_IsInstance(parent_obj, (PyObject *)get_python_executable_format_type()); - if (!ret) - { - PyErr_SetString(PyExc_TypeError, _("The second argument must be a container format or None.")); - return NULL; - } - - parent = G_EXE_FORMAT(pygobject_get(parent_obj)); - - } - - if (status_obj == Py_None) - status = NULL; - - else - { - ret = PyObject_IsInstance(status_obj, (PyObject *)get_python_binary_content_type()); - if (!ret) - { - PyErr_SetString(PyExc_TypeError, _("The third argument must be a status bar object or None.")); - return NULL; - } - - status = GTK_STATUS_STACK(pygobject_get(status_obj)); - - } - - format = g_dex_format_new(content, parent, status); - if (format == NULL) - { - PyErr_SetString(PyExc_RuntimeError, _("Unable to load the DEX format.")); - return NULL; - } + format = g_dex_format_new(content); + assert(format != NULL); result = pygobject_new(G_OBJECT(format)); diff --git a/plugins/elf/core.c b/plugins/elf/core.c index 0cfd49c..7486242 100644 --- a/plugins/elf/core.c +++ b/plugins/elf/core.c @@ -24,7 +24,7 @@ #include "core.h" -#include +#include #include @@ -34,7 +34,7 @@ DEFINE_CHRYSALIDE_PLUGIN("elf", "Add support for the ELF format", "0.1.0", - RL("PyChrysalide"), AL(PGA_PLUGIN_INIT)); + RL("PyChrysalide"), AL(PGA_PLUGIN_INIT, PGA_CONTENT_RESOLVER)); @@ -65,3 +65,49 @@ G_MODULE_EXPORT bool chrysalide_plugin_init(GPluginModule *plugin) return result; } + + +/****************************************************************************** +* * +* Paramètres : plugin = greffon à manipuler. * +* action = type d'action attendue. * +* content = contenu binaire à traiter. * +* gid = identifiant du groupe de traitement. * +* status = barre de statut à tenir informée. * +* * +* Description : Procède à une opération liée à un contenu binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +G_MODULE_EXPORT void chrysalide_plugin_handle_binary_content(const GPluginModule *plugin, PluginAction action, GBinContent *content, gid_t gid, GtkStatusStack *status) +{ + vmpa2t addr; /* Tête de lecture initiale */ + bool test; /* Bilan des accès mémoire */ + char magic[SELFMAG]; /* Idenfiant standard */ + GExeFormat *format; /* Format ELF reconnu */ + GLoadedContent *loaded; /* Représentation chargée */ + GContentResolver *resolver; /* Resolveur de contenus */ + + init_vmpa(&addr, 0, VMPA_NO_VIRTUAL); + + test = g_binary_content_read_raw(content, &addr, SELFMAG, (bin_t *)magic); + + if (test) + test = (memcmp(magic, ELFMAG, SELFMAG) == 0); + + if (test) + { + format = g_elf_format_new(content); + loaded = g_loaded_binary_new(format); + + resolver = get_current_content_resolver(); + g_content_resolver_add_detected(resolver, gid, loaded); + g_object_unref(G_OBJECT(resolver)); + + } + +} diff --git a/plugins/elf/core.h b/plugins/elf/core.h index 52ded90..ec9ed5c 100644 --- a/plugins/elf/core.h +++ b/plugins/elf/core.h @@ -33,6 +33,9 @@ /* Prend acte du chargement du greffon. */ G_MODULE_EXPORT bool chrysalide_plugin_init(GPluginModule *); +/* Procède à une opération liée à un contenu binaire. */ +G_MODULE_EXPORT void chrysalide_plugin_handle_binary_content(const GPluginModule *, PluginAction, GBinContent *, gid_t, GtkStatusStack *); + #endif /* _PLUGINS_ELF_CORE_H */ diff --git a/plugins/elf/elf_def.h b/plugins/elf/elf_def.h index bb33d6d..a820eac 100644 --- a/plugins/elf/elf_def.h +++ b/plugins/elf/elf_def.h @@ -111,6 +111,11 @@ typedef union _elf_header #define EI_ABIVERSION 8 /* Version de l'ABI */ #define EI_PAD 9 /* Premier octet de bourrage */ +/* ... EI_MAG* */ + +#define ELFMAG "\x7f\x45\x4c\x46" /* .ELF */ +#define SELFMAG 4 + /* ... EI_CLASS */ #define ELFCLASSNONE 0 /* Objet invalide */ diff --git a/plugins/elf/format.c b/plugins/elf/format.c index eb22059..0fb2d1e 100644 --- a/plugins/elf/format.c +++ b/plugins/elf/format.c @@ -60,6 +60,12 @@ static void g_elf_format_dispose(GElfFormat *); /* Procède à la libération totale de la mémoire. */ static void g_elf_format_finalize(GElfFormat *); +/* Indique la désignation interne du format. */ +static const char *g_elf_format_get_name(const GElfFormat *); + +/* Assure l'interprétation d'un format en différé. */ +static bool g_elf_format_analyze(GElfFormat *, wgroup_id_t, GtkStatusStack *); + /* Informe quant au boutisme utilisé. */ static SourceEndian g_elf_format_get_endianness(const GElfFormat *); @@ -159,6 +165,8 @@ static void g_elf_format_class_init(GElfFormatClass *klass) fmt = G_BIN_FORMAT_CLASS(klass); + fmt->get_name = (format_get_name_fc)g_elf_format_get_name; + fmt->analyze = (format_analyze_fc)g_elf_format_analyze; fmt->get_endian = (format_get_endian_fc)g_elf_format_get_endianness; fmt->complete = (format_complete_analysis_fc)g_elf_format_complete_analysis; @@ -236,8 +244,6 @@ static void g_elf_format_finalize(GElfFormat *format) /****************************************************************************** * * * Paramètres : content = contenu binaire à parcourir. * -* parent = éventuel format exécutable déjà chargé. * - status = barre de statut à tenir informée. * * * * Description : Prend en charge un nouveau format ELF. * * * @@ -247,65 +253,113 @@ static void g_elf_format_finalize(GElfFormat *format) * * ******************************************************************************/ -GBinFormat *g_elf_format_new(GBinContent *content, GExeFormat *parent, GtkStatusStack *status) +GExeFormat *g_elf_format_new(GBinContent *content) { GElfFormat *result; /* Structure à retourner */ - GBinFormat *base; /* Version basique du format */ - GExeFormat *exe_format; /* Autre version du format */ result = g_object_new(G_TYPE_ELF_FORMAT, NULL); - base = G_BIN_FORMAT(result); - exe_format = G_EXE_FORMAT(result); + g_binary_format_set_content(G_BIN_FORMAT(result), content); + + return G_EXE_FORMAT(result); - g_binary_format_set_content(base, content); +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* * +* Description : Indique la désignation interne du format. * +* * +* Retour : Description du format. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static const char *g_elf_format_get_name(const GElfFormat *format) +{ + const char *result; /* Désignation à retourner */ + + result = "elf"; + + return result; + +} - if (!read_elf_header(result, &result->header, &result->is_32b, &result->endian)) - goto gefn_error; + +/****************************************************************************** +* * +* Paramètres : format = format chargé dont l'analyse est lancée. * +* gid = groupe de travail dédié. * +* status = barre de statut à tenir informée. * +* * +* Description : Assure l'interprétation d'un format en différé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_elf_format_analyze(GElfFormat *format, wgroup_id_t gid, GtkStatusStack *status) +{ + bool result; /* Bilan à retourner */ + GBinFormat *base; /* Version basique du format */ + GExeFormat *exe; /* Autre version du format */ + + result = false; + + base = G_BIN_FORMAT(format); + exe = G_EXE_FORMAT(format); + + if (!read_elf_header(format, &format->header, &format->is_32b, &format->endian)) + goto gefa_error; /* Vérification des tailles d'entrée de table */ - if (ELF_HDR(result, result->header, e_phentsize) != ELF_SIZEOF_PHDR(result)) + if (ELF_HDR(format, format->header, e_phentsize) != ELF_SIZEOF_PHDR(format)) { log_variadic_message(LMT_BAD_BINARY, _("Corrupted program header size (%hu); fixed!" \ " -- replacing 0x%04hx by 0x%04hx at offset 0x%x"), - ELF_HDR(result, result->header, e_phentsize), - ELF_HDR(result, result->header, e_phentsize), - ELF_SIZEOF_PHDR(result), - ELF_HDR_OFFSET_OF(result, e_phentsize)); + ELF_HDR(format, format->header, e_phentsize), + ELF_HDR(format, format->header, e_phentsize), + ELF_SIZEOF_PHDR(format), + ELF_HDR_OFFSET_OF(format, e_phentsize)); - ELF_HDR_SET(result, result->header, e_phentsize, ELF_SIZEOF_PHDR(result)); + ELF_HDR_SET(format, format->header, e_phentsize, ELF_SIZEOF_PHDR(format)); } - if (ELF_HDR(result, result->header, e_shentsize) != ELF_SIZEOF_SHDR(result)) + if (ELF_HDR(format, format->header, e_shentsize) != ELF_SIZEOF_SHDR(format)) { log_variadic_message(LMT_BAD_BINARY, _("Corrupted section header size (%hu); fixed!" \ " -- replacing 0x%04hx by 0x%04hx at offset 0x%x"), - ELF_HDR(result, result->header, e_shentsize), - ELF_HDR(result, result->header, e_shentsize), - ELF_SIZEOF_SHDR(result), - ELF_HDR_OFFSET_OF(result, e_shentsize)); + ELF_HDR(format, format->header, e_shentsize), + ELF_HDR(format, format->header, e_shentsize), + ELF_SIZEOF_SHDR(format), + ELF_HDR_OFFSET_OF(format, e_shentsize)); - ELF_HDR_SET(result, result->header, e_shentsize, ELF_SIZEOF_SHDR(result)); + ELF_HDR_SET(format, format->header, e_shentsize, ELF_SIZEOF_SHDR(format)); } /* Opérations spécifiques à l'architecture */ - switch (ELF_HDR(result, result->header, e_machine)) + switch (ELF_HDR(format, format->header, e_machine)) { case EM_ARM: - result->ops.get_type_desc = (get_elf_prgm_type_desc_cb)get_elf_program_arm_type_desc; - result->ops.fix_virt = (fix_elf_virt_addr_cb)fix_elf_arm_virtual_address; - result->ops.get_linkage_offset = (get_elf_linkage_offset_cb)retrieve_arm_linkage_offset; + format->ops.get_type_desc = (get_elf_prgm_type_desc_cb)get_elf_program_arm_type_desc; + format->ops.fix_virt = (fix_elf_virt_addr_cb)fix_elf_arm_virtual_address; + format->ops.get_linkage_offset = (get_elf_linkage_offset_cb)retrieve_arm_linkage_offset; break; default: log_variadic_message(LMT_ERROR, "Architecture not supported for ELF binaries"); - goto gefn_error; + goto gefa_error; break; } @@ -323,23 +377,20 @@ GBinFormat *g_elf_format_new(GBinContent *content, GExeFormat *parent, GtkStatus preload_binary_format(PGA_FORMAT_PRELOAD, base, base->info, status); + if (!load_elf_symbols(format, status)) + goto gefa_error; - if (!load_elf_symbols(result, status)) - goto gefn_error; + if (!find_all_elf_strings(format)) + goto gefa_error; - if (!find_all_elf_strings(result)) - goto gefn_error; + if (!g_executable_format_complete_loading(exe, status)) + goto gefa_error; - if (!g_executable_format_complete_loading(exe_format, status)) - goto gefn_error; + result = true; - return base; + gefa_error: - gefn_error: - - g_object_unref(G_OBJECT(result)); - - return NULL; + return result; } diff --git a/plugins/elf/format.h b/plugins/elf/format.h index a822105..47b3171 100644 --- a/plugins/elf/format.h +++ b/plugins/elf/format.h @@ -59,7 +59,7 @@ FormatMatchStatus elf_is_matching(GBinContent *, GExeFormat *, void *, char **); GType g_elf_format_get_type(void); /* Prend en charge un nouveau format ELF. */ -GBinFormat *g_elf_format_new(GBinContent *, GExeFormat *, GtkStatusStack *); +GExeFormat *g_elf_format_new(GBinContent *); /* Présente l'en-tête ELF du format chargé. */ const elf_header *g_elf_format_get_header(const GElfFormat *); diff --git a/plugins/elf/python/format.c b/plugins/elf/python/format.c index a3d8758..2d5bfd8 100644 --- a/plugins/elf/python/format.c +++ b/plugins/elf/python/format.c @@ -72,67 +72,17 @@ static PyObject *py_elf_format_new(PyTypeObject *type, PyObject *args, PyObject { PyObject *result; /* Instance à retourner */ PyObject *content_obj; /* Objet pour le contenu */ - PyObject *parent_obj; /* Objet pour le parent */ - PyObject *status_obj; /* Objet pour la progression */ int ret; /* Bilan de lecture des args. */ GBinContent *content; /* Instance GLib du contenu */ - GExeFormat *parent; /* Instance GLib du parent */ - GtkStatusStack *status; /* Instance GTK de suivi */ - GBinFormat *format; /* Création GLib à transmettre */ + GExeFormat *format; /* Création GLib à transmettre */ - parent_obj = Py_None; - status_obj = Py_None; - - ret = PyArg_ParseTuple(args, "O|OO", &content_obj, &parent_obj, &status_obj); + ret = PyArg_ParseTuple(args, "O!", get_python_binary_content_type(), &content_obj); if (!ret) return NULL; - ret = PyObject_IsInstance(content_obj, (PyObject *)get_python_binary_content_type()); - if (!ret) - { - PyErr_SetString(PyExc_TypeError, _("The first argument must be an instance of BinContent.")); - return NULL; - } - content = G_BIN_CONTENT(pygobject_get(content_obj)); - if (parent_obj == Py_None) - parent = NULL; - - else - { - ret = PyObject_IsInstance(parent_obj, (PyObject *)get_python_executable_format_type()); - if (!ret) - { - PyErr_SetString(PyExc_TypeError, _("The second argument must be a container format or None.")); - return NULL; - } - - parent = G_EXE_FORMAT(pygobject_get(parent_obj)); - - } - - if (status_obj == Py_None) - status = NULL; - - else - { - ret = PyObject_IsInstance(status_obj, (PyObject *)get_python_binary_content_type()); - if (!ret) - { - PyErr_SetString(PyExc_TypeError, _("The third argument must be a status bar object or None.")); - return NULL; - } - - status = GTK_STATUS_STACK(pygobject_get(status_obj)); - - } - - format = g_elf_format_new(content, parent, status); - if (format == NULL) - { - PyErr_SetString(PyExc_RuntimeError, _("Unable to load the ELF format.")); - return NULL; - } + format = g_elf_format_new(content); + assert(format != NULL); result = pygobject_new(G_OBJECT(format)); diff --git a/plugins/pychrysalide/analysis/Makefile.am b/plugins/pychrysalide/analysis/Makefile.am index 5c3c46c..61d2c94 100644 --- a/plugins/pychrysalide/analysis/Makefile.am +++ b/plugins/pychrysalide/analysis/Makefile.am @@ -6,6 +6,7 @@ libpychrysaanalysis_la_SOURCES = \ block.h block.c \ content.h content.c \ loaded.h loaded.c \ + loading.h loading.c \ module.h module.c \ project.h project.c \ routine.h routine.c \ diff --git a/plugins/pychrysalide/analysis/binary.c b/plugins/pychrysalide/analysis/binary.c index 6be767c..1ca5b3c 100644 --- a/plugins/pychrysalide/analysis/binary.c +++ b/plugins/pychrysalide/analysis/binary.c @@ -34,8 +34,8 @@ #include -#include "content.h" #include "../helpers.h" +#include "../format/executable.h" @@ -45,12 +45,6 @@ static PyObject *py_loaded_binary_new(PyTypeObject *, PyObject *, PyObject *); /* Fournit le nom associé à l'élément binaire. */ static PyObject *py_loaded_binary_get_name(PyObject *, void *); -/* Lance l'analyse d'un élément binaire chargé. */ -static PyObject *py_loaded_binary_analyse(PyObject *, PyObject *); - -/* Lance l'analyse d'un binaire chargé et attend sa conclusion. */ -static PyObject *py_loaded_binary_analyse_and_wait(PyObject *, PyObject *); - /* Fournit le format de fichier reconnu dans le contenu binaire. */ static PyObject *py_loaded_binary_get_format(PyObject *, void *); @@ -79,23 +73,18 @@ static PyObject *py_loaded_binary_get_disassembled_cache(PyObject *, void *); static PyObject *py_loaded_binary_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *result; /* Instance à retourner */ - PyObject *content_obj; /* Objet pour le contenu */ + PyObject *format_obj; /* Objet pour le contenu */ int ret; /* Bilan de lecture des args. */ - GBinContent *content; /* Instance GLib correspondante*/ - GLoadedBinary *binary; /* Version GLib du format */ + GExeFormat *format; /* Instance GLib correspondante*/ + GLoadedContent *binary; /* Version GLib du binaire */ - ret = PyArg_ParseTuple(args, "O", &content_obj); + ret = PyArg_ParseTuple(args, "O!", get_python_executable_format_type(), &format_obj); if (!ret) return NULL; - ret = PyObject_IsInstance(content_obj, (PyObject *)get_python_binary_content_type()); - if (ret == 0) - { - PyErr_SetString(PyExc_TypeError, _("Expected a BinContent as argument")); - return NULL; - } + format = G_EXE_FORMAT(pygobject_get(format_obj)); - content = G_BIN_CONTENT(pygobject_get(content_obj)); - binary = g_loaded_binary_new(content); + g_object_ref(G_OBJECT(format)); + binary = g_loaded_binary_new(format); result = pygobject_new(G_OBJECT(binary)); @@ -138,58 +127,6 @@ static PyObject *py_loaded_binary_get_name(PyObject *self, void *closure) /****************************************************************************** * * -* Paramètres : self = contenu binaire à manipuler. * -* args = non utilisé ici. * -* * -* Description : Lance l'analyse d'un élément binaire chargé. * -* * -* Retour : Rien (None). * -* * -* Remarques : - * -* * -******************************************************************************/ - -static PyObject *py_loaded_binary_analyse(PyObject *self, PyObject *args) -{ - GLoadedBinary *binary; /* Version GLib du format */ - - binary = G_LOADED_BINARY(pygobject_get(self)); - - g_loaded_binary_analyse(binary); - - Py_RETURN_NONE; - -} - - -/****************************************************************************** -* * -* Paramètres : self = contenu binaire à manipuler. * -* args = non utilisé ici. * -* * -* Description : Lance l'analyse d'un binaire chargé et attend sa conclusion. * -* * -* Retour : Rien (None). * -* * -* Remarques : - * -* * -******************************************************************************/ - -static PyObject *py_loaded_binary_analyse_and_wait(PyObject *self, PyObject *args) -{ - GLoadedBinary *binary; /* Version GLib du format */ - - binary = G_LOADED_BINARY(pygobject_get(self)); - - g_loaded_binary_analyse_and_wait(binary); - - Py_RETURN_NONE; - -} - - -/****************************************************************************** -* * * Paramètres : self = objet Python concerné par l'appel. * * closure = non utilisé ici. * * * @@ -296,18 +233,6 @@ static PyObject *py_loaded_binary_get_disassembled_cache(PyObject *self, void *c PyTypeObject *get_python_loaded_binary_type(void) { static PyMethodDef py_loaded_binary_methods[] = { - { - "analyse", py_loaded_binary_analyse, - METH_NOARGS, - "analyse(/)\n--\n\nStart the analysis of the loaded binary and " \ - "send a \"disassembly-done\" signal when done." - }, - { - "analyse_and_wait", py_loaded_binary_analyse_and_wait, - METH_NOARGS, - "analyse_and_wait(/)\n--\n\nRun the analysis of the loaded binary and " \ - "wait for its completion." - }, { NULL } }; diff --git a/plugins/pychrysalide/analysis/loaded.c b/plugins/pychrysalide/analysis/loaded.c index b38025a..328bf7b 100644 --- a/plugins/pychrysalide/analysis/loaded.c +++ b/plugins/pychrysalide/analysis/loaded.c @@ -36,6 +36,12 @@ +/* Lance l'analyse propre à l'élément chargé. */ +static PyObject *py_loaded_content_analyze(PyObject *, PyObject *); + +/* Lance l'analyse de l'élément chargé et attend sa conclusion. */ +static PyObject *py_loaded_content_analyze_and_wait(PyObject *, PyObject *); + /* Détermine le nombre de vues disponibles pour un contenu. */ static PyObject *py_loaded_content_count_views(PyObject *, PyObject *); @@ -43,6 +49,63 @@ static PyObject *py_loaded_content_count_views(PyObject *, PyObject *); /****************************************************************************** * * +* Paramètres : self = contenu binaire à manipuler. * +* args = non utilisé ici. * +* * +* Description : Lance l'analyse propre à l'élément chargé. * +* * +* Retour : Rien (None). * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_loaded_content_analyze(PyObject *self, PyObject *args) +{ + GLoadedContent *content; /* Version GLib de l'élément */ + + content = G_LOADED_CONTENT(pygobject_get(self)); + + g_loaded_content_analyze(content); + + Py_RETURN_NONE; + +} + + +/****************************************************************************** +* * +* Paramètres : self = contenu binaire à manipuler. * +* args = non utilisé ici. * +* * +* Description : Lance l'analyse de l'élément chargé et attend sa conclusion. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_loaded_content_analyze_and_wait(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + GLoadedContent *content; /* Version GLib de l'élément */ + bool status; /* Bilan de l'opération */ + + content = G_LOADED_CONTENT(pygobject_get(self)); + + status = g_loaded_content_analyze_and_wait(content); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : self = contenu chargé à manipuler. * * args = non utilisé ici. * * * @@ -57,7 +120,7 @@ static PyObject *py_loaded_content_count_views(PyObject *, PyObject *); static PyObject *py_loaded_content_count_views(PyObject *self, PyObject *args) { PyObject *result; /* Instance à retourner */ - GLoadedContent *content; /* Version GLib du format */ + GLoadedContent *content; /* Version GLib de l'élément */ size_t count; /* Quantité à retourner */ content = G_LOADED_CONTENT(pygobject_get(self)); @@ -87,6 +150,18 @@ PyTypeObject *get_python_loaded_content_type(void) { static PyMethodDef py_loaded_content_methods[] = { { + "analyze", py_loaded_content_analyze, + METH_NOARGS, + "analyze($self, /)\n--\n\nStart the analysis of the loaded binary and " \ + "send a \"disassembly-done\" signal when done." + }, + { + "analyze_and_wait", py_loaded_content_analyze_and_wait, + METH_NOARGS, + "analyze_and_wait($self, /)\n--\n\nRun the analysis of the loaded binary and " \ + "wait for its completion." + }, + { "count_views", py_loaded_content_count_views, METH_NOARGS, "count_views($self, /)\n--\n\nCompute the quantity of available views." diff --git a/plugins/pychrysalide/analysis/loading.c b/plugins/pychrysalide/analysis/loading.c new file mode 100644 index 0000000..fca9929 --- /dev/null +++ b/plugins/pychrysalide/analysis/loading.c @@ -0,0 +1,196 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * loading.c - équivalent Python du fichier "analysis/loading.c" + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "loading.h" + + +#include + + +#include + + +#include "../helpers.h" + + + +/* --------------------- EXPLORATION NON BLOQUANTE DES CONTENUS --------------------- */ + + + +/* ------------------- RESOLUTION DE CONTENUS BINAIRES EN CHARGES ------------------- */ + + + +/* ---------------------------------------------------------------------------------- */ +/* EXPLORATION NON BLOQUANTE DES CONTENUS */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_content_explorer_type(void) +{ + static PyMethodDef py_content_explorer_methods[] = { + { NULL } + }; + + static PyGetSetDef py_content_explorer_getseters[] = { + { NULL } + }; + + static PyTypeObject py_content_explorer_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.analysis.ContentExplorer", + + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, + + .tp_doc = "PyChrysalide content explorer", + + .tp_methods = py_content_explorer_methods, + .tp_getset = py_content_explorer_getseters + + }; + + return &py_content_explorer_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide...ContentExplorer'. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_python_content_explorer(PyObject *module) +{ + PyTypeObject *py_content_explorer_type; /* Type 'ContentExplorer' */ + PyObject *dict; /* Dictionnaire du module */ + + py_content_explorer_type = get_python_content_explorer_type(); + + dict = PyModule_GetDict(module); + + if (!register_class_for_pygobject(dict, G_TYPE_CONTENT_EXPLORER, py_content_explorer_type, &PyGObject_Type)) + return false; + + return true; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* RESOLUTION DE CONTENUS BINAIRES EN CHARGES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_content_resolver_type(void) +{ + static PyMethodDef py_content_resolver_methods[] = { + { NULL } + }; + + static PyGetSetDef py_content_resolver_getseters[] = { + { NULL } + }; + + static PyTypeObject py_content_resolver_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.analysis.ContentResolver", + + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, + + .tp_doc = "PyChrysalide content resolver", + + .tp_methods = py_content_resolver_methods, + .tp_getset = py_content_resolver_getseters + + }; + + return &py_content_resolver_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide...ContentResolver'. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_python_content_resolver(PyObject *module) +{ + PyTypeObject *py_content_resolver_type; /* Type 'ContentResolver' */ + PyObject *dict; /* Dictionnaire du module */ + + py_content_resolver_type = get_python_content_resolver_type(); + + dict = PyModule_GetDict(module); + + if (!register_class_for_pygobject(dict, G_TYPE_CONTENT_RESOLVER, py_content_resolver_type, &PyGObject_Type)) + return false; + + return true; + +} diff --git a/plugins/pychrysalide/analysis/loading.h b/plugins/pychrysalide/analysis/loading.h new file mode 100644 index 0000000..56cdd21 --- /dev/null +++ b/plugins/pychrysalide/analysis/loading.h @@ -0,0 +1,56 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * loading.h - prototypes pour l'équivalent Python du fichier "analysis/loading.h" + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _PLUGINS_PYCHRYSALIDE_ANALYSIS_LOADING_H +#define _PLUGINS_PYCHRYSALIDE_ANALYSIS_LOADING_H + + +#include +#include + + + +/* --------------------- EXPLORATION NON BLOQUANTE DES CONTENUS --------------------- */ + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_content_explorer_type(void); + +/* Prend en charge l'objet 'pychrysalide.analysis.ContentExplorer'. */ +bool register_python_content_explorer(PyObject *); + + + +/* ------------------- RESOLUTION DE CONTENUS BINAIRES EN CHARGES ------------------- */ + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_content_resolver_type(void); + +/* Prend en charge l'objet 'pychrysalide.analysis.ContentResolver'. */ +bool register_python_content_resolver(PyObject *); + + + +#endif /* _PLUGINS_PYCHRYSALIDE_ANALYSIS_LOADING_H */ diff --git a/plugins/pychrysalide/analysis/module.c b/plugins/pychrysalide/analysis/module.c index a77121b..c9ab1e5 100644 --- a/plugins/pychrysalide/analysis/module.c +++ b/plugins/pychrysalide/analysis/module.c @@ -32,6 +32,7 @@ #include "block.h" #include "content.h" #include "loaded.h" +#include "loading.h" #include "project.h" #include "routine.h" #include "type.h" @@ -90,6 +91,8 @@ bool add_analysis_module_to_python_module(PyObject *super) result &= register_python_binary_content(module); result &= register_python_loaded_content(module); + result &= register_python_content_explorer(module); + result &= register_python_content_resolver(module); result &= register_python_loaded_binary(module); result &= register_python_instr_block(module); result &= register_python_binary_routine(module); diff --git a/plugins/pychrysalide/analysis/project.c b/plugins/pychrysalide/analysis/project.c index cd7578d..fa7de72 100644 --- a/plugins/pychrysalide/analysis/project.c +++ b/plugins/pychrysalide/analysis/project.c @@ -32,18 +32,66 @@ #include +#include "loaded.h" #include "../helpers.h" +/* Crée un nouvel objet Python de type 'StudyProject'. */ +static PyObject *py_study_project_new(PyTypeObject *, PyObject *, PyObject *); + /* Procède à l'enregistrement d'un projet donné. */ static PyObject *py_study_project_save(PyObject *, PyObject *); +/* Attache un contenu donné à un projet donné. */ +static PyObject *py_study_project_attach_content(PyObject *, PyObject *); + + + +/****************************************************************************** +* * +* Paramètres : type = type de l'objet à instancier. * +* args = arguments fournis à l'appel. * +* kwds = arguments de type key=val fournis. * +* * +* Description : Crée un nouvel objet Python de type 'StudyProject'. * +* * +* Retour : Instance Python mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_study_project_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *result; /* Instance à retourner */ + const char *filename; /* Destination de la sauvegarde*/ + int ret; /* Bilan de lecture des args. */ + GStudyProject *project; /* Version GLib du projet */ + + filename = NULL; + + ret = PyArg_ParseTuple(args, "|s", &filename); + if (!ret) return NULL; + + if (filename != NULL) + project = g_study_project_open(filename); + else + project = g_study_project_new(); + + result = pygobject_new(G_OBJECT(project)); + + if (project != NULL) + g_object_unref(project); + + return result; + +} /****************************************************************************** * * -* Paramètres : self = contenu binaire à manipuler. * +* Paramètres : self = projet d'étude à manipuler. * * args = arguments accompagnant l'appel. * * * * Description : Procède à l'enregistrement d'un projet donné. * @@ -80,6 +128,41 @@ static PyObject *py_study_project_save(PyObject *self, PyObject *args) /****************************************************************************** * * +* Paramètres : self = projet d'étude à manipuler. * +* args = arguments accompagnant l'appel. * +* * +* Description : Attache un contenu donné à un projet donné. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_study_project_attach_content(PyObject *self, PyObject *args) +{ + GStudyProject *project; /* Version GLib du format */ + PyObject *content_obj; /* Objet pour le contenu */ + int ret; /* Bilan de lecture des args. */ + GLoadedContent *content; /* Instance GLib correspondante*/ + + project = G_STUDY_PROJECT(pygobject_get(self)); + assert(project != NULL); + + ret = PyArg_ParseTuple(args, "O!", get_python_loaded_content_type(), &content_obj); + if (!ret) return NULL; + + content = G_LOADED_CONTENT(pygobject_get(content_obj)); + + g_study_project_attach_content(project, content); + + Py_RETURN_NONE; + +} + + +/****************************************************************************** +* * * Paramètres : - * * * * Description : Fournit un accès à une définition de type à diffuser. * @@ -98,6 +181,11 @@ PyTypeObject *get_python_study_project_type(void) METH_VARARGS, "save($self, filename, /)\n--\n\nSave the project into a given file." }, + { + "attach", py_study_project_attach_content, + METH_VARARGS, + "attach($self, loaded, /)\n--\n\nAdd a loaded content to the project." + }, { NULL } }; @@ -116,7 +204,8 @@ PyTypeObject *get_python_study_project_type(void) .tp_doc = "PyChrysalide study project", .tp_methods = py_study_project_methods, - .tp_getset = py_study_project_getseters + .tp_getset = py_study_project_getseters, + .tp_new = py_study_project_new }; diff --git a/plugins/pychrysalide/core/Makefile.am b/plugins/pychrysalide/core/Makefile.am index bc21d77..999674d 100644 --- a/plugins/pychrysalide/core/Makefile.am +++ b/plugins/pychrysalide/core/Makefile.am @@ -4,6 +4,7 @@ noinst_LTLIBRARIES = libpychrysacore.la libpychrysacore_la_SOURCES = \ demanglers.h demanglers.c \ formats.h formats.c \ + global.h global.c \ logs.h logs.c \ module.h module.c \ params.h params.c diff --git a/plugins/pychrysalide/core/global.c b/plugins/pychrysalide/core/global.c new file mode 100644 index 0000000..0fe767f --- /dev/null +++ b/plugins/pychrysalide/core/global.c @@ -0,0 +1,280 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * global.c - équivalent Python du fichier "core/global.c" + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "global.h" + + +#include + + +#include + + +#include "../helpers.h" +#include "../analysis/project.h" + + + +/* Fournit l'adresse de l'explorateur de contenus courant. */ +static PyObject *py_global_get_content_explorer(PyObject *, void *); + +/* Fournit l'adresse du résolveur de contenus courant. */ +static PyObject *py_global_get_content_resolver(PyObject *, void *); + +/* Fournit l'adresse du projet courant. */ +static PyObject *py_global_get_current_project(PyObject *, void *); + +/* Définit l'adresse du projet courant. */ +static int py_global_set_current_project(PyObject *, PyObject *, void *); + + + +/****************************************************************************** +* * +* Paramètres : self = objet Python concerné par l'appel. * +* closure = non utilisé ici. * +* * +* Description : Fournit l'adresse de l'explorateur de contenus courant. * +* * +* Retour : Adresse de l'explorateur global ou None si aucun (!). * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_global_get_content_explorer(PyObject *self, void *closure) +{ + PyObject *result; /* Instance Python à retourner */ + GContentExplorer *explorer; /* Gestionnaire natif récupéré */ + + explorer = get_current_content_explorer(); + + if (explorer != NULL) + { + result = pygobject_new(G_OBJECT(explorer)); + g_object_unref(G_OBJECT(explorer)); + } + else + { + result = Py_None; + Py_INCREF(result); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet Python concerné par l'appel. * +* closure = non utilisé ici. * +* * +* Description : Fournit l'adresse du résolveur de contenus courant. * +* * +* Retour : Adresse du résolveur global ou None si aucun (!). * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_global_get_content_resolver(PyObject *self, void *closure) +{ + PyObject *result; /* Instance Python à retourner */ + GContentResolver *resolver; /* Gestionnaire natif récupéré */ + + resolver = get_current_content_resolver(); + + if (resolver != NULL) + { + result = pygobject_new(G_OBJECT(resolver)); + g_object_unref(G_OBJECT(resolver)); + } + else + { + result = Py_None; + Py_INCREF(result); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet Python concerné par l'appel. * +* closure = non utilisé ici. * +* * +* Description : Fournit l'adresse du projet courant. * +* * +* Retour : Adresse du résolveur global ou None si aucun. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_global_get_current_project(PyObject *self, void *closure) +{ + PyObject *result; /* Instance Python à retourner */ + GStudyProject *project; /* Projet courant récupéré */ + + project = get_current_project(); + + if (project != NULL) + { + result = pygobject_new(G_OBJECT(project)); + g_object_unref(G_OBJECT(project)); + } + else + { + result = Py_None; + Py_INCREF(result); + } + + printf("result: %p (project=%p)\n", result, project); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet Python concerné par l'appel. * +* value = valeur fournie à intégrer ou prendre en compte. * +* closure = adresse non utilisée ici. * +* * +* Description : Définit l'adresse du projet courant. * +* * +* Retour : Bilan de l'opération pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static int py_global_set_current_project(PyObject *self, PyObject *value, void *closure) +{ + int ret; /* Bilan d'analyse */ + GStudyProject *project; /* Version GLib du format */ + + ret = PyObject_IsInstance(value, (PyObject *)get_python_study_project_type()); + if (!ret) return -1; + + project = G_STUDY_PROJECT(pygobject_get(value)); + + g_object_ref(G_OBJECT(project)); + + set_current_project(project); + + return 0; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_global_type(void) +{ + static PyMethodDef py_global_methods[] = { + { NULL } + }; + + static PyGetSetDef py_global_getseters[] = { + { + "content_explorer", py_global_get_content_explorer, NULL, + "Get the global exploration manager discovering contents.", NULL + }, + { + "content_resolver", py_global_get_content_resolver, NULL, + "Get the global resolution manager translating binary contents into loaded contents.", NULL + }, + { + "current_project", py_global_get_current_project, py_global_set_current_project, + "Get or set the current global project.", NULL + }, + { NULL } + }; + + static PyTypeObject py_global_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.core._global", + .tp_basicsize = sizeof(PyObject), + + .tp_flags = Py_TPFLAGS_DEFAULT, + + .tp_doc = "Access to the global properties", + + .tp_methods = py_global_methods, + .tp_getset = py_global_getseters + + }; + + return &py_global_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide.core._global'. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_python_global(PyObject *module) +{ + PyTypeObject *py_global_type; /* Type Python de 'global' */ + int ret; /* Bilan d'un appel */ + + py_global_type = get_python_global_type(); + + py_global_type->tp_new = PyType_GenericNew; + + if (PyType_Ready(py_global_type) != 0) + return false; + + Py_INCREF(py_global_type); + ret = PyModule_AddObject(module, "_global", (PyObject *)py_global_type); + + return (ret == 0); + +} diff --git a/plugins/pychrysalide/core/global.h b/plugins/pychrysalide/core/global.h new file mode 100644 index 0000000..b136cdb --- /dev/null +++ b/plugins/pychrysalide/core/global.h @@ -0,0 +1,42 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * global.h - prototypes pour l'équivalent Python du fichier "core/global.h" + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _PLUGINS_PYCHRYSALIDE_CORE_GLOBAL_H +#define _PLUGINS_PYCHRYSALIDE_CORE_GLOBAL_H + + +#include +#include + + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_global_type(void); + +/* Prend en charge l'objet 'pychrysalide.core._global'. */ +bool register_python_global(PyObject *); + + + +#endif /* _PLUGINS_PYCHRYSALIDE_CORE_GLOBAL_H */ diff --git a/plugins/pychrysalide/core/module.c b/plugins/pychrysalide/core/module.c index dd89ea0..22d9a48 100644 --- a/plugins/pychrysalide/core/module.c +++ b/plugins/pychrysalide/core/module.c @@ -30,6 +30,7 @@ #include "demanglers.h" #include "formats.h" +#include "global.h" #include "logs.h" #include "params.h" #include "../access.h" @@ -84,6 +85,7 @@ bool add_core_module_to_python_module(PyObject *super) result &= register_python_demanglers(module); result &= register_python_formats(module); + result &= register_python_global(module); result &= register_python_logs(module); result &= register_python_params(module); diff --git a/plugins/pychrysalide/format/executable.c b/plugins/pychrysalide/format/executable.c index 1b1bfe8..9ae45ff 100644 --- a/plugins/pychrysalide/format/executable.c +++ b/plugins/pychrysalide/format/executable.c @@ -28,7 +28,7 @@ #include -#include +#include #include "format.h" diff --git a/plugins/pychrysalide/plugin.c b/plugins/pychrysalide/plugin.c index fad0084..4689d0c 100644 --- a/plugins/pychrysalide/plugin.c +++ b/plugins/pychrysalide/plugin.c @@ -76,6 +76,9 @@ static bool g_python_plugin_do_init(GPythonPlugin *); /* Procède à l'extinction du greffon. */ static bool g_python_plugin_do_exit(GPythonPlugin *, GObject *); +/* Procède à une opération liée à un contenu binaire. */ +static void g_python_plugin_handle_binary_content(const GPythonPlugin *, PluginAction, GBinContent *, gid_t, GtkStatusStack *); + /* Indique si le format peut être pris en charge ici. */ FormatMatchStatus python_plugin_is_matching(GBinContent *, GExeFormat *, GPythonPlugin *, char **); @@ -285,6 +288,27 @@ GPluginModule *g_python_plugin_new(const char *modname, const char *filename) switch (sub) { + case DPS_CONTENT: + + switch (action) + { + case PGA_CONTENT_EXPLORER: + case PGA_CONTENT_RESOLVER: + if (!register_python_binding(instance, handle_content, \ + (pg_handle_content)g_python_plugin_handle_binary_content)) + goto gppn_bad_plugin; + break; + + default: + log_variadic_message(LMT_WARNING, + _("Unknown action '0x%02x' in plugin '%s'..."), + action, filename); + break; + + } + + break; + case DPS_FORMAT: switch (action) @@ -439,7 +463,7 @@ static bool g_python_plugin_read_interface(GPythonPlugin *plugin) { action = PyList_GET_ITEM(tuple, i); - interface.actions[i] = PyLong_AsLong(action); + interface.actions[i] = PyLong_AsUnsignedLong(action); } @@ -543,6 +567,42 @@ static bool g_python_plugin_do_exit(GPythonPlugin *plugin, GObject *ref) /****************************************************************************** * * +* Paramètres : plugin = greffon à manipuler. * +* action = type d'action attendue. * +* content = contenu binaire à traiter. * +* gid = identifiant du groupe de traitement. * +* status = barre de statut à tenir informée. * +* * +* Description : Procède à une opération liée à un contenu binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_python_plugin_handle_binary_content(const GPythonPlugin *plugin, PluginAction action, GBinContent *content, gid_t gid, GtkStatusStack *status) +{ + PyObject *args; /* Arguments pour l'appel */ + PyObject *value; /* Valeurs obtenues */ + + args = PyTuple_New(4); + + PyTuple_SetItem(args, 0, PyLong_FromUnsignedLong(action)); + PyTuple_SetItem(args, 1, pygobject_new(G_OBJECT(content))); + PyTuple_SetItem(args, 2, PyLong_FromUnsignedLong(gid)); + PyTuple_SetItem(args, 3, pygobject_new(G_OBJECT(status))); + + value = run_python_method(plugin->instance, "handle_binary_content", args); + + Py_XDECREF(value); + Py_DECREF(args); + +} + + +/****************************************************************************** +* * * Paramètres : content = contenu binaire à parcourir. * * parent = éventuel format exécutable déjà chargé. * * plugin = grefon C interne représentant le grefon Python. * @@ -678,7 +738,7 @@ static void g_python_plugin_process_disass(const GPythonPlugin *plugin, PluginAc args = PyTuple_New(2); - PyTuple_SetItem(args, 0, PyLong_FromLong(action)); + PyTuple_SetItem(args, 0, PyLong_FromUnsignedLong(action)); PyTuple_SetItem(args, 1, pygobject_new(G_OBJECT(binary))); value = run_python_method(plugin->instance, "process_binary_disassembly", args); @@ -716,6 +776,8 @@ static bool py_plugin_module_define_constants(PyTypeObject *obj_type) result &= PyDict_AddIntMacro(obj_type, PGA_BASIC_NONE); result &= PyDict_AddIntMacro(obj_type, PGA_PLUGIN_INIT); result &= PyDict_AddIntMacro(obj_type, PGA_PLUGIN_EXIT); + result &= PyDict_AddIntMacro(obj_type, PGA_CONTENT_EXPLORER); + result &= PyDict_AddIntMacro(obj_type, PGA_CONTENT_RESOLVER); result &= PyDict_AddIntMacro(obj_type, PGA_FORMAT_MATCHER); result &= PyDict_AddIntMacro(obj_type, PGA_FORMAT_LOADER_LAST); result &= PyDict_AddIntMacro(obj_type, PGA_DISASSEMBLY_STARTED); diff --git a/src/analysis/binary.c b/src/analysis/binary.c index d7cb29c..38cb503 100644 --- a/src/analysis/binary.c +++ b/src/analysis/binary.c @@ -120,19 +120,16 @@ static void g_loaded_binary_dispose(GLoadedBinary *); /* Procède à la libération totale de la mémoire. */ static void g_loaded_binary_finalize(GLoadedBinary *); -/* Acquitte la fin d'un désasemblage différé et complet. */ -static void ack_completed_disassembly(GDelayedDisassembly *, GLoadedBinary *); - /* ------------------------- INFORMATIONS D'ENREGISTREMENTS ------------------------- */ /* Charge en mémoire les formes d'enregistrement du XML. */ -static bool g_loaded_binary_load_storage(GLoadedBinary *, xmlXPathContextPtr, const char *); +static bool g_loaded_binary_load_storage(GLoadedBinary *, xmlXPathContext *, const char *); /* Ecrit les formes d'enregistrement du binaire dans du XML. */ -static bool g_loaded_binary_save_storage(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *); +static bool g_loaded_binary_save_storage(const GLoadedBinary *, xmlDoc *, xmlXPathContext *, const char *); /* Etablit une connexion au serveur interne en tant que client. */ static bool g_loaded_binary_connect_internal(GLoadedBinary *); @@ -146,13 +143,26 @@ static bool g_loaded_binary_connect_remote(GLoadedBinary *); -/* Lance l'analyse d'un élément binaire chargé. */ -static void _g_loaded_binary_analyse(GLoadedBinary *, disassembly_ack_fc); /* ---------------------- GESTION SOUS FORME DE CONTENU CHARGE ---------------------- */ +/* Interprète un contenu binaire chargé avec un appui XML. */ +static bool g_loaded_binary_restore(GLoadedBinary *, xmlDoc *, xmlXPathContext *, const char *); + +/* Ecrit une sauvegarde du binaire dans un fichier XML. */ +static bool g_loaded_binary_save(const GLoadedBinary *, xmlDoc *, xmlXPathContext *, const char *); + +/* Fournit le contenu représenté de l'élément chargé. */ +static GBinContent *g_loaded_binary_get_content(const GLoadedBinary *); + +/* Fournit le contenu représenté de l'élément chargé. */ +static const char *g_loaded_binary_get_format_name(const GLoadedBinary *); + +/* Assure le désassemblage en différé. */ +static bool g_loaded_binary_analyze(GLoadedBinary *, wgroup_id_t, GtkStatusStack *); + /* Fournit le désignation associée à l'élément chargé. */ static const char *g_loaded_binary_describe(const GLoadedBinary *, bool); @@ -269,6 +279,14 @@ static void g_loaded_binary_init(GLoadedBinary *binary) static void g_loaded_binary_interface_init(GLoadedContentInterface *iface) { + iface->restore = (restore_content_fc)g_loaded_binary_restore; + iface->save = (save_content_fc)g_loaded_binary_save; + + iface->get_content = (get_content_fc)g_loaded_binary_get_content; + iface->get_format_name = (get_format_name_fc)g_loaded_binary_get_format_name; + + iface->analyze = (analyze_loaded_fc)g_loaded_binary_analyze; + iface->describe = (describe_loaded_fc)g_loaded_binary_describe; iface->count_views = (count_loaded_views_fc)g_loaded_binary_count_views; @@ -333,6 +351,32 @@ static void g_loaded_binary_finalize(GLoadedBinary *binary) /****************************************************************************** * * +* Paramètres : format = format d'exécutable établi. * +* * +* Description : Interprète un contenu binaire chargé. * +* * +* Retour : Adresse de la représentation ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GLoadedContent *g_loaded_binary_new(GExeFormat *format) +{ + GLoadedBinary *result; /* Adresse à retourner */ + + result = g_object_new(G_TYPE_LOADED_BINARY, NULL); + + result->format = format; + + return G_LOADED_CONTENT(result); + +} + + + +/****************************************************************************** +* * * Paramètres : content = contenu binaire chargé en mémoire. * * * * Description : Interprète un contenu binaire chargé. * @@ -343,7 +387,7 @@ static void g_loaded_binary_finalize(GLoadedBinary *binary) * * ******************************************************************************/ -GLoadedBinary *g_loaded_binary_new(GBinContent *content) +GLoadedBinary *g_loaded_binary_new_old(GBinContent *content) { GLoadedBinary *result; /* Adresse à retourner */ FormatMatchStatus status; /* Statut d'une reconnaissance */ @@ -420,198 +464,6 @@ GLoadedBinary *g_loaded_binary_new(GBinContent *content) /****************************************************************************** * * -* Paramètres : context = contexte pour les recherches XPath. * -* path = chemin d'accès au noeud XML à lire. * -* project = projet dans lequel venir rechercher les contenus. * -* * -* Description : Interprète un contenu binaire chargé avec un appui XML. * -* * -* Retour : Adresse de la représentation ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr context, const char *path, GStudyProject *project) -{ - GLoadedBinary *result; /* Adresse à retourner */ - char *content_path; /* Partie "Contenus" */ - char *access; /* Chemin d'accès à un élément */ - char *hash; /* Empreinte à retrouver */ - GBinContent *content; /* Contenu à référencer */ - xmlXPathObjectPtr xobject; /* Cible d'une recherche */ - unsigned int i; /* Boucle de parcours */ - bool attached; /* Bilan d'un chargement */ - - /* Contenus binaires associés */ - - content_path = strdup(path); - content_path = stradd(content_path, "/Contents"); - - access = strdup(content_path); - access = stradd(access, "/Main"); - - hash = get_node_text_value(context, access); - - free(access); - - if (hash == NULL) - goto glbnfx_early_error; - - content = g_study_project_find_binary_content_by_hash(project, hash); - - free(hash); - - if (content == NULL) - goto glbnfx_early_error; - - result = g_loaded_binary_new(content); - - g_object_unref(G_OBJECT(content)); - - if (result == NULL) - goto glbnfx_early_error; - - asprintf(&access, "%s/DebugInfo", content_path); - - xobject = get_node_xpath_object(context, access); - - free(access); - - for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++) - { - asprintf(&access, "%s/DebugInfo[position()=%u]", content_path, i + 1); - - hash = get_node_text_value(context, access); - - free(access); - - if (hash == NULL) - goto glbnfx_error; - - content = g_study_project_find_binary_content_by_hash(project, hash); - - free(hash); - - if (content == NULL) - goto glbnfx_error; - - attached = g_loaded_binary_attach_debug_info(result, content); - - g_object_unref(G_OBJECT(content)); - - if (!attached) - goto glbnfx_error; - - } - - if(xobject != NULL) - xmlXPathFreeObject(xobject); - - free(content_path); - - /* Elément divers associés au binaire */ - - if (!g_loaded_binary_load_storage(result, context, path)) - goto glbnfx_final_error; - - return result; - - glbnfx_error: - - free(content_path); - - glbnfx_final_error: - - g_object_unref(G_OBJECT(result)); - - return NULL; - - glbnfx_early_error: - - g_object_unref(G_OBJECT(result)); - - free(content_path); - - return NULL; - -} - - -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à traiter. * -* xdoc = structure XML en cours d'édition. * -* context = contexte à utiliser pour les recherches. * -* path = chemin d'accès réservé au binaire. * -* base = référence au lieu d'enregistrement du projet. * -* * -* Description : Ecrit une sauvegarde du binaire dans un fichier XML. * -* * -* Retour : true si l'opération a bien tourné, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool g_loaded_binary_save(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path, const char *base) -{ - bool result; /* Bilan à faire remonter */ - char *content_path; /* Partie "Contenus" */ - char *access; /* Chemin d'accès à un élément */ - GBinContent *content; /* Contenu à référencer */ - size_t debugs_count; /* Quantité de formats liés */ - size_t i; /* Boucle de parcours */ - GDbgFormat *debug; /* Informations de débogage */ - - /* Contenus binaires associés */ - - content_path = strdup(path); - content_path = stradd(content_path, "/Contents"); - - asprintf(&access, "%s/Main", content_path); - - content = g_binary_format_get_content(G_BIN_FORMAT(binary->format)); - result = g_binary_content_save(content, xdoc, context, access, base); - g_object_unref(G_OBJECT(content)); - - free(access); - - debugs_count = g_exe_format_count_debug_info(binary->format); - - for (i = 0; i < debugs_count && result; i++) - { - asprintf(&access, "%s/DebugInfo[position()=%zu]", content_path, i); - - debug = g_exe_format_get_debug_info(binary->format, i); - - content = g_binary_format_get_content(G_BIN_FORMAT(debug)); - result = g_binary_content_save(content, xdoc, context, access, base); - g_object_unref(G_OBJECT(content)); - - g_object_unref(G_OBJECT(debug)); - - free(access); - - } - - free(content_path); - - /* Elément divers associés au binaire */ - - result = g_loaded_binary_save_storage(binary, xdoc, context, path); - - /* Sauvegarde côté serveur */ - - g_db_client_save(binary->local); - - return result; - -} - - -/****************************************************************************** -* * * Paramètres : binary = élément binaire à consulter. * * full = précise s'il s'agit d'une version longue ou non. * * * @@ -659,7 +511,7 @@ const char *g_loaded_binary_get_name(const GLoadedBinary *binary, bool full) * * ******************************************************************************/ -static bool g_loaded_binary_load_storage(GLoadedBinary *binary, xmlXPathContextPtr context, const char *path) +static bool g_loaded_binary_load_storage(GLoadedBinary *binary, xmlXPathContext *context, const char *path) { bool result; /* Bilan à faire remonter */ char *storage_path; /* Partie "Enregistrement" */ @@ -783,7 +635,7 @@ static bool g_loaded_binary_load_storage(GLoadedBinary *binary, xmlXPathContextP * * ******************************************************************************/ -static bool g_loaded_binary_save_storage(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path) +static bool g_loaded_binary_save_storage(const GLoadedBinary *binary, xmlDoc *xdoc, xmlXPathContext *context, const char *path) { bool result; /* Bilan à faire remonter */ char *storage_path; /* Partie "Enregistrement" */ @@ -1414,86 +1266,6 @@ bool _g_loaded_binary_remove_from_collection(GLoadedBinary *binary, DBFeatures f -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à traiter. * -* ack = éventuelle fonction à appeler en conclusion. * -* * -* Description : Lance l'analyse d'un élément binaire chargé. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void _g_loaded_binary_analyse(GLoadedBinary *binary, disassembly_ack_fc ack) -{ - /* Détermination de l'identifiant */ - - - - /* Contacts avec les serveurs */ - - - // Déconnexion... - - g_loaded_binary_connect_internal(binary); - - - disassemble_binary(binary, &binary->disass_cache, ack); - - - - /* TODO : remme ! */ - //ack_completed_disassembly(NULL, binary); - -} - - -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à traiter. * -* * -* Description : Lance l'analyse d'un élément binaire chargé. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_loaded_binary_analyse(GLoadedBinary *binary) -{ - _g_loaded_binary_analyse(binary, ack_completed_disassembly); - -} - - -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à traiter. * -* * -* Description : Lance l'analyse d'un binaire chargé et attend sa conclusion. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_loaded_binary_analyse_and_wait(GLoadedBinary *binary) -{ - GWorkQueue *queue; /* Gestionnaire de différés */ - - _g_loaded_binary_analyse(binary, NULL); - - queue = get_work_queue(); - g_work_queue_wait_for_completion(queue, DEFAULT_WORK_GROUP); - - ack_completed_disassembly(NULL, binary); - -} /****************************************************************************** @@ -1682,80 +1454,183 @@ bool *g_loaded_binary_display_decomp_lines(GLoadedBinary *binary) } + +/* ---------------------------------------------------------------------------------- */ +/* GESTION SOUS FORME DE CONTENU CHARGE */ +/* ---------------------------------------------------------------------------------- */ + + /****************************************************************************** * * -* Paramètres : disass = travail de désassemblage mené à bien. * -* binary = représentation de binaire à l'origine de l'opérat°. * +* Paramètres : binary = élément binaire à traiter. * +* xdoc = structure XML en cours d'édition. * +* context = contexte à utiliser pour les recherches. * +* path = chemin d'accès réservé au binaire. * * * -* Description : Acquitte la fin d'un désasemblage différé et complet. * +* Description : Interprète un contenu binaire chargé avec un appui XML. * * * -* Retour : - * +* Retour : true si l'opération a bien tourné, false sinon. * * * * Remarques : - * * * ******************************************************************************/ -#include "../gui/core/global.h" -void ack_completed_disassembly(GDelayedDisassembly *disass, GLoadedBinary *binary) -{ - //GRenderingLine *line; /* "Première" ligne de rendu */ - size_t i; /* Boucle de parcours */ +static bool g_loaded_binary_restore(GLoadedBinary *binary, xmlDoc *xdoc, xmlXPathContext *context, const char *path) +{ + bool result; /* Bilan à faire remonter */ - const char * const *files; /* Liste de fichiers source */ + /* Elément divers associés au binaire */ + result = g_loaded_binary_load_storage(binary, context, path); + return result; +} - g_binary_format_complete_analysis(G_BIN_FORMAT(binary->format), get_global_status()); +/****************************************************************************** +* * +* Paramètres : binary = élément binaire à traiter. * +* xdoc = structure XML en cours d'édition. * +* context = contexte à utiliser pour les recherches. * +* path = chemin d'accès réservé au binaire. * +* * +* Description : Ecrit une sauvegarde du binaire dans un fichier XML. * +* * +* Retour : true si l'opération a bien tourné, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ +static bool g_loaded_binary_save(const GLoadedBinary *binary, xmlDoc *xdoc, xmlXPathContext *context, const char *path) +{ + bool result; /* Bilan à faire remonter */ - /* ... = *///g_loaded_binary_connect_internal(binary); + /* Elément divers associés au binaire */ + result = g_loaded_binary_save_storage(binary, xdoc, context, path); - /* Décompilation... */ + /* Sauvegarde côté serveur */ + if (result) + g_db_client_save(binary->local); + return result; - files = g_binary_format_get_source_files(G_BIN_FORMAT(binary->format), - &binary->decbuf_count, &binary->defsrc); +} -#if 0 - if (binary->decbuf_count > 0) - { - binary->dec_buffers = (GCodeBuffer **)calloc(binary->decbuf_count, sizeof(GCodeBuffer *)); - /* - for (i = 0; i < binary->decbuf_count; i++) - binary->dec_buffers[i] = decompile_all_from_file(binary, files[i]); - */ - } -#endif +/****************************************************************************** +* * +* Paramètres : binary = élément chargé à manipuler. * +* * +* Description : Fournit le contenu représenté de l'élément chargé. * +* * +* Retour : Contenu représenté. * +* * +* Remarques : - * +* * +******************************************************************************/ +static GBinContent *g_loaded_binary_get_content(const GLoadedBinary *binary) +{ + GBinContent *result; /* Contenu interne à renvoyer */ + result = g_binary_format_get_content(G_BIN_FORMAT(binary->format)); -#if 0 - g_rendering_line_merge(&binary->lines, &disass->lines); + return result; +} +/****************************************************************************** +* * +* Paramètres : binary = élément chargé à manipuler. * +* * +* Description : Fournit le contenu représenté de l'élément chargé. * +* * +* Retour : Contenu représenté. * +* * +* Remarques : - * +* * +******************************************************************************/ - line = g_rendering_line_find_by_address(disass->lines, NULL, - g_exe_format_get_entry_point(binary->format)); - if (line != NULL) g_rendering_line_add_flag(line, RLF_ENTRY_POINT); +static const char *g_loaded_binary_get_format_name(const GLoadedBinary *binary) +{ + const char *result; /* Désignation à retourner */ - /* On réintègre le flot premier */ -#endif + result = g_binary_format_get_name(G_BIN_FORMAT(binary->format)); - g_signal_emit_by_name(binary, "disassembly-done"); + return result; } +/****************************************************************************** +* * +* Paramètres : binary = élément chargé dont l'analyse est lancée. * +* gid = groupe de travail dédié. * +* status = barre de statut à tenir informée. * +* * +* Description : Assure le désassemblage en différé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ -/* ---------------------------------------------------------------------------------- */ -/* GESTION SOUS FORME DE CONTENU CHARGE */ -/* ---------------------------------------------------------------------------------- */ +static bool g_loaded_binary_analyze(GLoadedBinary *binary, wgroup_id_t gid, GtkStatusStack *status) +{ + bool result; /* Bilan à retourner */ + GBinFormat *format; /* Format lié au binaire */ + const char *arch; /* Architecture d'exécution */ + const char *desc; /* Description humaine associée*/ + + /* Interprétation du format associé */ + + format = G_BIN_FORMAT(binary->format); + + result = g_binary_format_analyze(format, gid, status); + if (!result) goto glba_exit; + + /* Architecture visée */ + + arch = g_exe_format_get_target_machine(binary->format); + desc = get_arch_processor_name(arch); + + if (desc == NULL) + { + log_simple_message(LMT_INFO, _("Unknown architecture")); + goto glba_exit; + } + else + log_variadic_message(LMT_INFO, _("Detected architecture: %s"), desc); + + binary->proc = get_arch_processor_for_type(arch); + + if (binary->proc == NULL) + { + log_simple_message(LMT_ERROR, _("Unable to load the required processor")); + goto glba_exit; + } + + /* Phase de désassemblage pur */ + + g_loaded_binary_connect_internal(binary); + + disassemble_binary(binary, gid, status, &binary->disass_cache); + + g_binary_format_complete_analysis(format, status); + + result = true; + + glba_exit: + + return result; + +} /****************************************************************************** diff --git a/src/analysis/binary.h b/src/analysis/binary.h index ca62084..b57e072 100644 --- a/src/analysis/binary.h +++ b/src/analysis/binary.h @@ -29,22 +29,17 @@ #include #include "content.h" +#include "loaded.h" #include "db/collection.h" #include "db/client.h" #include "db/protocol.h" #include "../arch/processor.h" -#include "../common/xml.h" #include "../format/debuggable.h" #include "../format/executable.h" #include "../glibext/gbuffercache.h" -/* Redéfinition depuis project.c : projet d'étude regroupant les binaires analysés (instance) */ -typedef struct _GStudyProject GStudyProject; - - - /* ------------------------ ENCADREMENTS D'UN BINAIRE CHARGE ------------------------ */ @@ -79,13 +74,10 @@ typedef enum _BinaryPartModel GType g_loaded_binary_get_type(void); /* Interprète un contenu binaire chargé. */ -GLoadedBinary *g_loaded_binary_new(GBinContent *); - -/* Interprète un contenu binaire chargé avec un appui XML. */ -GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr, const char *, GStudyProject *); +GLoadedContent *g_loaded_binary_new(GExeFormat *); -/* Ecrit une sauvegarde du binaire dans un fichier XML. */ -bool g_loaded_binary_save(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *, const char *); +/* Interprète un contenu binaire chargé. */ +GLoadedBinary *g_loaded_binary_new_old(GBinContent *); /* Fournit le nom associé à l'élément binaire. */ const char *g_loaded_binary_get_name(const GLoadedBinary *, bool); @@ -160,12 +152,6 @@ bool _g_loaded_binary_remove_from_collection(GLoadedBinary *, DBFeatures, GDbIte -/* Lance l'analyse d'un élément binaire chargé. */ -void g_loaded_binary_analyse(GLoadedBinary *); - -/* Lance l'analyse d'un binaire chargé et attend sa conclusion. */ -void g_loaded_binary_analyse_and_wait(GLoadedBinary *); - /* Fournit le format de fichier reconnu dans le contenu binaire. */ bool g_loaded_binary_attach_debug_info(GLoadedBinary *, GBinContent *); diff --git a/src/analysis/content-int.h b/src/analysis/content-int.h index e8b4add..49d5269 100644 --- a/src/analysis/content-int.h +++ b/src/analysis/content-int.h @@ -29,6 +29,9 @@ +/* Donne l'origine d'un contenu binaire. */ +typedef GBinContent * (* get_content_root_fc) (GBinContent *); + /* Fournit le nom associé au contenu binaire. */ typedef const char * (* describe_content_fc) (const GBinContent *, bool); @@ -80,6 +83,8 @@ struct _GBinContentIface { GTypeInterface base_iface; /* A laisser en premier */ + get_content_root_fc get_root; /* Renvoie à l'origine */ + describe_content_fc describe; /* Fournit une description */ save_content_fc save; /* Sauvegarde du contenu */ diff --git a/src/analysis/content.c b/src/analysis/content.c index 2c2d366..3c394f1 100644 --- a/src/analysis/content.c +++ b/src/analysis/content.c @@ -99,6 +99,34 @@ GBinContent *g_binary_content_new_from_xml(xmlXPathContextPtr context, const cha /****************************************************************************** * * * Paramètres : content = contenu binaire à consulter. * +* * +* Description : Donne l'origine d'un contenu binaire. * +* * +* Retour : Contenu à l'origine du contenu courant. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GBinContent *g_binary_content_get_root(GBinContent *content) +{ + GBinContent *result; /* Contenu en place à renvoyer */ + GBinContentIface *iface; /* Interface utilisée */ + + iface = G_BIN_CONTENT_GET_IFACE(content); + + result = iface->get_root(content); + + g_object_ref(G_OBJECT(result)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à consulter. * * full = précise s'il s'agit d'une version longue ou non. * * * * Description : Fournit le nom associé au contenu binaire. * diff --git a/src/analysis/content.h b/src/analysis/content.h index b06a17b..3f471f9 100644 --- a/src/analysis/content.h +++ b/src/analysis/content.h @@ -57,6 +57,9 @@ GType g_binary_content_get_type(void) G_GNUC_CONST; /* Charge en mémoire un contenu binaire à partir d'XML. */ GBinContent *g_binary_content_new_from_xml(xmlXPathContextPtr, const char *, const char *); +/* Donne l'origine d'un contenu binaire. */ +GBinContent *g_binary_content_get_root(GBinContent *); + /* Fournit le nom associé au contenu binaire. */ const char *g_binary_content_describe(const GBinContent *, bool); diff --git a/src/analysis/contents/encapsulated.c b/src/analysis/contents/encapsulated.c index 1fd4203..e307e6b 100644 --- a/src/analysis/contents/encapsulated.c +++ b/src/analysis/contents/encapsulated.c @@ -70,6 +70,9 @@ static void g_encaps_content_dispose(GEncapsContent *); /* Procède à la libération totale de la mémoire. */ static void g_encaps_content_finalize(GEncapsContent *); +/* Donne l'origine d'un contenu binaire. */ +static GBinContent *g_encaps_content_get_root(GEncapsContent *); + /* Fournit le nom associé au contenu binaire. */ static const char *g_encaps_content_describe(const GEncapsContent *, bool); @@ -181,6 +184,8 @@ static void g_encaps_content_init(GEncapsContent *content) static void g_encaps_content_interface_init(GBinContentInterface *iface) { + iface->get_root = (get_content_root_fc)g_encaps_content_get_root; + iface->describe = (describe_content_fc)g_encaps_content_describe; iface->save = (save_content_fc)g_encaps_content_save; @@ -367,6 +372,29 @@ GBinContent *g_encaps_content_new_from_xml(xmlXPathContextPtr context, const cha /****************************************************************************** * * * Paramètres : content = contenu binaire à consulter. * +* * +* Description : Donne l'origine d'un contenu binaire. * +* * +* Retour : Contenu à l'origine du contenu courant. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GBinContent *g_encaps_content_get_root(GEncapsContent *content) +{ + GBinContent *result; /* Contenu en place à renvoyer */ + + result = g_binary_content_get_root(content->base); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à consulter. * * full = précise s'il s'agit d'une version longue ou non. * * * * Description : Fournit le nom associé au contenu binaire. * diff --git a/src/analysis/contents/file.c b/src/analysis/contents/file.c index 31acb6f..901a848 100644 --- a/src/analysis/contents/file.c +++ b/src/analysis/contents/file.c @@ -73,6 +73,9 @@ static void g_file_content_dispose(GFileContent *); /* Procède à la libération totale de la mémoire. */ static void g_file_content_finalize(GFileContent *); +/* Donne l'origine d'un contenu binaire. */ +static GBinContent *g_file_content_get_root(GFileContent *); + /* Fournit le nom associé au contenu binaire. */ static const char *g_file_content_describe(const GFileContent *, bool); @@ -181,6 +184,8 @@ static void g_file_content_init(GFileContent *content) static void g_file_content_interface_init(GBinContentInterface *iface) { + iface->get_root = (get_content_root_fc)g_file_content_get_root; + iface->describe = (describe_content_fc)g_file_content_describe; iface->save = (save_content_fc)g_file_content_save; @@ -376,6 +381,29 @@ GBinContent *g_file_content_new_from_xml(xmlXPathContextPtr context, const char /****************************************************************************** * * * Paramètres : content = contenu binaire à consulter. * +* * +* Description : Donne l'origine d'un contenu binaire. * +* * +* Retour : Contenu à l'origine du contenu courant. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GBinContent *g_file_content_get_root(GFileContent *content) +{ + GBinContent *result; /* Contenu en place à renvoyer */ + + result = G_BIN_CONTENT(content); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à consulter. * * full = précise s'il s'agit d'une version longue ou non. * * * * Description : Fournit le nom associé au contenu binaire. * diff --git a/src/analysis/contents/memory.c b/src/analysis/contents/memory.c index a7bdbea..beefe89 100644 --- a/src/analysis/contents/memory.c +++ b/src/analysis/contents/memory.c @@ -73,6 +73,9 @@ static void g_memory_content_dispose(GMemoryContent *); /* Procède à la libération totale de la mémoire. */ static void g_memory_content_finalize(GMemoryContent *); +/* Donne l'origine d'un contenu binaire. */ +static GBinContent *g_memory_content_get_root(GMemoryContent *); + /* Fournit le nom associé au contenu binaire. */ static const char *g_memory_content_describe(const GMemoryContent *, bool); @@ -183,6 +186,8 @@ static void g_memory_content_init(GMemoryContent *content) static void g_memory_content_interface_init(GBinContentInterface *iface) { + iface->get_root = (get_content_root_fc)g_memory_content_get_root; + iface->describe = (describe_content_fc)g_memory_content_describe; iface->save = (save_content_fc)g_memory_content_save; @@ -357,6 +362,29 @@ GBinContent *g_memory_content_new_from_xml(xmlXPathContextPtr context, const cha /****************************************************************************** * * * Paramètres : content = contenu binaire à consulter. * +* * +* Description : Donne l'origine d'un contenu binaire. * +* * +* Retour : Contenu à l'origine du contenu courant. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GBinContent *g_memory_content_get_root(GMemoryContent *content) +{ + GBinContent *result; /* Contenu en place à renvoyer */ + + result = G_BIN_CONTENT(content); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à consulter. * * full = précise s'il s'agit d'une version longue ou non. * * * * Description : Fournit le nom associé au contenu binaire. * diff --git a/src/analysis/contents/restricted.c b/src/analysis/contents/restricted.c index 711f963..d52e1c0 100644 --- a/src/analysis/contents/restricted.c +++ b/src/analysis/contents/restricted.c @@ -66,6 +66,9 @@ static void g_restricted_content_dispose(GRestrictedContent *); /* Procède à la libération totale de la mémoire. */ static void g_restricted_content_finalize(GRestrictedContent *); +/* Donne l'origine d'un contenu binaire. */ +static GBinContent *g_restricted_content_get_root(GRestrictedContent *); + /* Calcule une empreinte unique (SHA256) pour les données. */ static void g_restricted_content_compute_checksum(GRestrictedContent *, GChecksum *); @@ -168,6 +171,8 @@ static void g_restricted_content_init(GRestrictedContent *content) static void g_restricted_content_interface_init(GBinContentInterface *iface) { + iface->get_root = (get_content_root_fc)g_restricted_content_get_root; + iface->compute_checksum = (compute_checksum_fc)g_restricted_content_compute_checksum; iface->compute_size = (compute_size_fc)g_restricted_content_compute_size; @@ -290,6 +295,29 @@ GBinContent *g_restricted_content_new_ro(const GBinContent *content, const mrang /****************************************************************************** * * +* Paramètres : content = contenu binaire à consulter. * +* * +* Description : Donne l'origine d'un contenu binaire. * +* * +* Retour : Contenu à l'origine du contenu courant. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GBinContent *g_restricted_content_get_root(GRestrictedContent *content) +{ + GBinContent *result; /* Contenu en place à renvoyer */ + + result = g_binary_content_get_root(content->internal); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : content = contenu binaire à venir lire. * * checksum = empreinte de zone mémoire à compléter. * * * diff --git a/src/analysis/disass/disassembler.c b/src/analysis/disass/disassembler.c index 6c63b0b..dded65b 100644 --- a/src/analysis/disass/disassembler.c +++ b/src/analysis/disass/disassembler.c @@ -33,13 +33,10 @@ #include "fetch.h" -#include "output.h" - #include "instructions.h" +#include "output.h" #include "routines.h" #include "../../core/global.h" -#include "../../format/format.h" -#include "../../glibext/delayed-int.h" #include "../../glibext/generators/prologue.h" #include "../../plugins/pglist.h" @@ -49,190 +46,18 @@ -/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ - - -/* Ensembles binaires à désassembler (instance) */ -struct _GDelayedDisassembly -{ - GDelayedWork parent; /* A laisser en premier */ - - GLoadedBinary *binary; /* Destinataire final */ - GExeFormat *format; /* Format du binaire représenté*/ - GCodingLanguage *lang; /* Traduction en ASM préférée */ - - GBufferCache *cache; /* Tampon pour le rendu */ - -}; - -/* Ensembles binaires à désassembler (classe) */ -struct _GDelayedDisassemblyClass -{ - GDelayedWorkClass parent; /* A laisser en premier */ - -}; - - -/* 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 *); - -/* Supprime toutes les références externes. */ -static void g_delayed_disassembly_dispose(GDelayedDisassembly *); - -/* Procède à la libération totale de la mémoire. */ -static void g_delayed_disassembly_finalize(GDelayedDisassembly *); - -/* Crée une tâche de désassemblage différé. */ -static GDelayedDisassembly *g_delayed_disassembly_new(GLoadedBinary *, GBufferCache *); - /* Opère sur toutes les instructions. */ static void process_all_instructions(wgroup_id_t, GtkStatusStack *, const char *, ins_fallback_cb, GArchProcessor *, GProcContext *, GExeFormat *); /* Opère sur toutes les routines. */ static void process_all_routines(wgroup_id_t, GtkStatusStack *, const char *, rtn_fallback_cb, GArchProcessor *, GBinFormat *); -/* Assure le désassemblage en différé. */ -static void g_delayed_disassembly_process(GDelayedDisassembly *, GtkStatusStack *); - - - -/* -------------------------- GESTION GLOBALE DE PROCEDURE -------------------------- */ - - -/* Construit la description d'introduction du désassemblage. */ -static void build_disass_prologue(GBufferCache *, const GBinFormat *, const GCodingLanguage *, const char *, const char *); - - - -/* ---------------------------------------------------------------------------------- */ -/* 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 : klass = classe à initialiser. * -* * -* Description : Initialise la classe des tâches de désassemblage différé. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *klass) -{ - GObjectClass *object; /* Autre version de la classe */ - GDelayedWorkClass *work; /* Version en classe parente */ - - object = G_OBJECT_CLASS(klass); - - object->dispose = (GObjectFinalizeFunc/* ! */)g_delayed_disassembly_dispose; - object->finalize = (GObjectFinalizeFunc)g_delayed_disassembly_finalize; - - work = G_DELAYED_WORK_CLASS(klass); - - work->run = (run_task_fc)g_delayed_disassembly_process; - -} - - -/****************************************************************************** -* * -* Paramètres : disass = instance à initialiser. * -* * -* Description : Initialise une tâche de désassemblage différé. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_delayed_disassembly_init(GDelayedDisassembly *disass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : disass = instance d'objet GLib à traiter. * -* * -* Description : Supprime toutes les références externes. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_delayed_disassembly_dispose(GDelayedDisassembly *disass) -{ - g_object_unref(G_OBJECT(disass->format)); - g_object_unref(G_OBJECT(disass->lang)); - - G_OBJECT_CLASS(g_delayed_disassembly_parent_class)->dispose(G_OBJECT(disass)); - -} - - -/****************************************************************************** -* * -* Paramètres : disass = instance d'objet GLib à traiter. * -* * -* Description : Procède à la libération totale de la mémoire. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ +/* Réalise un désassemblage effectif. */ +static void compute_disassembly(GLoadedBinary *, GProcContext *, wgroup_id_t, GtkStatusStack *); -static void g_delayed_disassembly_finalize(GDelayedDisassembly *disass) -{ - G_OBJECT_CLASS(g_delayed_disassembly_parent_class)->finalize(G_OBJECT(disass)); +/* Imprime le résultat d'un désassemblage. */ +static void output_disassembly(GLoadedBinary *, GProcContext *, GtkStatusStack *, GBufferCache **); -} - - -/****************************************************************************** -* * -* Paramètres : binary = binaire chargé en attente des résultats. * -* format = format du binaire représenté. * -* buffer = tampon de sortie pour les instructions. * -* * -* Description : Crée une tâche de désassemblage différé. * -* * -* Retour : Tâche créée. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static GDelayedDisassembly *g_delayed_disassembly_new(GLoadedBinary *binary, GBufferCache *cache) -{ - GDelayedDisassembly *result; /* Tâche à retourner */ - - result = g_object_new(G_TYPE_DELAYED_DISASSEMBLY, NULL); - - result->binary = binary; - result->format = g_loaded_binary_get_format(binary); - result->lang = g_asm_language_new(); - - result->cache = cache; - - return result; - -} /****************************************************************************** @@ -374,10 +199,12 @@ static void process_all_routines(wgroup_id_t gid, GtkStatusStack *status, const /****************************************************************************** * * -* Paramètres : disass = analyse à mener. * -* status = barre de statut à tenir informée. * +* Paramètres : binary = représentation de binaire chargé. * +* context = contexte de désassemblage utilisé. * +* gid = groupe de travail dédié. * +* status = barre de statut à tenir informée. * * * -* Description : Assure le désassemblage en différé. * +* Description : Réalise un désassemblage effectif. * * * * Retour : - * * * @@ -385,249 +212,100 @@ static void process_all_routines(wgroup_id_t gid, GtkStatusStack *status, const * * ******************************************************************************/ -static void g_delayed_disassembly_process(GDelayedDisassembly *disass, GtkStatusStack *status) +static void compute_disassembly(GLoadedBinary *binary, GProcContext *context, wgroup_id_t gid, GtkStatusStack *status) { - wgroup_id_t gid; /* Identifiant pour les tâches */ - - //GBinFormat *format; /* Format du fichier binaire */ GArchProcessor *proc; /* Architecture du binaire */ - GProcContext *ctx; /* Contexte de suivi dédié */ - - //size_t i; /* Boucle de parcours */ - + GExeFormat *format; /* Format du binaire représenté*/ GArchInstruction **instrs; /* Instructions résultantes */ size_t count; /* Quantité de ces instructions*/ + /** + * Récupération des objets utiles. + */ + proc = g_loaded_binary_get_processor(binary); - proc = g_loaded_binary_get_processor(disass->binary); - ctx = g_arch_processor_get_context(proc); - - - - gid = g_work_queue_define_work_group(get_work_queue()); - - - - - - - /* Première étape */ - - //id = gtk_extended_status_bar_push(statusbar, _("Disassembling..."), true); - - - - process_disassembly_event(PGA_DISASSEMBLY_STARTED, disass->binary); - - + format = g_loaded_binary_get_format(binary); - instrs = disassemble_binary_content(disass->binary, ctx, gid, status, &count); + /** + * Première étape : collecte des instructions. + */ + instrs = disassemble_binary_content(binary, context, gid, status, &count); g_arch_processor_set_instructions(proc, instrs, count); + process_disassembly_event(PGA_DISASSEMBLY_RAW, binary); - // plugins ////////////////////////// - process_disassembly_event(PGA_DISASSEMBLY_RAW, disass->binary); - - + /** + * Seconde étape : liaisons des instructions. + */ process_all_instructions(gid, status, _("Calling 'link' hook on all instructions..."), g_instructions_study_do_link_operation, - proc, ctx, disass->format); - - - // plugins ////////////////////////// - process_disassembly_event(PGA_DISASSEMBLY_HOOKED_LINK, disass->binary); - - - - //gtk_extended_status_bar_remove(statusbar, id); - + proc, context, format); - //run_plugins_on_binary(disass->binary, PGA_BINARY_DISASSEMBLED, true); + process_disassembly_event(PGA_DISASSEMBLY_HOOKED_LINK, binary); + /** + * Troisième étape : exécution d'éventuels post-traitements. + */ process_all_instructions(gid, status, _("Calling 'post' hook on all instructions..."), g_instructions_study_do_post_operation, - proc, ctx, disass->format); - - - - // plugins ////////////////////////// - process_disassembly_event(PGA_DISASSEMBLY_HOOKED_POST, disass->binary); - + proc, context, format); + process_disassembly_event(PGA_DISASSEMBLY_HOOKED_POST, binary); /** - * TODO : établir les couvertures de fonctions, - * pour être en mesure de disposer de résolution de type XXX+yyy lors - * de l'établissement des liens. + * Quatrième étape : établissement des couvertures de routines restantes. */ - - /* Seconde étape */ - - - - process_all_routines(gid, status, _("Finding remaining limits..."), - g_routines_study_compute_limits, proc, G_BIN_FORMAT(disass->format)); - - - - // plugins ////////////////////////// - process_disassembly_event(PGA_DISASSEMBLY_LIMITED, disass->binary); + g_routines_study_compute_limits, proc, G_BIN_FORMAT(format)); + process_disassembly_event(PGA_DISASSEMBLY_LIMITED, binary); - - /* Troisième étape */ + /** + * Cinquième étape : liaisons entre instructions. + */ process_all_instructions(gid, status, _("Establishing links betweek all instructions..."), g_instructions_study_establish_links, - proc, ctx, disass->format); - - - - // plugins ////////////////////////// - process_disassembly_event(PGA_DISASSEMBLY_LINKED, disass->binary); - - - - - - /* Quatrième étape */ - - // -- old -- id = gtk_extended_status_bar_push(statusbar, _("Detecting loops..."), true); - - // -- old -- detect_loops_in_code(proc, routines, routines_count, statusbar, 0/*id*/); - - // -- old -- gtk_extended_status_bar_remove(statusbar, 0/*id*/); - - /// + proc, context, format); - // plugins ////////////////////////// - // -- old -- process_disassembly_event(PGA_DISASSEMBLY_LOOPS, disass->binary); + process_disassembly_event(PGA_DISASSEMBLY_LINKED, binary); + /** + * Sixième étape : regroupement en blocs basiques. + */ - - - - - - - - - ////////////////////////////////////// - - - // Control-flow analysis... - -#if 1 process_all_routines(gid, status, _("Control-flow analysis for routines..."), - g_routines_study_handle_blocks, proc, G_BIN_FORMAT(disass->format)); -#endif - - - - - /* Cinquième étape */ - - // -- old -- id = gtk_extended_status_bar_push(statusbar, _("Grouping routines instructions..."), true); - - //qsort(routines, routines_count, sizeof(GBinRoutine *), (__compar_fn_t)g_binary_routine_rcompare); + g_routines_study_handle_blocks, proc, G_BIN_FORMAT(format)); - // -- old -- group_routines_instructions(proc, routines, routines_count, statusbar, 0/*id*/); + process_disassembly_event(PGA_DISASSEMBLY_GROUPED, binary); - // -- old -- gtk_extended_status_bar_remove(statusbar, 0/*id*/); - - //run_plugins_on_binary(disass->binary, PGA_BINARY_GROUPED, true); - - - // -- old -- process_disassembly_event(PGA_DISASSEMBLY_GROUPED, disass->binary); - - - - - - /* Sixième étape */ - - // -- old -- id = gtk_extended_status_bar_push(statusbar, _("Ranking each instructions block..."), true); - - //qsort(routines, routines_count, sizeof(GBinRoutine *), (__compar_fn_t)g_binary_routine_rcompare); - - // -- old -- rank_routines_blocks(routines, routines_count, statusbar, 0/*id*/); - - // -- old -- gtk_extended_status_bar_remove(statusbar, 0/*id*/); - - //run_plugins_on_binary(disass->binary, PGA_BINARY_GROUPED, true); - - - // -- old -- process_disassembly_event(PGA_DISASSEMBLY_RANKED, disass->binary); - - - - /* Septième étape */ - - //id = gtk_extended_status_bar_push(statusbar, _("Printing disassembled code..."), true); - - - - - print_disassembled_instructions(disass->cache, disass->lang, disass->binary, G_PRELOAD_INFO(ctx), status); - - - - - /* Rajout de tous les éléments mis en place automatiquement */ - - void add_to_collection(GDbItem *item, GLoadedBinary *binary) - { - g_object_ref(G_OBJECT(item)); - - g_loaded_binary_add_to_collection(binary, item); - - } - - g_proc_context_foreach_db_item(ctx, (GFunc)add_to_collection, disass->binary); - - /* Nettoyage final et sortie ! */ + /** + * Nettoyage final et sortie ! + */ - g_object_unref(G_OBJECT(ctx)); + g_object_unref(G_OBJECT(format)); g_object_unref(G_OBJECT(proc)); - process_disassembly_event(PGA_DISASSEMBLY_ENDED, disass->binary); - - - - //gtk_extended_status_bar_remove(statusbar, 0/*id*/); - - //run_plugins_on_binary(disass->binary, PGA_BINARY_PRINTED, true); - - - } - -/* ---------------------------------------------------------------------------------- */ -/* GESTION GLOBALE DE PROCEDURE */ -/* ---------------------------------------------------------------------------------- */ - - /****************************************************************************** * * -* Paramètres : cache = tampon de destination pour le texte. * -* format = format associé au contenu représenté. * -* lang = trauducteur pour l'impression finale. * -* filename = nom du fichier ciblé à décompiler. * -* checksum = empreinte identifiant le binaire chargé. * +* Paramètres : binary = représentation de binaire chargé. * +* context = contexte de désassemblage utilisé. * +* status = barre de statut à tenir informée. * +* cache = tampon de code mis en place. [OUT] * * * -* Description : Construit la description d'introduction du désassemblage. * +* Description : Imprime le résultat d'un désassemblage. * * * * Retour : - * * * @@ -635,31 +313,82 @@ static void g_delayed_disassembly_process(GDelayedDisassembly *disass, GtkStatus * * ******************************************************************************/ -static void build_disass_prologue(GBufferCache *cache, const GBinFormat *format, const GCodingLanguage *lang, const char *filename, const char *checksum) +static void output_disassembly(GLoadedBinary *binary, GProcContext *context, GtkStatusStack *status, GBufferCache **cache) { + GBinFormat *format; /* Format associé au binaire */ + GBinContent *content; /* Contenu bianire manipulé */ + GCodingLanguage *lang; /* Langage de sortie préféré */ char **text; /* Contenu brute à imprimer */ + const char *desc; /* Désignation du binaire */ + const gchar *checksum; /* Identifiant de binaire */ GIntroGenerator *generator; /* Générateur constitué */ + /** + * Initialisation des biens communs. + */ + + format = G_BIN_FORMAT(g_loaded_binary_get_format(binary)); + content = g_binary_format_get_content(format); + lang = g_asm_language_new(); + + *cache = g_buffer_cache_new(content); + + /** + * Impression du prologue. + */ + text = calloc(4, sizeof(char *)); /* Introduction */ text[0] = strdup(_("Disassembly generated by Chrysalide")); - text[1] = strdup(_("Chrysalide is free software - © 2008-2016 Cyrille Bagard")); + text[1] = strdup(_("Chrysalide is free software - © 2008-2018 Cyrille Bagard")); /* Fichier */ - asprintf(&text[2], "%s%s", _("File: "), filename); + desc = g_binary_content_describe(content, true); + + asprintf(&text[2], "%s%s", _("Source: "), desc); /* Checksum SHA256 */ + checksum = g_binary_content_get_checksum(content); + asprintf(&text[3], "%s%s", _("Sha256: "), checksum); /* Intégration finale */ generator = g_intro_generator_new(format, lang, text, 4); - g_buffer_cache_append(cache, G_LINE_GENERATOR(generator), BLF_NONE); + g_buffer_cache_append(*cache, G_LINE_GENERATOR(generator), BLF_NONE); + + /** + * Impression des instructions désassemblées. + */ + + print_disassembled_instructions(*cache, lang, binary, G_PRELOAD_INFO(context), status); + + /** + * Rajout de tous les éléments mis en place automatiquement. + */ + + void add_to_collection(GDbItem *item, gpointer unused) + { + g_object_ref(G_OBJECT(item)); + + g_loaded_binary_add_to_collection(binary, item); + + } + + g_proc_context_foreach_db_item(context, (GFunc)add_to_collection, NULL); + + /** + * Nettoyage avant sortie. + */ + + g_object_unref(G_OBJECT(lang)); + g_object_unref(G_OBJECT(content)); + g_object_unref(G_OBJECT(format)); } @@ -667,11 +396,9 @@ static void build_disass_prologue(GBufferCache *cache, const GBinFormat *format, /****************************************************************************** * * * Paramètres : binary = représentation de binaire chargé. * -* parts = parties binaires à désassembler. * -* count = nombre de parties à traiter. * -* instrs = liste des instructions chargées. [OUT] * +* gid = groupe de travail dédié. * +* status = barre de statut à tenir informée. * * cache = tampon de code mis en place. [OUT] * -* ack = fonction à appeler une fois l'opération terminée. * * * * Description : Procède au désassemblage d'un contenu binaire donné. * * * @@ -681,38 +408,31 @@ static void build_disass_prologue(GBufferCache *cache, const GBinFormat *format, * * ******************************************************************************/ -void disassemble_binary(GLoadedBinary *binary, GBufferCache **cache, disassembly_ack_fc ack) +void disassemble_binary(GLoadedBinary *binary, wgroup_id_t gid, GtkStatusStack *status, GBufferCache **cache) { - GBinFormat *format; /* Format associé au binaire */ - GBinContent *content; /* Contenu bianire manipulé */ - GCodingLanguage *lang; /* Langage de sortie préféré */ - const char *desc; /* Désignation du binaire */ - const gchar *checksum; /* Identifiant de binaire */ - GDelayedDisassembly *disass; /* Désassemblage à mener */ - GWorkQueue *queue; /* Gestionnaire de différés */ + GArchProcessor *proc; /* Architecture du binaire */ + GProcContext *context; /* Contexte de suivi dédié */ - format = G_BIN_FORMAT(g_loaded_binary_get_format(binary)); - content = g_binary_format_get_content(format); + /* Préparatifs */ - *cache = g_buffer_cache_new(content); + process_disassembly_event(PGA_DISASSEMBLY_STARTED, binary); - lang = g_asm_language_new(); + proc = g_loaded_binary_get_processor(binary); - desc = g_binary_content_describe(content, true); - checksum = g_binary_content_get_checksum(content); + context = g_arch_processor_get_context(proc); - build_disass_prologue(*cache, format, lang, desc, checksum); + /* Lancement des opérations ! */ - g_object_unref(G_OBJECT(lang)); - g_object_unref(G_OBJECT(content)); - g_object_unref(G_OBJECT(format)); + compute_disassembly(binary, context, gid, status); - disass = g_delayed_disassembly_new(binary, *cache); + process_disassembly_event(PGA_DISASSEMBLY_ENDED, binary); - if (ack != NULL) - g_signal_connect(disass, "work-completed", G_CALLBACK(ack), binary); + output_disassembly(binary, context, status, cache); - queue = get_work_queue(); - g_work_queue_schedule_work(queue, G_DELAYED_WORK(disass), DEFAULT_WORK_GROUP); + /* Nettoyage final et sortie ! */ + + g_object_unref(G_OBJECT(context)); + + g_object_unref(G_OBJECT(proc)); } diff --git a/src/analysis/disass/disassembler.h b/src/analysis/disass/disassembler.h index a3fb74f..1adc9a1 100644 --- a/src/analysis/disass/disassembler.h +++ b/src/analysis/disass/disassembler.h @@ -26,40 +26,12 @@ #include "../binary.h" +#include "../../glibext/delayed.h" -/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ - - -#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)) - - -/* Ensembles binaires à désassembler (instance) */ -typedef struct _GDelayedDisassembly GDelayedDisassembly; - -/* Ensembles binaires à désassembler (classe) */ -typedef struct _GDelayedDisassemblyClass GDelayedDisassemblyClass; - - -/* Indique le type défini pour les tâches de désassemblage différé. */ -GType g_delayed_disassembly_get_type(void); - - - -/* -------------------------- GESTION GLOBALE DE PROCEDURE -------------------------- */ - - -/* Acquitte la fin d'un désasemblage différé et complet. */ -typedef void (* disassembly_ack_fc) (GDelayedDisassembly *, GLoadedBinary *); - -/* Procède à la décompilation des routines d'un fichier donné. */ -void disassemble_binary(GLoadedBinary *, GBufferCache **, disassembly_ack_fc); +/* Procède au désassemblage d'un contenu binaire donné. */ +void disassemble_binary(GLoadedBinary *, wgroup_id_t, GtkStatusStack *, GBufferCache **); diff --git a/src/analysis/disass/fetch.c b/src/analysis/disass/fetch.c index 55afe5a..934c755 100644 --- a/src/analysis/disass/fetch.c +++ b/src/analysis/disass/fetch.c @@ -395,7 +395,7 @@ static bool check_if_extra_wait_is_needed(GWorkQueue *queue, wgroup_id_t id, GPr GArchInstruction **disassemble_binary_content(GLoadedBinary *binary, GProcContext *ctx, wgroup_id_t gid, GtkStatusStack *status, size_t *count) { - GArchInstruction **result; /* Instruction désassemblées */ + GArchInstruction **result; /* Instruction désassemblées */ GDelayedFetching template; /* Patron des tâches à venir */ GBinFormat *format; /* Format du fichier binaire */ GBinContent *content; /* Contenu binaire à manipuler */ diff --git a/src/analysis/loaded-int.h b/src/analysis/loaded-int.h index 60d7304..7d4bb19 100644 --- a/src/analysis/loaded-int.h +++ b/src/analysis/loaded-int.h @@ -26,9 +26,25 @@ #include "loaded.h" +#include "../glibext/delayed-int.h" +/* Interprète un contenu chargé avec un appui XML. */ +typedef bool (* restore_content_fc) (GLoadedContent *, xmlDoc *, xmlXPathContext *, const char *); + +/* Ecrit une sauvegarde de l'élément dans un fichier XML. */ +typedef bool (* save_content_fc) (const GLoadedContent *, xmlDoc *, xmlXPathContext *, const char *); + +/* Fournit le contenu représenté de l'élément chargé. */ +typedef GBinContent * (* get_content_fc) (const GLoadedContent *); + +/* Fournit le format associé à l'élément chargé. */ +typedef const char * (* get_format_name_fc) (const GLoadedContent *); + +/* Assure l'analyse d'un contenu chargé en différé. */ +typedef bool (* analyze_loaded_fc) (GLoadedContent *, wgroup_id_t, GtkStatusStack *); + /* Fournit le désignation associée à l'élément chargé. */ typedef const char * (* describe_loaded_fc) (const GLoadedContent *, bool); @@ -55,6 +71,14 @@ struct _GLoadedContentIface /* Méthodes virtuelles */ + restore_content_fc restore; /* Restauration depuis du XML */ + save_content_fc save; /* Sauvegarde dans du XML */ + + get_content_fc get_content; /* Fourniture du contenu brut */ + get_format_name_fc get_format_name; /* Fourniture du format associé*/ + + analyze_loaded_fc analyze; /* Analyse du contenu chargé */ + describe_loaded_fc describe; /* Description de contenu */ count_loaded_views_fc count_views; /* Compteur de vues */ @@ -66,6 +90,8 @@ struct _GLoadedContentIface /* Signaux */ + void (* analyzed) (GLoadedContent *, gboolean); + void (* display_changed) (GLoadedContent *, unsigned int, unsigned int); }; diff --git a/src/analysis/loaded.c b/src/analysis/loaded.c index 450784b..1273ebd 100644 --- a/src/analysis/loaded.c +++ b/src/analysis/loaded.c @@ -28,17 +28,79 @@ #include "loaded-int.h" +#include "../core/global.h" #include "../glibext/chrysamarshal.h" #include "../glibext/gloadedpanel.h" +/* Analyse de contenu chargé (instance) */ +typedef struct _GLoadedAnalysis GLoadedAnalysis; + + + /* ---------------------- GESTION SOUS FORME DE CONTENU CHARGE ---------------------- */ /* Procède à l'initialisation de l'interface de contenu chargé. */ static void g_loaded_content_default_init(GLoadedContentInterface *); +/* Acquitte la fin d'une tâche d'analyse différée et complète. */ +static void on_loaded_content_analysis_completed(GLoadedAnalysis *, GLoadedContent *); + + + +/* -------------------------- PHASE D'ANALYSE EN PARALLELE -------------------------- */ + + +#define G_TYPE_LOADED_ANALYSIS g_loaded_analysis_get_type() +#define G_LOADED_ANALYSIS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_LOADED_ANALYSIS, GDelayedDisassembly)) +#define G_IS_LOADED_ANALYSIS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_LOADED_ANALYSIS)) +#define G_LOADED_ANALYSIS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_LOADED_ANALYSIS, GDelayedDisassemblyClass)) +#define G_IS_LOADED_ANALYSIS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_LOADED_ANALYSIS)) +#define G_LOADED_ANALYSIS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_LOADED_ANALYSIS, GDelayedDisassemblyClass)) + + +/* Analyse de contenu chargé (instance) */ +struct _GLoadedAnalysis +{ + GDelayedWork parent; /* A laisser en premier */ + + GLoadedContent *content; /* Cible de l'analyse à mener */ + + bool success; /* Bilan de l'opération */ + +}; + +/* Analyse de contenu chargé (classe) */ +typedef struct _GLoadedAnalysisClass +{ + GDelayedWorkClass parent; /* A laisser en premier */ + +} GLoadedAnalysisClass; + + +/* Indique le type défini pour les tâches d'analyse différée. */ +static GType g_loaded_analysis_get_type(void); + +/* Initialise la classe des tâches d'analyse différées. */ +static void g_loaded_analysis_class_init(GLoadedAnalysisClass *); + +/* Initialise une tâche d'analyse de contenu différée. */ +static void g_loaded_analysis_init(GLoadedAnalysis *); + +/* Supprime toutes les références externes. */ +static void g_loaded_analysis_dispose(GLoadedAnalysis *); + +/* Procède à la libération totale de la mémoire. */ +static void g_loaded_analysis_finalize(GLoadedAnalysis *); + +/* Crée une tâche d'analyse de contenu différée. */ +static GLoadedAnalysis *g_loaded_analysis_new(GLoadedContent *); + +/* Assure l'analyse d'un contenu chargé en différé. */ +static void g_loaded_analysis_process(GLoadedAnalysis *, GtkStatusStack *); + /* ---------------------------------------------------------------------------------- */ @@ -64,6 +126,14 @@ G_DEFINE_INTERFACE(GLoadedContent, g_loaded_content, G_TYPE_OBJECT) static void g_loaded_content_default_init(GLoadedContentInterface *iface) { + g_signal_new("analyzed", + G_TYPE_LOADED_CONTENT, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GLoadedContentIface, analyzed), + NULL, NULL, + g_cclosure_marshal_VOID__BOOLEAN, + G_TYPE_NONE, 1, G_TYPE_BOOLEAN); + g_signal_new("display-changed", G_TYPE_LOADED_CONTENT, G_SIGNAL_RUN_LAST, @@ -77,6 +147,205 @@ static void g_loaded_content_default_init(GLoadedContentInterface *iface) /****************************************************************************** * * +* Paramètres : content = élément chargé à traiter. * +* xdoc = structure XML en cours d'édition. * +* context = contexte à utiliser pour les recherches. * +* path = chemin d'accès réservé au binaire. * +* * +* Description : Interprète un contenu chargé avec un appui XML. * +* * +* Retour : true si l'opération a bien tourné, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_loaded_content_restore(GLoadedContent *content, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path) +{ + bool result; /* Bilan à faire remonter */ + GLoadedContentIface *iface; /* Interface utilisée */ + + iface = G_LOADED_CONTENT_GET_IFACE(content); + + result = iface->restore(content, xdoc, context, path); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = élément chargé à traiter. * +* xdoc = structure XML en cours d'édition. * +* context = contexte à utiliser pour les recherches. * +* path = chemin d'accès réservé à l'élément. * +* * +* Description : Ecrit une sauvegarde de l'élément dans un fichier XML. * +* * +* Retour : true si l'opération a bien tourné, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_loaded_content_save(const GLoadedContent *content, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path) +{ + bool result; /* Bilan à faire remonter */ + GLoadedContentIface *iface; /* Interface utilisée */ + + iface = G_LOADED_CONTENT_GET_IFACE(content); + + result = iface->save(content, xdoc, context, path); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = élément chargé à manipuler. * +* * +* Description : Fournit le contenu représenté de l'élément chargé. * +* * +* Retour : Contenu représenté. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GBinContent *g_loaded_content_get_content(const GLoadedContent *content) +{ + GBinContent *result; /* Contenu interne à renvoyer */ + GLoadedContentIface *iface; /* Interface utilisée */ + + iface = G_LOADED_CONTENT_GET_IFACE(content); + + result = iface->get_content(content); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = élément chargé à manipuler. * +* * +* Description : Fournit le format associé à l'élément chargé. * +* * +* Retour : Format associé à l'élément chargé. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const char *g_loaded_content_get_format_name(const GLoadedContent *content) +{ + const char *result; /* Contenu interne à renvoyer */ + GLoadedContentIface *iface; /* Interface utilisée */ + + iface = G_LOADED_CONTENT_GET_IFACE(content); + + result = iface->get_format_name(content); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = élément chargé à manipuler. * +* * +* Description : Lance l'analyse propre à l'élément chargé. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_loaded_content_analyze(GLoadedContent *content) +{ + GLoadedAnalysis *analysis; /* Analyse à mener */ + GWorkQueue *queue; /* Gestionnaire de différés */ + + analysis = g_loaded_analysis_new(content); + + g_signal_connect(analysis, "work-completed", + G_CALLBACK(on_loaded_content_analysis_completed), content); + + queue = get_work_queue(); + + g_work_queue_schedule_work(queue, G_DELAYED_WORK(analysis), DEFAULT_WORK_GROUP); + +} + + +/****************************************************************************** +* * +* Paramètres : analysis = tâche d'analyse menée à bien. * +* content = contenu chargé dont l'analyse est terminée. * +* * +* Description : Acquitte la fin d'une tâche d'analyse différée et complète. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void on_loaded_content_analysis_completed(GLoadedAnalysis *analysis, GLoadedContent *content) +{ + g_signal_emit_by_name(content, "analyzed", analysis->success); + +} + + +/****************************************************************************** +* * +* Paramètres : content = élément chargé à manipuler. * +* * +* Description : Lance l'analyse de l'élément chargé et attend sa conclusion. * +* * +* Retour : Conclusion obtenue suite à l'analyse. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_loaded_content_analyze_and_wait(GLoadedContent *content) +{ + bool result; /* Bilan à retourner */ + GLoadedAnalysis *analysis; /* Analyse à mener */ + GWorkQueue *queue; /* Gestionnaire de différés */ + wgroup_id_t gid; /* Identifiant pour les tâches */ + + analysis = g_loaded_analysis_new(content); + g_object_ref(G_OBJECT(analysis)); + + queue = get_work_queue(); + + gid = g_work_queue_define_work_group(queue); + + g_work_queue_schedule_work(queue, G_DELAYED_WORK(analysis), gid); + + g_work_queue_wait_for_completion(queue, gid); + + g_work_queue_delete_work_group(queue, gid); + + result = analysis->success; + g_object_unref(G_OBJECT(analysis)); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : content = élément chargé à consulter. * * long = précise s'il s'agit d'une version longue ou non. * * * @@ -243,6 +512,162 @@ void g_loaded_content_set_display_option(GLoadedContent *content, unsigned int i /* ---------------------------------------------------------------------------------- */ +/* PHASE D'ANALYSE EN PARALLELE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour les tâches d'analyse différée. */ +G_DEFINE_TYPE(GLoadedAnalysis, g_loaded_analysis, G_TYPE_DELAYED_WORK); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des tâches d'analyse différées. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_loaded_analysis_class_init(GLoadedAnalysisClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GDelayedWorkClass *work; /* Version en classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_loaded_analysis_dispose; + object->finalize = (GObjectFinalizeFunc)g_loaded_analysis_finalize; + + work = G_DELAYED_WORK_CLASS(klass); + + work->run = (run_task_fc)g_loaded_analysis_process; + +} + + +/****************************************************************************** +* * +* Paramètres : analysis = instance à initialiser. * +* * +* Description : Initialise une tâche d'analyse de contenu différée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_loaded_analysis_init(GLoadedAnalysis *analysis) +{ + analysis->success = false; + +} + + +/****************************************************************************** +* * +* Paramètres : disass = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_loaded_analysis_dispose(GLoadedAnalysis *analysis) +{ + g_object_unref(G_OBJECT(analysis->content)); + + G_OBJECT_CLASS(g_loaded_analysis_parent_class)->dispose(G_OBJECT(analysis)); + +} + + +/****************************************************************************** +* * +* Paramètres : analysis = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_loaded_analysis_finalize(GLoadedAnalysis *analysis) +{ + G_OBJECT_CLASS(g_loaded_analysis_parent_class)->finalize(G_OBJECT(analysis)); + +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu chargé à traiter. * +* * +* Description : Crée une tâche d'analyse de contenu différée. * +* * +* Retour : Tâche créée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GLoadedAnalysis *g_loaded_analysis_new(GLoadedContent *content) +{ + GLoadedAnalysis *result; /* Tâche à retourner */ + + result = g_object_new(G_TYPE_LOADED_ANALYSIS, NULL); + + result->content = content; + g_object_ref(G_OBJECT(content)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : analysis = analyse à mener. * +* status = barre de statut à tenir informée. * +* * +* Description : Assure l'analyse d'un contenu chargé en différé. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_loaded_analysis_process(GLoadedAnalysis *analysis, GtkStatusStack *status) +{ + GLoadedContentIface *iface; /* Interface utilisée */ + GWorkQueue *queue; /* Gestionnaire de différés */ + wgroup_id_t gid; /* Identifiant pour les tâches */ + + iface = G_LOADED_CONTENT_GET_IFACE(analysis->content); + + queue = get_work_queue(); + + gid = g_work_queue_define_work_group(queue); + + analysis->success = iface->analyze(analysis->content, gid, status); + + g_work_queue_delete_work_group(queue, gid); + +} + + + +/* ---------------------------------------------------------------------------------- */ /* VUES ET BASCULEMENT ENTRE LES VUES */ /* ---------------------------------------------------------------------------------- */ diff --git a/src/analysis/loaded.h b/src/analysis/loaded.h index b74a03d..643e170 100644 --- a/src/analysis/loaded.h +++ b/src/analysis/loaded.h @@ -30,6 +30,8 @@ #include +#include "content.h" +#include "../common/xml.h" #include "../gtkext/gtkdockstation.h" @@ -55,6 +57,24 @@ typedef struct _GLoadedContentIface GLoadedContentIface; /* Détermine le type d'une interface pour l'intégration de contenu chargé. */ GType g_loaded_content_get_type(void) G_GNUC_CONST; +/* Interprète un contenu chargé avec un appui XML. */ +bool g_loaded_content_restore(GLoadedContent *, xmlDoc *, xmlXPathContext *, const char *); + +/* Ecrit une sauvegarde de l'élément dans un fichier XML. */ +bool g_loaded_content_save(const GLoadedContent *, xmlDoc *, xmlXPathContext *, const char *); + +/* Fournit le contenu représenté de l'élément chargé. */ +GBinContent *g_loaded_content_get_content(const GLoadedContent *); + +/* Fournit le format associé à l'élément chargé. */ +const char *g_loaded_content_get_format_name(const GLoadedContent *); + +/* Lance l'analyse propre à l'élément chargé. */ +void g_loaded_content_analyze(GLoadedContent *); + +/* Lance l'analyse de l'élément chargé et attend sa conclusion. */ +bool g_loaded_content_analyze_and_wait(GLoadedContent *); + /* Fournit le désignation associée à l'élément chargé. */ const char *g_loaded_content_describe(const GLoadedContent *, bool); diff --git a/src/analysis/loading.c b/src/analysis/loading.c index 5aff20f..f2ae882 100644 --- a/src/analysis/loading.c +++ b/src/analysis/loading.c @@ -24,134 +24,268 @@ #include "loading.h" -#include "../core/formats.h" +#include +#include +#include + + #include "../core/global.h" -#include "../core/logs.h" #include "../glibext/delayed-int.h" -#include "../glibext/signal.h" +#include "../plugins/pglist.h" + + +/* ------------------------- TACHE D'EXPLORATION DE CONTENU ------------------------- */ -/* ----------------------- AMORCE POUR CHARGEMENT DE CONTENUS ----------------------- */ +#define G_TYPE_EXPLORING_WORK g_exploring_work_get_type() +#define G_EXPLORING_WORK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_EXPLORING_WORK, GExploringWork)) +#define G_IS_EXPLORING_WORK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_EXPLORING_WORK)) +#define G_EXPLORING_WORK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_EXPLORING_WORK, GExploringWorkClass)) +#define G_IS_EXPLORING_WORK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_EXPLORING_WORK)) +#define G_EXPLORING_WORK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_EXPLORING_WORK, GExploringWorkClass)) -/* Ensembles binaires à désassembler (instance) */ -struct _GDelayedStudy +/* Conversion de contenu binaire en contenu chargé (instance) */ +typedef struct _GExploringWork { GDelayedWork parent; /* A laisser en premier */ - GStudyProject *project; /* Projet de rattachement */ - GBinContent *content; /* Contenu binaire à traiter */ - ProjectContentState state; /* Renseigne le type de contenu*/ + const gid_t *gid; /* Groupe d'appartenance */ - bool only_preload; /* Enregistrement seulement ? */ + GBinContent *content; /* Contenu brut à disposition */ -}; +} GExploringWork; -/* Ensembles binaires à désassembler (classe) */ -struct _GDelayedStudyClass +/* Conversion de contenu binaire en contenu chargé (classe) */ +typedef struct _GExploringWorkClass { GDelayedWorkClass parent; /* A laisser en premier */ -}; +} GExploringWorkClass; -/* Initialise la classe des intégrations de binaires à étudier. */ -static void g_delayed_study_class_init(GDelayedStudyClass *); +/* Indique le type défini pour l'exploration de contenu binaire. */ +GType g_exploring_work_get_type(void); -/* Initialise une intégration de binaire à étudier. */ -static void g_delayed_study_init(GDelayedStudy *); +/* Initialise la classe des tâches d'exploration de contenu. */ +static void g_exploring_work_class_init(GExploringWorkClass *); + +/* Initialise une tâche d'exploration de contenu. */ +static void g_exploring_work_init(GExploringWork *); /* Supprime toutes les références externes. */ -static void g_delayed_study_dispose(GDelayedStudy *); +static void g_exploring_work_dispose(GExploringWork *); /* Procède à la libération totale de la mémoire. */ -static void g_delayed_study_finalize(GDelayedStudy *); +static void g_exploring_work_finalize(GExploringWork *); + +/* Prépare la conversion non bloquée d'un contenu binaire. */ +static GExploringWork *g_exploring_work_new(GBinContent *); -/* Prépare une intégration de binaire au projet courant. */ -static void g_delayed_study_process(GDelayedStudy *, GtkStatusStack *); +/* Fournit l'identifiant du groupe de rattachement de la tâche. */ +static gid_t g_exploring_work_get_group_id(const GExploringWork *); +/* Définit l'identifiant du groupe de rattachement de la tâche. */ +static void g_exploring_work_set_group_id(GExploringWork *, const gid_t *); +/* Réalise l'exploration effective de formes de contenus. */ +static void g_exploring_work_process(GExploringWork *, GtkStatusStack *); -/* ----------------------- CHARGEMENT DE BINAIRE NON BLOQUANT ----------------------- */ -#define G_TYPE_BINARY_LOADER g_binary_loader_get_type() -#define G_BINARY_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BINARY_LOADER, GBinaryLoader)) -#define G_IS_BINARY_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BINARY_LOADER)) -#define G_BINARY_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BINARY_LOADER, GBinaryLoaderClass)) -#define G_IS_BINARY_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BINARY_LOADER)) -#define G_BINARY_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BINARY_LOADER, GBinaryLoaderClass)) +/* --------------------- EXPLORATION NON BLOQUANTE DES CONTENUS --------------------- */ -/* Chargement non bloquant d'un binaire (instance) */ -struct _GBinaryLoader +/* Regroupement des chargements */ +typedef struct _exploring_group { - GDelayedWork parent; /* A laisser en premier */ + GBinContent *original; /* Contenu binaire initial */ - bool from_content; /* Sélection de champs */ + wgroup_id_t wid; /* Groupe de travail */ + gid_t gid; /* Groupe d'appartenance */ - union - { - GBinContent *content; /* Contenu brut à disposition */ + GBinContent **contents; /* Contenus reconnus dispos. */ + size_t count; /* Taille de cette liste */ + +} exploring_group; + +/* Exploration de contenus binaires (instance) */ +struct _GContentExplorer +{ + GObject parent; /* A laisser en premier */ + + gid_t generator; /* Générateur d'identifiants */ - struct - { - char *filename; /* Chemin vers l'ensemble XML */ - char *path; /* Chemin de la définition XML */ + exploring_group *groups; /* Rassemblement de chargements*/ + size_t count; /* Nombre de ces groupes */ + GMutex mutex; /* Accès protégé à la liste */ - }; +}; - }; +/* Exploration de contenus binaires (classe) */ +struct _GContentExplorerClass +{ + GObjectClass parent; /* A laisser en premier */ - GStudyProject *project; /* Accès aux contenus liés */ + /* Signaux */ - GLoadedBinary *binary; /* Résultat du chargement */ + void (* explored) (GContentExplorer *, gid_t); }; -/* Chargement non bloquant d'un binaire (classe) */ -struct _GBinaryLoaderClass + +/* Initialise la classe les explorations de contenus binaires. */ +static void g_content_explorer_class_init(GContentExplorerClass *); + +/* Initialise une exploration de contenus binaires. */ +static void g_content_explorer_init(GContentExplorer *); + +/* Supprime toutes les références externes. */ +static void g_content_explorer_dispose(GContentExplorer *); + +/* Procède à la libération totale de la mémoire. */ +static void g_content_explorer_finalize(GContentExplorer *); + +/* Retrouve le groupe correspondant à un identifiant donné. */ +static exploring_group *g_content_explorer_find_group(GContentExplorer *, gid_t); + +/* Note la fin d'une phase d'exploration de contenu. */ +static void g_content_explorer_ack(GContentExplorer *, GExploringWork *); + + + +/* ------------------------- TACHE DE RESOLUTION DE CONTENU ------------------------- */ + + +#define G_TYPE_RESOLVING_WORK g_resolving_work_get_type() +#define G_RESOLVING_WORK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RESOLVING_WORK, GResolvingWork)) +#define G_IS_RESOLVING_WORK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RESOLVING_WORK)) +#define G_RESOLVING_WORK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RESOLVING_WORK, GResolvingWorkClass)) +#define G_IS_RESOLVING_WORK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RESOLVING_WORK)) +#define G_RESOLVING_WORK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RESOLVING_WORK, GResolvingWorkClass)) + + +/* Conversion de contenu binaire en contenu chargé (instance) */ +typedef struct _GResolvingWork +{ + GDelayedWork parent; /* A laisser en premier */ + + const gid_t *gid; /* Groupe d'appartenance */ + + GBinContent *content; /* Contenu brut à disposition */ + +} GResolvingWork; + +/* Conversion de contenu binaire en contenu chargé (classe) */ +typedef struct _GResolvingWorkClass { GDelayedWorkClass parent; /* A laisser en premier */ +} GResolvingWorkClass; + + +/* Indique le type défini pour la conversion de contenu binaire en contenu chargé. */ +GType g_resolving_work_get_type(void); + +/* Initialise la classe des tâches de conversion de contenu. */ +static void g_resolving_work_class_init(GResolvingWorkClass *); + +/* Initialise une tâche de conversion de contenu. */ +static void g_resolving_work_init(GResolvingWork *); + +/* Supprime toutes les références externes. */ +static void g_resolving_work_dispose(GResolvingWork *); + +/* Procède à la libération totale de la mémoire. */ +static void g_resolving_work_finalize(GResolvingWork *); + +/* Prépare la conversion non bloquée d'un contenu binaire. */ +static GResolvingWork *g_resolving_work_new(GBinContent *); + +/* Fournit l'identifiant du groupe de rattachement de la tâche. */ +static gid_t g_resolving_work_get_group_id(const GResolvingWork *); + +/* Définit l'identifiant du groupe de rattachement de la tâche. */ +static void g_resolving_work_set_group_id(GResolvingWork *, const gid_t *); + +/* Réalise la conversion effective de formes de contenus. */ +static void g_resolving_work_process(GResolvingWork *, GtkStatusStack *); + + + +/* ------------------- RESOLUTION DE CONTENUS BINAIRES EN CHARGES ------------------- */ + + +/* Regroupement des chargements */ +typedef struct _resolving_group +{ + size_t remaining; /* Nombre de tâches restantes */ + + const gid_t *gid; /* Groupe d'appartenance */ + + GLoadedContent **loaded; /* Contenus reconnus à intégrer*/ + size_t count; /* Taille de cette liste */ + +} resolving_group; + +/* Résolution de contenus binaires en formats chargés (instance) */ +struct _GContentResolver +{ + GObject parent; /* A laisser en premier */ + + resolving_group *groups; /* Rassemblement de chargements*/ + size_t count; /* Nombre de ces groupes */ + GMutex mutex; /* Accès protégé à la liste */ + }; +/* Résolution de contenus binaires en formats chargés (classe) */ +struct _GContentResolverClass +{ + GObjectClass parent; /* A laisser en premier */ + + /* Signaux */ -/* Indique le type défini pour le chargement non bloquant d'un binaire. */ -GType g_binary_loader_get_type(void); + void (* resolved) (GContentResolver *, gid_t); + +}; -/* Initialise la classe des tâches de chargement non bloquant. */ -static void g_binary_loader_class_init(GBinaryLoaderClass *); -/* Initialise une tâche de chargement non bloquant d'un binaire. */ -static void g_binary_loader_init(GBinaryLoader *); +/* Initialise la classe des résolutions de contenus binaires. */ +static void g_content_resolver_class_init(GContentResolverClass *); + +/* Initialise une résolution de contenus binaires. */ +static void g_content_resolver_init(GContentResolver *); /* Supprime toutes les références externes. */ -static void g_binary_loader_dispose(GBinaryLoader *); +static void g_content_resolver_dispose(GContentResolver *); /* Procède à la libération totale de la mémoire. */ -static void g_binary_loader_finalize(GBinaryLoader *); +static void g_content_resolver_finalize(GContentResolver *); + +/* Retrouve le groupe correspondant à un identifiant donné. */ +static resolving_group *g_content_resolver_find_group(GContentResolver *, gid_t); -/* Réalise le chargement effectif d'un binaire. */ -static void g_binary_loader_process(GBinaryLoader *, GtkStatusStack *); +/* Note la fin d'une phase de resolution de contenu. */ +static void g_content_resolver_ack(GContentResolver *, GResolvingWork *); /* ---------------------------------------------------------------------------------- */ -/* AMORCE POUR CHARGEMENT DE CONTENUS */ +/* TACHE D'EXPLORATION DE CONTENU */ /* ---------------------------------------------------------------------------------- */ -/* Indique le type défini pour les tâches de préparations d'étude. */ -G_DEFINE_TYPE(GDelayedStudy, g_delayed_study, G_TYPE_DELAYED_WORK); +/* Indique le type défini pour l'exploration de contenu binaire. */ +G_DEFINE_TYPE(GExploringWork, g_exploring_work, G_TYPE_DELAYED_WORK); /****************************************************************************** * * * Paramètres : klass = classe à initialiser. * * * -* Description : Initialise la classe des intégrations de binaires à étudier. * +* Description : Initialise la classe des tâches d'exploration de contenu. * * * * Retour : - * * * @@ -159,27 +293,28 @@ G_DEFINE_TYPE(GDelayedStudy, g_delayed_study, G_TYPE_DELAYED_WORK); * * ******************************************************************************/ -static void g_delayed_study_class_init(GDelayedStudyClass *klass) +static void g_exploring_work_class_init(GExploringWorkClass *klass) { GObjectClass *object; /* Autre version de la classe */ GDelayedWorkClass *work; /* Version en classe parente */ object = G_OBJECT_CLASS(klass); - work = G_DELAYED_WORK_CLASS(klass); - object->dispose = (GObjectFinalizeFunc/* ! */)g_delayed_study_dispose; - object->finalize = (GObjectFinalizeFunc)g_delayed_study_finalize; + object->dispose = (GObjectFinalizeFunc/* ! */)g_exploring_work_dispose; + object->finalize = (GObjectFinalizeFunc)g_exploring_work_finalize; + + work = G_DELAYED_WORK_CLASS(klass); - work->run = (run_task_fc)g_delayed_study_process; + work->run = (run_task_fc)g_exploring_work_process; } /****************************************************************************** * * -* Paramètres : dstudy = instance à initialiser. * +* Paramètres : work = instance à initialiser. * * * -* Description : Initialise une intégration de binaire à étudier. * +* Description : Initialise une tâche d'exploration de contenu. * * * * Retour : - * * * @@ -187,16 +322,18 @@ static void g_delayed_study_class_init(GDelayedStudyClass *klass) * * ******************************************************************************/ -static void g_delayed_study_init(GDelayedStudy *dstudy) +static void g_exploring_work_init(GExploringWork *work) { - dstudy->only_preload = false; + work->gid = NULL; + + work->content = NULL; } /****************************************************************************** * * -* Paramètres : binary = instance d'objet GLib à traiter. * +* Paramètres : work = instance d'objet GLib à traiter. * * * * Description : Supprime toutes les références externes. * * * @@ -206,19 +343,18 @@ static void g_delayed_study_init(GDelayedStudy *dstudy) * * ******************************************************************************/ -static void g_delayed_study_dispose(GDelayedStudy *dstudy) +static void g_exploring_work_dispose(GExploringWork *work) { - g_object_unref(G_OBJECT(dstudy->project)); - g_object_unref(G_OBJECT(dstudy->content)); + g_object_unref(G_OBJECT(work->content)); - G_OBJECT_CLASS(g_delayed_study_parent_class)->dispose(G_OBJECT(dstudy)); + G_OBJECT_CLASS(g_exploring_work_parent_class)->dispose(G_OBJECT(work)); } /****************************************************************************** * * -* Paramètres : binary = instance d'objet GLib à traiter. * +* Paramètres : work = instance d'objet GLib à traiter. * * * * Description : Procède à la libération totale de la mémoire. * * * @@ -228,40 +364,58 @@ static void g_delayed_study_dispose(GDelayedStudy *dstudy) * * ******************************************************************************/ -static void g_delayed_study_finalize(GDelayedStudy *dstudy) +static void g_exploring_work_finalize(GExploringWork *work) { - G_OBJECT_CLASS(g_delayed_study_parent_class)->finalize(G_OBJECT(dstudy)); + G_OBJECT_CLASS(g_exploring_work_parent_class)->finalize(G_OBJECT(work)); } /****************************************************************************** * * -* Paramètres : project = projet dont le contenu est à compléter. * -* content = contenu binaire chargé à analyser. * -* state = état du contenu à conserver. * +* Paramètres : content = contenu binaire disponible pour traitements. * * * -* Description : Crée une tâche d'intégration de contenu binaire. * +* Description : Prépare l'exploration non bloquée d'un contenu binaire. * * * -* Retour : Tâche créée. * +* Retour : Tâche de travail mise en place. * * * -* Remarques : L'appelant perd la propriété du contenu. * +* Remarques : - * * * ******************************************************************************/ -GDelayedStudy *g_delayed_study_new(GStudyProject *project, GBinContent *content, ProjectContentState state) +static GExploringWork *g_exploring_work_new(GBinContent *content) { - GDelayedStudy *result; /* Tâche à retourner */ - - result = g_object_new(G_TYPE_DELAYED_STUDY, NULL); + GExploringWork *result; /* Tâche à retourner */ - g_object_ref(G_OBJECT(project)); - result->project = project; + result = g_object_new(G_TYPE_EXPLORING_WORK, NULL); - g_object_ref(G_OBJECT(content)); result->content = content; + g_object_ref(G_OBJECT(content)); + + return result; + +} - result->state = state; + +/****************************************************************************** +* * +* Paramètres : work = instance à consulter. * +* * +* Description : Fournit l'identifiant du groupe de rattachement de la tâche. * +* * +* Retour : Identifiant d'un même ensemble d'explorations. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static gid_t g_exploring_work_get_group_id(const GExploringWork *work) +{ + gid_t result; /* Identifiant à retourner */ + + assert(work->gid != NULL); + + result = *work->gid; return result; @@ -270,10 +424,30 @@ GDelayedStudy *g_delayed_study_new(GStudyProject *project, GBinContent *content, /****************************************************************************** * * -* Paramètres : dstudy = intégration à mener. * +* Paramètres : work = instance à compléter. * +* gid = identifiant d'un même ensemble d'explorations. * +* * +* Description : Définit l'identifiant du groupe de rattachement de la tâche. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_exploring_work_set_group_id(GExploringWork *work, const gid_t *gid) +{ + work->gid = gid; + +} + + +/****************************************************************************** +* * +* Paramètres : work = encadrement de conversion à mener. * * status = barre de statut à tenir informée. * * * -* Description : Prépare une intégration de binaire au projet courant. * +* Description : Réalise l'exploration effective de formes de contenus. * * * * Retour : - * * * @@ -281,64 +455,64 @@ GDelayedStudy *g_delayed_study_new(GStudyProject *project, GBinContent *content, * * ******************************************************************************/ -static void g_delayed_study_process(GDelayedStudy *dstudy, GtkStatusStack *status) +static void g_exploring_work_process(GExploringWork *work, GtkStatusStack *status) { - FormatMatchStatus mstatus; /* Statut d'une reconnaissance */ - char *target; /* Sous-traitance requise */ - GBinaryLoader *loader; /* Dispositif de chargement */ - GWorkQueue *queue; /* Gestionnaire de différés */ + gid_t gid; /* Groupe d'appartenance */ - mstatus = find_matching_format(dstudy->content, NULL, &target); + gid = g_exploring_work_get_group_id(work); - switch (mstatus) - { - case FMS_MATCHED: + handle_binary_content(PGA_CONTENT_EXPLORER, work->content, gid, status); - if (dstudy->only_preload) - g_study_project_add_binary_content(dstudy->project, dstudy->content, dstudy->state); +} - else - { - loader = g_binary_loader_new(dstudy->content, dstudy->project); - queue = get_work_queue(); - g_work_queue_schedule_work(queue, G_DELAYED_WORK(loader), DEFAULT_WORK_GROUP); - } +/* ---------------------------------------------------------------------------------- */ +/* EXPLORATION NON BLOQUANTE DES CONTENUS */ +/* ---------------------------------------------------------------------------------- */ - break; - case FMS_FORWARDED: - /** - * L'émetteur de ce type de réponse a pour charge de - * reprogrammer lui même l'analyse de nouveaux contenus. - */ - log_variadic_message(LMT_PROCESS, _("binary '%s' contains other binaries..."), - g_binary_content_describe(dstudy->content, true)); +/* Indique le type défini pour l'exploration de contenus binaires. */ +G_DEFINE_TYPE(GContentExplorer, g_content_explorer, G_TYPE_OBJECT); - if (dstudy->state == PCS_ROOT) - g_study_project_add_binary_content(dstudy->project, dstudy->content, PCS_ROOT); - break; +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe les explorations de contenus binaires. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ - default: - /** - * Les jeux sont faits pour le contenu binaire courant. - */ - log_variadic_message(LMT_PROCESS, _("Unknown binary format for '%s'..."), - g_binary_content_describe(dstudy->content, true)); - break; +static void g_content_explorer_class_init(GContentExplorerClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ - } + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_content_explorer_dispose; + object->finalize = (GObjectFinalizeFunc)g_content_explorer_finalize; + + g_signal_new("explored", + G_TYPE_CONTENT_EXPLORER, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GContentExplorerClass, explored), + NULL, NULL, + g_cclosure_marshal_VOID__UINT, + G_TYPE_NONE, 1, G_TYPE_UINT); } /****************************************************************************** * * -* Paramètres : dstudy = tâche d'analyse de contenu pour projet à mener. * +* Paramètres : explorer = instance à initialiser. * * * -* Description : Limite l'étude et l'intégration d'un contenu binaire. * +* Description : Initialise une exploration de contenus binaires. * * * * Retour : - * * * @@ -346,19 +520,23 @@ static void g_delayed_study_process(GDelayedStudy *dstudy, GtkStatusStack *statu * * ******************************************************************************/ -void g_delayed_study_preload_only(GDelayedStudy *dstudy) +static void g_content_explorer_init(GContentExplorer *explorer) { - dstudy->only_preload = true; + explorer->generator = 0; + + explorer->groups = NULL; + explorer->count = 0; + + g_mutex_init(&explorer->mutex); } /****************************************************************************** * * -* Paramètres : content = contenu binaire chargé à analyser. * -* state = état du contenu à conserver. * +* Paramètres : explorer = instance d'objet GLib à traiter. * * * -* Description : Programme l'étude et l'intégration d'un contenu binaire. * +* Description : Supprime toutes les références externes. * * * * Retour : - * * * @@ -366,28 +544,26 @@ void g_delayed_study_preload_only(GDelayedStudy *dstudy) * * ******************************************************************************/ -void qck_study_new_content(GBinContent *content, ProjectContentState state) +static void g_content_explorer_dispose(GContentExplorer *explorer) { - GStudyProject *project; /* Projet courant */ - GDelayedStudy *dstudy; /* Etude à conduire */ - - project = get_current_project(); + while (explorer->count > 0) + g_content_explorer_delete_group(explorer, explorer->groups[0].gid); - dstudy = g_delayed_study_new(project, content, state); + if (explorer->groups != NULL) + free(explorer->groups); - g_object_unref(G_OBJECT(project)); + g_mutex_clear(&explorer->mutex); - study_new_content(dstudy); + G_OBJECT_CLASS(g_content_explorer_parent_class)->dispose(G_OBJECT(explorer)); } /****************************************************************************** * * -* Paramètres : content = contenu binaire chargé à analyser. * -* state = état du contenu à conserver. * +* Paramètres : explorer = instance d'objet GLib à traiter. * * * -* Description : Programme l'étude et l'intégration d'un contenu binaire. * +* Description : Procède à la libération totale de la mémoire. * * * * Retour : - * * * @@ -395,60 +571,73 @@ void qck_study_new_content(GBinContent *content, ProjectContentState state) * * ******************************************************************************/ -void study_new_content(GDelayedStudy *dstudy) +static void g_content_explorer_finalize(GContentExplorer *explorer) { - GWorkQueue *queue; /* Gestionnaire de différés */ - - queue = get_work_queue(); - g_work_queue_schedule_work(queue, G_DELAYED_WORK(dstudy), DEFAULT_WORK_GROUP); + G_OBJECT_CLASS(g_content_explorer_parent_class)->finalize(G_OBJECT(explorer)); } +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Crée un gestionnaire des explorations de contenus binaires. * +* * +* Retour : Instance mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GContentExplorer *g_content_explorer_new(void) +{ + GContentExplorer *result; /* Tâche à retourner */ -/* ---------------------------------------------------------------------------------- */ -/* CHARGEMENT DE BINAIRE NON BLOQUANT */ -/* ---------------------------------------------------------------------------------- */ + result = g_object_new(G_TYPE_CONTENT_EXPLORER, NULL); + return result; -/* Indique le type défini pour le chargement non bloquant d'un binaire. */ -G_DEFINE_TYPE(GBinaryLoader, g_binary_loader, G_TYPE_DELAYED_WORK); +} /****************************************************************************** * * -* Paramètres : klass = classe à initialiser. * +* Paramètres : explorer = gestionnaire d'explorations à consulter. * +* gid = identifiant du groupe recherché. * * * -* Description : Initialise la classe des tâches de chargement non bloquant. * +* Description : Retrouve le groupe correspondant à un identifiant donné. * * * -* Retour : - * +* Retour : Groupe trouvé ou NULL en cas d'échec. * * * * Remarques : - * * * ******************************************************************************/ -static void g_binary_loader_class_init(GBinaryLoaderClass *klass) +static exploring_group *g_content_explorer_find_group(GContentExplorer *explorer, gid_t gid) { - GObjectClass *object; /* Autre version de la classe */ - GDelayedWorkClass *work; /* Version en classe parente */ + exploring_group *result; /* Trouvaille à retourner */ + size_t i; /* Boucle de parcours */ - object = G_OBJECT_CLASS(klass); + assert(!g_mutex_trylock(&explorer->mutex)); - object->dispose = (GObjectFinalizeFunc/* ! */)g_binary_loader_dispose; - object->finalize = (GObjectFinalizeFunc)g_binary_loader_finalize; + result = NULL; - work = G_DELAYED_WORK_CLASS(klass); + for (i = 0; i < explorer->count && result == NULL; i++) + if (explorer->groups[i].gid == gid) + result = &explorer->groups[i]; - work->run = (run_task_fc)g_binary_loader_process; + return result; } /****************************************************************************** * * -* Paramètres : loader = instance à initialiser. * +* Paramètres : explorer = gestionnaire d'explorations à consulter. * +* work = exploration qui vient de se terminer. * * * -* Description : Initialise une tâche de chargement non bloquant d'un binaire.* +* Description : Note la fin d'une phase d'exploration de contenu. * * * * Retour : - * * * @@ -456,213 +645,877 @@ static void g_binary_loader_class_init(GBinaryLoaderClass *klass) * * ******************************************************************************/ -static void g_binary_loader_init(GBinaryLoader *loader) +static void g_content_explorer_ack(GContentExplorer *explorer, GExploringWork *work) { - loader->binary = NULL; + gid_t gid; /* Groupe d'appartenance */ + exploring_group *group; /* Groupe d'opération concerné */ + GWorkQueue *queue; /* Gestionnaire de différés */ + bool empty; /* Fin de l'exploration ? */ + + gid = g_exploring_work_get_group_id(work); + + g_mutex_lock(&explorer->mutex); + + group = g_content_explorer_find_group(explorer, gid); + assert(group != NULL); + + queue = get_work_queue(); + + empty = g_work_queue_is_empty(queue, group->wid); + + g_mutex_unlock(&explorer->mutex); + + if (empty) + g_signal_emit_by_name(explorer, "explored", gid); } /****************************************************************************** * * -* Paramètres : loader = instance d'objet GLib à traiter. * +* Paramètres : explorer = gestionnaire d'explorations à manipuler. * +* content = contenu initial à découvrir. * * * -* Description : Supprime toutes les références externes. * +* Description : Initie une nouvelle vague d'exploration de contenu. * * * -* Retour : - * +* Retour : Identifiant du nouveau groupe mis en place. * * * * Remarques : - * * * ******************************************************************************/ -static void g_binary_loader_dispose(GBinaryLoader *loader) +const gid_t *g_content_explorer_create_group(GContentExplorer *explorer, GBinContent *content) { - if (loader->from_content) - g_object_unref(G_OBJECT(loader->content)); + const gid_t *result; /* Identifiant à retourner */ + gid_t loop; /* Détection de boucle */ + gid_t id; /* Nouvelle identifiant généré */ + exploring_group *group; /* Groupe ciblé par l'opération*/ + GWorkQueue *queue; /* Gestionnaire de différés */ + GExploringWork *work; /* Nouvelle vague d'exploration*/ + + g_mutex_lock(&explorer->mutex); + + /* Récupération d'un identifiant libre */ + + /** + * Note : + * + * Comme 0 est l'identifiant du groupe de travail par défaut (DEFAULT_WORK_GROUP) + * et qu'il n'est pas possible de bloquer ce groupe lors des appels à + * g_work_queue_is_empty(), on différencie les identifiants de groupes + * de contenus et les identifiants de groupes de travail. + */ + + loop = explorer->generator; + + do + { + id = ++explorer->generator; + + /* Verification de la satisfaisabilité de la création */ + + assert(id != loop); + + /* Vérification que la place est libre... */ + + group = g_content_explorer_find_group(explorer, id); + + if (group == NULL) + break; + + } + while (1); + + /* Mise en place du groupe */ + + explorer->groups = (exploring_group *)realloc(explorer->groups, ++explorer->count * sizeof(exploring_group)); + + group = &explorer->groups[explorer->count - 1]; + + group->original = content; + g_object_ref(G_OBJECT(content)); - g_object_unref(G_OBJECT(loader->project)); + queue = get_work_queue(); + + group->wid = g_work_queue_define_work_group(queue); + group->gid = id; + + result = &group->gid; + + group->contents = NULL; + group->count = 0; + + /* Alimentation du contenu initial */ + + work = g_exploring_work_new(content); + g_exploring_work_set_group_id(work, &group->gid); + + g_signal_connect_swapped(work, "work-completed", G_CALLBACK(g_content_explorer_ack), explorer); + + g_work_queue_schedule_work(queue, G_DELAYED_WORK(work), group->wid); - if (loader->binary != NULL) - g_object_unref(G_OBJECT(loader->binary)); + g_mutex_unlock(&explorer->mutex); - G_OBJECT_CLASS(g_binary_loader_parent_class)->dispose(G_OBJECT(loader)); + return result; } /****************************************************************************** * * -* Paramètres : loader = instance d'objet GLib à traiter. * +* Paramètres : explorer = gestionnaire d'explorations à manipuler. * +* gid = identifiant du groupe à consulter. * * * -* Description : Procède à la libération totale de la mémoire. * +* Description : Fournit l'identifiant attribué pour les tâches parallèles. * * * -* Retour : - * +* Retour : Identifiant des tâches liées au groupe. * * * * Remarques : - * * * ******************************************************************************/ -static void g_binary_loader_finalize(GBinaryLoader *loader) +const wgroup_id_t *g_content_explorer_get_group_work_id(GContentExplorer *explorer, gid_t gid) { - if (!loader->from_content) - { - free(loader->filename); - free(loader->path); - } + const wgroup_id_t *result; /* Identifiant à retourner */ + exploring_group *group; /* Groupe d'opération concerné */ + + g_mutex_lock(&explorer->mutex); + + group = g_content_explorer_find_group(explorer, gid); + assert(group != NULL); + + result = &group->wid; - G_OBJECT_CLASS(g_binary_loader_parent_class)->finalize(G_OBJECT(loader)); + g_mutex_unlock(&explorer->mutex); + + return result; } /****************************************************************************** * * -* Paramètres : content = contenu binaire chargé en mémoire. * -* project = projet dans lequel venir ajouter des contenus. * +* Paramètres : explorer = gestionnaire d'explorations à manipuler. * +* gid = identifiant du groupe à supprimer. * * * -* Description : Prépare le chargement non bloqué d'un contenu binaire. * +* Description : Termine une vague d'exploration de contenu. * * * -* Retour : Instance de binaire chargé ou NULL en cas d'échec. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GBinaryLoader *g_binary_loader_new(GBinContent *content, GStudyProject *project) +void g_content_explorer_delete_group(GContentExplorer *explorer, gid_t gid) { - GBinaryLoader *result; /* Tâche à retourner */ - result = g_object_new(G_TYPE_BINARY_LOADER, NULL); - result->from_content = true; - result->content = content; - g_object_ref(G_OBJECT(content)); + exploring_group *group; /* Groupe ciblé par l'opération*/ + GWorkQueue *queue; /* Gestionnaire de différés */ + size_t i; /* Boucle de parcours */ + size_t index; /* Indice des paramètres */ - result->project = project; - g_object_ref(G_OBJECT(project)); + g_mutex_lock(&explorer->mutex); - return result; + group = g_content_explorer_find_group(explorer, gid); + + /* Supression des contenus chargés */ + + queue = get_work_queue(); + + g_work_queue_delete_work_group(queue, group->wid); + + for (i = 0; i < group->count; i++) + g_object_unref(G_OBJECT(group->contents[i])); + + /* Réorganisation de la liste */ + + index = group - explorer->groups; + + if ((index + 1) < explorer->count) + memmove(&explorer->groups[index], &explorer->groups[index + 1], + (explorer->count - index - 1) * sizeof(exploring_group)); + + explorer->groups = (exploring_group *)realloc(explorer->groups, + --explorer->count * sizeof(exploring_group)); + + /* Sortie */ + + g_mutex_unlock(&explorer->mutex); } /****************************************************************************** * * -* Paramètres : filename = chemin d'accès au fichier à charger. * -* path = chemin d'accès au noeud XML à lire. * -* project = projet dans lequel venir rechercher les contenus. * +* Paramètres : explorer = gestionnaire d'explorations à consulter. * +* gid = identifiant du groupe à parcourir. * +* content = nouveau contenu à intégrer. * * * -* Description : Prépare le chargement non bloqué d'un contenu XML. * +* Description : Ajoute un nouveau contenu découvert au crédit d'un groupe. * * * -* Retour : Instance de binaire chargé ou NULL en cas d'échec. * +* Retour : - * * * -* Remarques : - * +* Remarques : La propritété du contenu fourni est cédée. * * * ******************************************************************************/ -GBinaryLoader *g_binary_loader_new_from_xml(const char *filename, const char *path, GStudyProject *project) +void g_content_explorer_populate_group(GContentExplorer *explorer, gid_t gid, GBinContent *content) { - GBinaryLoader *result; /* Tâche à retourner */ + exploring_group *group; /* Groupe d'opération concerné */ + GWorkQueue *queue; /* Gestionnaire de différés */ + GExploringWork *work; /* Nouvelle vague d'exploration*/ - result = g_object_new(G_TYPE_BINARY_LOADER, NULL); + g_mutex_lock(&explorer->mutex); - result->from_content = false; + group = g_content_explorer_find_group(explorer, gid); + assert(group != NULL); - result->filename = strdup(filename); - result->path = strdup(path); + /* Conservation du résultat */ - result->project = project; - g_object_ref(G_OBJECT(project)); + group->contents = (GBinContent **)realloc(group->contents, ++group->count * sizeof(GBinContent *)); - return result; + group->contents[group->count - 1] = content; + + /* Relancement des explorations */ + + work = g_exploring_work_new(content); + g_exploring_work_set_group_id(work, &group->gid); + + g_signal_connect_swapped(work, "work-completed", G_CALLBACK(g_content_explorer_ack), explorer); + + queue = get_work_queue(); + + g_work_queue_schedule_work(queue, G_DELAYED_WORK(work), group->wid); + + g_mutex_unlock(&explorer->mutex); } /****************************************************************************** * * -* Paramètres : loader = encadrement du chargement à mener. * -* status = barre de statut à tenir informée. * +* Paramètres : explorer = gestionnaire d'explorations à consulter. * +* gid = identifiant du groupe à parcourir. * +* count = nombre de contenus binaires retournés. [OUT] * * * -* Description : Réalise le chargement effectif d'un binaire. * +* Description : Fournit la liste de tous les contenus disponibles. * * * -* Retour : - * +* Retour : Liste de contenus binaires enregistrés. * * * * Remarques : - * * * ******************************************************************************/ -static void g_binary_loader_process(GBinaryLoader *loader, GtkStatusStack *status) +GBinContent **g_content_explorer_get_all(GContentExplorer *explorer, gid_t gid, size_t *count) { - xmlDocPtr xdoc; /* Structure XML chargée */ - xmlXPathContextPtr context; /* Contexte pour les XPath */ - GLoadedBinary *binary; /* Binaire désormais en place */ + GBinContent **result; /* Trouvailles à retourner */ + exploring_group *group; /* Groupe d'opération concerné */ + size_t i; /* Boucle de parcours */ - /* Tentative de chargement de binaire */ + g_mutex_lock(&explorer->mutex); - if (loader->from_content) - loader->binary = g_loaded_binary_new(loader->content); + group = g_content_explorer_find_group(explorer, gid); + assert(group != NULL); - else - { - if (open_xml_file(loader->filename, &xdoc, &context)) - { - loader->binary = g_loaded_binary_new_from_xml(context, loader->path, loader->project); + /* Allocation de la liste finale */ - close_xml_file(xdoc, context); + *count = 1 + group->count; + result = (GBinContent **)malloc(*count * sizeof(GBinContent *)); - } + /* On regarde déjà du côté de la source */ - } + result[0] = group->original; + + g_object_ref(G_OBJECT(result[0])); - /* Poursuites qui peuvent être traitées dans la foulée */ + /* On parcourt les éventuels contenus encapsulés découverts */ - if (loader->binary != NULL) + for (i = 0; i < group->count; i++) { - /* Si le contenu n'a pas déjà été ajouté au projet au moment du chargement de ce dernier... */ - if (loader->from_content) - g_study_project_add_binary_content(loader->project, loader->content, PCS_ROOT/* FIXME : dstudy->state*/); + result[1 + i] = group->contents[i]; - binary = g_binary_loader_get_result(loader); + g_object_ref(G_OBJECT(result[i + 1])); + + } - if (binary != NULL) - { - g_signal_connect_to_main_swapped(binary, "disassembly-done", - G_CALLBACK(g_study_project_attach_content), loader->project, - g_cclosure_marshal_VOID__VOID); + g_mutex_unlock(&explorer->mutex); - g_loaded_binary_analyse(binary); + return result; - g_object_unref(G_OBJECT(binary)); +} - } - } -} +/* ---------------------------------------------------------------------------------- */ +/* TACHE DE RESOLUTION DE CONTENU */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour la conversion de contenu binaire en contenu chargé. */ +G_DEFINE_TYPE(GResolvingWork, g_resolving_work, G_TYPE_DELAYED_WORK); /****************************************************************************** * * -* Paramètres : loader = encadrement du chargement à consulter. * +* Paramètres : klass = classe à initialiser. * * * -* Description : Retourne l'instance du binaire chargé en cas de succès. * +* Description : Initialise la classe des tâches de conversion de contenu. * * * -* Retour : Instance mise en place ou NULL. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GLoadedBinary *g_binary_loader_get_result(const GBinaryLoader *loader) +static void g_resolving_work_class_init(GResolvingWorkClass *klass) { - GLoadedBinary *result; /* Chargement à faire suivre */ + GObjectClass *object; /* Autre version de la classe */ + GDelayedWorkClass *work; /* Version en classe parente */ - result = loader->binary; + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_resolving_work_dispose; + object->finalize = (GObjectFinalizeFunc)g_resolving_work_finalize; + + work = G_DELAYED_WORK_CLASS(klass); + + work->run = (run_task_fc)g_resolving_work_process; + +} + + +/****************************************************************************** +* * +* Paramètres : work = instance à initialiser. * +* * +* Description : Initialise une tâche de conversion de contenu. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_resolving_work_init(GResolvingWork *work) +{ + work->gid = NULL; + + work->content = NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : work = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_resolving_work_dispose(GResolvingWork *work) +{ + g_object_unref(G_OBJECT(work->content)); + + G_OBJECT_CLASS(g_resolving_work_parent_class)->dispose(G_OBJECT(work)); + +} + + +/****************************************************************************** +* * +* Paramètres : work = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_resolving_work_finalize(GResolvingWork *work) +{ + G_OBJECT_CLASS(g_resolving_work_parent_class)->finalize(G_OBJECT(work)); + +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu binaire disponible pour traitements. * +* * +* Description : Prépare la conversion non bloquée d'un contenu binaire. * +* * +* Retour : Tâche de travail mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GResolvingWork *g_resolving_work_new(GBinContent *content) +{ + GResolvingWork *result; /* Tâche à retourner */ + + result = g_object_new(G_TYPE_RESOLVING_WORK, NULL); + + result->content = content; + g_object_ref(G_OBJECT(content)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : work = instance à consulter. * +* * +* Description : Fournit l'identifiant du groupe de rattachement de la tâche. * +* * +* Retour : Identifiant d'un même ensemble de conversions. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static gid_t g_resolving_work_get_group_id(const GResolvingWork *work) +{ + gid_t result; /* Identifiant à retourner */ + + assert(work->gid != NULL); + + result = *work->gid; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : work = instance à compléter. * +* gid = identifiant d'un même ensemble de conversions. * +* * +* Description : Définit l'identifiant du groupe de rattachement de la tâche. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_resolving_work_set_group_id(GResolvingWork *work, const gid_t *gid) +{ + work->gid = gid; + +} + + +/****************************************************************************** +* * +* Paramètres : work = encadrement de conversion à mener. * +* status = barre de statut à tenir informée. * +* * +* Description : Réalise la conversion effective de formes de contenus. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_resolving_work_process(GResolvingWork *work, GtkStatusStack *status) +{ + gid_t gid; /* Groupe d'appartenance */ + + gid = g_resolving_work_get_group_id(work); + + handle_binary_content(PGA_CONTENT_RESOLVER, work->content, gid, status); + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* RESOLUTION DE CONTENUS BINAIRES EN CHARGES */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour la résolution de contenus binaires en formats chargés. */ +G_DEFINE_TYPE(GContentResolver, g_content_resolver, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des résolutions de contenus binaires. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_content_resolver_class_init(GContentResolverClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_content_resolver_dispose; + object->finalize = (GObjectFinalizeFunc)g_content_resolver_finalize; + + g_signal_new("resolved", + G_TYPE_CONTENT_RESOLVER, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GContentResolverClass, resolved), + NULL, NULL, + g_cclosure_marshal_VOID__UINT, + G_TYPE_NONE, 1, G_TYPE_UINT); + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = instance à initialiser. * +* * +* Description : Initialise une résolution de contenus binaires. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_content_resolver_init(GContentResolver *resolver) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_content_resolver_dispose(GContentResolver *resolver) +{ + while (resolver->count > 0) + g_content_resolver_delete_group(resolver, *resolver->groups[0].gid); + + if (resolver->groups != NULL) + free(resolver->groups); + + g_mutex_clear(&resolver->mutex); + + G_OBJECT_CLASS(g_content_resolver_parent_class)->dispose(G_OBJECT(resolver)); + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_content_resolver_finalize(GContentResolver *resolver) +{ + G_OBJECT_CLASS(g_content_resolver_parent_class)->finalize(G_OBJECT(resolver)); + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Crée un gestionnaire des résolutions de contenus binaires. * +* * +* Retour : Instance mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GContentResolver *g_content_resolver_new(void) +{ + GContentResolver *result; /* Tâche à retourner */ + + result = g_object_new(G_TYPE_CONTENT_RESOLVER, NULL); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = gestionnaire de résolutions à consulter. * +* gid = identifiant du groupe recherché. * +* * +* Description : Retrouve le groupe correspondant à un identifiant donné. * +* * +* Retour : Groupe trouvé ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static resolving_group *g_content_resolver_find_group(GContentResolver *resolver, gid_t gid) +{ + resolving_group *result; /* Trouvaille à retourner */ + size_t i; /* Boucle de parcours */ + + assert(!g_mutex_trylock(&resolver->mutex)); + + result = NULL; + + for (i = 0; i < resolver->count && result == NULL; i++) + if (*resolver->groups[i].gid == gid) + result = &resolver->groups[i]; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = gestionnaire de résolutions à consulter. * +* work = resolvation qui vient de se terminer. * +* * +* Description : Note la fin d'une phase de resolution de contenu. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_content_resolver_ack(GContentResolver *resolver, GResolvingWork *work) +{ + gid_t gid; /* Groupe d'appartenance */ + resolving_group *group; /* Groupe d'opération concerné */ + bool empty; /* Fin de l'resolvation ? */ + + gid = g_resolving_work_get_group_id(work); + + g_mutex_lock(&resolver->mutex); + + group = g_content_resolver_find_group(resolver, gid); + assert(group != NULL); + + assert(group->remaining > 0); + + empty = (--group->remaining == 0); + + g_mutex_unlock(&resolver->mutex); + + if (empty) + g_signal_emit_by_name(resolver, "resolved", gid); + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = gestionnaire de résolutions à manipuler. * +* wid = identifiant du groupe de tâches réservé. * +* gid = identifiant unique généré en amont. * +* contents = contenus à analyser. * +* count = nombre de ces contenus. * +* * +* Description : Initie une nouvelle vague de résolution de contenus. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_content_resolver_create_group(GContentResolver *resolver, const wgroup_id_t *wid, const gid_t *gid, GBinContent **contents, size_t count) +{ + resolving_group *group; /* Groupe ciblé par l'opération*/ + GWorkQueue *queue; /* Gestionnaire de différés */ + size_t i; /* Boucle de parcours */ + GResolvingWork *work; /* Nouvelle vague de résolution*/ + + g_mutex_lock(&resolver->mutex); + + /* Mise en place du groupe */ + + resolver->groups = (resolving_group *)realloc(resolver->groups, ++resolver->count * sizeof(resolving_group)); + + group = &resolver->groups[resolver->count - 1]; + + group->remaining = count; + + group->gid = gid; + + group->loaded = NULL; + group->count = 0; + + /* Alimentation du contenu initial */ + + queue = get_work_queue(); + + for (i = 0; i < count; i++) + { + work = g_resolving_work_new(contents[i]); + g_resolving_work_set_group_id(work, gid); + + g_signal_connect_swapped(work, "work-completed", G_CALLBACK(g_content_resolver_ack), resolver); + + g_work_queue_schedule_work(queue, G_DELAYED_WORK(work), *wid); + + } + + g_mutex_unlock(&resolver->mutex); + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = gestionnaire d'explorations à manipuler. * +* gid = identifiant du groupe à supprimer. * +* * +* Description : Termine une vague de résolution de contenu. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_content_resolver_delete_group(GContentResolver *resolver, gid_t gid) +{ + resolving_group *group; /* Groupe ciblé par l'opération*/ + size_t i; /* Boucle de parcours */ + size_t index; /* Indice des paramètres */ + + g_mutex_lock(&resolver->mutex); + + group = g_content_resolver_find_group(resolver, gid); + + /* Supression des contenus chargés */ + + for (i = 0; i < group->count; i++) + g_object_unref(G_OBJECT(group->loaded[i])); + + /* Réorganisation de la liste */ + + index = group - resolver->groups; + + if ((index + 1) < resolver->count) + memmove(&resolver->groups[index], &resolver->groups[index + 1], + (resolver->count - index - 1) * sizeof(resolving_group)); + + resolver->groups = (resolving_group *)realloc(resolver->groups, + --resolver->count * sizeof(resolving_group)); + + /* Sortie */ + + g_mutex_unlock(&resolver->mutex); + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = gestionnaire de résolutions à consulter. * +* gid = identifiant du groupe recherché. * +* loaded = contenu chargé et pouvant être représenté. * +* * +* Description : Intègre un contenu chargé dans les résultats. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_content_resolver_add_detected(GContentResolver *resolver, gid_t gid, GLoadedContent *loaded) +{ + resolving_group *group; /* Groupe ciblé par l'opération*/ + + g_mutex_lock(&resolver->mutex); + + group = g_content_resolver_find_group(resolver, gid); + + group->loaded = (GLoadedContent **)realloc(group->loaded, ++group->count * sizeof(GLoadedContent *)); + + group->loaded[group->count - 1] = loaded; + + g_mutex_unlock(&resolver->mutex); + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = gestionnaire de resolutions à consulter. * +* gid = identifiant du groupe à parcourir. * +* count = nombre de contenus binaires retournés. [OUT] * +* * +* Description : Fournit la liste de tous les contenus chargés valables. * +* * +* Retour : Liste de contenus chargés enregistrés. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GLoadedContent **g_content_resolver_get_all(GContentResolver *resolver, gid_t gid, size_t *count) +{ + GLoadedContent **result; /* Trouvailles à retourner */ + resolving_group *group; /* Groupe d'opération concerné */ + size_t i; /* Boucle de parcours */ + + g_mutex_lock(&resolver->mutex); + + group = g_content_resolver_find_group(resolver, gid); + assert(group != NULL); + + /* Allocation de la liste finale */ + + *count = group->count; + result = (GLoadedContent **)malloc(*count * sizeof(GLoadedContent *)); + + /* On parcourt les éventuels contenus encapsulés découverts */ + + for (i = 0; i < group->count; i++) + { + result[i] = group->loaded[i]; + + g_object_ref(G_OBJECT(result[i])); + + } - if (result != NULL) - g_object_ref(G_OBJECT(result)); + g_mutex_unlock(&resolver->mutex); return result; diff --git a/src/analysis/loading.h b/src/analysis/loading.h index 46b42a1..4755226 100644 --- a/src/analysis/loading.h +++ b/src/analysis/loading.h @@ -28,74 +28,88 @@ #include -#include "project.h" +#include "content.h" +#include "loaded.h" +#include "../glibext/delayed.h" -/* ----------------------- AMORCE POUR CHARGEMENT DE CONTENUS ----------------------- */ +/* --------------------- EXPLORATION NON BLOQUANTE DES CONTENUS --------------------- */ -#define G_TYPE_DELAYED_STUDY g_delayed_study_get_type() -#define G_DELAYED_STUDY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_study_get_type(), GDelayedStudy)) -#define G_IS_DELAYED_STUDY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_study_get_type())) -#define G_DELAYED_STUDY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_STUDY, GDelayedStudyClass)) -#define G_IS_DELAYED_STUDY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_STUDY)) -#define G_DELAYED_STUDY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_STUDY, GDelayedStudyClass)) +#define G_TYPE_CONTENT_EXPLORER g_content_explorer_get_type() +#define G_CONTENT_EXPLORER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_CONTENT_EXPLORER, GContentExplorer)) +#define G_IS_CONTENT_EXPLORER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_CONTENT_EXPLORER)) +#define G_CONTENT_EXPLORER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_CONTENT_EXPLORER, GContentExplorerClass)) +#define G_IS_CONTENT_EXPLORER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_CONTENT_EXPLORER)) +#define G_CONTENT_EXPLORER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_CONTENT_EXPLORER, GContentExplorerClass)) -/* Ensembles binaires à désassembler (instance) */ -typedef struct _GDelayedStudy GDelayedStudy; +/* Exploration de contenus binaires (instance) */ +typedef struct _GContentExplorer GContentExplorer; -/* Ensembles binaires à désassembler (classe) */ -typedef struct _GDelayedStudyClass GDelayedStudyClass; +/* Exploration de contenus binaires (classe) */ +typedef struct _GContentExplorerClass GContentExplorerClass; -/* Indique le type défini pour les tâches de préparations d'étude. */ -GType g_delayed_study_get_type(void); +/* Indique le type défini pour l'exploration de contenus binaires. */ +GType g_content_explorer_get_type(void); -/* Crée une tâche d'intégration de contenu binaire. */ -GDelayedStudy *g_delayed_study_new(GStudyProject *, GBinContent *, ProjectContentState); +/* Crée un gestionnaire des explorations de contenus binaires. */ +GContentExplorer *g_content_explorer_new(void); -/* Limite l'étude et l'intégration d'un contenu binaire. */ -void g_delayed_study_preload_only(GDelayedStudy *); +/* Initie une nouvelle vague d'exploration de contenu. */ +const gid_t *g_content_explorer_create_group(GContentExplorer *, GBinContent *); -/* Programme l'étude et l'intégration d'un contenu binaire. */ -void qck_study_new_content(GBinContent *, ProjectContentState); +/* Fournit l'identifiant attribué pour les tâches parallèles. */ +const wgroup_id_t *g_content_explorer_get_group_work_id(GContentExplorer *, gid_t); -/* Programme l'étude et l'intégration d'un contenu binaire. */ -void study_new_content(GDelayedStudy *); +/* Termine une vague d'exploration de contenu. */ +void g_content_explorer_delete_group(GContentExplorer *, gid_t); +/* Ajoute un nouveau contenu découvert au crédit d'un groupe. */ +void g_content_explorer_populate_group(GContentExplorer *, gid_t, GBinContent *); +/* Fournit la liste de tous les contenus disponibles. */ +GBinContent **g_content_explorer_get_all(GContentExplorer *, gid_t, size_t *); -/* ----------------------- CHARGEMENT DE BINAIRE NON BLOQUANT ----------------------- */ -#define G_TYPE_BINARY_LOADER g_binary_loader_get_type() -#define G_BINARY_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BINARY_LOADER, GBinaryLoader)) -#define G_IS_BINARY_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BINARY_LOADER)) -#define G_BINARY_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BINARY_LOADER, GBinaryLoaderClass)) -#define G_IS_BINARY_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BINARY_LOADER)) -#define G_BINARY_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BINARY_LOADER, GBinaryLoaderClass)) +/* ------------------- RESOLUTION DE CONTENUS BINAIRES EN CHARGES ------------------- */ -/* Chargement non bloquant d'un binaire (instance) */ -typedef struct _GBinaryLoader GBinaryLoader; +#define G_TYPE_CONTENT_RESOLVER g_content_resolver_get_type() +#define G_CONTENT_RESOLVER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_CONTENT_RESOLVER, GContentResolver)) +#define G_IS_CONTENT_RESOLVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_CONTENT_RESOLVER)) +#define G_CONTENT_RESOLVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_CONTENT_RESOLVER, GContentResolverClass)) +#define G_IS_CONTENT_RESOLVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_CONTENT_RESOLVER)) +#define G_CONTENT_RESOLVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_CONTENT_RESOLVER, GContentResolverClass)) -/* Chargement non bloquant d'un binaire (classe) */ -typedef struct _GBinaryLoaderClass GBinaryLoaderClass; +/* Résolution de contenus binaires en formats chargés (instance) */ +typedef struct _GContentResolver GContentResolver; -/* Indique le type défini pour le chargement non bloquant d'un binaire. */ -GType g_binary_loader_get_type(void); +/* Résolution de contenus binaires en formats chargés (classe) */ +typedef struct _GContentResolverClass GContentResolverClass; -/* Prépare le chargement non bloqué d'un contenu binaire. */ -GBinaryLoader *g_binary_loader_new(GBinContent *, GStudyProject *); -/* Prépare le chargement non bloqué d'un contenu XML. */ -GBinaryLoader *g_binary_loader_new_from_xml(const char *, const char *, GStudyProject *); +/* Indique le type défini pour la résolution de contenus binaires en formats chargés. */ +GType g_content_resolver_get_type(void); -/* Retourne l'instance du binaire chargé en cas de succès. */ -GLoadedBinary *g_binary_loader_get_result(const GBinaryLoader *); +/* Crée un gestionnaire des résolutions de contenus binaires. */ +GContentResolver *g_content_resolver_new(void); + +/* Initie une nouvelle vague de résolution de contenus. */ +void g_content_resolver_create_group(GContentResolver *, const wgroup_id_t *, const gid_t *, GBinContent **, size_t); + +/* Termine une vague de résolution de contenu. */ +void g_content_resolver_delete_group(GContentResolver *, gid_t); + +/* Intègre un contenu chargé dans les résultats. */ +void g_content_resolver_add_detected(GContentResolver *, gid_t, GLoadedContent *); + +/* Fournit la liste de tous les contenus chargés valables. */ +GLoadedContent **g_content_resolver_get_all(GContentResolver *, gid_t, size_t *); diff --git a/src/analysis/project.c b/src/analysis/project.c index 09b4aad..88b468a 100644 --- a/src/analysis/project.c +++ b/src/analysis/project.c @@ -25,7 +25,6 @@ #include -#include #include #include @@ -33,40 +32,33 @@ #include -#include "loaded.h" #include "loading.h" #include "../common/xml.h" #include "../core/global.h" #include "../core/logs.h" #include "../core/params.h" -#include "../glibext/delayed-int.h" -#include "../gui/core/panels.h" -#include "../gui/panels/panel.h" -#include "../format/format.h" /* ------------------------- DEFINITION D'UN PROJET INTERNE ------------------------- */ -/* Conservation d'un contenu chargé */ -typedef struct _loaded_content +/* Suivi du chargement de contenus binaires */ +typedef struct _loading_params { - GBinContent *content; /* Contenu binaire en place */ - ProjectContentState state; /* Renseigne le type de contenu*/ - -} loaded_content; - -/* Conservation d'un binaire chargé */ -typedef struct _loaded_binary -{ - GLoadedBinary *binary; /* Binaire en question */ + union + { + const gid_t *exp_gid; /* Identifiant d'exploration */ + const gid_t **exp_gids; /* Identifiants d'exploration */ + }; + size_t exp_count; /* Quantitié d'identifiants */ - GPanelItem **items; /* Supports d'affichage final */ - size_t count; /* Nombre de ces supports */ + size_t resolved; /* Compteur de résolutions */ -} loaded_binary; + xmlDoc *xdoc; /* Structure XML chargée ? */ + xmlXPathContext *context; /* Eventuel contexte XML */ +} loading_params; /* Projet d'étude regroupant les binaires analysés (instance) */ struct _GStudyProject @@ -75,6 +67,10 @@ struct _GStudyProject char *filename; /* Lieu d'enregistrement */ + loading_params *ld_params; /* Infos d'accompagnement */ + size_t ld_count; /* Quantité de ces infos */ + GMutex ld_mutex; /* Encadrement des accès */ + GLoadedContent **contents; /* Contenus chargés et intégrés*/ size_t count; /* Quantité de ces contenus */ GMutex mutex; /* Encadrement des accès */ @@ -101,6 +97,38 @@ static void g_study_project_class_init(GStudyProjectClass *); /*Initialise une instance de projet d'étude. */ static void g_study_project_init(GStudyProject *); +/* Supprime toutes les références externes. */ +static void g_study_project_dispose(GStudyProject *); + +/* Procède à la libération totale de la mémoire. */ +static void g_study_project_finalize(GStudyProject *); + + + +/* ------------------------ INTEGRATION DE CONTENUS BINAIRES ------------------------ */ + + +/* Prépare le suivi d'une nouvelle phase d'intégration. */ +static loading_params *g_study_project_prepare_content_loading(GStudyProject *); + +/* Efface le suivi d'une phase d'intégration obsolète. */ +static void g_study_project_destroy_content_loading(GStudyProject *, loading_params *); + +/* Retrouve les infos de chargements liées à une exploration. */ +static loading_params *g_study_project_find_exploration(GStudyProject *, gid_t, const gid_t **); + +/* Assure l'intégration de contenus listés dans du XML. */ +static void g_study_project_recover_binary_contents(GStudyProject *, xmlDoc *, xmlXPathContext *); + +/* Note la fin d'une phase d'exploration de contenu. */ +static void on_new_content_explored(GContentExplorer *, gid_t, GStudyProject *); + +/* Note la fin d'une phase de resolution de contenu. */ +static void on_new_content_resolved(GContentResolver *, gid_t, GStudyProject *); + +/* Réceptionne la recette d'une analyse de contenu. */ +static void on_loaded_content_analyzed(GLoadedContent *, gboolean, GStudyProject *); + /* ---------------------------------------------------------------------------------- */ @@ -126,6 +154,13 @@ G_DEFINE_TYPE(GStudyProject, g_study_project, G_TYPE_OBJECT); static void g_study_project_class_init(GStudyProjectClass *klass) { + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_study_project_dispose; + object->finalize = (GObjectFinalizeFunc)g_study_project_finalize; + g_signal_new("content-added", G_TYPE_STUDY_PROJECT, G_SIGNAL_RUN_LAST, @@ -159,8 +194,104 @@ static void g_study_project_class_init(GStudyProjectClass *klass) static void g_study_project_init(GStudyProject *project) { + GContentExplorer *explorer; /* Explorateur de contenus */ + GContentResolver *resolver; /* Resolveur de contenus */ + + project->filename = NULL; + + project->ld_params = NULL; + project->ld_count = 0; + g_mutex_init(&project->ld_mutex); + + project->contents = NULL; + project->count = 0; g_mutex_init(&project->mutex); + explorer = get_current_content_explorer(); + g_signal_connect(explorer, "explored", G_CALLBACK(on_new_content_explored), project); + g_object_unref(G_OBJECT(explorer)); + + resolver = get_current_content_resolver(); + g_signal_connect(resolver, "resolved", G_CALLBACK(on_new_content_resolved), project); + g_object_unref(G_OBJECT(resolver)); + +} + + +/****************************************************************************** +* * +* Paramètres : binary = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_study_project_dispose(GStudyProject *project) +{ + GContentExplorer *explorer; /* Explorateur de contenus */ + GContentResolver *resolver; /* Resolveur de contenus */ + size_t i; /* Boucle de parcours */ + + explorer = get_current_content_explorer(); + g_signal_handlers_disconnect_by_func(explorer, G_CALLBACK(on_new_content_explored), project); + g_object_unref(G_OBJECT(explorer)); + + resolver = get_current_content_resolver(); + g_signal_handlers_disconnect_by_func(resolver, G_CALLBACK(on_new_content_resolved), project); + g_object_unref(G_OBJECT(resolver)); + + g_mutex_lock(&project->ld_mutex); + + while (project->ld_count > 0) + g_study_project_destroy_content_loading(project, project->ld_params); + + if (project->ld_params != NULL) + free(project->ld_params); + + g_mutex_unlock(&project->ld_mutex); + + g_mutex_clear(&project->ld_mutex); + + g_mutex_lock(&project->mutex); + + for (i = 0; i < project->count; i++) + g_object_unref(G_OBJECT(project->contents[i])); + + if (project->contents != NULL) + free(project->contents); + + g_mutex_unlock(&project->mutex); + + g_mutex_clear(&project->mutex); + + G_OBJECT_CLASS(g_study_project_parent_class)->dispose(G_OBJECT(project)); + +} + + +/****************************************************************************** +* * +* Paramètres : binary = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_study_project_finalize(GStudyProject *project) +{ + if (project->filename != NULL) + free(project->filename); + + G_OBJECT_CLASS(g_study_project_parent_class)->finalize(G_OBJECT(project)); + } @@ -201,25 +332,9 @@ GStudyProject *g_study_project_new(void) GStudyProject *g_study_project_open(const char *filename) { - return NULL; - -#if 0 - GStudyProject *result; /* Adresse à retourner */ - xmlDocPtr xdoc; /* Structure XML chargée */ - xmlXPathContextPtr context; /* Contexte pour les XPath */ - unsigned int root_contents; /* Quantité de contenus majeurs*/ - GAsyncQueue *sema; /* Sémaphore taisant son nom */ - xmlXPathObjectPtr xobject; /* Cible d'une recherche */ - unsigned int i; /* Boucle de parcours */ - size_t access_len; /* Taille d'un chemin interne */ - char *access; /* Chemin pour une sous-config.*/ - GBinContent *content; /* Contenu binaire retrouvé */ - long state; /* Etat de ce contenu binaire */ - bool status; /* Bilan d'une lecture */ - GDelayedStudy *dstudy; /* Etude complémentaire à mener*/ - GBinaryLoader *loader; /* Dispositif de chargement */ - GWorkQueue *queue; /* Gestionnaire de différés */ + xmlDoc *xdoc; /* Structure XML chargée */ + xmlXPathContext *context; /* Contexte pour les XPath */ if (!open_xml_file(filename, &xdoc, &context)) return NULL; @@ -227,186 +342,416 @@ GStudyProject *g_study_project_open(const char *filename) result->filename = strdup(filename); - /* Préparations aux traitements parallèles */ + g_study_project_recover_binary_contents(result, xdoc, context); - root_contents = 0; + return result; - sema = g_async_queue_new(); +} - void ack_content_processing(GDelayedStudy *dstudy, GAsyncQueue *aqueue) - { - g_async_queue_push(aqueue, GINT_TO_POINTER(1)); - } - /* Chargement des contenus binaires attachés */ +/****************************************************************************** +* * +* Paramètres : project = project à sauvegarder. * +* filename = nom de fichier à utiliser ou NULL pour l'existant.* +* * +* Description : Procède à l'enregistrement d'un projet donné. * +* * +* Retour : true si l'enregistrement s'est déroule sans encombre. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_study_project_save(GStudyProject *project, const char *filename) +{ + bool result; /* Bilan à retourner */ + xmlDocPtr xdoc; /* Document XML à créer */ + xmlXPathContextPtr context; /* Contexte pour les recherches*/ + const char *final; /* Lieu d'enregistrement final */ + size_t root_count; /* Quantité d'origines */ + size_t i; /* Boucle de parcours */ + GBinContent *content; /* Contenu brut à manipuler */ + GBinContent *root; /* Contenu d'origine à traiter */ + const gchar *hash; /* Empreinte d'un contenu */ + char *access; /* Chemin pour une sous-config.*/ + xmlXPathObjectPtr xobject; /* Cible d'une recherche */ + const char *format; /* Format associé à un élément */ + + /* Forme générale */ + + result = create_new_xml_file(&xdoc, &context); + + if (result) + result = (ensure_node_exist(xdoc, context, "/ChrysalideProject") != NULL); + + if (result) + result = add_string_attribute_to_node(xdoc, context, "/ChrysalideProject", "version", PROJECT_XML_VERSION); + + if (result) + result = (ensure_node_exist(xdoc, context, "/ChrysalideProject/RootContents") != NULL); + + if (result) + result = (ensure_node_exist(xdoc, context, "/ChrysalideProject/LoadedContents") != NULL); + + final = filename != NULL ? filename : project->filename; + + /* Inscriptions des contenus */ + + root_count = 0; - xobject = get_node_xpath_object(context, "/ChrysalideProject/Contents/Content"); + g_mutex_lock(&project->mutex); - for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++) + for (i = 0; i < project->count && result; i++) { - access_len = strlen("/ChrysalideProject/Contents/Content[position()=") + SIZE_T_MAXLEN + strlen("]") + 1; + content = g_loaded_content_get_content(project->contents[i]); - access = calloc(access_len, sizeof(char)); - snprintf(access, access_len, "/ChrysalideProject/Contents/Content[position()=%u]", i + 1); + /* Racine */ - content = g_binary_content_new_from_xml(context, access, filename); - status = get_node_prop_long_value(context, access, "state", &state); + root = g_binary_content_get_root(content); - free(access); + hash = g_binary_content_get_checksum(root); - if (content == NULL) - { - log_variadic_message(LMT_ERROR, _("Unable to load the binary content #%u ; skipping..."), i); - continue; - } + asprintf(&access, "/ChrysalideProject/RootContents/Content[@hash='%s']", hash); - if (!status) - { - log_variadic_message(LMT_ERROR, _("Bad state for content '%s' ; skipping..."), - g_binary_content_describe(content, true)); - continue; - } + xobject = get_node_xpath_object(context, access); - /* Le contenu peut être un conteneur ? */ - if (state == PCS_ROOT) + free(access); + + if (XPATH_OBJ_NODES_COUNT(xobject) == 0) { - dstudy = g_delayed_study_new(result, content, state); - g_signal_connect(dstudy, "work-completed", G_CALLBACK(ack_content_processing), sema); + asprintf(&access, "/ChrysalideProject/RootContents/Content[position()=%zu]", ++root_count); + + if (result) + result = (ensure_node_exist(xdoc, context, access) != NULL); - g_delayed_study_preload_only(dstudy); + if (result) + { + hash = g_binary_content_get_checksum(content); + result = add_string_attribute_to_node(xdoc, context, access, "hash", hash); + } - root_contents++; + if (result) + result = g_binary_content_save(root, xdoc, context, access, final); - study_new_content(dstudy); + free(access); } - } + if(xobject != NULL) + xmlXPathFreeObject(xobject); - if(xobject != NULL) - xmlXPathFreeObject(xobject); + /* Charge utile */ - /* Attente pour la réception de contenus supplémentaires éventuels */ + asprintf(&access, "/ChrysalideProject/LoadedContents/Content[position()=%zu]", i + 1); - for (i = 0; i < root_contents; i++) - g_async_queue_pop(sema); + if (result) + result = (ensure_node_exist(xdoc, context, access) != NULL); - g_async_queue_unref(sema); + if (result) + { + hash = g_binary_content_get_checksum(content); + result = add_string_attribute_to_node(xdoc, context, access, "hash", hash); + } - /* Chargement des binaires analysés */ + if (result) + { + format = g_loaded_content_get_format_name(project->contents[i]); + result = add_string_attribute_to_node(xdoc, context, access, "format", format); + } - xobject = get_node_xpath_object(context, "/ChrysalideProject/Binaries/Binary"); + if (result) + result = g_loaded_content_save(project->contents[i], xdoc, context, access); - for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++) - { - access_len = strlen("/ChrysalideProject/Binaries/Binary[position()=") + SIZE_T_MAXLEN + strlen("]") + 1; + free(access); - access = calloc(access_len, sizeof(char)); - snprintf(access, access_len, "/ChrysalideProject/Binaries/Binary[position()=%u]", i + 1); + g_object_unref(G_OBJECT(content)); - loader = g_binary_loader_new_from_xml(filename, access, result); + } - free(access); + g_mutex_unlock(&project->mutex); - queue = get_work_queue(); - g_work_queue_schedule_work(queue, G_DELAYED_WORK(loader), DEFAULT_WORK_GROUP); + /* Sauvegarde finale */ - } + if (result) + result = save_xml_file(xdoc, final); - if(xobject != NULL) - xmlXPathFreeObject(xobject); + if (result && filename != NULL) + { + if (project->filename != NULL) free(project->filename); + project->filename = strdup(filename); - /* Fin du chargement */ + } close_xml_file(xdoc, context); return result; -#endif +} + + +/****************************************************************************** +* * +* Paramètres : project = project à consulter. * +* * +* Description : Indique le chemin du fichier destiné à la sauvegarde. * +* * +* Retour : Chemin de fichier pour l'enregistrement ou NULL si indéfini. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const char *g_study_project_get_filename(const GStudyProject *project) +{ + return project->filename; } + +/* ---------------------------------------------------------------------------------- */ +/* INTEGRATION DE CONTENUS BINAIRES */ +/* ---------------------------------------------------------------------------------- */ + + /****************************************************************************** * * -* Paramètres : project = project à sauvegarder. * -* filename = nom de fichier à utiliser ou NULL pour l'existant.* +* Paramètres : project = projet dont le contenu est à compléter. * * * -* Description : Procède à l'enregistrement d'un projet donné. * +* Description : Prépare le suivi d'une nouvelle phase d'intégration. * * * -* Retour : true si l'enregistrement s'est déroule sans encombre. * +* Retour : Nouvelle structure de suivi prête à être complétée. * * * * Remarques : - * * * ******************************************************************************/ -bool g_study_project_save(GStudyProject *project, const char *filename) +static loading_params *g_study_project_prepare_content_loading(GStudyProject *project) { - return false; + loading_params *result; /* Trouvaille à retourner */ -#if 0 + assert(!g_mutex_trylock(&project->ld_mutex)); - bool result; /* Bilan à retourner */ - xmlDocPtr xdoc; /* Document XML à créer */ - xmlXPathContextPtr context; /* Contexte pour les recherches*/ - const char *final; /* Lieu d'enregistrement final */ - size_t i; /* Boucle de parcours */ - char *access; /* Chemin pour une sous-config.*/ + project->ld_params = (loading_params *)realloc(project->ld_params, + ++project->ld_count * sizeof(loading_params)); - result = create_new_xml_file(&xdoc, &context); + result = &project->ld_params[project->ld_count - 1]; - if (result) - result = (ensure_node_exist(xdoc, context, "/ChrysalideProject") != NULL); + return result; - final = filename != NULL ? filename : project->filename; +} + +/****************************************************************************** +* * +* Paramètres : project = projet dont le contenu est à compléter. * +* params = paramètres de chargemeent à supprimer. * +* * +* Description : Efface le suivi d'une phase d'intégration obsolète. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_study_project_destroy_content_loading(GStudyProject *project, loading_params *params) +{ + GContentExplorer *explorer; /* Explorateur de contenus */ + GContentResolver *resolver; /* Resolveur de contenus */ + size_t i; /* Boucle de parcours */ + size_t index; /* Indice des paramètres */ + + assert(!g_mutex_trylock(&project->ld_mutex)); - /* Enregistrement des binaires analysés */ + /* Supression des groupes de travail */ - for (i = 0; i < project->binaries_count && result; i++) + explorer = get_current_content_explorer(); + resolver = get_current_content_resolver(); + + if (params->exp_count == 1) { - asprintf(&access, "/ChrysalideProject/Binaries/Binary[position()=%zu]", i + 1); + g_content_resolver_delete_group(resolver, *params->exp_gid); + g_content_explorer_delete_group(explorer, *params->exp_gid); + } - result = g_loaded_binary_save(project->binaries[i]->binary, xdoc, context, access, final); + else + { + for (i = 0; i < params->exp_count; i++) + { + g_content_resolver_delete_group(resolver, *params->exp_gids[i]); + g_content_explorer_delete_group(explorer, *params->exp_gids[i]); + } - free(access); + free(params->exp_gids); } - /* Sauvegarde finale */ + g_object_unref(G_OBJECT(explorer)); + g_object_unref(G_OBJECT(resolver)); - result &= save_xml_file(xdoc, final); + /* Fermture de l'éventuel fichier XML de chargement */ - if (result && filename != NULL) + if (params->xdoc != NULL) + close_xml_file(params->xdoc, params->context); + + /* Réorganisation de la liste */ + + index = params - project->ld_params; + + if ((index + 1) < project->ld_count) + memmove(&project->ld_params[index], &project->ld_params[index + 1], + (project->ld_count - index - 1) * sizeof(loading_params)); + + project->ld_params = (loading_params *)realloc(project->ld_params, + --project->ld_count * sizeof(loading_params)); + +} + + +/****************************************************************************** +* * +* Paramètres : project = projet dont le contenu est à consulter. * +* gid = identifiant du groupe d'exploration recherché. * +* ptr = pointeur vers la valeur d'origine externe. * +* * +* Description : Retrouve les infos de chargements liées à une exploration. * +* * +* Retour : Informations trouvées ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static loading_params *g_study_project_find_exploration(GStudyProject *project, gid_t gid, const gid_t **ptr) +{ + loading_params *result; /* Trouvaille à retourner */ + const gid_t *value; /* Raccourci de confort */ + size_t i; /* Boucle de parcours #1 */ + size_t k; /* Boucle de parcours #2 */ + + assert(!g_mutex_trylock(&project->ld_mutex)); + + result = NULL; + + value = NULL; + + for (i = 0; i < project->ld_count && result == NULL; i++) { - if (project->filename != NULL) free(project->filename); - project->filename = strdup(filename); + if (project->ld_params[i].exp_count == 1) + { + value = project->ld_params[i].exp_gid; + + if (*value == gid) + result = &project->ld_params[i]; + + } + + else + for (k = 0; k < project->ld_params[i].exp_count && result == NULL; k++) + { + value = project->ld_params[i].exp_gids[k]; + + if (*value == gid) + result = &project->ld_params[i]; + + } } - close_xml_file(xdoc, context); + if (ptr != NULL) + { + assert(result == NULL || value != NULL); + *ptr = (result == NULL ? NULL : value); + } return result; -#endif - } /****************************************************************************** * * -* Paramètres : project = project à consulter. * +* Paramètres : project = projet dont le contenu est à compléter. * +* xdoc = structure XML en cours d'édition. * +* context = contexte à utiliser pour les recherches. * * * -* Description : Indique le chemin du fichier destiné à la sauvegarde. * +* Description : Assure l'intégration de contenus listés dans du XML. * * * -* Retour : Chemin de fichier pour l'enregistrement ou NULL si indéfini. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -const char *g_study_project_get_filename(const GStudyProject *project) +static void g_study_project_recover_binary_contents(GStudyProject *project, xmlDoc *xdoc, xmlXPathContext *context) { - return project->filename; + loading_params *params; /* Informations de chargement */ + xmlXPathObjectPtr xobject; /* Cible d'une recherche */ + size_t count; /* Nombre de contenus premiers */ + GContentExplorer *explorer; /* Explorateur de contenus */ + size_t explored; /* Qté. d'explorations lancées */ + size_t i; /* Boucle de parcours */ + char *access; /* Chemin pour un contenu */ + GBinContent *content; /* Contenu binaire retrouvé */ + + xobject = get_node_xpath_object(context, "/ChrysalideProject/RootContents/Content"); + + count = XPATH_OBJ_NODES_COUNT(xobject); + + if (count > 0) + { + explorer = get_current_content_explorer(); + + g_mutex_lock(&project->ld_mutex); + + params = g_study_project_prepare_content_loading(project); + + if (count > 1) + params->exp_gids = (const gid_t **)malloc(count * sizeof(gid_t *)); + + params->resolved = 0; + + params->xdoc = xdoc; + params->context = context; + + explored = 0; + + for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++) + { + asprintf(&access, "/ChrysalideProject/RootContents/Content[position()=%zu]", i + 1); + + content = g_binary_content_new_from_xml(context, access, project->filename); + + free(access); + + if (content == NULL) + { + log_variadic_message(LMT_ERROR, _("Unable to load the root content #%zu ; skipping..."), i); + continue; + } + + if (count == 1) + { + params->exp_gid = g_content_explorer_create_group(explorer, content); + explored++; + } + else + params->exp_gids[explored++] = g_content_explorer_create_group(explorer, content); + + g_object_unref(G_OBJECT(content)); + + } + + params->exp_count = explored; + + g_mutex_unlock(&project->ld_mutex); + + g_object_unref(G_OBJECT(explorer)); + + } + + if(xobject != NULL) + xmlXPathFreeObject(xobject); } @@ -415,9 +760,8 @@ const char *g_study_project_get_filename(const GStudyProject *project) * * * Paramètres : project = projet dont le contenu est à compléter. * * content = contenu binaire à mémoriser pour le projet. * -* state = état du contenu à conserver. * * * -* Description : Assure l'intégration d'un contenu binaire dans un projet. * +* Description : Assure l'intégration de contenus binaires dans un projet. * * * * Retour : - * * * @@ -425,77 +769,246 @@ const char *g_study_project_get_filename(const GStudyProject *project) * * ******************************************************************************/ -void g_study_project_add_binary_content(GStudyProject *project, GBinContent *content, ProjectContentState state) +void g_study_project_discover_binary_content(GStudyProject *project, GBinContent *content) { -#if 0 + loading_params *params; /* Informations de chargement */ + GContentExplorer *explorer; /* Explorateur de contenus */ - loaded_content *new; /* Nouveau contenu à définir */ + explorer = get_current_content_explorer(); - g_mutex_lock(&project->cnt_mutex); + g_mutex_lock(&project->ld_mutex); - project->contents = (loaded_content *)realloc(project->contents, - ++project->contents_count * sizeof(loaded_content)); + params = g_study_project_prepare_content_loading(project); - new = &project->contents[project->contents_count - 1]; + params->exp_gid = g_content_explorer_create_group(explorer, content); + params->exp_count = 1; - g_object_ref(G_OBJECT(content)); + params->resolved = 0; - new->content = content; - new->state = state; + params->xdoc = NULL; + params->context = NULL; - g_mutex_unlock(&project->cnt_mutex); + g_mutex_unlock(&project->ld_mutex); -#endif + g_object_unref(G_OBJECT(explorer)); } /****************************************************************************** * * -* Paramètres : project = projet dont le contenu est à compléter. * -* hash = empreinte du contenu à retrouver. * +* Paramètres : explorer = gestionnaire d'explorations à consulter. * +* gid = groupe d'exploration concerné. * +* project = projet avide des résultats des opérations. * * * -* Description : Recherche un contenu binaire du projet selon son empreinte. * +* Description : Note la fin d'une phase d'exploration de contenu. * * * -* Retour : Contenu avec propriété transférée ou NULL en cas d'échec. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GBinContent *g_study_project_find_binary_content_by_hash(GStudyProject *project, const char *hash) +static void on_new_content_explored(GContentExplorer *explorer, gid_t gid, GStudyProject *project) { - return NULL; + const gid_t *gid_ptr; /* Référence vers l'origine */ + loading_params *params; /* Informations de chargement */ + GBinContent **available; /* Contenus binaires présents */ + size_t count; /* Quantité de ces contenus */ + const wgroup_id_t *wid; /* Groupe de tâches */ + GContentResolver *resolver; /* Resolveur de contenus */ + size_t i; /* Boucle de parcours */ -#if 0 + g_mutex_lock(&project->ld_mutex); + + params = g_study_project_find_exploration(project, gid, &gid_ptr); + + /* S'il s'agit bien d'une exploration nouvelle */ + if (params != NULL) + { + wid = g_content_explorer_get_group_work_id(explorer, gid); + + available = g_content_explorer_get_all(explorer, gid, &count); + assert(count > 0); + + resolver = get_current_content_resolver(); + + g_content_resolver_create_group(resolver, wid, gid_ptr, available, count); + + g_object_unref(G_OBJECT(resolver)); + + for (i = 0; i < count; i++) + g_object_unref(G_OBJECT(available[i])); - GBinContent *result; /* Trouvaille à retourner */ + free(available); + + } + + g_mutex_unlock(&project->ld_mutex); + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = gestionnaire de résolutions à consulter. * +* gid = groupe d'exploration concerné. * +* project = projet avide des résultats des opérations. * +* * +* Description : Note la fin d'une phase de resolution de contenu. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void on_new_content_resolved(GContentResolver *resolver, gid_t gid, GStudyProject *project) +{ + loading_params *params; /* Informations de chargement */ + GLoadedContent **available; /* Contenus chargés valables */ + size_t count; /* Quantité de ces contenus */ size_t i; /* Boucle de parcours */ - GBinContent *iter; /* Contenu binaire analysé */ - const gchar *other; /* Autre empreinte à comparer */ + GBinContent *content; /* Contenu brut à manipuler */ + const gchar *hash; /* Empreinte d'un contenu */ + const char *format; /* Format associé à un élément */ + char *access; /* Chemin pour une sous-config.*/ + xmlXPathObjectPtr xobject; /* Cible d'une recherche */ + bool status; /* Bilan d'une restauration */ - result = NULL; + g_mutex_lock(&project->ld_mutex); - g_mutex_lock(&project->cnt_mutex); + params = g_study_project_find_exploration(project, gid, NULL); - for (i = 0; i < project->contents_count && result == NULL; i++) + /* S'il s'agit bien d'une exploration nouvelle */ + if (params != NULL) { - iter = project->contents[i].content; - other = g_binary_content_get_checksum(iter); + available = g_content_resolver_get_all(resolver, gid, &count); - if (strcmp(hash, other) == 0) + /* Rechargement à partir d'XML ? */ + if (params->xdoc != NULL) { - g_object_ref(G_OBJECT(iter)); - result = iter; + assert(params->context != NULL); + + for (i = 0; i < count; i++) + { + content = g_loaded_content_get_content(available[i]); + hash = g_binary_content_get_checksum(content); + g_object_unref(G_OBJECT(content)); + + format = g_loaded_content_get_format_name(available[i]); + + asprintf(&access, "/ChrysalideProject/LoadedContents/Content[@hash='%s' and @format='%s']", + hash, format); + + xobject = get_node_xpath_object(params->context, access); + + if (XPATH_OBJ_NODES_COUNT(xobject) > 0) + { + + status = g_loaded_content_restore(available[i], params->xdoc, params->context, access); + + if (!status) + log_variadic_message(LMT_ERROR, + _("Unable to reload binary from XML (hash=%s) ; skipping..."), hash); + + else + { + /** + * S'il s'agit des résultats de la dernière exploration, + * alors les groupes contenant les éléments chargés vont + * être libéré, potentiellement pendant l'analyse. + * + * On temporise en incrémentant les références. + */ + g_object_ref(G_OBJECT(available[i])); + + g_signal_connect(available[i], "analyzed", G_CALLBACK(on_loaded_content_analyzed), project); + + g_loaded_content_analyze(available[i]); + + } + + } + + free(access); + + if(xobject != NULL) + xmlXPathFreeObject(xobject); + + g_object_unref(G_OBJECT(available[i])); + + } + + } + + /* Découverte(s) initiale(s) ? */ + else + { + for (i = 0; i < count; i++) + { + /** + * S'il s'agit des résultats de la dernière exploration, + * alors les groupes contenant les éléments chargés vont + * être libéré, potentiellement pendant l'analyse. + * + * On temporise en incrémentant les références. + */ + g_object_ref(G_OBJECT(available[i])); + + g_signal_connect(available[i], "analyzed", G_CALLBACK(on_loaded_content_analyzed), project); + + g_loaded_content_analyze(available[i]); + + g_object_unref(G_OBJECT(available[i])); + + } + } + /* Dans tous les cas... */ + if (available != NULL) + free(available); + + /* Si c'était la dernière résolution... */ + if (++params->resolved == params->exp_count) + g_study_project_destroy_content_loading(project, params); + } - g_mutex_unlock(&project->cnt_mutex); + g_mutex_unlock(&project->ld_mutex); - return result; +} -#endif + +/****************************************************************************** +* * +* Paramètres : content = contenu chargé et analysé. * +* success = bilan d'une analyse menée. * +* project = projet avide des résultats des opérations. * +* * +* Description : Réceptionne la recette d'une analyse de contenu. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void on_loaded_content_analyzed(GLoadedContent *content, gboolean success, GStudyProject *project) +{ + const char *desc; /* Description du contenu */ + + if (success) + g_study_project_attach_content(project, content); + + else + { + desc = g_loaded_content_describe(content, true); + log_variadic_message(LMT_ERROR, _("Failed to load '%s'"), desc); + } + + g_object_ref(G_OBJECT(content)); } @@ -521,6 +1034,7 @@ void g_study_project_attach_content(GStudyProject *project, GLoadedContent *cont ++project->count * sizeof(GLoadedContent *)); project->contents[project->count - 1] = content; + g_object_ref(G_OBJECT(content)); g_mutex_unlock(&project->mutex); @@ -732,7 +1246,7 @@ void push_project_into_recent_list(const GStudyProject *project) recent.mime_type = "application/chrysalide.project"; recent.app_name = "Chrysalide"; - recent.app_exec = "chrysalide %f"; + recent.app_exec = "chrysalide -p %f"; gtk_recent_manager_add_full(manager, qualified, &recent); diff --git a/src/analysis/project.h b/src/analysis/project.h index c24ee43..2ee178b 100644 --- a/src/analysis/project.h +++ b/src/analysis/project.h @@ -28,20 +28,23 @@ #include -#include "binary.h" #include "loaded.h" +#define PROJECT_XML_VERSION "2" + + + /* ------------------------- DEFINITION D'UN PROJET INTERNE ------------------------- */ -#define G_TYPE_STUDY_PROJECT g_study_project_get_type() -#define G_STUDY_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_study_project_get_type(), GStudyProject)) -#define G_IS_STUDY_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_study_project_get_type())) -#define G_STUDY_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_STUDY_PROJECT, GStudyProjectClass)) -#define G_IS_STUDY_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_STUDY_PROJECT)) -#define G_STUDY_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_STUDY_PROJECT, GStudyProjectClass)) +#define G_TYPE_STUDY_PROJECT g_study_project_get_type() +#define G_STUDY_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_STUDY_PROJECT, GStudyProject)) +#define G_IS_STUDY_PROJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_STUDY_PROJECT)) +#define G_STUDY_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_STUDY_PROJECT, GStudyProjectClass)) +#define G_IS_STUDY_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_STUDY_PROJECT)) +#define G_STUDY_PROJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_STUDY_PROJECT, GStudyProjectClass)) /* Projet d'étude regroupant les binaires analysés (instance) */ @@ -66,22 +69,13 @@ bool g_study_project_save(GStudyProject *, const char *); /* Indique le chemin du fichier destiné à la sauvegarde. */ const char *g_study_project_get_filename(const GStudyProject *); -/* Etat d'un contenu binaire du projet */ -typedef enum _ProjectContentState -{ - PCS_ROOT, /* Contenu principal */ - PCS_INTERNAL, /* Contenu dérivé */ - PCS_ATTACHED, /* Contenu complémentaire */ - PCS_COUNT -} ProjectContentState; +/* ------------------------ INTEGRATION DE CONTENUS BINAIRES ------------------------ */ -/* Assure l'intégration d'un contenu binaire dans un projet. */ -void g_study_project_add_binary_content(GStudyProject *, GBinContent *, ProjectContentState); -/* Recherche un contenu binaire du projet selon son empreinte. */ -GBinContent *g_study_project_find_binary_content_by_hash(GStudyProject *, const char *); +/* Assure l'intégration de contenus binaires dans un projet. */ +void g_study_project_discover_binary_content(GStudyProject *, GBinContent *); /* Attache un contenu donné à un projet donné. */ void g_study_project_attach_content(GStudyProject *, GLoadedContent *); @@ -111,5 +105,4 @@ void push_project_into_recent_list(const GStudyProject *); - #endif /* _PROJECT_H */ diff --git a/src/core/core.c b/src/core/core.c index 2d790ce..1b6b033 100644 --- a/src/core/core.c +++ b/src/core/core.c @@ -64,6 +64,8 @@ bool load_all_basic_components(void) static bool result = false; /* Bilan à retourner */ char *cfgdir; /* Répertoire de configuration */ GWorkQueue *queue; /* Singleton pour tâches */ + GContentExplorer *explorer; /* Explorateur de contenus */ + GContentResolver *resolver; /* Résolveur de contenus */ /** * On mémorise les passages réussis. @@ -97,6 +99,12 @@ bool load_all_basic_components(void) queue = g_work_queue_new(); set_work_queue(queue); + explorer = g_content_explorer_new(); + set_current_content_explorer(explorer); + + resolver = g_content_resolver_new(); + set_current_content_resolver(resolver); + result &= init_segment_content_hash_table(); result &= load_hard_coded_processors_definitions(); diff --git a/src/core/global.c b/src/core/global.c index b227a5d..decf300 100644 --- a/src/core/global.c +++ b/src/core/global.c @@ -31,6 +31,12 @@ /* Gestionnaire de tâches parallèles */ static GWorkQueue *_queue = NULL; +/* Explorateur de contenus */ +static GContentExplorer *_explorer = NULL; + +/* Résolveur de contenus */ +static GContentResolver *_resolver = NULL; + /* Projet global actif */ static GStudyProject *_project = NULL; @@ -81,6 +87,96 @@ GWorkQueue *get_work_queue(void) /****************************************************************************** * * +* Paramètres : explorer = éventuelle adresse du nouveau gestionnaire. * +* * +* Description : Définit l'adresse de l'explorateur de contenus courant. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void set_current_content_explorer(GContentExplorer *explorer) +{ + if (_explorer != NULL) + g_object_unref(G_OBJECT(_explorer)); + + _explorer = explorer; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit l'adresse de l'explorateur de contenus courant. * +* * +* Retour : Adresse de l'explorateur global ou NULL si aucun (!). * +* * +* Remarques : - * +* * +******************************************************************************/ + +GContentExplorer *get_current_content_explorer(void) +{ + assert(_explorer != NULL); + + g_object_ref(G_OBJECT(_explorer)); + + return _explorer; + +} + + +/****************************************************************************** +* * +* Paramètres : resolver = éventuelle adresse du nouveau gestionnaire. * +* * +* Description : Définit l'adresse du résolveur de contenus courant. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void set_current_content_resolver(GContentResolver *resolver) +{ + if (_resolver != NULL) + g_object_unref(G_OBJECT(_resolver)); + + _resolver = resolver; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit l'adresse du résolveur de contenus courant. * +* * +* Retour : Adresse du résolveur global ou NULL si aucun (!). * +* * +* Remarques : - * +* * +******************************************************************************/ + +GContentResolver *get_current_content_resolver(void) +{ + assert(_resolver != NULL); + + g_object_ref(G_OBJECT(_resolver)); + + return _resolver; + +} + + +/****************************************************************************** +* * * Paramètres : project = éventuelle adresse du nouveau projet principal. * * * * Description : Définit l'adresse du projet courant. * @@ -112,7 +208,7 @@ void set_current_project(GStudyProject *project) /****************************************************************************** * * -* Paramètres : project = éventuel adresse à renvoyer désormais. * +* Paramètres : - * * * * Description : Fournit l'adresse du projet courant. * * * diff --git a/src/core/global.h b/src/core/global.h index 6cf029f..5f01909 100644 --- a/src/core/global.h +++ b/src/core/global.h @@ -25,6 +25,7 @@ #define _CORE_GLOBAL_H +#include "../analysis/loading.h" #include "../analysis/project.h" #include "../glibext/delayed.h" @@ -36,6 +37,18 @@ void set_work_queue(GWorkQueue *); /* Fournit le gestionnaire de traitements parallèles courant. */ GWorkQueue *get_work_queue(void); +/* Définit l'adresse de l'explorateur de contenus courant. */ +void set_current_content_explorer(GContentExplorer *); + +/* Fournit l'adresse de l'explorateur de contenus courant. */ +GContentExplorer *get_current_content_explorer(void); + +/* Définit l'adresse du résolveur de contenus courant. */ +void set_current_content_resolver(GContentResolver *); + +/* Fournit l'adresse du résolveur de contenus courant. */ +GContentResolver *get_current_content_resolver(void); + /* Définit l'adresse du projet courant. */ void set_current_project(GStudyProject *); diff --git a/src/format/format-int.h b/src/format/format-int.h index 78da2f6..37dac0f 100644 --- a/src/format/format-int.h +++ b/src/format/format-int.h @@ -37,6 +37,12 @@ /* ------------------------ TRAITEMENT INDIVIDUEL DE FORMATS ------------------------ */ +/* Indique la désignation interne du format. */ +typedef const char * (* format_get_name_fc) (const GBinFormat *); + +/*Assure l'interprétation d'un format en différé. */ +typedef bool (* format_analyze_fc) (GBinFormat *, wgroup_id_t, GtkStatusStack *); + /* Indique le boutisme employé par le format binaire analysé. */ typedef SourceEndian (* format_get_endian_fc) (const GBinFormat *); @@ -109,6 +115,10 @@ struct _GBinFormatClass { GObjectClass parent; /* A laisser en premier */ + format_get_name_fc get_name; /* Désignation interne */ + + format_analyze_fc analyze; /* Interprétation du format */ + format_get_endian_fc get_endian; /* Boutisme employé */ format_complete_analysis_fc complete; /* Terminaison d'analyse */ diff --git a/src/format/format.c b/src/format/format.c index 29709c9..675fd2f 100644 --- a/src/format/format.c +++ b/src/format/format.c @@ -262,6 +262,54 @@ GBinContent *g_binary_format_get_content(const GBinFormat *format) * * * Paramètres : format = description de l'exécutable à consulter. * * * +* Description : Indique la désignation interne du format. * +* * +* Retour : Description du format. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const char *g_binary_format_get_name(const GBinFormat *format) +{ + const char *result; /* Désignation à retourner */ + + result = G_BIN_FORMAT_GET_CLASS(format)->get_name(format); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = format chargé dont l'analyse est lancée. * +* gid = groupe de travail dédié. * +* status = barre de statut à tenir informée. * +* * +* Description : Assure l'interprétation d'un format en différé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_binary_format_analyze(GBinFormat *format, wgroup_id_t gid, GtkStatusStack *status) +{ + bool result; /* Bilan à retourner */ + + result = G_BIN_FORMAT_GET_CLASS(format)->analyze(format, gid, status); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* * * Description : Indique le boutisme employé par le format binaire analysé. * * * * Retour : Boutisme associé au format. * diff --git a/src/format/format.h b/src/format/format.h index 806c14f..982907c 100644 --- a/src/format/format.h +++ b/src/format/format.h @@ -33,7 +33,7 @@ #include "symbol.h" #include "../analysis/content.h" #include "../arch/context.h" -#include "../gtkext/gtkstatusstack.h" +#include "../glibext/delayed.h" @@ -58,6 +58,12 @@ GType g_binary_format_get_type(void); /* Fournit une référence vers le contenu binaire analysé. */ GBinContent *g_binary_format_get_content(const GBinFormat *); +/* Indique la désignation interne du format. */ +const char *g_binary_format_get_name(const GBinFormat *); + +/* Assure l'interprétation d'un format en différé. */ +bool g_binary_format_analyze(GBinFormat *, wgroup_id_t, GtkStatusStack *); + /* Indique le boutisme employé par le format binaire analysé. */ SourceEndian g_binary_format_get_endianness(const GBinFormat *); diff --git a/src/glibext/delayed-int.h b/src/glibext/delayed-int.h index 2e1b4be..6ffff75 100644 --- a/src/glibext/delayed-int.h +++ b/src/glibext/delayed-int.h @@ -21,6 +21,10 @@ */ +#ifndef _GLIBEXT_DELAYED_INT_H +#define _GLIBEXT_DELAYED_INT_H + + #include "delayed.h" @@ -65,3 +69,7 @@ struct _GDelayedWorkClass #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) + + + +#endif /* _GLIBEXT_DELAYED_INT_H */ diff --git a/src/glibext/delayed.c b/src/glibext/delayed.c index b7793cd..78c8a10 100644 --- a/src/glibext/delayed.c +++ b/src/glibext/delayed.c @@ -123,6 +123,9 @@ static void g_work_group_schedule(GWorkGroup *, GDelayedWork *); /* Assure le traitement en différé. */ static void *g_work_group_process(GWorkGroup *); +/* Détermine si le groupe est vide de toute programmation. */ +static bool g_work_group_is_empty(GWorkGroup *); + /* Attend que toutes les tâches d'un groupe soient traitées. */ static void g_work_group_wait_for_completion(GWorkGroup *, GWorkQueue *); @@ -607,6 +610,46 @@ static void *g_work_group_process(GWorkGroup *group) /****************************************************************************** * * +* Paramètres : group = gestionnaire des actions à consulter. * +* * +* Description : Détermine si le groupe est vide de toute programmation. * +* * +* Retour : Etat du groupe de travail. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_work_group_is_empty(GWorkGroup *group) +{ + bool result; /* Etat à retourner */ + + /** + * Pour que le résultat soit exploitable, il ne doit pas varier + * en dehors de la zone couverte par le verrou du groupe avant + * son utilisation par l'appelant. + * + * Il doit donc logiquement y avoir un autre verrou en amont et, + * comme à priori on ne devrait pas bloquer le groupe principal + * pour un traitement particulier, on ajoute ici une simple vérification + * de bonne pratique. + */ + + assert(group->id != DEFAULT_WORK_GROUP); + + g_mutex_lock(&group->mutex); + + result = dl_list_empty(group->works); + + g_mutex_unlock(&group->mutex); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : group = groupe dont les conclusions sont attendues. * * queue = queue d'appartenance pour les appels externes. * * * @@ -911,6 +954,13 @@ wgroup_id_t g_work_queue_define_work_group(GWorkQueue *queue) void g_work_queue_delete_work_group(GWorkQueue *queue, wgroup_id_t id) { size_t i; /* Boucle de parcours */ +#ifndef NDEBUG + bool found; /* Repérage du groupe visé */ +#endif + +#ifndef NDEBUG + found = false; +#endif g_mutex_lock(&queue->mutex); @@ -924,11 +974,15 @@ void g_work_queue_delete_work_group(GWorkQueue *queue, wgroup_id_t id) queue->groups = (GWorkGroup **)realloc(queue->groups, queue->groups_count * sizeof(GWorkGroup *)); +#ifndef NDEBUG + found = true; +#endif + break; } - assert(i < queue->groups_count); + assert(found); g_mutex_unlock(&queue->mutex); @@ -1010,6 +1064,40 @@ static GWorkGroup *g_work_queue_find_group_for_id(GWorkQueue *queue, wgroup_id_t * Paramètres : queue = gestionnaire de l'ensemble des groupes de travail. * * id = identifiant d'un groupe de travail. * * * +* Description : Détermine si un groupe est vide de toute programmation. * +* * +* Retour : Etat du groupe de travail. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_work_queue_is_empty(GWorkQueue *queue, wgroup_id_t id) +{ + bool result; /* Etat à retourner */ + GWorkGroup *group; /* Groupe de travail à attendre*/ + + group = g_work_queue_find_group_for_id(queue, id); + + if (group != NULL) + { + result = g_work_group_is_empty(group); + g_object_unref(G_OBJECT(group)); + } + + else + result = true; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : queue = gestionnaire de l'ensemble des groupes de travail. * +* id = identifiant d'un groupe de travail. * +* * * Description : Attend que toutes les tâches d'un groupe soient traitées. * * * * Retour : - * diff --git a/src/glibext/delayed.h b/src/glibext/delayed.h index 7c620e6..ab43640 100644 --- a/src/glibext/delayed.h +++ b/src/glibext/delayed.h @@ -101,6 +101,9 @@ void g_work_queue_delete_work_group(GWorkQueue *, wgroup_id_t); /* Place une nouvelle tâche en attente. */ void g_work_queue_schedule_work(GWorkQueue *, GDelayedWork *, wgroup_id_t); +/* Détermine si un groupe est vide de toute programmation. */ +bool g_work_queue_is_empty(GWorkQueue *, wgroup_id_t); + /* Attend que toutes les tâches d'un groupe soient traitées. */ void g_work_queue_wait_for_completion(GWorkQueue *, wgroup_id_t); diff --git a/src/gui/editem-int.h b/src/gui/editem-int.h index a70cc87..801e54c 100644 --- a/src/gui/editem-int.h +++ b/src/gui/editem-int.h @@ -32,6 +32,7 @@ #include +#include "../analysis/project.h" #include "../common/dllist.h" #include "../gtkext/gtkdisplaypanel.h" diff --git a/src/gui/editor.c b/src/gui/editor.c index 7047f32..ea2fe1f 100644 --- a/src/gui/editor.c +++ b/src/gui/editor.c @@ -1608,7 +1608,7 @@ static void notify_paned_handle_position_change(GObject *obj, GParamSpec *pspec, * Remarques : - * * * ******************************************************************************/ - +#include "../glibext/signal.h" static void notify_editor_project_change(GStudyProject *project, bool new) { @@ -1616,7 +1616,9 @@ static void notify_editor_project_change(GStudyProject *project, bool new) { - g_signal_connect(project, "content-added", G_CALLBACK(on_editor_loaded_content_added), NULL); + g_signal_connect_to_main(project, "content-added", G_CALLBACK(on_editor_loaded_content_added), NULL, + g_cclosure_marshal_VOID__OBJECT); + @@ -1630,8 +1632,8 @@ static void notify_editor_project_change(GStudyProject *project, bool new) g_study_project_hide(project); - - g_signal_handlers_disconnect_by_func(project, G_CALLBACK(on_editor_loaded_content_added), NULL); + // FIXME + //g_signal_handlers_disconnect_by_func(project, G_CALLBACK(on_editor_loaded_content_added), NULL); } diff --git a/src/gui/menus/project.c b/src/gui/menus/project.c index 424a506..5a28a7e 100644 --- a/src/gui/menus/project.c +++ b/src/gui/menus/project.c @@ -286,8 +286,6 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar) free(dir); } - g_object_unref(G_OBJECT(project)); - if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); @@ -296,7 +294,7 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar) if (content != NULL) { - qck_study_new_content(content, PCS_ROOT); + g_study_project_discover_binary_content(project, content); g_object_unref(G_OBJECT(content)); } @@ -304,6 +302,8 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar) } + g_object_unref(G_OBJECT(project)); + gtk_widget_destroy(dialog); } diff --git a/src/main.c b/src/main.c index 19b0544..626cae8 100644 --- a/src/main.c +++ b/src/main.c @@ -418,18 +418,21 @@ static gboolean load_last_project(GGenConfig *cfg) static int open_binaries(char **files, int count) { int result; /* Bilan à retourner */ + GStudyProject *project; /* Projet courant à compléter */ int i; /* Boucle de parcours */ GBinContent *content; /* Contenu binaire à charger */ result = EXIT_SUCCESS; + project = get_current_project(); + for (i = 0; i < count && result == EXIT_SUCCESS; i++) { content = g_file_content_new(files[i]); if (content != NULL) { - qck_study_new_content(content, PCS_ROOT); + g_study_project_discover_binary_content(project, content); g_object_unref(G_OBJECT(content)); } @@ -438,6 +441,8 @@ static int open_binaries(char **files, int count) } + g_object_unref(G_OBJECT(project)); + return result; } diff --git a/src/plugins/pglist.h b/src/plugins/pglist.h index d406cc8..4c8194d 100644 --- a/src/plugins/pglist.h +++ b/src/plugins/pglist.h @@ -85,14 +85,20 @@ GPluginModule **get_all_plugins_for_action(PluginAction, size_t *); while (0) -/* DPS_FORMAT */ -//#define find_matching_format() -#define handle_binary_format(a, f, s) \ + +/* DPS_CONTENT */ + +#define handle_binary_content(a, c, i, s) \ + process_all_plugins_for(a, g_plugin_module_handle_binary_content, c, i, s) + +/* DPS_FORMAT */ + +#define handle_binary_format(a, f, s) \ process_all_plugins_for(a, g_plugin_module_handle_binary_format, f, s) -#define preload_binary_format(a, f, i, s) \ +#define preload_binary_format(a, f, i, s) \ process_all_plugins_for(a, g_plugin_module_preload_binary_format, f, i, s) /* DPS_DISASSEMBLY */ diff --git a/src/plugins/plugin-def.h b/src/plugins/plugin-def.h index ed09e91..c32c9e3 100644 --- a/src/plugins/plugin-def.h +++ b/src/plugins/plugin-def.h @@ -79,8 +79,9 @@ typedef uint32_t plugin_action_t; /* DPC_BINARY_PROCESSING */ -#define DPS_FORMAT DEFINE_PLUGIN_SUB_CATEGORY(0) -#define DPS_DISASSEMBLY DEFINE_PLUGIN_SUB_CATEGORY(1) +#define DPS_CONTENT DEFINE_PLUGIN_SUB_CATEGORY(0) +#define DPS_FORMAT DEFINE_PLUGIN_SUB_CATEGORY(1) +#define DPS_DISASSEMBLY DEFINE_PLUGIN_SUB_CATEGORY(2) // GUI -> project // binary loaded @@ -111,6 +112,16 @@ typedef enum _PluginAction PGA_PLUGIN_EXIT = DPC_BASIC | DPS_PG_MANAGEMENT | DEFINE_PLUGIN_ACTION(1), /** + * DPC_BINARY_PROCESSING | DPS_CONTENT + */ + + /* Exploration de contenus binaires */ + PGA_CONTENT_EXPLORER = DPC_BINARY_PROCESSING | DPS_CONTENT | DEFINE_PLUGIN_ACTION(0), + + /* Conversion de contenus binaires en contenus chargés */ + PGA_CONTENT_RESOLVER = DPC_BINARY_PROCESSING | DPS_CONTENT | DEFINE_PLUGIN_ACTION(1), + + /** * DPC_BINARY_PROCESSING | DPS_FORMAT */ diff --git a/src/plugins/plugin-int.h b/src/plugins/plugin-int.h index 213ae92..5fae2de 100644 --- a/src/plugins/plugin-int.h +++ b/src/plugins/plugin-int.h @@ -46,8 +46,8 @@ typedef void (* pg_process_disassembly_fc) (const GPluginModule *, PluginAction, -/* Indique si le format peut être pris en charge ici. */ -//typedef bool (* pg_format_is_matching) (const GPluginModule *, GBinContent **); +/* Procède à une opération liée à un contenu binaire. */ +typedef void (* pg_handle_content) (const GPluginModule *, PluginAction, GBinContent *, gid_t, GtkStatusStack *); /* Procède à une opération liée au format de fichier uniquement. */ typedef bool (* pg_handle_format) (const GPluginModule *, PluginAction, GBinFormat *, GtkStatusStack *); @@ -115,7 +115,7 @@ struct _GPluginModule //execute_on_debugger_fc handle_debugger; /* Action liée à un débogueur */ - //pg_format_is_matching is_matching; /* Recherche de correspondance */ + pg_handle_content handle_content; /* Explorations ou résolutions */ pg_handle_format handle_format; /* Manipulation du format */ pg_preload_format preload_format; /* Préchargement d'un format */ diff --git a/src/plugins/plugin.c b/src/plugins/plugin.c index d9072d7..02684d6 100644 --- a/src/plugins/plugin.c +++ b/src/plugins/plugin.c @@ -260,6 +260,28 @@ GPluginModule *g_plugin_module_new(const gchar *filename) switch (sub) { + case DPS_CONTENT: + + switch (action) + { + case PGA_CONTENT_EXPLORER: + case PGA_CONTENT_RESOLVER: + if (!load_plugin_symbol(result->module, + "chrysalide_plugin_handle_binary_content", + &result->handle_content)) + goto bad_plugin; + break; + + default: + log_variadic_message(LMT_WARNING, + _("Unknown action '0x%02x' in plugin '%s'..."), + result->interface->actions[i], filename); + break; + + } + + break; + case DPS_FORMAT: switch (action) @@ -684,6 +706,29 @@ void g_plugin_module_log_variadic_message(const GPluginModule *plugin, LogMessag /****************************************************************************** * * +* Paramètres : plugin = greffon à manipuler. * +* action = type d'action attendue. * +* content = contenu binaire à traiter. * +* gid = identifiant du groupe de traitement. * +* status = barre de statut à tenir informée. * +* * +* Description : Procède à une opération liée à un contenu binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_plugin_module_handle_binary_content(const GPluginModule *plugin, PluginAction action, GBinContent *content, gid_t gid, GtkStatusStack *status) +{ + return plugin->handle_content(plugin, action, content, gid, status); + +} + + +/****************************************************************************** +* * * Paramètres : plugin = greffon à manipuler. * * action = type d'action attendue. * * format = format de binaire à manipuler pendant l'opération. * diff --git a/src/plugins/plugin.h b/src/plugins/plugin.h index d86682c..9ac6aa6 100644 --- a/src/plugins/plugin.h +++ b/src/plugins/plugin.h @@ -91,7 +91,8 @@ bool g_plugin_module_resolve_dependencies(GPluginModule *, GPluginModule **, siz /* Termine le chargement du greffon préparé. */ bool g_plugin_module_load(GPluginModule *, GPluginModule **, size_t); - +/* Procède à une opération liée à un contenu binaire. */ +void g_plugin_module_handle_binary_content(const GPluginModule *, PluginAction, GBinContent *, gid_t, GtkStatusStack *); /* Procède à une opération liée au format de fichier uniquement. */ bool g_plugin_module_handle_binary_format(const GPluginModule *, PluginAction, GBinFormat *, GtkStatusStack *); -- cgit v0.11.2-87-g4458