diff options
Diffstat (limited to 'plugins')
| -rw-r--r-- | plugins/pychrysa/Makefile.am | 8 | ||||
| -rw-r--r-- | plugins/pychrysa/analysis/binaries/file.c | 4 | ||||
| -rw-r--r-- | plugins/pychrysa/core/Makefile.am | 15 | ||||
| -rw-r--r-- | plugins/pychrysa/core/module.c | 91 | ||||
| -rw-r--r-- | plugins/pychrysa/core/module.h | 39 | ||||
| -rw-r--r-- | plugins/pychrysa/core/params.c | 178 | ||||
| -rw-r--r-- | plugins/pychrysa/core/params.h | 42 | ||||
| -rw-r--r-- | plugins/pychrysa/glibext/Makefile.am | 8 | ||||
| -rw-r--r-- | plugins/pychrysa/glibext/configuration.c | 1214 | ||||
| -rw-r--r-- | plugins/pychrysa/glibext/configuration.h | 66 | ||||
| -rw-r--r-- | plugins/pychrysa/glibext/module.c | 49 | ||||
| -rw-r--r-- | plugins/pychrysa/glibext/module.h | 6 | ||||
| -rw-r--r-- | plugins/pychrysa/pychrysa.c | 16 |
13 files changed, 1713 insertions, 23 deletions
diff --git a/plugins/pychrysa/Makefile.am b/plugins/pychrysa/Makefile.am index 8664193..8c59c10 100644 --- a/plugins/pychrysa/Makefile.am +++ b/plugins/pychrysa/Makefile.am @@ -27,11 +27,13 @@ pychrysalide_la_SOURCES = \ pychrysalide_la_LIBADD = \ analysis/libpychrysaanalysis.la \ - arch/libpychrysaarch.la + arch/libpychrysaarch.la \ + core/libpychrysacore.la \ + glibext/libpychrysaglibext.la pychrysalide_la_LDFLAGS = -module -avoid-version \ $(LIBPYTHON_LIBS) $(LIBSQLITE_LIBS) $(LIBARCHIVE_LIBS) \ - -L../../src/.libs -lchrysadisass -lchrysagtkext \ + -L../../src/.libs -lchrysadisass -lchrysagtkext -lchrysacore \ -L../../src/plugins/.libs -lplugins @@ -41,4 +43,4 @@ AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) $(LIBPYTHON_CFLAGS) $(LIBPYGOBJE AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) -SUBDIRS = analysis arch debug format glibext gtkext gui +SUBDIRS = analysis arch core debug format glibext gtkext gui diff --git a/plugins/pychrysa/analysis/binaries/file.c b/plugins/pychrysa/analysis/binaries/file.c index e5cc2f1..6bf553b 100644 --- a/plugins/pychrysa/analysis/binaries/file.c +++ b/plugins/pychrysa/analysis/binaries/file.c @@ -155,7 +155,7 @@ PyTypeObject *get_python_binary_file_type(void) * * * Paramètres : module = module dont la définition est à compléter. * * * -* Description : Prend en charge l'objet 'pychrysalide.analysis.LoadedBinary'.* +* Description : Prend en charge l'objet 'pychrysalide.analysis.BinaryFile'. * * * * Retour : Bilan de l'opération. * * * @@ -174,7 +174,7 @@ bool register_python_binary_file(PyObject *module) py_binary_file_type->tp_base = get_python_loaded_binary_type(); py_binary_file_type->tp_basicsize = py_binary_file_type->tp_base->tp_basicsize; - if (PyType_Ready(py_binary_file_type) < 0) + if (PyType_Ready(py_binary_file_type) != 0) return false; Py_INCREF(py_binary_file_type); diff --git a/plugins/pychrysa/core/Makefile.am b/plugins/pychrysa/core/Makefile.am new file mode 100644 index 0000000..1ffacf4 --- /dev/null +++ b/plugins/pychrysa/core/Makefile.am @@ -0,0 +1,15 @@ + +noinst_LTLIBRARIES = libpychrysacore.la + +libpychrysacore_la_SOURCES = \ + module.h module.c \ + params.h params.c + + +libpychrysacore_la_LDFLAGS = + + +AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) $(LIBPYTHON_CFLAGS) $(LIBPYGOBJECT_CFLAGS) \ + -I../../../src + +AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) diff --git a/plugins/pychrysa/core/module.c b/plugins/pychrysa/core/module.c new file mode 100644 index 0000000..489f173 --- /dev/null +++ b/plugins/pychrysa/core/module.c @@ -0,0 +1,91 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * module.c - intégration du répertoire core en tant que module + * + * Copyright (C) 2014 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 "module.h" + + +#include "params.h" + + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Ajoute le module 'core' au module Python. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool add_core_module_to_python_module(PyObject *super) +{ + bool result; /* Bilan à retourner */ + PyObject *module; /* Sous-module mis en place */ + int ret; /* Bilan d'un appel */ + + static PyModuleDef py_chrysalide_core_module = { + + .m_base = PyModuleDef_HEAD_INIT, + + .m_name = "pychrysalide.core", + .m_doc = "Python module for Chrysalide.core", + + .m_size = -1, + + }; + + result = false; + + module = PyModule_Create(&py_chrysalide_core_module); + if (module == NULL) return false; + + ret = PyState_AddModule(super, &py_chrysalide_core_module); + if (ret != 0) goto acmtpm_exit; + + ret = _PyImport_FixupBuiltin(module, "pychrysalide.core"); + if (ret != 0) goto acmtpm_exit; + + Py_INCREF(module); + ret = PyModule_AddObject(super, "core", module); + if (ret != 0) goto acmtpm_exit; + + result = true; + + result &= register_python_params(module); + + acmtpm_exit: + + if (!result) + { + printf("something went wrong in %s...\n", __FUNCTION__); + /* ... */ + + } + + return result; + +} diff --git a/plugins/pychrysa/core/module.h b/plugins/pychrysa/core/module.h new file mode 100644 index 0000000..1da57a1 --- /dev/null +++ b/plugins/pychrysa/core/module.h @@ -0,0 +1,39 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * module.h - prototypes pour l'intégration du répertoire core en tant que module + * + * Copyright (C) 2014 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 + */ + + +#ifndef _PLUGINS_PYCHRYSALIDE_CORE_MODULE_H +#define _PLUGINS_PYCHRYSALIDE_CORE_MODULE_H + + +#include <Python.h> +#include <stdbool.h> + + + +/* Ajoute le module 'core' au module Python. */ +bool add_core_module_to_python_module(PyObject *); + + + +#endif /* _PLUGINS_PYCHRYSALIDE_CORE_MODULE_H */ diff --git a/plugins/pychrysa/core/params.c b/plugins/pychrysa/core/params.c new file mode 100644 index 0000000..987bca6 --- /dev/null +++ b/plugins/pychrysa/core/params.c @@ -0,0 +1,178 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * params.c - équivalent Python du fichier "core/params.c" + * + * Copyright (C) 2014 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 "params.h" + + +#include <pygobject.h> + + +#include <core/params.h> + + + +/* Fournit la version du programme global. */ +static PyObject *py_params_get_main_configuration(PyObject *, PyObject *); + +/* Définit les constantes pour les paramètres. */ +static bool py_params_define_constants(PyObject *); + + + +/****************************************************************************** +* * +* Paramètres : self = NULL car méthode statique. * +* args = non utilisé ici. * +* * +* Description : Fournit la version du programme global. * +* * +* Retour : Numéro de révision. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_params_get_main_configuration(PyObject *self, PyObject *args) +{ + PyObject *result; /* Instance GLib à retourner */ + GGenConfig *config; /* Configuration à convertir */ + + config = get_main_configuration(); + + result = pygobject_new(G_OBJECT(config)); + Py_XINCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_params_type(void) +{ + static PyMethodDef py_params_methods[] = { + + { "get_main_configuration", py_params_get_main_configuration, + METH_NOARGS | METH_STATIC, + "Give access to the main configuration of Chrysalide." + }, + { NULL } + + }; + + static PyTypeObject py_params_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.core.params", + .tp_basicsize = sizeof(PyObject), + + .tp_flags = Py_TPFLAGS_DEFAULT, + + .tp_doc = "Python object for parameters", + + .tp_methods = py_params_methods + + }; + + return &py_params_type; + +} + + +/****************************************************************************** +* * +* Paramètres : dict = dictionnaire à compléter. * +* * +* Description : Définit les constantes pour les paramètres. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool py_params_define_constants(PyObject *dict) +{ + int ret; /* Bilan d'un ajout */ + +#define DEF_STR_CONST(name) \ + ret = PyDict_SetItemString(dict, #name, PyUnicode_FromString(name)); \ + if (ret == -1) return false; + + DEF_STR_CONST(MPK_LAST_PROJECT); + DEF_STR_CONST(MPK_ELLIPSIS_HEADER); + DEF_STR_CONST(MPK_ELLIPSIS_TAB); + DEF_STR_CONST(MPK_KEYBINDINGS_EDIT); + DEF_STR_CONST(MPK_AUTO_SAVE); + + return true; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide.core.params'. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_python_params(PyObject *module) +{ + PyTypeObject *py_params_type; /* Type Python pour 'params' */ + int ret; /* Bilan d'un appel */ + + py_params_type = get_python_params_type(); + + py_params_type->tp_new = PyType_GenericNew; + + if (PyType_Ready(py_params_type) != 0) + return false; + + if (!py_params_define_constants(py_params_type->tp_dict)) + return false; + + Py_INCREF(py_params_type); + ret = PyModule_AddObject(module, "params", (PyObject *)py_params_type); + + return (ret == 0); + +} diff --git a/plugins/pychrysa/core/params.h b/plugins/pychrysa/core/params.h new file mode 100644 index 0000000..23d1db5 --- /dev/null +++ b/plugins/pychrysa/core/params.h @@ -0,0 +1,42 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * params.h - prototypes pour l'équivalent Python du fichier "core/params.h" + * + * Copyright (C) 2014 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 + */ + + +#ifndef _PLUGINS_PYCHRYSALIDE_CORE_PARAMS_H +#define _PLUGINS_PYCHRYSALIDE_CORE_PARAMS_H + + +#include <Python.h> +#include <stdbool.h> + + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_params_type(void); + +/* Prend en charge l'objet 'pychrysalide.core.params'. */ +bool register_python_params(PyObject *); + + + +#endif /* _PLUGINS_PYCHRYSALIDE_CORE_PARAMS_H */ diff --git a/plugins/pychrysa/glibext/Makefile.am b/plugins/pychrysa/glibext/Makefile.am index 14ab026..8383434 100644 --- a/plugins/pychrysa/glibext/Makefile.am +++ b/plugins/pychrysa/glibext/Makefile.am @@ -1,9 +1,13 @@ noinst_LTLIBRARIES = libpychrysaglibext.la +# libpychrysaglibext_la_SOURCES = \ +# bufferline.h bufferline.c \ +# codebuffer.h codebuffer.c \ +# module.h module.c + libpychrysaglibext_la_SOURCES = \ - bufferline.h bufferline.c \ - codebuffer.h codebuffer.c \ + configuration.h configuration.c \ module.h module.c diff --git a/plugins/pychrysa/glibext/configuration.c b/plugins/pychrysa/glibext/configuration.c new file mode 100644 index 0000000..9820af3 --- /dev/null +++ b/plugins/pychrysa/glibext/configuration.c @@ -0,0 +1,1214 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * configuration.c - prototypes pour l'équivalent Python du fichier "glibext/configuration.c" + * + * 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 "configuration.h" + + +#include <pygobject.h> + + +#include <glibext/configuration.h> + + + +/* ---------------------------- ELEMENT DE CONFIGURATION ---------------------------- */ + + +/* Crée un nouvel objet Python de type 'ConfigParam'. */ +static PyObject *py_config_param_new(PyTypeObject *, PyObject *, PyObject *); + +/* Efface toute valeur courante d'un paramètre de configuration. */ +static PyObject *py_config_param_make_empty(PyObject *, PyObject *); + +/* Réinitialise la valeur d'un paramètre de configuration. */ +static PyObject *py_config_param_reset(PyObject *, PyObject *); + +/* Indique le chemin d'accès utilisé pour un paramètre. */ +static PyObject *py_config_param_get_path(PyObject *, void *); + +/* Indique le type de valeur utilisée par un paramètre. */ +static PyObject *py_config_param_get_type(PyObject *, void *); + +/* Indique le statut d'une valeur utilisée par un paramètre. */ +static PyObject *py_config_param_get_state(PyObject *, void *); + +/* Indique la valeur courante d'un paramètre de configuration. */ +static PyObject *py_config_param_get_value(PyObject *, void *); + +/* Modifie la valeur courante d'un paramètre de configuration. */ +static int py_config_param_set_value(PyObject *, PyObject *, void *); + +/* Définit les constantes pour les paramètres. */ +static bool py_config_param_define_constants(PyObject *); + + + +/* ----------------------------- PARCOURS DE PARAMETRES ----------------------------- */ + + + +typedef struct _pyConfigParamIterator +{ + + PyObject_HEAD + long int m; + long int i; + + + + GGenConfig *config; /* Configuration à parcourir */ + GList *params; /* Liste de paramètres */ + + GList *last; /* Dernier élément retourné */ + +} pyConfigParamIterator; + + + + +/* Prend acte d'un compteur de référence à 0. */ +static void py_config_param_iterator_dealloc(PyObject *); + +/* Fournit un itérateur pour paramètres de configuration. */ +static PyObject *py_config_param_iterator_iter(PyObject *); + +/* Fournit un itérateur pour paramètres de configuration. */ +static PyObject *py_config_param_iterator_next(PyObject *); + +/* Initialise un objet Python de type 'ConfigParamIterator'. */ +static int py_config_param_iterator_init(PyObject *, PyObject *, PyObject *); + + + +/* ----------------------- GESTION GENERIQUE DE CONFIGURATION ----------------------- */ + + +/* Crée un nouvel objet Python de type 'GenConfig'. */ +static PyObject *py_generic_config_new(PyTypeObject *, PyObject *, PyObject *); + +/* Lit la configuration depuis un fichier. */ +static PyObject *py_generic_config_read(PyObject *, PyObject *); + +/* Ecrit la configuration dans un fichier. */ +static PyObject *py_generic_config_write(PyObject *, PyObject *); + +/* Retrouve un élément de configuration par son chemin. */ +static PyObject *py_generic_config_search(PyObject *, PyObject *); + +/* Ajoute un paramètre à une configuration. */ +static PyObject *py_generic_config_add(PyObject *, PyObject *); + +/* Retire un paramètre d'une configuration. */ +static PyObject *py_generic_config_delete(PyObject *, PyObject *); + +/* Fournit le chemin d'accès au binaire représenté. */ +static PyObject *py_generic_config_get_filename(PyObject *, void *); + + + +/* ---------------------------------------------------------------------------------- */ +/* ELEMENT DE CONFIGURATION */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* 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 'ConfigParam'. * +* * +* Retour : Instance Python mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *result; /* Instance à retourner */ + char *path; /* Accès au paramètre */ + unsigned int ptype; /* Type de paramètre */ + PyObject *value; /* Valeur par défaut éventuelle*/ + int ret; /* Bilan de lecture des args. */ + GCfgParam *param; /* Paramètre mis en place */ + + value = NULL; + + ret = PyArg_ParseTuple(args, "sI|O", &path, &ptype, &value); + if (!ret) Py_RETURN_NONE; + + if (value == NULL || value == Py_None) + param = g_config_param_new_empty(path, ptype); + + else + switch (ptype) + { + case CPT_BOOLEAN: + if (PyBool_Check(value)) + param = g_config_param_new(path, CPT_BOOLEAN, (bool)(value == Py_True)); + else + param = NULL; + break; + + case CPT_INTEGER: + if (PyLong_Check(value)) + param = g_config_param_new(path, CPT_INTEGER, (int)PyLong_AsLong(value)); + else + param = NULL; + break; + + case CPT_STRING: + if (PyUnicode_Check(value)) + param = g_config_param_new(path, CPT_STRING, PyUnicode_DATA(value)); + else + param = NULL; + break; + + default: + param = NULL; + break; + + } + + if (param != NULL) + { + result = pygobject_new(G_OBJECT(param)); + g_object_unref(param); + } + else result = NULL; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = paramètre de configuration à manipuler. * +* args = non utilisé ici. * +* * +* Description : Efface toute valeur courante d'un paramètre de configuration.* +* * +* Retour : None. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_make_empty(PyObject *self, PyObject *args) +{ + GCfgParam *param; /* Paramètre visé par l'opérat°*/ + + param = G_CFG_PARAM(pygobject_get(self)); + + g_config_param_make_empty(param); + + Py_RETURN_NONE; + +} + + +/****************************************************************************** +* * +* Paramètres : self = paramètre de configuration à manipuler. * +* args = non utilisé ici. * +* * +* Description : Réinitialise la valeur d'un paramètre de configuration. * +* * +* Retour : None. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_reset(PyObject *self, PyObject *args) +{ + GCfgParam *param; /* Paramètre visé par l'opérat°*/ + + param = G_CFG_PARAM(pygobject_get(self)); + + g_config_param_reset(param); + + Py_RETURN_NONE; + +} + + +/****************************************************************************** +* * +* Paramètres : self = paramètre de configuration à manipuler. * +* closure = non utilisé ici. * +* * +* Description : Indique le chemin d'accès utilisé pour un paramètre. * +* * +* Retour : Chemin d'accès en Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_get_path(PyObject *self, void *closure) +{ + GCfgParam *param; /* Paramètre visé par l'opérat°*/ + const char *path; /* Chemin d'accès à diffuser */ + + param = G_CFG_PARAM(pygobject_get(self)); + path = g_config_param_get_path(param); + + return PyUnicode_FromString(path); + +} + + +/****************************************************************************** +* * +* Paramètres : self = paramètre de configuration à manipuler. * +* closure = non utilisé ici. * +* * +* Description : Indique le type de valeur utilisée par un paramètre. * +* * +* Retour : Type en Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_get_type(PyObject *self, void *closure) +{ + GCfgParam *param; /* Paramètre visé par l'opérat°*/ + ConfigParamType type; /* Type de paramètre */ + + param = G_CFG_PARAM(pygobject_get(self)); + type = g_config_param_get_ptype(param); + + return PyLong_FromLong(type); + +} + + +/****************************************************************************** +* * +* Paramètres : self = paramètre de configuration à manipuler. * +* closure = non utilisé ici. * +* * +* Description : Indique le statut d'une valeur utilisée par un paramètre. * +* * +* Retour : Etat en Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_get_state(PyObject *self, void *closure) +{ + GCfgParam *param; /* Paramètre visé par l'opérat°*/ + ConfigParamState state; /* Statut de paramètre */ + + param = G_CFG_PARAM(pygobject_get(self)); + state = g_config_param_get_state(param); + + return PyLong_FromLong(state); + +} + + +/****************************************************************************** +* * +* Paramètres : self = paramètre de configuration à manipuler. * +* closure = non utilisé ici. * +* * +* Description : Indique la valeur courante d'un paramètre de configuration. * +* * +* Retour : Etat en Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_get_value(PyObject *self, void *closure) +{ + PyObject *result; /* Valeur à retourner */ + GCfgParam *param; /* Paramètre visé par l'opérat°*/ + ConfigParamType type; /* Type de paramètre manipulé */ + bool boolean; /* Valeur booléenne */ + int integer; /* Valeur entière */ + char *string; /* Chaîne de caractères */ + + param = G_CFG_PARAM(pygobject_get(self)); + type = g_config_param_get_ptype(param); + + switch (type) + { + case CPT_BOOLEAN: + g_config_param_get_value(param, &boolean); + result = (boolean ? Py_True : Py_False); + Py_INCREF(result); + break; + + case CPT_INTEGER: + g_config_param_get_value(param, &integer); + result = PyLong_FromLong(integer); + break; + + case CPT_STRING: + g_config_param_get_value(param, &string); + if (string != NULL) + result = PyUnicode_FromString(string); + else + { + result = Py_None; + Py_INCREF(result); + } + break; + + default: + result = NULL; + break; + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = paramètre de configuration à manipuler. * +* value = nouvelle valeur à convertir et définir. * +* closure = non utilisé ici. * +* * +* Description : Modifie la valeur courante d'un paramètre de configuration. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static int py_config_param_set_value(PyObject *self, PyObject *value, void *closure) +{ + int result; /* Conclusion à remonter */ + GCfgParam *param; /* Paramètre visé par l'opérat°*/ + ConfigParamType type; /* Type de paramètre manipulé */ + + result = -1; + + param = G_CFG_PARAM(pygobject_get(self)); + + if (value == Py_None) + { + g_config_param_make_empty(param); + result = 0; + } + + else + { + type = g_config_param_get_ptype(param); + + switch (type) + { + case CPT_BOOLEAN: + if (PyBool_Check(value)) + { + g_config_param_set_value(param, (bool)(value == Py_True)); + result = 0; + } + break; + + case CPT_INTEGER: + if (PyLong_Check(value)) + { + g_config_param_set_value(param, (int)PyLong_AsLong(value)); + result = 0; + } + break; + + case CPT_STRING: + if (PyUnicode_Check(value)) + { + g_config_param_set_value(param, PyUnicode_DATA(value)); + result = 0; + } + break; + + default: + break; + + } + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_config_param_type(void) +{ + static PyMethodDef py_config_param_methods[] = { + { "make_empty", py_config_param_make_empty, + METH_NOARGS, + "Unset the value of the current parameter." + }, + { "reset", py_config_param_reset, + METH_NOARGS, + "Reset the content of the current parameter." + }, + { NULL } + }; + + static PyGetSetDef py_config_param_getseters[] = { + { + "path", py_config_param_get_path, NULL, + "Show the path used as key for a configuration parameter.", NULL + }, + { + "type", py_config_param_get_type, NULL, + "Show the type of value provided by a configuration parameter.", NULL + }, + { + "state", py_config_param_get_state, NULL, + "Show the state of a configuration parameter.", NULL + }, + { + "value", py_config_param_get_value, py_config_param_set_value, + "Handle the value of a configuration parameter.", NULL + }, + { NULL } + }; + + static PyTypeObject py_config_param_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.glibext.ConfigParam", + .tp_basicsize = sizeof(PyGObject), + + .tp_flags = Py_TPFLAGS_DEFAULT, + + .tp_doc = "PyChrysalide generic configuration", + + .tp_methods = py_config_param_methods, + .tp_getset = py_config_param_getseters, + .tp_new = (newfunc)py_config_param_new + + }; + + return &py_config_param_type; + +} + + +/****************************************************************************** +* * +* Paramètres : dict = dictionnaire à compléter. * +* * +* Description : Définit les constantes pour les paramètres. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool py_config_param_define_constants(PyObject *dict) +{ + int ret; /* Bilan d'un ajout */ + +#define DEF_ULONG_CONST(name) \ + ret = PyDict_SetItemString(dict, #name, PyLong_FromUnsignedLong(name)); \ + if (ret == -1) return false; + + DEF_ULONG_CONST(CPT_BOOLEAN); + DEF_ULONG_CONST(CPT_INTEGER); + DEF_ULONG_CONST(CPT_STRING); + DEF_ULONG_CONST(CPT_COUNT); + + DEF_ULONG_CONST(CPS_UNDEFINED); + DEF_ULONG_CONST(CPS_CHANGED); + DEF_ULONG_CONST(CPS_DEFAULT); + DEF_ULONG_CONST(CPS_EMPTY); + + return true; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide.glibext.ConfigParam'. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_python_config_param(PyObject *module) +{ + PyTypeObject *py_config_param_type; /* Type Python 'ConfigParam' */ + int ret; /* Bilan d'un appel */ + PyObject *dict; /* Dictionnaire du module */ + + py_config_param_type = get_python_config_param_type(); + + py_config_param_type->tp_base = &PyGObject_Type; + py_config_param_type->tp_basicsize = py_config_param_type->tp_base->tp_basicsize; + + if (PyType_Ready(py_config_param_type) != 0) + return false; + + if (!py_config_param_define_constants(py_config_param_type->tp_dict)) + return false; + + Py_INCREF(py_config_param_type); + ret = PyModule_AddObject(module, "ConfigParam", (PyObject *)py_config_param_type); + if (ret != 0) return false; + + dict = PyModule_GetDict(module); + pygobject_register_class(dict, "ConfigParam", G_TYPE_CFG_PARAM, py_config_param_type, + Py_BuildValue("(O)", py_config_param_type->tp_base)); + + return true; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* PARCOURS DE PARAMETRES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : self = instance Python à libérer de la mémoire. * +* * +* Description : Prend acte d'un compteur de référence à 0. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void py_config_param_iterator_dealloc(PyObject *self) +{ + pyConfigParamIterator *iterator; /* Références pour le parcours */ + + /** + * Il aurait été sans doute mieux de reposer ici sur .tp_finalize, + * mais cela semble impliquer de mettre en place tous les mécanismes de GC... + * + * cf. https://docs.python.org/3/extending/newtypes.html#finalization-and-de-allocation + */ + + iterator = (pyConfigParamIterator *)self; + + g_generic_config_runlock(iterator->config); + g_object_unref(G_OBJECT(iterator->config)); + + Py_TYPE(self)->tp_free((PyObject*)self); + +} + + +/****************************************************************************** +* * +* Paramètres : self = itérateur à manipuler. * +* * +* Description : Fournit un itérateur pour paramètres de configuration. * +* * +* Retour : Instance Python prête à emploi. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_iterator_iter(PyObject *self) +{ + Py_INCREF(self); + + return self; + +} + + +/****************************************************************************** +* * +* Paramètres : self = itérateur à manipuler. * +* * +* Description : Fournit un itérateur pour paramètres de configuration. * +* * +* Retour : Instance Python prête à emploi. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_config_param_iterator_next(PyObject *self) +{ + PyObject *result; /* Instance à retourner */ + pyConfigParamIterator *iterator; /* Références pour le parcours */ + GList *item; /* Nouvel élément courant */ + + iterator = (pyConfigParamIterator *)self; + + if (iterator->last == NULL) item = iterator->params; + else item = g_list_next(iterator->last); + + iterator->last = item; + + if (item != NULL) + { + result = pygobject_new(G_OBJECT(item->data)); + Py_XINCREF(result); + } + else + { + PyErr_SetNone(PyExc_StopIteration); + result = NULL; + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet instancié à initialiser. * +* args = arguments fournis à l'appel. * +* kwds = arguments de type key=val fournis. * +* * +* Description : Initialise un objet Python de type 'ConfigParamIterator'. * +* * +* Retour : Instance Python mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static int py_config_param_iterator_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + pyConfigParamIterator *iterator; /* Références pour le parcours */ + PyObject *config; /* Configuration format Python */ + int ret; /* Bilan de lecture des args. */ + + ret = PyArg_ParseTuple(args, "O", &config); + if (!ret) return -1; + + ret = PyObject_IsInstance(config, (PyObject *)get_python_generic_config_type()); + if (!ret) return -1; + + iterator = (pyConfigParamIterator *)self; + + iterator->config = G_GEN_CONFIG(pygobject_get(config)); + g_object_ref(G_OBJECT(iterator->config)); + + g_generic_config_rlock(iterator->config); + + iterator->params = g_generic_config_list_params(iterator->config); + + iterator->last = NULL; + + return 0; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_config_param_iterator_type(void) +{ + static PyTypeObject py_config_param_iterator_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.glibext.ConfigParamIterator", + .tp_basicsize = sizeof(pyConfigParamIterator), + + .tp_dealloc = py_config_param_iterator_dealloc, + + .tp_flags = Py_TPFLAGS_DEFAULT, + + .tp_doc = "Iterator for configuration parameters", + + .tp_iter = py_config_param_iterator_iter, + .tp_iternext = py_config_param_iterator_next, + + .tp_init = py_config_param_iterator_init, + + .tp_new = PyType_GenericNew, + + }; + + return &py_config_param_iterator_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide...ConfigParamIterator'.* +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_python_config_param_iterator(PyObject *module) +{ + PyTypeObject *py_config_param_iterator_type; /* Type Python 'ConfigParamIterator' */ + int ret; /* Bilan d'un appel */ + + py_config_param_iterator_type = get_python_config_param_iterator_type(); + + py_config_param_iterator_type->tp_base = &PyBaseObject_Type; + py_config_param_iterator_type->tp_basicsize = py_config_param_iterator_type->tp_base->tp_basicsize; + + if (PyType_Ready(py_config_param_iterator_type) != 0) + return false; + + Py_INCREF(py_config_param_iterator_type); + ret = PyModule_AddObject(module, "ConfigParamIterator", (PyObject *)py_config_param_iterator_type); + if (ret != 0) return false; + + return true; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* GESTION GENERIQUE DE CONFIGURATION */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* 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 'GenConfig'. * +* * +* Retour : Instance Python mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *result; /* Instance à retourner */ + char *name; /* Nom du fichier à charger */ + int ret; /* Bilan de lecture des args. */ + GGenConfig *config; /* Version GLib du format */ + + ret = PyArg_ParseTuple(args, "s", &name); + if (!ret) Py_RETURN_NONE; + + config = g_generic_config_new(name); + + result = pygobject_new(G_OBJECT(config)); + g_object_unref(config); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = configuration à manipuler. * +* args = non utilisé ici. * +* * +* Description : Lit la configuration depuis un fichier. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_read(PyObject *self, PyObject *args) +{ + PyObject *result; /* Instance à retourner */ + GGenConfig *config; /* Version GLib du format */ + bool status; /* Bilan de l'opération */ + + config = G_GEN_CONFIG(pygobject_get(self)); + + status = g_generic_config_read(config); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = configuration à manipuler. * +* args = non utilisé ici. * +* * +* Description : Ecrit la configuration dans un fichier. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_write(PyObject *self, PyObject *args) +{ + PyObject *result; /* Instance à retourner */ + GGenConfig *config; /* Version GLib du format */ + bool status; /* Bilan de l'opération */ + + config = G_GEN_CONFIG(pygobject_get(self)); + + status = g_generic_config_write(config); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = configuration à manipuler. * +* args = indication sur l'élément à retrouver. * +* * +* Description : Retrouve un élément de configuration par son chemin. * +* * +* Retour : Elément trouvé ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_search(PyObject *self, PyObject *args) +{ + PyObject *result; /* Instance à retourner */ + GGenConfig *config; /* Version GLib du format */ + char *path; /* Chemin d'accès du paramètre */ + int ret; /* Bilan de lecture des args. */ + GCfgParam *param; /* Paramètre trouvé ou NULL */ + + config = G_GEN_CONFIG(pygobject_get(self)); + + ret = PyArg_ParseTuple(args, "s", &path); + if (!ret) Py_RETURN_NONE; + + param = g_generic_config_search(config, path); + + result = pygobject_new(G_OBJECT(param)); + Py_XINCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = configuration à manipuler. * +* args = indication sur l'élément à retrouver. * +* * +* Description : Ajoute un paramètre à une configuration. * +* * +* Retour : Elément ajouté ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_add(PyObject *self, PyObject *args) +{ + PyObject *result; /* Instance à retourner */ + GGenConfig *config; /* Version GLib du format */ + PyObject *param; /* Paramètre transmis */ + int ret; /* Bilan de lecture des args. */ + GCfgParam *added; /* Elément ajouté ou NULL */ + + config = G_GEN_CONFIG(pygobject_get(self)); + + ret = PyArg_ParseTuple(args, "O", ¶m); + if (!ret) Py_RETURN_NONE; + + ret = PyObject_IsInstance(param, (PyObject *)get_python_config_param_type()); + if (!ret) Py_RETURN_NONE; + + added = g_generic_config_add_param(config, G_CFG_PARAM(pygobject_get(param))); + + if (added != NULL) + { + result = pygobject_new(G_OBJECT(added)); + Py_XINCREF(result); + } + else + result = NULL; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = configuration à manipuler. * +* args = indication sur l'élément à retrouver. * +* * +* Description : Retire un paramètre d'une configuration. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_delete(PyObject *self, PyObject *args) +{ + GGenConfig *config; /* Version GLib du format */ + char *path; /* Chemin d'accès du paramètre */ + int ret; /* Bilan de lecture des args. */ + + config = G_GEN_CONFIG(pygobject_get(self)); + + ret = PyArg_ParseTuple(args, "s", &path); + if (!ret) Py_RETURN_NONE; + + g_generic_config_delete_param(config, path); + + Py_RETURN_NONE; + +} + + +/****************************************************************************** +* * +* Paramètres : self = configuration à manipuler. * +* args = non utilisé ici. * +* * +* Description : Renvoie la liste des paramètres de configuration. * +* * +* Retour : Itérateur pour la liste des paramètres. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_list_params(PyObject *self, PyObject *args) +{ + PyObject *result; /* Instance à retourner */ + PyTypeObject *iterator_type; /* Type Python de l'itérateur */ + PyObject *args_list; /* Arguments de mise en place */ + + iterator_type = get_python_config_param_iterator_type(); + + Py_INCREF(self); + + args_list = Py_BuildValue("(O)", self); + result = PyObject_CallObject((PyObject *)iterator_type, args_list); + + Py_DECREF(args_list); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = NULL car méthode statique. * +* closure = non utilisé ici. * +* * +* Description : Fournit le chemin d'accès au binaire représenté. * +* * +* Retour : Chemin d'accès en Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_generic_config_get_filename(PyObject *self, void *closure) +{ + GGenConfig *config; /* Version GLib du format */ + const char *filename; /* Chemin d'accès au fichier */ + + config = G_GEN_CONFIG(pygobject_get(self)); + + filename = g_generic_config_get_filename(config); + + return PyUnicode_FromString(filename); + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_generic_config_type(void) +{ + static PyMethodDef py_generic_config_methods[] = { + { "read", py_generic_config_read, + METH_NOARGS, + "Read the configuration from its relative XML file." + }, + { "write", py_generic_config_write, + METH_NOARGS, + "Write the configuration to its relative XML file." + }, + { "search", py_generic_config_search, + METH_VARARGS, + "Look for a given configuration parameter." + }, + { "add", py_generic_config_add, + METH_VARARGS, + "Add an existing parameter to a configuration." + }, + { "delete", py_generic_config_delete, + METH_VARARGS, + "Delete an existing parameter from a configuration." + }, + { "params", py_generic_config_list_params, + METH_NOARGS, + "List all registered configuration parameters." + }, + { NULL } + }; + + static PyGetSetDef py_generic_config_getseters[] = { + { + "filename", py_generic_config_get_filename, NULL, + "Show the filename of the loaded binary file.", NULL + }, + { NULL } + }; + + static PyTypeObject py_generic_config_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.glibext.GenConfig", + .tp_basicsize = sizeof(PyGObject), + + .tp_flags = Py_TPFLAGS_DEFAULT, + + .tp_doc = "PyChrysalide generic configuration", + + .tp_methods = py_generic_config_methods, + .tp_getset = py_generic_config_getseters, + .tp_new = (newfunc)py_generic_config_new + + }; + + return &py_generic_config_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide.glibext.GenConfig'. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_python_generic_config(PyObject *module) +{ + PyTypeObject *py_generic_config_type; /* Type Python 'GenConfig' */ + int ret; /* Bilan d'un appel */ + PyObject *dict; /* Dictionnaire du module */ + + py_generic_config_type = get_python_generic_config_type(); + + py_generic_config_type->tp_base = &PyGObject_Type; + py_generic_config_type->tp_basicsize = py_generic_config_type->tp_base->tp_basicsize; + + if (PyType_Ready(py_generic_config_type) != 0) + return false; + + Py_INCREF(py_generic_config_type); + ret = PyModule_AddObject(module, "GenConfig", (PyObject *)py_generic_config_type); + if (ret != 0) return false; + + dict = PyModule_GetDict(module); + pygobject_register_class(dict, "GenConfig", G_TYPE_GEN_CONFIG, py_generic_config_type, + Py_BuildValue("(O)", py_generic_config_type->tp_base)); + + return true; + +} diff --git a/plugins/pychrysa/glibext/configuration.h b/plugins/pychrysa/glibext/configuration.h new file mode 100644 index 0000000..e55b3e1 --- /dev/null +++ b/plugins/pychrysa/glibext/configuration.h @@ -0,0 +1,66 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * configuration.h - prototypes pour l'équivalent Python du fichier "glibext/configuration.h" + * + * Copyright (C) 2014 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 + */ + + +#ifndef _PLUGINS_PYCHRYSA_GLIBEXT_CONFIGURATION_H +#define _PLUGINS_PYCHRYSA_GLIBEXT_CONFIGURATION_H + + +#include <Python.h> +#include <stdbool.h> + + + +/* ---------------------------- ELEMENT DE CONFIGURATION ---------------------------- */ + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_config_param_type(void); + +/* Prend en charge l'objet 'pychrysalide.glibext.ConfigParam'. */ +bool register_python_config_param(PyObject *); + + + +/* ----------------------------- PARCOURS DE PARAMETRES ----------------------------- */ + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_config_param_iterator_type(void); + +/* Prend en charge l'objet 'pychrysalide.glibext.ConfigParamIterator'. */ +bool register_python_config_param_iterator(PyObject *); + + +/* ----------------------- GESTION GENERIQUE DE CONFIGURATION ----------------------- */ + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_generic_config_type(void); + +/* Prend en charge l'objet 'pychrysalide.glibext.GenConfig'. */ +bool register_python_generic_config(PyObject *); + + + +#endif /* _PLUGINS_PYCHRYSA_GLIBEXT_CONFIGURATION_H */ diff --git a/plugins/pychrysa/glibext/module.c b/plugins/pychrysa/glibext/module.c index b62ae7b..9f3d3a8 100644 --- a/plugins/pychrysa/glibext/module.c +++ b/plugins/pychrysa/glibext/module.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * module.c - intégration du répertoire glibext en tant que module * - * Copyright (C) 2012 Cyrille Bagard + * Copyright (C) 2012-2014 Cyrille Bagard * * This file is part of Chrysalide. * @@ -25,8 +25,7 @@ #include "module.h" -#include "bufferline.h" -#include "codebuffer.h" +#include "configuration.h" @@ -44,24 +43,50 @@ bool add_glibext_module_to_python_module(PyObject *super) { - bool result; - PyObject *module; + bool result; /* Bilan à retourner */ + PyObject *module; /* Sous-module mis en place */ int ret; /* Bilan d'un appel */ - static PyMethodDef py_glibext_methods[] = { - { NULL } + static PyModuleDef py_chrysalide_glibext_module = { + + .m_base = PyModuleDef_HEAD_INIT, + + .m_name = "pychrysalide.glibext", + .m_doc = "Python module for Chrysalide.glibext", + + .m_size = -1, + }; - module = Py_InitModule("pychrysalide.glibext", py_glibext_methods); + result = false; + + module = PyModule_Create(&py_chrysalide_glibext_module); if (module == NULL) return false; + ret = PyState_AddModule(super, &py_chrysalide_glibext_module); + if (ret != 0) goto agmtpm_exit; + + ret = _PyImport_FixupBuiltin(module, "pychrysalide.glibext"); + if (ret != 0) goto agmtpm_exit; + Py_INCREF(module); - ret = PyModule_AddObject(super, "pychrysalide.glibext", module); + ret = PyModule_AddObject(super, "glibext", module); + if (ret != 0) goto agmtpm_exit; + + result = true; + + result &= register_python_config_param(module); + result &= register_python_config_param_iterator(module); + result &= register_python_generic_config(module); + + agmtpm_exit: - result = (ret == 0); + if (!result) + { + printf("something went wrong in %s...\n", __FUNCTION__); + /* ... */ - result &= register_python_buffer_line(module); - result &= register_python_code_buffer(module); + } return result; diff --git a/plugins/pychrysa/glibext/module.h b/plugins/pychrysa/glibext/module.h index fe13d4c..ddcab15 100644 --- a/plugins/pychrysa/glibext/module.h +++ b/plugins/pychrysa/glibext/module.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * module.h - prototypes pour l'intégration du répertoire glibext en tant que module * - * Copyright (C) 2012 Cyrille Bagard + * Copyright (C) 2012-2014 Cyrille Bagard * * This file is part of Chrysalide. * @@ -22,8 +22,8 @@ */ -#ifndef _PLUGINS_PYOIDA_GLIBEXT_MODULE_H -#define _PLUGINS_PYOIDA_GLIBEXT_MODULE_H +#ifndef _PLUGINS_PYCHRYSALIDE_GLIBEXT_MODULE_H +#define _PLUGINS_PYCHRYSALIDE_GLIBEXT_MODULE_H #include <Python.h> diff --git a/plugins/pychrysa/pychrysa.c b/plugins/pychrysa/pychrysa.c index 865c0fc..1835b18 100644 --- a/plugins/pychrysa/pychrysa.c +++ b/plugins/pychrysa/pychrysa.c @@ -57,7 +57,6 @@ - static PyMethodDef SpamMethods[] = { {NULL, NULL, 0, NULL} /* Sentinel */ }; @@ -351,8 +350,15 @@ PyMODINIT_FUNC initpychrysa(void) #include "../../revision.h" + +#include <core/core.h> + + + #include "analysis/module.h" #include "arch/module.h" +#include "core/module.h" +#include "glibext/module.h" @@ -458,6 +464,12 @@ PyMODINIT_FUNC PyInit_pychrysalide(void) if (pygobject_init(-1, -1, -1) == NULL) return NULL; + if (!load_all_basic_components()) + return NULL; + + + + /** * Pour une raison non identifiée, si le module n'est pas préchargé, * le flot d'exécution plante dans la fonction insertdict() de Objects/dictobject.c:818. @@ -472,6 +484,8 @@ PyMODINIT_FUNC PyInit_pychrysalide(void) status &= add_analysis_module_to_python_module(result); status &= add_arch_module_to_python_module(result); + status &= add_core_module_to_python_module(result); + status &= add_glibext_module_to_python_module(result); printf("status :: %d\n", status); |