/* 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.
*
* Chrysalide is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Chrysalide is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "debugger.h"
#if 0
#include <malloc.h>
#include <pygobject.h>
#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