Handled Dalvik exception handlers in the graphic view.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@285 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

21 files changed, 681 insertions, 50 deletions

diff --git a/src/analysis/disass/links.c b/src/analysis/disass/links.c
index 4d799fc..7cc3c27 100644
--- a/src/analysis/disass/links.c
+++ b/src/analysis/disass/links.c
@@ -50,12 +50,14 @@ void establish_links_between_lines(GArchInstruction *list, GBinRoutine **routine
     vmpa_t addr;                            /* Adresse référencée          */
     InstructionLinkType type;               /* Type de référence           */
     GArchInstruction *target;               /* Ligne visée par la référence*/
+    GArchInstruction *prev;                 /* Instruction précédente      */
 
     for (i = 0; i < count; i++)
     {
         start = g_binary_routine_get_address(routines[i]);
         end = start + g_binary_routine_get_size(routines[i]);
 
+        /* Définition de toutes les destinations */
         for (iter = g_arch_instruction_find_by_address(list, start, true);
              iter != NULL;
              iter = g_arch_instruction_get_next_iter(list, iter, end))
@@ -104,10 +106,39 @@ void establish_links_between_lines(GArchInstruction *list, GBinRoutine **routine
 
                     break;
 
+                default:
+                    /**
+                     * Note pour GCC : à ce stade du désassemblage, ILT_CATCH_EXCEPTION
+                     * ne peut être présente, car ne provenant que de greffons.
+                     * Pour ILT_EXEC_FLOW, sa seule insertion est ici, plus bas.
+                     */
+                    break;
+
             }
 
         }
 
+        /* Rattachement de deux blocs selon le flux normal */
+
+        iter = g_arch_instruction_find_by_address(list, start, true);
+
+        for (iter = g_arch_instruction_get_next_iter(list, iter, end);
+             iter != NULL;
+             iter = g_arch_instruction_get_next_iter(list, iter, end))
+        {
+            if (!g_arch_instruction_has_sources(iter))
+                continue;
+
+            prev = g_arch_instruction_get_prev_iter(list, iter);
+
+            if (g_arch_instruction_is_return(prev))
+                continue;
+
+            if (!g_arch_instruction_has_destinations(prev))
+                g_arch_instruction_link_with(prev, iter, ILT_EXEC_FLOW);
+
+        }
+
         gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / count);
 
     }
diff --git a/src/analysis/type-int.h b/src/analysis/type-int.h
new file mode 100644
index 0000000..a26deeb
--- /dev/null
+++ b/src/analysis/type-int.h
@@ -0,0 +1,67 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * type-int.h - prototypes pour la définition interne des types de données
+ *
+ * Copyright (C) 2012 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_TYPE_INT_H
+#define _ANALYSIS_TYPE_INT_H
+
+
+#include "type.h"
+
+
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef GDataType * (* type_dup_fc) (const GDataType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef char * (* type_to_string_fc) (const GDataType *);
+
+/* Procède à l'impression de la description d'un type. */
+typedef void (* output_type_fc) (const GDataType *, GLangOutput *, GBufferLine *, bool, bool);
+
+
+/* Description de type quelconque (instance) */
+struct _GDataType
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    type_dup_fc dup;                        /* Copie d'instance existante  */
+    type_to_string_fc to_string;            /* Conversion au format texte  */
+    output_type_fc output;                  /* Impression à l'écran        */
+
+    GDataType *namespace;                   /* Espace de noms / classe     */
+    TypeQualifier qualifiers;               /* Eventuels qualificatifs     */
+
+    GTypesManager *manager;                 /* Gestionnaire global         */
+
+};
+
+/* Description de type quelconque (classe) */
+struct _GDataTypeClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+
+#endif  /* _ANALYSIS_TYPE_INT_H */
diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h
index e323d6c..c89a51b 100644
--- a/src/arch/instruction-int.h
+++ b/src/arch/instruction-int.h
@@ -83,6 +83,7 @@ struct _GArchInstructionClass
 };
 
 
