/* Chrysalide - Outil d'analyse de fichiers binaires * debugger.c - instances Python de débogueurs * * Copyright (C) 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 this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "debugger.h" #if 0 #include #include #include "../quirks.h" /* Crée un nouvel objet Python de type 'BinaryDebugger'. */ static PyObject *py_binary_debugger_new(PyTypeObject *, PyObject *, PyObject *); /* Fournit les identifiants de tous les threads actifs. */ static PyObject *py_binary_debugger_list_all_threads(PyObject *, PyObject *); /* Fournit la pile d'exécution courante via un débogueur. */ static PyObject *py_binary_debugger_get_frames_stack(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 'BinaryDebugger'. * * * * Retour : Instance Python mise en place. * * * * Remarques : - * * * ******************************************************************************/ static PyObject *py_binary_debugger_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *result; /* Instance à retourner */ DebuggerType dtype; /* Type de débogueur à créer */ int ret; /* Bilan de lecture des args. */ GBinaryDebugger *debugger; /* Version GLib du format */ ret = PyArg_ParseTuple(args, "l", &dtype); if (!ret) Py_RETURN_NONE; debugger = g_new_binary_debugger(dtype, NULL/* FIXME */); result = py_binary_debugger_from_c(debugger); g_object_unref(debugger); return (PyObject *)result; } /****************************************************************************** * * * Paramètres : debugger = instance existante GLib. * * * * Description : Crée un nouvel objet Python de type 'BinaryDebugger'. * * * * Retour : Instance Python mise en place. * * * * Remarques : - * * * ******************************************************************************/ PyObject *py_binary_debugger_from_c(GBinaryDebugger *debugger) { PyObject *module; /* Module d'appartenance */ PyTypeObject *type; /* Type Python correspondant */ module = PyImport_ImportModule("pychrysalide.debug"); type = (PyTypeObject*)PyObject_GetAttrString(module, "BinaryDebugger"); Py_DECREF(module); pychrysalide_set_instance_data(G_OBJECT(debugger), type); return pygobject_new(G_OBJECT(debugger)); } /****************************************************************************** * * * Paramètres : self = classe représentant un débogueur. * * args = arguments fournis à l'appel. * * * * Description : Fournit les identifiants de tous les threads actifs. * * * * Retour : Object Python représentant le résultat de l'opération. * * * * Remarques : - * * * ******************************************************************************/ static PyObject *py_binary_debugger_list_all_threads(PyObject *self, PyObject *args) { PyObject *result; /* Trouvailles à retourner */ GBinaryDebugger *debugger; /* Version native */ char **names; /* Noms associés aux threads */ size_t count; /* Taille de cette liste */ pid_t *threads; /* Liste des threads actifs */ size_t i; /* Boucle de parcours */ PyObject *thread; /* Détails sur un thread donné */ debugger = G_BINARY_DEBUGGER(pygobject_get(self)); threads = g_binary_debugger_list_all_threads(debugger, &names, &count); result = PyTuple_New(count); for (i = 0; i < count; i++) { thread = PyTuple_New(2); PyTuple_SetItem(result, i, thread); PyTuple_SetItem(thread, 0, PyLong_FromLong(threads[i])); PyTuple_SetItem(thread, 1, PyString_FromString(names[i])); free(names[i]); } if (names != NULL) free(names); if (threads != NULL) free(threads); return result; } /****************************************************************************** * * * Paramètres : self = classe représentant un débogueur. * * args = arguments fournis à l'appel. * * * * Description : Fournit la pile d'exécution courante via un débogueur. * * * * Retour : Object Python représentant le résultat de l'opération. * * * * Remarques : - * * * ******************************************************************************/ static PyObject *py_binary_debugger_get_frames_stack(PyObject *self, PyObject *args) { PyObject *result; /* Trouvailles à retourner */ GBinaryDebugger *debugger; /* Version native */ unsigned long thread; /* Identifiant du thread visé */ size_t count; /* Taille de cette liste */ dbg_frame_t *frames; /* Frames courantes trouvées */ size_t i; /* Boucle de parcours */ PyObject *frame; /* Détails sur une frame */ debugger = G_BINARY_DEBUGGER(pygobject_get(self)); if (!PyArg_ParseTuple(args, "k", &thread)) Py_RETURN_NONE; frames = g_binary_debugger_get_frames_stack(debugger, thread, &count); result = PyTuple_New(count); for (i = 0; i < count; i++) { frame = PyTuple_New(1); PyTuple_SetItem(result, i, frame); PyTuple_SetItem(frame, 0, PyLong_FromUnsignedLongLong(frames[i].addr)); } if (frames != NULL) free(frames); return result; } /****************************************************************************** * * * Paramètres : module = module dont la définition est à compléter. * * * * Description : Ajoute l'objet 'pychrysalide.debug.BinaryDebugger' au module.* * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ bool register_python_binary_debugger(PyObject *module) { PyObject *pygobj_mod; /* Module Python-GObject */ int ret; /* Bilan d'un appel */ static PyMethodDef py_binary_debugger_methods[] = { { "list_all_threads", (PyCFunction)py_binary_debugger_list_all_threads, METH_NOARGS, "List all current active threads." }, { "get_frames_stack", (PyCFunction)py_binary_debugger_get_frames_stack, METH_VARARGS, "Provide the current callstack using a debugger." }, { NULL } }; static PyTypeObject py_binary_debugger_type = { PyObject_HEAD_INIT(NULL) .tp_name = "pychrysalide.debug.BinaryDebugger", .tp_basicsize = sizeof(PyGObject), .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_doc = "PyChrysalide binary debugger", .tp_methods = py_binary_debugger_methods, .tp_new = (newfunc)py_binary_debugger_new }; pygobj_mod = PyImport_ImportModule("gobject"); if (pygobj_mod == NULL) return false; py_binary_debugger_type.tp_base = (PyTypeObject *)PyObject_GetAttrString(pygobj_mod, "GObject"); Py_DECREF(pygobj_mod); if (PyType_Ready(&py_binary_debugger_type) < 0) return false; Py_INCREF(&py_binary_debugger_type); ret = PyModule_AddObject(module, "BinaryDebugger", (PyObject *)&py_binary_debugger_type); return (ret == 0); } #endif