/* OpenIDA - Outil d'analyse de fichiers binaires
* binary.c - traitement des flots de code binaire
*
* Copyright (C) 2008-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 .
*/
#include "binary.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "line_code.h" /* TODO : supprimer ? */
#include "line_comment.h" /* TODO : supprimer ? */
#include "line_prologue.h"
#include "routine.h"
#include "decomp/decompiler.h"
#include "disass/disassembler.h"
#include "../common/cpp.h"
#include "../common/extstr.h"
#include "../debug/break.h"
#include "../format/format.h"
#include "../gui/panels/log.h"
#include "../plugins/pglist.h" /* TODO : supprimer ? */
#include "../format/dbg_format.h"
/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
/* Description de fichier binaire (instance) */
struct _GOpenidaBinary
{
GObject parent; /* A laisser en premier */
char *filename; /* Fichier chargé en mémoire */
off_t bin_length; /* Taille des données brutes */
bin_t *bin_data; /* Données binaires brutes */
GExeFormat *format; /* Format du binaire */
GArchProcessor *proc; /* Architecture du binaire */
BinaryPartModel model; /* Modèle de sélection */
GBinPart **parts[BPM_COUNT]; /* Parties binaires à analyser */
size_t parts_count[BPM_COUNT]; /* Quantité de ces parties */
GRenderingLine *lines; /* Lignes de rendu en place */
GRenderingOptions *options; /* Options de désassemblage */
GArchInstruction *instrs; /* Instructions d'assemblage */
GCodeBuffer *disass_buffer; /* Instructions lisibles */
GCodeBuffer **dec_buffers; /* Sources sous forme de texte */
size_t decbuf_count; /* Taille des tableaux */
size_t defsrc; /* Fichier source principal */
bool text_display[2]; /* Position et code binaire #1 */
bool lines_display; /* Affichage des lignes */
GBreakGroup **brk_groups; /* Groupes de points d'arrêt */
size_t brk_count; /* Taille de cette liste */
GBreakGroup *brk_default; /* Groupe par défaut */
};
/* Description de fichier binaire (classe) */
struct _GOpenidaBinaryClass
{
GObjectClass parent; /* A laisser en premier */
/* Signaux */
void (* disassembly_done) (GOpenidaBinary *);
};
/* Initialise la classe des descriptions de fichier binaire. */
static void g_openida_binary_class_init(GOpenidaBinaryClass *);
/* Initialise une description de fichier binaire. */
static void g_openida_binary_init(GOpenidaBinary *);
/* Charge en mémoire le contenu d'un fichier. */
bin_t *map_binary_file(const char *, off_t *);
/* Acquitte la fin d'un désasemblage différé et complet. */
void ack_completed_disassembly(void/*GDelayedDisassembly*/ *, GOpenidaBinary *);
/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */
/* Réagit à une nouvelle création de point d'arrêt. */
static void g_openida_binary_breakpoint_added(GBreakGroup *, GBreakPoint *, GOpenidaBinary *);
/* Réagit à une suppression de point d'arrêt. */
static void g_openida_binary_breakpoint_removed(GBreakGroup *, GBreakPoint *, GOpenidaBinary *);
/* Indique le type défini pour une description de fichier binaire. */
G_DEFINE_TYPE(GOpenidaBinary, g_openida_binary, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des descriptions de fichier binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_openida_binary_class_init(GOpenidaBinaryClass *klass)
{
g_signal_new("disassembly-done",
G_TYPE_OPENIDA_BINARY,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GOpenidaBinaryClass, disassembly_done),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
/******************************************************************************
* *
* Paramètres : binary = instance à initialiser. *
* *
* Description : Initialise une description de fichier binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_openida_binary_init(GOpenidaBinary *binary)
{
binary->text_display[0] = true;
binary->text_display[1] = true;
binary->lines_display = true;
/* FIXME : à replacer ailleurs */
g_openida_binary_add_break_group(binary, _("default"));
}
/******************************************************************************
* *
* Paramètres : filename = nom du fichier à charger. *
* *
* Description : Charge en mémoire le contenu d'un fichier. *
* *
* Retour : Adresse de la représentation ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
GOpenidaBinary *g_openida_binary_new_from_file(const char *filename)
{
GOpenidaBinary *result; /* Adresse à retourner */
GPluginModule **pglist; /* Liste de greffons */
size_t pgcount; /* Taille de cette liste */
size_t i; /* Boucle de parcours */
char *file = strdup(filename);
result = g_object_new(G_TYPE_OPENIDA_BINARY, NULL);
printf("%s\n", filename);
pglist = get_all_plugins_for_action(PGA_FORMAT_MATCHER, &pgcount);
if (pgcount > 0)
{
printf("===>>>> FOUND :: %d\n", pgcount);
/*
for (i = 0; i < pgcount; i++)
g_plugin_module_execute_action_on_binary(pglist[i], binary, PGA_CODE_PROCESS);
*/
free(pglist);
}
log_variadic_message(LMT_PROCESS, _("Opening '%s' file..."), filename);
result->filename = strdup(filename);
/*
result->bin_data = map_binary_file(filename, &result->bin_length);
if (result->bin_data == NULL) goto lbf_error;
*/
result->format = G_EXE_FORMAT(load_new_format(FMT_EXEC, file,
&result->bin_data, &result->bin_length));
if (result->format == NULL)
{
log_simple_message(LMT_INFO, _("Unknown binary format"));
goto lbf_error;
}
/* FIXME : à déplacer dans arch/... */
switch (g_exe_format_get_target_machine(result->format))
{
case FTM_ARM:
log_simple_message(LMT_INFO, _("Detected architecture: ARM"));
break;
case FTM_DALVIK:
log_simple_message(LMT_INFO, _("Detected architecture: Dalvik Virtual Machine"));
break;
case FTM_JVM:
log_simple_message(LMT_INFO, _("Detected architecture: Java Virtual Machine"));
break;
case FTM_MIPS:
log_simple_message(LMT_INFO, _("Detected architecture: Microprocessor without Interlocked Pipeline Stages"));
break;
case FTM_386:
log_simple_message(LMT_INFO, _("Detected architecture: i386"));
break;
default:
log_simple_message(LMT_INFO, _("Unknown architecture"));
goto lbf_error;
break;
}
result->lines = NULL;
result->proc = get_arch_processor_from_format(result->format);
result->options = g_rendering_options_new(result->format);
g_rendering_options_show_address(result->options, MRD_BLOCK, true);
g_rendering_options_show_code(result->options, MRD_BLOCK, true);
g_rendering_options_show_address(result->options, MRD_GRAPH, true);
g_rendering_options_show_code(result->options, MRD_GRAPH, false);
return result;
lbf_error:
//unload_binary_file(result);
return NULL;
}
/******************************************************************************
* *
* Paramètres : context = contexte pour les recherches XPath. *
* path = chemin d'accès au noeud XML à lire. *
* *
* Description : Charge en mémoire le contenu d'un fichier à partir d'XML. *
* *
* Retour : Adresse de la représentation ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const char *path)
{
GOpenidaBinary *result; /* Adresse à retourner */
char *type; /* Tupe de binaire à charger */
size_t access_len; /* Taille d'un chemin interne */
char *access; /* Chemin pour une sous-config.*/
char *filename; /* Chemin du binaire à charger */
xmlXPathObjectPtr xobjects; /* Cible d'une recherche */
int i; /* Boucle de parcours */
GBinPart *part; /* Partie binaire à traiter */
off_t offset; /* Position de cette partie */
vmpa_t addr; /* Adresse correspondante */
result = NULL;
/* Type */
type = get_node_prop_value(context, path, "type");
printf("###type### %s\n", type);
free(type);
/* Chemin du fichier à retrouver */
access = strdup(path);
access = stradd(access, "/Filename");
filename = get_node_text_value(context, access);
free(access);
/* Chargement */
if (filename != NULL)
{
result = g_openida_binary_new_from_file(filename);
free(filename);
}
if (result == NULL) return NULL;
/* Parties à désassembler : default */
access = strdup(path);
access = stradd(access, "/BinParts/Default/Part");
xobjects = get_node_xpath_object(context, access);
for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobjects); i++)
{
part = g_binary_part_load_from_xml(NODE_FROM_PATH_OBJ(xobjects, i));
if (part != NULL)
{
g_binary_part_get_values(part, &offset, NULL, NULL);
if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr))
{
g_object_unref(G_OBJECT(part));
continue;
}
result->parts_count[BPM_DEFAULT]++;
result->parts[BPM_DEFAULT] = (GBinPart **)realloc(result->parts[BPM_DEFAULT],
result->parts_count[BPM_DEFAULT] * sizeof(GBinPart *));
result->parts[BPM_DEFAULT][result->parts_count[BPM_DEFAULT] - 1] = part;
}
}
if(xobjects != NULL) /* FIXME */
xmlXPathFreeObject(xobjects);
free(access);
qsort(result->parts[BPM_DEFAULT], result->parts_count[BPM_DEFAULT],
sizeof(GBinPart *), g_binary_part_compare);
/* Parties à désassembler : routines */
access = strdup(path);
access = stradd(access, "/BinParts/Routines/Part");
xobjects = get_node_xpath_object(context, access);
for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobjects); i++)
{
part = g_binary_part_load_from_xml(NODE_FROM_PATH_OBJ(xobjects, i));
if (part != NULL)
{
g_binary_part_get_values(part, &offset, NULL, NULL);
if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr))
{
g_object_unref(G_OBJECT(part));
continue;
}
else g_binary_part_set_address(part, addr);
result->parts_count[BPM_ROUTINES]++;
result->parts[BPM_ROUTINES] = (GBinPart **)realloc(result->parts[BPM_ROUTINES],
result->parts_count[BPM_ROUTINES] * sizeof(GBinPart *));
result->parts[BPM_ROUTINES][result->parts_count[BPM_ROUTINES] - 1] = part;
}
}
if(xobjects != NULL) /* FIXME */
xmlXPathFreeObject(xobjects);
free(access);
qsort(result->parts[BPM_ROUTINES], result->parts_count[BPM_ROUTINES],
sizeof(GBinPart *), g_binary_part_compare);
/* Parties à désassembler : utilisateur */
access = strdup(path);
access = stradd(access, "/BinParts/User/Part");
xobjects = get_node_xpath_object(context, access);
for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobjects); i++)
{
part = g_binary_part_load_from_xml(NODE_FROM_PATH_OBJ(xobjects, i));
if (part != NULL)
{
g_binary_part_get_values(part, &offset, NULL, NULL);
if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr))
{
g_object_unref(G_OBJECT(part));
continue;
}
result->parts_count[BPM_USER]++;
result->parts[BPM_USER] = (GBinPart **)realloc(result->parts[BPM_USER],
result->parts_count[BPM_USER] * sizeof(GBinPart *));
result->parts[BPM_USER][result->parts_count[BPM_USER] - 1] = part;
}
}
if(xobjects != NULL) /* FIXME */
xmlXPathFreeObject(xobjects);
free(access);
qsort(result->parts[BPM_USER], result->parts_count[BPM_USER],
sizeof(GBinPart *), g_binary_part_compare);
return result;
}
/******************************************************************************
* *
* 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 : - *
* *
******************************************************************************/
bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
{
bool result; /* Bilan à faire remonter */
char *access; /* Chemin d'accès à un élément */
xmlNodePtr node; /* Point d'insertion XML */
size_t i; /* Boucle de parcours */
result = true;
/* Type */
result &= add_string_attribute_to_node(xdoc, context, path, "type", "file");
/* Nom du fichier associé */
access = strdup(path);
access = stradd(access, "/Filename");
result &= add_content_to_node(xdoc, context, access, binary->filename);
free(access);
/* Parties à désassembler */
if (binary->parts_count[BPM_DEFAULT] > 0)
{
access = strdup(path);
access = stradd(access, "/BinParts/Default");
node = ensure_node_exist(xdoc, context, access);
free(access);
for (i = 0; i < binary->parts_count[BPM_DEFAULT] && result; i++)
result &= g_binary_part_save_to_xml(binary->parts[BPM_DEFAULT][i], xdoc, node);
}
if (binary->parts_count[BPM_ROUTINES] > 0)
{
access = strdup(path);
access = stradd(access, "/BinParts/Routines");
node = ensure_node_exist(xdoc, context, access);
free(access);
for (i = 0; i < binary->parts_count[BPM_ROUTINES] && result; i++)
result &= g_binary_part_save_to_xml(binary->parts[BPM_ROUTINES][i], xdoc, node);
}
if (binary->parts_count[BPM_USER] > 0)
{
access = strdup(path);
access = stradd(access, "/BinParts/User");
node = ensure_node_exist(xdoc, context, access);
free(access);
for (i = 0; i < binary->parts_count[BPM_USER] && result; i++)
result &= g_binary_part_save_to_xml(binary->parts[BPM_USER][i], xdoc, node);
}
return result;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* parts = liste des zones binaires à analyser. *
* model = modèle de sélection des zones. *
* count = quantité de zones listées. *
* *
* Description : Définit les parties de binaire à analyser. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_openida_binary_set_parts(GOpenidaBinary *binary, BinaryPartModel model, GBinPart **parts, size_t count)
{
qsort(parts, count, sizeof(GBinPart *), g_binary_part_compare);
binary->parts[model] = parts;
binary->parts_count[model] = count;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* model = modèle de sélection des zones. [OUT] *
* count = quantité de zones listées. [OUT] *
* *
* Description : Fournit les parties de binaire analysées. *
* *
* Retour : Zones binaires à analyser. *
* *
* Remarques : - *
* *
******************************************************************************/
GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *binary, BinaryPartModel *model, size_t **count)
{
*model = binary->model;
*count = binary->parts_count;
return binary->parts;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à traiter. *
* *
* Description : Lance l'analyse d'un élément binaire chargé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_openida_binary_analyse(GOpenidaBinary *binary)
{
GBinPart **parts; /* Parties d'élément binaire */
size_t parts_count; /* Nombre de ces parties */
if (binary->parts_count[BPM_ROUTINES] > 0)
binary->model = BPM_ROUTINES;
if (binary->parts[binary->model] != NULL)
{
parts = binary->parts[binary->model];
parts_count = binary->parts_count[binary->model];
}
else
{
if (binary->parts[BPM_DEFAULT] != NULL)
{
parts = binary->parts[BPM_DEFAULT];
parts_count = binary->parts_count[BPM_DEFAULT];
}
else
{
parts = g_exe_format_get_parts(binary->format, &parts_count);
qsort(parts, parts_count, sizeof(GBinPart *), g_binary_part_compare);
}
}
disassemble_binary(binary, parts, parts_count,
&binary->instrs, &binary->disass_buffer);
/* TODO : remme ! */
ack_completed_disassembly(NULL, binary);
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit une description humaine d'un élément binaire. *
* *
* Retour : Chaîne de caractères humainenement lisible de représentation.*
* *
* Remarques : - *
* *
******************************************************************************/
const char *g_openida_binary_to_string(const GOpenidaBinary *binary)
{
return binary->filename;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit le fichier correspondant à l'élément binaire. *
* *
* Retour : Nom de fichier avec chemin absolu. *
* *
* Remarques : - *
* *
******************************************************************************/
const char *g_openida_binary_get_filename(const GOpenidaBinary *binary)
{
return binary->filename;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* length = taille en octets des données chargées. [OUT] *
* *
* Description : Fournit les détails du contenu binaire chargé en mémoire. *
* *
* Retour : Pointeur vers le début des données. *
* *
* Remarques : - *
* *
******************************************************************************/
bin_t *g_openida_binary_get_data(const GOpenidaBinary *binary, off_t *length)
{
if (length != NULL)
*length = binary->bin_length;
return binary->bin_data;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit le format de fichier reconnu dans le contenu binaire.*
* *
* Retour : Adresse du format reconnu. *
* *
* Remarques : - *
* *
******************************************************************************/
GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *binary)
{
return binary->format;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit les options d'affichage définies pour le binaire. *
* *
* Retour : Adresse des options d'affichage. *
* *
* Remarques : - *
* *
******************************************************************************/
GRenderingOptions *g_openida_binary_get_options(const GOpenidaBinary *binary)
{
return binary->options;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Donne la racine des lignes de rendu issues du désassemblage. *
* *
* Retour : Lieu d'enregistrement des lignes issues du désassemblage. *
* *
* Remarques : - *
* *
******************************************************************************/
GRenderingLine **g_openida_binary_get_lines_root(const GOpenidaBinary *binary)
{
return &binary->lines;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit les lignes de rendu issues du désassemblage. *
* *
* Retour : Lignes issues du désassemblage. *
* *
* Remarques : - *
* *
******************************************************************************/
GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *binary)
{
return binary->lines;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit les instructions issues du désassemblage. *
* *
* Retour : Instructions issues du désassemblage. *
* *
* Remarques : - *
* *
******************************************************************************/
GArchInstruction *g_openida_binary_get_instructions(const GOpenidaBinary *binary)
{
return binary->instrs;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit le tampon associé au contenu assembleur d'un binaire.*
* *
* Retour : Tampon mis en place ou NULL si aucun (!). *
* *
* Remarques : - *
* *
******************************************************************************/
GCodeBuffer *g_openida_binary_get_disassembled_buffer(const GOpenidaBinary *binary)
{
return binary->disass_buffer;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Indique si les adresses doivent apparaître dans le rendu. *
* *
* Retour : Consigne d'affichage. [OUT] *
* *
* Remarques : - *
* *
******************************************************************************/
bool *g_openida_binary_display_addresses_in_text(const GOpenidaBinary *binary)
{
return &binary->text_display[0];
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Indique si le code doit apparaître dans le rendu. *
* *
* Retour : Consigne d'affichage. [OUT] *
* *
* Remarques : - *
* *
******************************************************************************/
bool *g_openida_binary_display_code_in_text(const GOpenidaBinary *binary)
{
return &binary->text_display[1];
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* index = indice du fichier à retrouver. *
* *
* Description : Fournit le tampon associé au contenu d'un fichier source. *
* *
* Retour : Tampon mis en place ou NULL si aucun (!). *
* *
* Remarques : - *
* *
******************************************************************************/
GCodeBuffer *g_openida_binary_get_decompiled_buffer(const GOpenidaBinary *binary, size_t index)
{
GCodeBuffer *result; /* Tampon à retourner */
if (index >= binary->decbuf_count)
result = binary->dec_buffers[binary->defsrc];
else
result = binary->dec_buffers[index];
return result;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Indique si les lignes doivent apparaître dans le rendu. *
* *
* Retour : Consigne d'affichage. [OUT] *
* *
* Remarques : - *
* *
******************************************************************************/
bool *g_openida_binary_display_decomp_lines(const GOpenidaBinary *binary)
{
return &binary->lines_display;
}
/******************************************************************************
* *
* Paramètres : filename = nom du fichier à charger. *
* length = taille des données mises en mémoire. [OUT] *
* *
* Description : Charge en mémoire le contenu d'un fichier. *
* *
* Retour : Adresse du contenu binaire ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
bin_t *map_binary_file(const char *filename, off_t *length)
{
uint8_t *result; /* Données à retourner */
int fd; /* Fichier ouvert en lecture */
struct stat info; /* Informations sur le fichier */
int ret; /* Bilan d'un appel */
fd = open(filename, 0, O_RDONLY);
if (fd == -1)
{
perror("open()");
return NULL;
}
ret = fstat(fd, &info);
if (ret == -1)
{
perror("fstat()");
close(fd);
return NULL;
}
*length = info.st_size;
result = (uint8_t *)mmap(NULL, *length, PROT_READ, MAP_PRIVATE, fd, 0);
if (result == MAP_FAILED)
{
perror("mmap()");
result = NULL;
}
ret = close(fd);
if (ret == -1)
perror("close()");
return result;
}
/******************************************************************************
* *
* Paramètres : disass = travail de désassemblage mené à bien. *
* binary = représentation de binaire à l'origine de l'opérat°. *
* *
* Description : Acquitte la fin d'un désasemblage différé et complet. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void ack_completed_disassembly(void/*GDelayedDisassembly*/ *disass, GOpenidaBinary *binary)
{
GRenderingLine *line; /* "Première" ligne de rendu */
size_t i; /* Boucle de parcours */
const char * const *files; /* Liste de fichiers source */
/* Décompilation... */
files = g_binary_format_get_source_files(G_BIN_FORMAT(binary->format),
&binary->decbuf_count, &binary->defsrc);
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]);
#if 0
g_rendering_line_merge(&binary->lines, &disass->lines);
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);
/* On réintègre le flot premier */
#endif
g_signal_emit_by_name(binary, "disassembly-done");
}
/* ---------------------------------------------------------------------------------- */
/* ELEMENTS DE DEBOGAGE */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : binary = représentation de binaire à modifier. *
* name = éventuel nom à associer au groupe. *
* *
* Description : Ajoute un nouveau groupe de points d'arrêt au binaire. *
* *
* Retour : true si l'opération s'est bien effectuée, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_openida_binary_add_break_group(GOpenidaBinary *binary, const char *name)
{
bool result; /* Bilan à faire remonter */
const char *used; /* Désignation à utiliser */
size_t tmp_len; /* Longeur maximale à gérer */
char *tmp; /* Construction temporaire */
size_t i; /* Boucle de parcours */
const char *test; /* Nom existant à tester */
result = true;
/* Préparation du nom de scène */
if (name != NULL) used = name;
else
{
tmp_len = strlen(_("Group")) + 1 + SIZE_T_MAXLEN + 1;
tmp = (char *)calloc(tmp_len, sizeof(char));
snprintf(tmp, tmp_len, "%s %lu", _("Group"), binary->brk_count);
used = tmp;
}
/* Vérification d'unicité */
for (i = 0; i < binary->brk_count && result; i++)
{
test = g_break_group_get_name(binary->brk_groups[i]);
if (test != NULL)
result = (strcmp(used, test) != 0);
}
/* Mise en place finale */
if (result)
{
binary->brk_count++;
binary->brk_groups = (GBreakGroup **)realloc(binary->brk_groups,
binary->brk_count * sizeof(GBreakGroup *));
binary->brk_groups[i] = g_break_group_new();
g_break_group_set_name(binary->brk_groups[i], used);
if (binary->brk_default == NULL)
binary->brk_default = binary->brk_groups[i];
g_signal_connect(binary->brk_groups[i], "added",
G_CALLBACK(g_openida_binary_breakpoint_added), binary);
g_signal_connect(binary->brk_groups[i], "removed",
G_CALLBACK(g_openida_binary_breakpoint_removed), binary);
}
if (name == NULL) free(tmp);
return result;
}
/******************************************************************************
* *
* Paramètres : group = ensemble de points d'arrêt intervenant. *
* point = point d'arrêt à l'origine de la procédure. *
* binary = représentation de binaire à modifier. *
* *
* Description : Réagit à une nouvelle création de point d'arrêt. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_openida_binary_breakpoint_added(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary)
{
GRenderingLine *line; /* Ligne à retrouver */
line = g_rendering_line_find_by_address(binary->lines, NULL,
g_break_point_get_address(point));
if (line != NULL)
g_rendering_line_toggle_flag(line, RLF_BREAK_POINT);
}
/******************************************************************************
* *
* Paramètres : group = ensemble de points d'arrêt intervenant. *
* point = point d'arrêt à l'origine de la procédure. *
* binary = représentation de binaire à modifier. *
* *
* Description : Réagit à une suppression de point d'arrêt. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_openida_binary_breakpoint_removed(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary)
{
GRenderingLine *line; /* Ligne à retrouver */
line = g_rendering_line_find_by_address(binary->lines, NULL,
g_break_point_get_address(point));
if (line != NULL)
g_rendering_line_toggle_flag(line, RLF_BREAK_POINT);
}
/******************************************************************************
* *
* Paramètres : binary = représentation de binaire à mettre à jour. *
* addr = adresse mémoire à faire basculer. *
* *
* Description : Ajoute ou supprime un point d'arrêt dans un binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_openida_binary_toggle_breakpoint(GOpenidaBinary *binary, vmpa_t addr)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < binary->brk_count; i++)
if (g_break_group_has_address(binary->brk_groups[i], addr))
{
g_break_group_toggle_breakpoint(binary->brk_groups[i], addr);
break;
}
if (i == binary->brk_count)
g_break_group_toggle_breakpoint(binary->brk_default, addr);
}
/******************************************************************************
* *
* Paramètres : binary = représentation de binaire à parcourir. *
* func = fonction à appeler à chaque point trouvé. *
* data = éventuelle donnée de l'utilisateur à joindre. *
* *
* Description : Parcourt l'ensemble des groupes de points d'arrêt du binaire.*
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_openida_binary_for_each_bp_group(GOpenidaBinary *binary, GExtFunc func, gpointer data)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < binary->brk_count; i++)
func(binary, binary->brk_groups[i], data);
}