+#define ainstr_list_prev_iter(iter, head) dl_list_prev_iter(iter, head, GArchInstruction, flow)
 #define ainstr_list_next_iter(iter, head) dl_list_next_iter(iter, head, GArchInstruction, flow)
 #define ainstr_list_add_tail(new, head) dl_list_add_tail(new, head, GArchInstruction, flow)
 #define ainstr_list_for_each(pos, head) dl_list_for_each(pos, head, GArchInstruction, flow)
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index b553aec..98d7c85 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -381,7 +381,9 @@ bool g_arch_instruction_has_sources(const GArchInstruction *instr)
 
 bool g_arch_instruction_has_destinations(const GArchInstruction *instr)
 {
-    return (instr->to_count > 1 || (instr->to_count == 1 && instr->links_type[0] != ILT_CALL));
+    /* FIXME !? */
+    //return (instr->to_count > 1 || (instr->to_count == 1 && instr->links_type[0] != ILT_CALL));
+    return (instr->to_count > 0);
 
 }
 
@@ -607,6 +609,30 @@ void g_arch_instruction_add_to_list(GArchInstruction **list, GArchInstruction *i
 *                                                                             *
 *  Paramètres  : list = liste d'instructions à consulter.                     *
 *              : iter = position actuelle dans la liste.                      *
+*                                                                             *
+*  Description : Fournit l'élement suivant un autre pour un parcours.         *
+*                                                                             *
+*  Retour      : Elément suivant ou NULL si aucun.                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GArchInstruction *g_arch_instruction_get_prev_iter(const GArchInstruction *list, const GArchInstruction *iter)
+{
+    GArchInstruction *result;               /* Elément suivant à renvoyer  */
+
+    result = ainstr_list_prev_iter(iter, list);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : list = liste d'instructions à consulter.                     *
+*              : iter = position actuelle dans la liste.                      *
 *                max  = adresse marquant la limite (exclue) du parcours.      *
 *                                                                             *
 *  Description : Fournit l'élement suivant un autre pour un parcours.         *
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
index efd2b75..a4e26d4 100644
--- a/src/arch/instruction.h
+++ b/src/arch/instruction.h
@@ -42,10 +42,12 @@
 typedef enum _InstructionLinkType
 {
     ILT_NONE,                               /* Aucune instruction visée    */
+    ILT_EXEC_FLOW,                          /* Raccord attendu entre blocs */
     ILT_JUMP,                               /* Saut inconditionnel         */
     ILT_JUMP_IF_TRUE,                       /* Saut conditionnel (si vrai) */
     ILT_JUMP_IF_FALSE,                      /* Saut conditionnel (si faux) */
-    ILT_CALL                                /* Appel d'une fonction        */
+    ILT_CALL,                               /* Appel d'une fonction        */
+    ILT_CATCH_EXCEPTION                     /* Gestion d'une exception     */
 
 } InstructionLinkType;
 
@@ -133,6 +135,9 @@ GDecInstruction *g_arch_instruction_decompile(const GArchInstruction *, GDecCont
 void g_arch_instruction_add_to_list(GArchInstruction **, GArchInstruction *);
 
 /* Fournit l'élement suivant un autre pour un parcours. */
+GArchInstruction *g_arch_instruction_get_prev_iter(const GArchInstruction *, const GArchInstruction *);
+
+/* Fournit l'élement suivant un autre pour un parcours. */
 GArchInstruction *g_arch_instruction_get_next_iter(const GArchInstruction *, const GArchInstruction *, vmpa_t);
 
 /* Recherche une instruction d'après son adresse. */
diff --git a/src/common/leb128.h b/src/common/leb128.h
index 0364cf7..398785f 100644
--- a/src/common/leb128.h
+++ b/src/common/leb128.h
@@ -26,6 +26,7 @@
 
 
 #include <stdbool.h>
+#include <stdlib.h>
 
 
 #include "../arch/archbase.h"
@@ -37,6 +38,16 @@ typedef uint64_t uleb128_t;
 typedef int64_t leb128_t;
 
 
+/* Récupération de la valeur absolue */
+#define leb128_abs(v) llabs(v)
+
+
+/* Valeurs minimales et maximales */
+#define ULEB128_MIN UINT64_MIN
+#define ULEB128_MAX UINT64_MAX
+#define LEB128_MIN INT64_MIN
+#define LEB128_MAX INT64_MAX
+
 
 /* Lit un nombre non signé encodé au format LEB128. */
 bool read_uleb128(uleb128_t *, const bin_t *, off_t *, off_t);
diff --git a/src/format/dex/class.c b/src/format/dex/class.c
index 52389c4..52141ae 100644
--- a/src/format/dex/class.c
+++ b/src/format/dex/class.c
@@ -254,6 +254,61 @@ static void g_dex_class_register_method(const GDexClass *class, GBinFormat *form
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : class   = informations chargées à consulter.                 *
+*                virtual = précise la nature des méthodes ciblées.            *
+*                                                                             *
+*  Description : Dénombre les méthodes chargées d'un type donné.              *
+*                                                                             *
+*  Retour      : Quantité de méthodes trouvées.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_dex_class_count_methods(const GDexClass *class, bool virtual)
+{
+    size_t result;                          /* Compte à retourner          */
+
+    if (virtual)
+        result = class->vmethods_count;
+    else
+        result = class->dmethods_count;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class   = informations chargées à consulter.                 *
+*                virtual = précise la nature des méthodes ciblées.            *
+*                index   = indique l'indice de la méthode désirée.            *
+*                                                                             *
+*  Description : Fournit une méthode chargée correspondant à un type donné.   *
+*                                                                             *
+*  Retour      : Quantité de méthodes trouvées.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDexMethod *g_dex_class_get_method(const GDexClass *class, bool virtual, size_t index)
+{
+    GDexMethod *result;                     /* Instance à renvoyer         */
+
+    if (virtual)
+        result = class->virtual_methods[index];
+    else
+        result = class->direct_methods[index];
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : class = informations chargées à consulter.                   *
 *                parts = liste à venir compléter.                             *
 *                count = quantité de zones listées. [OUT]                     *
@@ -294,6 +349,10 @@ GBinPart **g_dex_class_get_parts(const GDexClass *class, GBinPart **parts, size_
 }
 
 
+
+
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : class = informations chargées à consulter.                   *
diff --git a/src/format/dex/class.h b/src/format/dex/class.h
index 998c1b7..e7094ff 100644
--- a/src/format/dex/class.h
+++ b/src/format/dex/class.h
@@ -54,6 +54,12 @@ typedef struct _GDexClassClass GDexClassClass;
 /* Détermine le type d'une classe issue du code source. */
 GType g_dex_class_get_type(void);
 
+/* Dénombre les méthodes chargées d'un type donné. */
+size_t g_dex_class_count_methods(const GDexClass *, bool);
+
+/* Fournit une méthode chargée correspondant à un type donné. */
+GDexMethod *g_dex_class_get_method(const GDexClass *, bool, size_t);
+
 /*  Fournit les références aux zones binaires à analyser. */
 GBinPart **g_dex_class_get_parts(const GDexClass *, GBinPart **, size_t *);
 
diff --git a/src/format/dex/dex-int.c b/src/format/dex/dex-int.c
index 5628e6b..200b01f 100644
--- a/src/format/dex/dex-int.c
+++ b/src/format/dex/dex-int.c
@@ -529,10 +529,226 @@ void reset_dex_class_data_item(class_data_item *item)
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                             PORTION DE CODE EXECUTABLE                             */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                pair   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_encoded_type_addr_pair(const GDexFormat *format, off_t *pos, encoded_type_addr_pair *pair)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+
+    result = true;
+
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    result &= read_uleb128(&pair->type_idx, content, pos, length);
+    result &= read_uleb128(&pair->addr, content, pos, length);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format  = informations chargées à consulter.                 *
+*                pos     = position de début de lecture. [OUT]                *
+*                handler = structure lue à retourner. [OUT]                   *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_encoded_catch_handler(const GDexFormat *format, off_t *pos, encoded_catch_handler *handler)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+    leb128_t count;                         /* Nombre de gestionnaires     */
+    leb128_t i;                             /* Boucle de parcours          */
+
+    result = true;
+
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    handler->offset = *pos;
+
+    result &= read_leb128(&handler->size, content, pos, length);
+
+    count = leb128_abs(handler->size);
+
+    if (count > 0 && result)
+    {
+        handler->handlers = (encoded_type_addr_pair *)calloc(count, sizeof(encoded_type_addr_pair));
+
+        for (i = 0; i < count && result; i++)
+            result &= read_dex_encoded_type_addr_pair(format, pos, &handler->handlers[i]);
+
+    }
+    else handler->handlers = NULL;
+
+    if (handler->size < 0)
+        result &= read_uleb128(&handler->catch_all_addr, content, pos, length);
+    else
+        handler->catch_all_addr = ULEB128_MAX;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : handler = structure à nettoyer.                              *
+*                                                                             *
+*  Description : Supprime tous les éléments chargés en mémoire à la lecture.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void reset_dex_encoded_catch_handler(encoded_catch_handler *handler)
+{
+    if (handler->handlers != NULL)
+        free(handler->handlers);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                list   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_encoded_catch_handler_list(const GDexFormat *format, off_t *pos, encoded_catch_handler_list *list)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+    off_t saved_off;                        /* Sauvegarde de position      */
+    uleb128_t i;                            /* Boucle de parcours          */
 
+    result = true;
 
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    saved_off = *pos;
+
+    result &= read_uleb128(&list->size, content, pos, length);
 
+    if (list->size > 0 && result)
+    {
+        list->list = (encoded_catch_handler *)calloc(list->size, sizeof(encoded_catch_handler));
 
+        for (i = 0; i < list->size && result; i++)
+        {
+            result &= read_dex_encoded_catch_handler(format, pos, &list->list[i]);
+            if (result) list->list[i].offset -= saved_off;
+        }
+
+    }
+    else list->list = NULL;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : list = structure à nettoyer.                                 *
+*                                                                             *
+*  Description : Supprime tous les éléments chargés en mémoire à la lecture.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void reset_dex_encoded_catch_handler_list(encoded_catch_handler_list *list)
+{
+    uleb128_t i;                            /* Boucle de parcours          */
+
+    if (list->list != NULL)
+    {
+        for (i = 0; i < list->size; i++)
+            reset_dex_encoded_catch_handler(&list->list[i]);
+
+        free(list->list);
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                item   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_try_item(const GDexFormat *format, off_t *pos, try_item *item)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+
+    result = true;
+
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    result &= read_u32(&item->start_addr, content, pos, length, SRE_LITTLE);
+    result &= read_u16(&item->insn_count, content, pos, length, SRE_LITTLE);
+    result &= read_u16(&item->handler_off, content, pos, length, SRE_LITTLE);
+
+    return result;
+
+}
 
 
 /******************************************************************************
@@ -554,6 +770,8 @@ bool read_dex_code_item(const GDexFormat *format, off_t *pos, code_item *item)
     bool result;                            /* Bilan à retourner           */
     const bin_t *content;                   /* Contenu binaire à lire      */
     off_t length;                           /* Taille totale du contenu    */
+    uint16_t padding;                       /* Eventuel alignement         */
+    uint16_t i;                             /* Boucle de parcours          */
 
     result = true;
 
@@ -569,11 +787,59 @@ bool read_dex_code_item(const GDexFormat *format, off_t *pos, code_item *item)
 
     item->insns = (uint16_t *)pos;
 
+    *pos += item->insns_size * sizeof(uint16_t);
+
+    /* Padding ? */
+    if (item->tries_size > 0 && item->insns_size % 2 == 1)
+        result &= read_u16(&padding, content, pos, length, SRE_LITTLE);
+
+    if (item->tries_size > 0 && result)
+    {
+        item->tries = (try_item *)calloc(item->tries_size, sizeof(try_item));
+
+        for (i = 0; i < item->tries_size && result; i++)
+            result &= read_dex_try_item(format, pos, &item->tries[i]);
+
+        if (result)
+        {
+            item->handlers = (encoded_catch_handler_list *)calloc(1, sizeof(encoded_catch_handler_list));
+            result &= read_dex_encoded_catch_handler_list(format, pos, item->handlers);
+        }
+
+    }
+
     return result;
 
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item = structure à nettoyer.                                 *
+*                                                                             *
+*  Description : Supprime tous les éléments chargés en mémoire à la lecture.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void reset_dex_code_item(code_item *item)
+{
+    if (item->tries != NULL)
+        free(item->tries);
+
+    if (item->handlers != NULL)
+    {
+        reset_dex_encoded_catch_handler_list(item->handlers);
+        free(item->handlers);
+    }
+
+}
+
+
+
 
 
 
diff --git a/src/format/dex/dex-int.h b/src/format/dex/dex-int.h
index 5feb427..6a153c1 100755
--- a/src/format/dex/dex-int.h
+++ b/src/format/dex/dex-int.h
@@ -61,6 +61,12 @@ struct _GDexFormatClass
 /* Retrouve si possible la méthode associée à une adresse. */
 GDexMethod *g_dex_format_find_method_by_address(const GDexFormat *, vmpa_t);
 
+/* Dénombre le nombre de classes trouvées. */
+size_t g_dex_format_count_classes(const GDexFormat *);
+
+/* Fournit une classe du format chargée en mémoire. */
+GDexClass *g_dex_format_get_class(const GDexFormat *, size_t);
+
 
 
 /* ------------------------ ELEMENTS DE TABLE DES CONSTANTES ------------------------ */
@@ -112,9 +118,33 @@ void reset_dex_class_data_item(class_data_item *);
 
 
 
+/* --------------------------- PORTION DE CODE EXECUTABLE --------------------------- */
+
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_type_addr_pair(const GDexFormat *, off_t *, encoded_type_addr_pair *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_catch_handler(const GDexFormat *, off_t *, encoded_catch_handler *);
+
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_encoded_catch_handler(encoded_catch_handler *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_catch_handler_list(const GDexFormat *, off_t *, encoded_catch_handler_list *);
+
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_encoded_catch_handler_list(encoded_catch_handler_list *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_try_item(const GDexFormat *, off_t *, try_item *);
+
 /* Procède à la lecture d'une portion de code DEX. */
 bool read_dex_code_item(const GDexFormat *, off_t *, code_item *);
 
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_code_item(code_item *);
+
 
 
 
diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c
index f0fb421..841f72f 100755
--- a/src/format/dex/dex.c
+++ b/src/format/dex/dex.c
@@ -2,7 +2,7 @@
 /* OpenIDA - Outil d'analyse de fichiers binaires
  * dex.c - support du format DEX
  *
- * Copyright (C) 2010-2011 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
  *
  *  This file is part of OpenIDA.
  *
@@ -450,3 +450,42 @@ static bool g_dex_format_translate_offset_into_address(const GDexFormat *format,
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                                                                             *
+*  Description : Dénombre le nombre de classes trouvées.                      *
+*                                                                             *
+*  Retour      : Quantité de classes présentes.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_dex_format_count_classes(const GDexFormat *format)
+{
+    return format->classes_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                index  = indice de la classe visée.                          *
+*                                                                             *
+*  Description : Fournit une classe du format chargée en mémoire.             *
+*                                                                             *
+*  Retour      : Instance représentant une classe chargée.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDexClass *g_dex_format_get_class(const GDexFormat *format, size_t index)
+{
+    return format->classes[index];
+
+}
diff --git a/src/format/dex/dex.h b/src/format/dex/dex.h
index cfa72c1..9b769c2 100755
--- a/src/format/dex/dex.h
+++ b/src/format/dex/dex.h
@@ -2,7 +2,7 @@
 /* OpenIDA - Outil d'analyse de fichiers binaires
  * dex.h - prototypes pour le support du format DEX
  *
- * Copyright (C) 2010 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
  *
  *  This file is part of OpenIDA.
  *
diff --git a/src/format/dex/dex_def.h b/src/format/dex/dex_def.h
index ba88d69..d21ac15 100755
--- a/src/format/dex/dex_def.h
+++ b/src/format/dex/dex_def.h
@@ -179,6 +179,49 @@ typedef struct _class_data_item
 /* --------------------------- PORTION DE CODE EXECUTABLE --------------------------- */
 
 
+/* Exception gérée */
+typedef struct _encoded_type_addr_pair
+{
+    uleb128_t type_idx;                     /* Type d'exception couverte   */
+    uleb128_t addr;                         /* Adresse du début du code    */
+
+} encoded_type_addr_pair;
+
+/* Ensemble d'exceptions prises en compte */
+typedef struct _encoded_catch_handler
+{
+    leb128_t size;                          /* Quantité d'exceptions       */
+    encoded_type_addr_pair *handlers;       /* Gestionnaires explicites    */
+    uleb128_t catch_all_addr;               /* Adresse par défaut          */
+
+    /**
+     * Note : les spécifications indiquent que le champ handler_off de
+     * try_item renvoie vers le gestionnaire à partir de la base de la structure
+     * encoded_catch_handler_list. Comme la représentation interne de cette
+     * structure efface la représentation physique, on conserve en mémoire
+     * le décalage rencontré à la lecture dans un champ artificiel.
+     */
+    off_t offset;                           /* Position dans le binaire    */
+
+} encoded_catch_handler;
+
+/* Liste des différents gestionnaires d'exceptions */
+typedef struct _encoded_catch_handler_list
+{
+    uleb128_t size;                         /* Taille de la liste          */
+    encoded_catch_handler *list;            /* Gestionnaires en place      */
+
+} encoded_catch_handler_list;
+
+/* Zone couverte en cas de pépin */
+typedef struct _try_item
+{
+    uint32_t start_addr;                    /* Adresse du début couvert    */
+    uint16_t insn_count;                    /* Nbre de doubles-octets gérés*/
+    uint16_t handler_off;                   /* Indice du gestionnaire      */
+
+} try_item;
+
 /* Description de la zone */
 typedef struct _code_item
 {
@@ -190,13 +233,13 @@ typedef struct _code_item
     uint32_t insns_size;                    /* Nbre de blocs de 2 octets   */
 
     uint16_t *insns;                        /* Code exécutable             */
-
+    try_item *tries;                        /* Zone d'exceptions           */
+    encoded_catch_handler_list *handlers;   /* Gestionnaires associés      */
 
 } code_item;
 
 
 
-
 /* -------------------------- DESCRIPTION DU FORMAT DALVIK -------------------------- */
 
 
diff --git a/src/format/dex/method.c b/src/format/dex/method.c
index 25145f5..6ea9697 100644
--- a/src/format/dex/method.c
+++ b/src/format/dex/method.c
@@ -147,7 +147,9 @@ GDexMethod *g_dex_method_new(const GDexFormat *format, const encoded_method *see
     result->info = *seed;
     result->body = item;
 
-    //printf(" ==== %s ====\n", g_binary_routine_get_name(routine));
+    //printf(" ==== (%p) %s ====\n", routine, g_binary_routine_to_string(routine));
+
+    //printf(" try ? %d\n", item.tries_size);
 
     //printf(" method idx :: %d\n", seed->method_idx_diff);
     //printf(" code size  :: %d\n", item.insns_size);
@@ -180,6 +182,44 @@ GDexMethod *g_dex_method_new(const GDexFormat *format, const encoded_method *see
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : method = représentation interne de la méthode à consulter.   *
+*                                                                             *
+*  Description : Fournit les indications Dex concernant la méthode.           *
+*                                                                             *
+*  Retour      : Données brutes du binaire.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const encoded_method *g_dex_method_get_dex_info(const GDexMethod *method)
+{
+    return &method->info;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : method = représentation interne de la méthode à consulter.   *
+*                                                                             *
+*  Description : Fournit les indications Dex relatives au corps de la méthode.*
+*                                                                             *
+*  Retour      : Données brutes du binaire.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const code_item *g_dex_method_get_dex_body(const GDexMethod *method)
+{
+    return &method->body;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : method = représentation interne du format DEX à consulter.   *
 *                                                                             *
 *  Description : Fournit la routine OpenIDA correspondant à la méthode.       *
@@ -272,7 +312,7 @@ DexVariableIndex g_dex_method_get_variable(const GDexMethod *method, uint32_t in
 
     pivot = body->registers_size - body->ins_size;
 
-    if (!(method->info.access_flags & ACC_STATIC))
+    if (!(info->access_flags & ACC_STATIC))
         pivot++;
 
     if (index >= pivot)
@@ -280,7 +320,7 @@ DexVariableIndex g_dex_method_get_variable(const GDexMethod *method, uint32_t in
 
     /* S'agit-il de "this" ? */
 
-    if (!(method->info.access_flags & ACC_STATIC)
+    if (!(info->access_flags & ACC_STATIC)
         && index == (body->registers_size - body->ins_size))
         return DVI_THIS;
 
diff --git a/src/format/dex/method.h b/src/format/dex/method.h
index c06df73..33f23b1 100644
--- a/src/format/dex/method.h
+++ b/src/format/dex/method.h
@@ -69,6 +69,12 @@ GType g_dex_method_get_type(void);
 /* Crée une nouvelle représentation de methode issue de code. */
 GDexMethod *g_dex_method_new(const GDexFormat *, const encoded_method *, uleb128_t *);
 
+/* Fournit les indications Dex concernant la méthode. */
+const encoded_method *g_dex_method_get_dex_info(const GDexMethod *);
+
+/* Fournit les indications Dex relatives au corps de la méthode. */
+const code_item *g_dex_method_get_dex_body(const GDexMethod *);
+
 /* Fournit la routine OpenIDA correspondant à la méthode. */
 GBinRoutine *g_dex_method_get_routine(const GDexMethod *);
 
diff --git a/src/gtkext/graph/dot.c b/src/gtkext/graph/dot.c
index 4c35089..0e7091e 100644
--- a/src/gtkext/graph/dot.c
+++ b/src/gtkext/graph/dot.c
@@ -25,6 +25,7 @@
 
 
 #include <malloc.h>
+#include <string.h>
 #include <graphviz/gvc.h>
 #include <graphviz/types.h>
 
@@ -210,14 +211,19 @@ GtkLinkRenderer **create_links_from_graph_layout(const graph_layout *layout, siz
 
             /* Détermination de la couleur */
 
+            color = LKC_DEFAULT;
+
             attrib = agfindedgeattr(agraphof(agtail(eiter)), "color");
 
-            if (eiter->attr[attrib->index][0] == 'g')   /* "green" */
-                color = LKC_GREEN;
-            else if (eiter->attr[attrib->index][0] == 'r')   /* "red" */
-                color = LKC_RED;
-            else
-                color = LKC_DEFAULT;
+            if (attrib != NULL)
+            {
+                if (strcmp("green", eiter->attr[attrib->index]) == 0)
+                    color = LKC_GREEN;
+                else if (strcmp("red", eiter->attr[attrib->index]) == 0)
+                    color = LKC_RED;
+                else if (strcmp("gray", eiter->attr[attrib->index]) == 0)
+                    color = LKC_DASHED_GRAY;
+            }
 
             /* Raccordement au point de départ */
 
diff --git a/src/gtkext/graph/layout.c b/src/gtkext/graph/layout.c
index 64a8236..3a2f4e3 100644
--- a/src/gtkext/graph/layout.c
+++ b/src/gtkext/graph/layout.c
@@ -137,7 +137,6 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
     size_t j;                               /* Boucle de parcours #2       */
     size_t k;                               /* Boucle de parcours #3       */
     char cmd[LINKS_DESC_LEN];               /* Tampon pour l'ajout de liens*/
-    GArchInstruction *next;                 /* Instruction suivante        */
 
     if (count == 0)
         return desc;
@@ -168,6 +167,7 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
                 if (k < count)
                     switch (types[j])
                     {
+                        case ILT_EXEC_FLOW:
                         case ILT_JUMP:
                             snprintf(cmd, LINKS_DESC_LEN,
                                      "_%p:s -> _%p:n  [ltail=cluster_%p, lhead=cluster_%p];\n",
@@ -191,6 +191,14 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
                             desc = stradd(desc, cmd);
                             break;
 
+                        case ILT_CATCH_EXCEPTION:
+                            snprintf(cmd, LINKS_DESC_LEN,
+                                     "_%p:s -> _%p:n  [ltail=cluster_%p, lhead=cluster_%p, " \
+                                     "color=gray];\n",
+                                     views[i], views[k], views[i], views[k]);
+                            desc = stradd(desc, cmd);
+                            break;
+
                         default:
                             break;
 
@@ -200,31 +208,6 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
 
         }
 
-        /* Sinon on suit le flux normal */
-        else
-        {
-            if (g_arch_instruction_is_return(last))
-                continue;
-
-            next = g_arch_instruction_get_next_iter(instrs, last, VMPA_MAX);
-            if (next == NULL) continue;
-
-            g_arch_instruction_get_location(next, NULL, NULL, &addr);
-
-            for (k = 0; k < count; k++)
-                if (gtk_view_panel_contain_address(views[k], addr))
-                    break;
-
-            if (k < count)
-            {
-                snprintf(cmd, LINKS_DESC_LEN,
-                         "_%p:s -> _%p:n  [ltail=cluster_%p, lhead=cluster_%p];\n",
-                         views[i], views[k], views[i], views[k]);
-                desc = stradd(desc, cmd);
-            }
-
-        }
-
     }
 
     return desc;
diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c
index f205ee2..1a48680 100644
--- a/src/gtkext/gtkgraphview.c
+++ b/src/gtkext/gtkgraphview.c
@@ -650,7 +650,7 @@ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinar
         g_arch_instruction_get_location(iter, NULL, NULL, &last);
         if (first == VMPA_MAX) first = last;
 
-        if (g_arch_instruction_has_destinations(iter))
+        if (g_arch_instruction_has_destinations(iter) || g_arch_instruction_is_return(iter))
         {
             result = (GtkViewPanel **)realloc(result, ++(*count) * sizeof(GtkViewPanel *));
 
diff --git a/src/gtkext/gtklinkrenderer.c b/src/gtkext/gtklinkrenderer.c
index 43eda38..8b43fa8 100644
--- a/src/gtkext/gtklinkrenderer.c
+++ b/src/gtkext/gtklinkrenderer.c
@@ -189,6 +189,22 @@ void _gtk_link_renderer_draw(const GtkLinkRenderer *renderer, cairo_t *cairo, bo
         case LKC_RED:
             cairo_set_source_rgb(cairo, 0.8, 0, 0);
             break;
+        case LKC_DASHED_GRAY:
+            cairo_set_source_rgb(cairo, 0.4, 0.4, 0.4);
+            break;
+    }
+
+    switch (renderer->color)
+    {
+        default:
+        case LKC_DEFAULT:
+        case LKC_GREEN:
+        case LKC_RED:
+            cairo_set_dash(cairo, (double []) { 6.0 }, 0, 0.0);
+            break;
+        case LKC_DASHED_GRAY:
+            cairo_set_dash(cairo, (double []) { 6.0 }, 1, 0.0);
+            break;
     }
 
     /**
diff --git a/src/gtkext/gtklinkrenderer.h b/src/gtkext/gtklinkrenderer.h
index 574bd1d..3f6442c 100644
--- a/src/gtkext/gtklinkrenderer.h
+++ b/src/gtkext/gtklinkrenderer.h
@@ -52,6 +52,7 @@ typedef enum _LinkColor
     LKC_DEFAULT,                            /* Noir, par défaut            */
     LKC_GREEN,                              /* Condition vérifiée          */
     LKC_RED,                                /* Condition non vérifiée      */
+    LKC_DASHED_GRAY,                        /* Exception omniprésente      */
 
     LKC_COUNT
 
diff --git a/src/plugins/plugin.c b/src/plugins/plugin.c
index 89b46f0..416c647 100644
--- a/src/plugins/plugin.c
+++ b/src/plugins/plugin.c
@@ -125,10 +125,7 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
     result->name = get_name();
 
     if (!g_module_symbol(result->module, "init_plugin", (gpointer *)&result->init))
-    {
-        printf("Err plugin init sym\n");
-        /* TODO */
-    }
+        result->init = NULL;
 
     /*
 
@@ -156,8 +153,7 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
 
     result->get_action = get_action;
 
-    /*
-    if (result->action & (PGA_DISASSEMBLE | PGA_CODE_PROCESS))
+    if (g_plugin_module_get_action(result) & (PGA_DISASSEMBLE | PGA_DISASS_PROCESS | PGA_CODE_PROCESS))
     {
         if (!g_module_symbol(result->module, "execute_action_on_binary", (gpointer *)&result->exec_on_bin))
         {
@@ -168,14 +164,13 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
 
 
     }
-    */
 
 
 
 
 
 
-    if (!result->init(result, ref))
+    if (result->init != NULL && !result->init(result, ref))
     {
         log_variadic_message(LMT_ERROR, _("Initialization of plugin '%s' failed !"), filename);
         goto bad_plugin;