/* 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 #include /* ---------------------------- 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; }