/* Chrysalide - Outil d'analyse de fichiers binaires * debugger.c - gestion des différents débogueurs * * Copyright (C) 2010-2012 Cyrille Bagard * * This file is part of Chrysalide. * * 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 "debugger.h" #include "debugger-int.h" #include "jdwp/debugger.h" #include "remgdb/gdb.h" #include "../glibext/chrysamarshal.h" #include "../plugins/pglist.h" /* Initialise la classe de base des débogueurs. */ static void g_binary_debugger_class_init(GBinaryDebuggerClass *); /* Initialise une instance de base d'un débogueur. */ static void g_binary_debugger_init(GBinaryDebugger *); /* Indique le type définit pour une ligne de représentation. */ G_DEFINE_TYPE(GBinaryDebugger, g_binary_debugger, G_TYPE_OBJECT); /****************************************************************************** * * * Paramètres : klass = classe à initialiser. * * * * Description : Initialise la classe de base des débogueurs. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_binary_debugger_class_init(GBinaryDebuggerClass *klass) { g_signal_new("debugger-stopped", G_TYPE_BINARY_DEBUGGER, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET(GBinaryDebuggerClass, debugger_stopped), NULL, NULL, g_cclosure_user_marshal_VOID__UINT64_UINT64, G_TYPE_NONE, 2, G_TYPE_UINT64, G_TYPE_UINT64); g_signal_new("halted", G_TYPE_BINARY_DEBUGGER, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET(GBinaryDebuggerClass, debugger_halted), NULL, NULL, g_cclosure_user_marshal_VOID__INT_UINT64_INT, G_TYPE_NONE, 3, G_TYPE_INT, G_TYPE_UINT64, G_TYPE_INT); } /****************************************************************************** * * * Paramètres : debugger = instance à initialiser. * * * * Description : Initialise une instance de base d'un débogueur. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_binary_debugger_init(GBinaryDebugger *debugger) { } /****************************************************************************** * * * Paramètres : type = type de débigueur choisi pour l'opération. * * binary = binaire devant être débogué. * * * * Description : Crée un nouveau débogueur. * * * * Retour : Composant GObject mis en place ou NULL. * * * * Remarques : - * * * ******************************************************************************/ GBinaryDebugger *g_new_binary_debugger(DebuggerType type, GLoadedBinary *binary) { GBinaryDebugger *result; switch (type) { case DGT_JDWP: result = g_java_debugger_new(binary, NULL); break; case DGT_REMOTE_GDB: result = g_gdb_debugger_new(binary, NULL); break; default: result = NULL; break; } if (result != NULL) result->binary = binary; return result; } /****************************************************************************** * * * Paramètres : debugger = débogueur à manipuler ici. * * * * Description : Démarre une procédure de débogage. * * * * Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ bool g_binary_debugger_attach(GBinaryDebugger *debugger) { bool result; /* Bilan à retourner */ GPluginModule **pglist; /* Liste de greffons */ size_t pgcount; /* Taille de cette liste */ size_t i; /* Boucle de parcours */ if (debugger->attach == NULL) result = true; else result = debugger->attach(debugger); pgcount = 0; pglist = NULL;//get_all_plugins_for_action(PGA_DEBUGGER_ATTACH, &pgcount); if (pgcount > 0) { /* for (i = 0; i < pgcount; i++) g_plugin_module_handle_debugger(pglist[i], debugger, PGA_DEBUGGER_ATTACH); */ free(pglist); } return result; } /****************************************************************************** * * * Paramètres : debugger = débogueur à manipuler ici. * * * * Description : Démarre une procédure de débogage. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_binary_debugger_run(GBinaryDebugger *debugger) { debugger->run(debugger); } /****************************************************************************** * * * Paramètres : debugger = débogueur à manipuler ici. * * * * Description : Reprend une procédure de débogage. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_binary_debugger_resume(GBinaryDebugger *debugger) { debugger->resume(debugger); } /****************************************************************************** * * * Paramètres : debugger = débogueur à manipuler ici. * * * * Description : Tue une procédure de débogage. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_binary_debugger_kill(GBinaryDebugger *debugger) { debugger->kill(debugger); } /****************************************************************************** * * * Paramètres : debugger = instance du module de débogage chargé. * * names = désignations de tous les threads ou NULL. [OUT] * * count = nombre de threads actifs. [OUT] * * * * Description : Fournit les identifiants de tous les threads actifs. * * * * Retour : Liste des threads décomptés. * * * * Remarques : - * * * ******************************************************************************/ pid_t *g_binary_debugger_list_all_threads(GBinaryDebugger *debugger, char ***names, size_t *count) { pid_t *result; /* Liste à retourner */ if (debugger->all_threads != NULL) result = debugger->all_threads(debugger, names, count); else result = NULL; return result; } /****************************************************************************** * * * Paramètres : debugger = instance du module de débogage chargé. * * thread = thread concerné par l'analyse. * * count = nombre de frames en place. [OUT] * * * * Description : Fournit la liste des frames courantes d'un thread donné. * * * * Retour : Liste des frames trouvées. * * * * Remarques : - * * * ******************************************************************************/ dbg_frame_t *g_binary_debugger_get_frames_stack(GBinaryDebugger *debugger, pid_t thread, size_t *count) { dbg_frame_t *result; /* Liste à retourner */ if (debugger->frames_stack != NULL) result = debugger->frames_stack(debugger, thread, count); else { *count = 0; result = NULL; } return result; } /****************************************************************************** * * * Paramètres : debugger = débogueur à manipuler ici. * * count = nombre de transmissions effetuées. * * * * Description : Fournit la valeur des registres de l'architecture. * * * * Retour : Tableau de valeurs transmises à libérer de la mémoire / NULL.* * * * Remarques : - * * * ******************************************************************************/ register_value *g_binary_debugger_get_registers(GBinaryDebugger *debugger, size_t *count) { return debugger->get_reg_values(debugger, count); }