summaryrefslogtreecommitdiff
path: root/plugins/pychrysalide/common
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/pychrysalide/common')
-rw-r--r--plugins/pychrysalide/common/Makefile.am18
-rw-r--r--plugins/pychrysalide/common/bits.c32
-rw-r--r--plugins/pychrysalide/common/entropy.c119
-rw-r--r--plugins/pychrysalide/common/entropy.h39
-rw-r--r--plugins/pychrysalide/common/leb128.c139
-rw-r--r--plugins/pychrysalide/common/module.c22
-rw-r--r--plugins/pychrysalide/common/xdg.c384
-rw-r--r--plugins/pychrysalide/common/xdg.h39
8 files changed, 706 insertions, 86 deletions
diff --git a/plugins/pychrysalide/common/Makefile.am b/plugins/pychrysalide/common/Makefile.am
index b5249b9..ad58900 100644
--- a/plugins/pychrysalide/common/Makefile.am
+++ b/plugins/pychrysalide/common/Makefile.am
@@ -1,16 +1,22 @@
noinst_LTLIBRARIES = libpychrysacommon.la
+# libpychrysacommon_la_SOURCES = \
+# bits.h bits.c \
+# fnv1a.h fnv1a.c \
+# hex.h hex.c \
+# itoa.h itoa.c \
+# module.h module.c \
+# packed.h packed.c \
+# pathname.h pathname.c \
+# pearson.h pearson.c
+
libpychrysacommon_la_SOURCES = \
bits.h bits.c \
- fnv1a.h fnv1a.c \
- hex.h hex.c \
- itoa.h itoa.c \
+ entropy.h entropy.c \
leb128.h leb128.c \
module.h module.c \
- packed.h packed.c \
- pathname.h pathname.c \
- pearson.h pearson.c
+ xdg.h xdg.c
libpychrysacommon_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBXML_CFLAGS) $(LIBPYTHON_INTERPRETER_CFLAGS) $(LIBPYGOBJECT_CFLAGS) \
-I$(top_srcdir)/src -DNO_IMPORT_PYGOBJECT
diff --git a/plugins/pychrysalide/common/bits.c b/plugins/pychrysalide/common/bits.c
index a127251..35d6ea4 100644
--- a/plugins/pychrysalide/common/bits.c
+++ b/plugins/pychrysalide/common/bits.c
@@ -534,27 +534,33 @@ static PyObject *py_bitfield_set_all(PyObject *self, PyObject *args)
static PyObject *py_bitfield_reset(PyObject *self, PyObject *args)
{
- unsigned long first; /* Indice du premier bit testé */
unsigned long count; /* Nombre de bits à analyser */
+ unsigned long first; /* Indice du premier bit testé */
int ret; /* Bilan de lecture des args. */
py_bitfield_t *bf; /* Instance à manipuler */
#define BITFIELD_RESET_METHOD PYTHON_METHOD_DEF \
( \
- reset, "$self, first, count, /", \
+ reset, "$self, first, /, count=1", \
METH_VARARGS, py_bitfield, \
"Switch to 0 a part of bits in a bitfield.\n" \
"\n" \
"The area to process starts at bit *first* and has a" \
- " size of *count* bits." \
+ " size of *count* bits (only one bit is processed if" \
+ " no *size* is provided)." \
)
- ret = PyArg_ParseTuple(args, "kk", &first, &count);
+ count = 1;
+
+ ret = PyArg_ParseTuple(args, "k|k", &first, &count);
if (!ret) return NULL;
bf = (py_bitfield_t *)self;
- reset_in_bit_field(bf->native, first, count);
+ if (count == 1)
+ reset_in_bit_field(bf->native, first);
+ else
+ reset_multi_in_bit_field(bf->native, first, count);
Py_RETURN_NONE;
@@ -576,27 +582,33 @@ static PyObject *py_bitfield_reset(PyObject *self, PyObject *args)
static PyObject *py_bitfield_set(PyObject *self, PyObject *args)
{
- unsigned long first; /* Indice du premier bit testé */
unsigned long count; /* Nombre de bits à analyser */
+ unsigned long first; /* Indice du premier bit testé */
int ret; /* Bilan de lecture des args. */
py_bitfield_t *bf; /* Instance à manipuler */
#define BITFIELD_SET_METHOD PYTHON_METHOD_DEF \
( \
- set, "$self, first, count, /", \
+ set, "$self, first, /, count=1", \
METH_VARARGS, py_bitfield, \
"Switch to 1 a part of bits in a bitfield.\n" \
"\n" \
"The area to process starts at bit *first* and has a" \
- " size of *count* bits." \
+ " size of *count* bits (only one bit is processed if" \
+ " no *size* is provided)." \
)
- ret = PyArg_ParseTuple(args, "kk", &first, &count);
+ count = 1;
+
+ ret = PyArg_ParseTuple(args, "k|k", &first, &count);
if (!ret) return NULL;
bf = (py_bitfield_t *)self;
- set_in_bit_field(bf->native, first, count);
+ if (count == 1)
+ set_in_bit_field(bf->native, first);
+ else
+ set_multi_in_bit_field(bf->native, first, count);
Py_RETURN_NONE;
diff --git a/plugins/pychrysalide/common/entropy.c b/plugins/pychrysalide/common/entropy.c
new file mode 100644
index 0000000..2817747
--- /dev/null
+++ b/plugins/pychrysalide/common/entropy.c
@@ -0,0 +1,119 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * entropy.c - équivalent Python du fichier "common/entropy.c"
+ *
+ * Copyright (C) 2024 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 "entropy.h"
+
+
+#include <common/entropy.h>
+
+
+#include "../access.h"
+#include "../helpers.h"
+
+
+
+/* Détermine l'entropie d'un contenu binaire. */
+static PyObject *py_entropy_compute_entropy(PyObject *, PyObject *);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : self = NULL car méthode statique. *
+* args = arguments fournis lors de l'appel à la fonction. *
+* *
+* Description : Détermine l'entropie d'un contenu binaire. *
+* *
+* Retour : Valeur d'entropie du contenu fourni. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_entropy_compute_entropy(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ const bin_t *data; /* Données à traiter */
+ int bits; /* Choix de référentiel */
+ size_t len; /* Quantité de ces données */
+ int ret; /* Bilan de lecture des args. */
+ double entropy; /* Valeur d'entropie déterminée*/
+
+#define COMPUTE_ENTROPY_METHOD PYTHON_METHOD_DEF \
+( \
+ compute_entropy, "data, /, bits=False", \
+ METH_VARARGS, py_entropy, \
+ "Compute the entropy of provided data.\n" \
+ "\n" \
+ "The *data* to process can be a string or bytes." \
+ " The optional *bits* argument defines if the" \
+ " computed value is expressed in bits (log base 2)" \
+ " or in bytes (log base 256).\n" \
+ "\n" \
+ "The result is a float value." \
+)
+
+ bits = 0;
+
+ ret = PyArg_ParseTuple(args, "s#|p", &data, &len, &bits);
+ if (!ret) return NULL;
+
+ entropy = compute_entropy((const bin_t *)data, len, bits);
+
+ result = PyFloat_FromDouble(entropy);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Définit une extension du module 'common' à compléter. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool populate_common_module_with_entropy(void)
+{
+ bool result; /* Bilan à retourner */
+ PyObject *module; /* Module à recompléter */
+
+ static PyMethodDef py_entropy_methods[] = {
+ COMPUTE_ENTROPY_METHOD,
+ { NULL }
+ };
+
+ module = get_access_to_python_module("pychrysalide.common");
+
+ result = register_python_module_methods(module, py_entropy_methods);
+
+ return result;
+
+}
diff --git a/plugins/pychrysalide/common/entropy.h b/plugins/pychrysalide/common/entropy.h
new file mode 100644
index 0000000..3fe5e28
--- /dev/null
+++ b/plugins/pychrysalide/common/entropy.h
@@ -0,0 +1,39 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * entropy.h - prototypes pour l'équivalent Python du fichier "common/entropy.c"
+ *
+ * Copyright (C) 2024 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
+ */
+
+
+#ifndef _PLUGINS_PYCHRYSALIDE_COMMON_ENTROPY_H
+#define _PLUGINS_PYCHRYSALIDE_COMMON_ENTROPY_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Définit une extension du module 'common' à compléter. */
+bool populate_common_module_with_entropy(void);
+
+
+
+#endif /* _PLUGINS_PYCHRYSALIDE_COMMON_ENTROPY_H */
diff --git a/plugins/pychrysalide/common/leb128.c b/plugins/pychrysalide/common/leb128.c
index 8b15303..2eeb191 100644
--- a/plugins/pychrysalide/common/leb128.c
+++ b/plugins/pychrysalide/common/leb128.c
@@ -2,7 +2,7 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
* leb128.c - équivalent Python du fichier "common/leb128.c"
*
- * Copyright (C) 2018-2020 Cyrille Bagard
+ * Copyright (C) 2018-2025 Cyrille Bagard
*
* This file is part of Chrysalide.
*
@@ -26,13 +26,13 @@
#include <assert.h>
+#include <malloc.h>
#include <pygobject.h>
#include <common/leb128.h>
-#include "packed.h"
#include "../access.h"
#include "../helpers.h"
@@ -69,31 +69,29 @@ static PyObject *py_leb128_pack_uleb128(PyObject *self, PyObject *args)
{
PyObject *result; /* Valeur à retourner */
uleb128_t value; /* Valeur à manipuler */
- packed_buffer_t *pbuf; /* Tampon de données à employer*/
int ret; /* Bilan de lecture des args. */
- bool status; /* Bilan de l'opération */
-
-#define LEB128_PACK_ULEB128_METHOD PYTHON_METHOD_DEF \
-( \
- pack_uleb128, "value, pbuf", \
- METH_VARARGS, py_leb128, \
- "Pack an unsigned LEB128 value into a data buffer.\n" \
- "\n" \
- "The *value* is an integer value. The *pbuf* argument has to" \
- " be a pychrysalide.common.PackedBuffer instance where data" \
- " will be appended.\n" \
- "\n" \
- "The returned value is the operation status: *True* for" \
- " success, *False* for failure." \
+ size_t count; /* Nombre d'octets produits */
+ void *bytes; /* Octets de représentation */
+
+#define LEB128_PACK_ULEB128_METHOD PYTHON_METHOD_DEF \
+( \
+ pack_uleb128, "value", \
+ METH_VARARGS, py_leb128, \
+ "Pack an unsigned LEB128 value into bytes.\n" \
+ "\n" \
+ "The *value* has to be an integer value.\n" \
+ "\n" \
+ "The returned value is byte data." \
)
- ret = PyArg_ParseTuple(args, "O&O&", convert_to_uleb128_value, &value, convert_to_packed_buffer, &pbuf);
+ ret = PyArg_ParseTuple(args, "O&", convert_to_uleb128_value, &value);
if (!ret) return NULL;
- status = pack_uleb128(&value, pbuf);
+ bytes = pack_uleb128(&value, &count);
- result = status ? Py_True : Py_False;
- Py_INCREF(result);
+ result = PyBytes_FromStringAndSize(bytes, count);
+
+ free(bytes);
return result;
@@ -117,31 +115,29 @@ static PyObject *py_leb128_pack_leb128(PyObject *self, PyObject *args)
{
PyObject *result; /* Valeur à retourner */
leb128_t value; /* Valeur à manipuler */
- packed_buffer_t *pbuf; /* Tampon de données à employer*/
int ret; /* Bilan de lecture des args. */
- bool status; /* Bilan de l'opération */
-
-#define LEB128_PACK_LEB128_METHOD PYTHON_METHOD_DEF \
-( \
- pack_leb128, "value, pbuf", \
- METH_VARARGS, py_leb128, \
- "Pack a signed LEB128 value into a data buffer.\n" \
- "\n" \
- "The *value* is an integer value. The *pbuf* argument has to" \
- " be a pychrysalide.common.PackedBuffer instance where data" \
- " will be appended.\n" \
- "\n" \
- "The returned value is the operation status: *True* for" \
- " success, *False* for failure." \
+ size_t count; /* Nombre d'octets produits */
+ void *bytes; /* Octets de représentation */
+
+#define LEB128_PACK_LEB128_METHOD PYTHON_METHOD_DEF \
+( \
+ pack_leb128, "value", \
+ METH_VARARGS, py_leb128, \
+ "Pack a signed LEB128 value into bytes.\n" \
+ "\n" \
+ "The *value* has to be an integer value.\n" \
+ "\n" \
+ "The returned value is byte data." \
)
- ret = PyArg_ParseTuple(args, "O&O&", convert_to_leb128_value, &value, convert_to_packed_buffer, &pbuf);
+ ret = PyArg_ParseTuple(args, "O&", convert_to_leb128_value, &value);
if (!ret) return NULL;
- status = pack_leb128(&value, pbuf);
+ bytes = pack_leb128(&value, &count);
+
+ result = PyBytes_FromStringAndSize(bytes, count);
- result = status ? Py_True : Py_False;
- Py_INCREF(result);
+ free(bytes);
return result;
@@ -164,33 +160,42 @@ static PyObject *py_leb128_pack_leb128(PyObject *self, PyObject *args)
static PyObject *py_leb128_unpack_uleb128(PyObject *self, PyObject *args)
{
PyObject *result; /* Valeur à retourner */
- packed_buffer_t *pbuf; /* Tampon de données à employer*/
+ const char *bytes; /* Octets brutes transmis */
+ Py_ssize_t count; /* Quantité de ces octets */
int ret; /* Bilan de lecture des args. */
+ const void *pos; /* Tëte de lecture */
+ const void *max; /* Position de lecture maximale*/
uleb128_t value; /* Valeur à manipuler */
bool status; /* Bilan de l'opération */
#define LEB128_UNPACK_ULEB128_METHOD PYTHON_METHOD_DEF \
( \
- unpack_uleb128, "pbuf", \
+ unpack_uleb128, "buf", \
METH_VARARGS, py_leb128, \
- "Unpack an unsigned LEB128 value into a data buffer.\n" \
+ "Unpack an unsigned LEB128 value from bytes.\n" \
"\n" \
- "The *pbuf* argument has to be a" \
- " pychrysalide.common.PackedBuffer instance from where data" \
- " will be read.\n" \
+ "The *buf* argument needs to be bytes with enough data aimed" \
+ " to get translated into an unsigned LEB128 value.\n" \
"\n" \
"The returned value depends on the operation status: *None*" \
- " for failure or a integer value for success." \
+ " for failure or a tuple with two items for success: the" \
+ " decoded value and the remaining bytes." \
)
- ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf);
+ ret = PyArg_ParseTuple(args, "y#", &bytes, &count);
if (!ret) return NULL;
- status = unpack_uleb128(&value, pbuf);
+ pos = bytes;
+ max = bytes + count;
- if (status)
- result = PyLong_FromUnsignedLongLong(value);
+ status = unpack_uleb128(&value, &pos, max);
+ if (status)
+ {
+ result = PyTuple_New(2);
+ PyTuple_SetItem(result, 0, PyLong_FromUnsignedLongLong(value));
+ PyTuple_SetItem(result, 1, PyBytes_FromStringAndSize(pos, (char *)max - (char *)pos));
+ }
else
{
result = Py_None;
@@ -218,33 +223,43 @@ static PyObject *py_leb128_unpack_uleb128(PyObject *self, PyObject *args)
static PyObject *py_leb128_unpack_leb128(PyObject *self, PyObject *args)
{
PyObject *result; /* Valeur à retourner */
- packed_buffer_t *pbuf; /* Tampon de données à employer*/
+ const char *bytes; /* Octets brutes transmis */
+ Py_ssize_t count; /* Quantité de ces octets */
int ret; /* Bilan de lecture des args. */
+ const void *pos; /* Tëte de lecture */
+ const void *max; /* Position de lecture maximale*/
leb128_t value; /* Valeur à manipuler */
bool status; /* Bilan de l'opération */
#define LEB128_UNPACK_LEB128_METHOD PYTHON_METHOD_DEF \
( \
- unpack_leb128, "pbuf", \
+ unpack_leb128, "buf", \
METH_VARARGS, py_leb128, \
- "Unpack a signed LEB128 value into a data buffer.\n" \
+ "Unpack a signed LEB128 value from bytes.\n" \
"\n" \
- "The *pbuf* argument has to be a" \
- " pychrysalide.common.PackedBuffer instance from where data" \
- " will be read.\n" \
+ "\n" \
+ "The *buf* argument needs to be bytes with enough data aimed" \
+ " to get translated into a signed LEB128 value.\n" \
"\n" \
"The returned value depends on the operation status: *None*" \
- " for failure or a integer value for success." \
+ " for failure or a tuple with two items for success: the" \
+ " decoded value and the remaining bytes." \
)
- ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf);
+ ret = PyArg_ParseTuple(args, "y#", &bytes, &count);
if (!ret) return NULL;
- status = unpack_leb128(&value, pbuf);
+ pos = bytes;
+ max = bytes + count;
- if (status)
- result = PyLong_FromLongLong(value);
+ status = unpack_leb128(&value, &pos, max);
+ if (status)
+ {
+ result = PyTuple_New(2);
+ PyTuple_SetItem(result, 0, PyLong_FromLongLong(value));
+ PyTuple_SetItem(result, 1, PyBytes_FromStringAndSize(pos, (char *)max - (char *)pos));
+ }
else
{
result = Py_None;
diff --git a/plugins/pychrysalide/common/module.c b/plugins/pychrysalide/common/module.c
index a0042ee..c82c7bc 100644
--- a/plugins/pychrysalide/common/module.c
+++ b/plugins/pychrysalide/common/module.c
@@ -26,13 +26,15 @@
#include "bits.h"
-#include "fnv1a.h"
-#include "hex.h"
-#include "itoa.h"
+#include "entropy.h"
+//#include "fnv1a.h"
+//#include "hex.h"
+//#include "itoa.h"
#include "leb128.h"
-#include "packed.h"
-#include "pathname.h"
-#include "pearson.h"
+//#include "packed.h"
+//#include "pathname.h"
+//#include "pearson.h"
+#include "xdg.h"
#include "../helpers.h"
@@ -98,15 +100,19 @@ bool populate_common_module(void)
result = true;
+ /*
if (result) result = populate_common_module_with_fnv1a();
if (result) result = populate_common_module_with_hex();
if (result) result = populate_common_module_with_itoa();
- if (result) result = populate_common_module_with_leb128();
if (result) result = populate_common_module_with_pathname();
if (result) result = populate_common_module_with_pearson();
+ */
+ if (result) result = populate_common_module_with_entropy();
+ if (result) result = populate_common_module_with_leb128();
+ if (result) result = populate_common_module_with_xdg();
if (result) result = ensure_python_bitfield_is_registered();
- if (result) result = ensure_python_packed_buffer_is_registered();
+ //if (result) result = ensure_python_packed_buffer_is_registered();
assert(result);
diff --git a/plugins/pychrysalide/common/xdg.c b/plugins/pychrysalide/common/xdg.c
new file mode 100644
index 0000000..e4b269e
--- /dev/null
+++ b/plugins/pychrysalide/common/xdg.c
@@ -0,0 +1,384 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * xdg.c - équivalent Python du fichier "common/xdg.c"
+ *
+ * Copyright (C) 2024 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 "xdg.h"
+
+
+#include <malloc.h>
+
+
+#include <common/xdg.h>
+
+
+#include "../access.h"
+#include "../helpers.h"
+
+
+
+/* Détermine le chemin d'un répertoire de données XDG. */
+static PyObject *py_xdg_get_xdg_cache_dir(PyObject *, PyObject *);
+
+/* Détermine le chemin d'un répertoire de données XDG. */
+static PyObject *py_xdg_get_xdg_config_dir(PyObject *, PyObject *);
+
+/* Détermine le chemin d'un répertoire de données XDG. */
+static PyObject *py_xdg_get_xdg_data_dir(PyObject *, PyObject *);
+
+/* Détermine le chemin d'un répertoire de données XDG. */
+static PyObject *py_xdg_get_xdg_state_dir(PyObject *, PyObject *);
+
+/* Détermine le chemin d'un répertoire éphémère XDG. */
+static PyObject *py_xdg_get_xdg_runtime_dir(PyObject *, PyObject *);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : self = NULL car méthode statique. *
+* args = arguments fournis lors de l'appel à la fonction. *
+* *
+* Description : Détermine le chemin d'un répertoire de données XDG. *
+* *
+* Retour : Chemin d'accès aux configurations personnelles ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_xdg_get_xdg_cache_dir(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ int create; /* Besoin en création */
+ const char *suffix; /* Fin de la localisation */
+ int ret; /* Bilan de lecture des args. */
+ char *filename; /* Chemin d'accès construit */
+
+#define GET_XDG_CACHE_DIR_METHOD PYTHON_METHOD_DEF \
+( \
+ get_xdg_cache_dir, "suffix, create=True", \
+ METH_VARARGS, py_xdg, \
+ "Get the location of a file belonging to the base directory" \
+ " pointed by the *XDG_CACHE_HOME* environment variable.\n" \
+ "\n" \
+ "The *suffix* argument is a string appended to the XDG base" \
+ " directory. The *create* option ensures all the directories" \
+ " involved in the returned path exist.\n" \
+ "\n" \
+ "The function returns the full filename to use for a content" \
+ " related to cache according to the XDG specifications, or" \
+ " *None* in case of failure." \
+)
+
+ create = 1;
+
+ ret = PyArg_ParseTuple(args, "s|p", &suffix, &create);
+ if (!ret) return NULL;
+
+ filename = get_xdg_cache_dir(suffix, create);
+
+ if (filename == NULL)
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ else
+ {
+ result = PyUnicode_FromString(filename);
+ free(filename);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = NULL car méthode statique. *
+* args = arguments fournis lors de l'appel à la fonction. *
+* *
+* Description : Détermine le chemin d'un répertoire de données XDG. *
+* *
+* Retour : Chemin d'accès aux configurations personnelles ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_xdg_get_xdg_config_dir(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ int create; /* Besoin en création */
+ const char *suffix; /* Fin de la localisation */
+ int ret; /* Bilan de lecture des args. */
+ char *filename; /* Chemin d'accès construit */
+
+#define GET_XDG_CONFIG_DIR_METHOD PYTHON_METHOD_DEF \
+( \
+ get_xdg_config_dir, "suffix, create=True", \
+ METH_VARARGS, py_xdg, \
+ "Get the location of a file belonging to the base directory" \
+ " pointed by the *XDG_CONFIG_HOME* environment variable.\n" \
+ "\n" \
+ "The *suffix* argument is a string appended to the XDG base" \
+ " directory. The *create* option ensures all the directories" \
+ " involved in the returned path exist.\n" \
+ "\n" \
+ "The function returns the full filename to use for a content" \
+ " related to configuration according to the XDG specifications,"\
+ " or *None* in case of failure." \
+)
+
+ create = 1;
+
+ ret = PyArg_ParseTuple(args, "s|p", &suffix, &create);
+ if (!ret) return NULL;
+
+ filename = get_xdg_config_dir(suffix, create);
+
+ if (filename == NULL)
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ else
+ {
+ result = PyUnicode_FromString(filename);
+ free(filename);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = NULL car méthode statique. *
+* args = arguments fournis lors de l'appel à la fonction. *
+* *
+* Description : Détermine le chemin d'un répertoire de données XDG. *
+* *
+* Retour : Chemin d'accès aux configurations personnelles ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_xdg_get_xdg_data_dir(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ int create; /* Besoin en création */
+ const char *suffix; /* Fin de la localisation */
+ int ret; /* Bilan de lecture des args. */
+ char *filename; /* Chemin d'accès construit */
+
+#define GET_XDG_DATA_DIR_METHOD PYTHON_METHOD_DEF \
+( \
+ get_xdg_data_dir, "suffix, create=True", \
+ METH_VARARGS, py_xdg, \
+ "Get the location of a file belonging to the base directory" \
+ " pointed by the *XDG_DATA_HOME* environment variable.\n" \
+ "\n" \
+ "The *suffix* argument is a string appended to the XDG base" \
+ " directory. The *create* option ensures all the directories" \
+ " involved in the returned path exist.\n" \
+ "\n" \
+ "The function returns the full filename to use for a content" \
+ " related to data according to the XDG specifications, or" \
+ " *None* in case of failure." \
+)
+
+ create = 1;
+
+ ret = PyArg_ParseTuple(args, "s|p", &suffix, &create);
+ if (!ret) return NULL;
+
+ filename = get_xdg_data_dir(suffix, create);
+
+ if (filename == NULL)
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ else
+ {
+ result = PyUnicode_FromString(filename);
+ free(filename);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = NULL car méthode statique. *
+* args = arguments fournis lors de l'appel à la fonction. *
+* *
+* Description : Détermine le chemin d'un répertoire de données XDG. *
+* *
+* Retour : Chemin d'accès aux configurations personnelles ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_xdg_get_xdg_state_dir(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ int create; /* Besoin en création */
+ const char *suffix; /* Fin de la localisation */
+ int ret; /* Bilan de lecture des args. */
+ char *filename; /* Chemin d'accès construit */
+
+#define GET_XDG_STATE_DIR_METHOD PYTHON_METHOD_DEF \
+( \
+ get_xdg_state_dir, "suffix, create=True", \
+ METH_VARARGS, py_xdg, \
+ "Get the location of a file belonging to the base directory" \
+ " pointed by the *XDG_STATE_HOME* environment variable.\n" \
+ "\n" \
+ "The *suffix* argument is a string appended to the XDG base" \
+ " directory. The *create* option ensures all the directories" \
+ " involved in the returned path exist.\n" \
+ "\n" \
+ "The function returns the full filename to use for a content" \
+ " related to states according to the XDG specifications, or" \
+ " *None* in case of failure." \
+)
+
+ create = 1;
+
+ ret = PyArg_ParseTuple(args, "s|p", &suffix, &create);
+ if (!ret) return NULL;
+
+ filename = get_xdg_state_dir(suffix, create);
+
+ if (filename == NULL)
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ else
+ {
+ result = PyUnicode_FromString(filename);
+ free(filename);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : self = NULL car méthode statique. *
+* args = arguments fournis lors de l'appel à la fonction. *
+* *
+* Description : Détermine le chemin d'un répertoire éphémère XDG. *
+* *
+* Retour : Chemin d'accès aux configurations personnelles ou None. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static PyObject *py_xdg_get_xdg_runtime_dir(PyObject *self, PyObject *args)
+{
+ PyObject *result; /* Instance à retourner */
+ const char *suffix; /* Fin de la localisation */
+ int ret; /* Bilan de lecture des args. */
+ char *filename; /* Chemin d'accès construit */
+
+#define GET_XDG_RUNTIME_DIR_METHOD PYTHON_METHOD_DEF \
+( \
+ get_xdg_runtime_dir, "suffix", \
+ METH_VARARGS, py_xdg, \
+ "Get the location of a file belonging to the base directory" \
+ " pointed by the *XDG_RUNTIME_DIR* environment variable.\n" \
+ "\n" \
+ "The *suffix* argument is a string appended to the XDG base" \
+ " directory.\n" \
+ "\n" \
+ "The function returns the full filename to use for a content" \
+ " related to runtime data according to the XDG specifications," \
+ " or *None* in case of failure." \
+)
+
+ ret = PyArg_ParseTuple(args, "s", &suffix);
+ if (!ret) return NULL;
+
+ filename = get_xdg_runtime_dir(suffix);
+
+ if (filename == NULL)
+ {
+ result = Py_None;
+ Py_INCREF(result);
+ }
+ else
+ {
+ result = PyUnicode_FromString(filename);
+ free(filename);
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Définit une extension du module 'common' à compléter. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool populate_common_module_with_xdg(void)
+{
+ bool result; /* Bilan à retourner */
+ PyObject *module; /* Module à recompléter */
+
+ static PyMethodDef py_xdg_methods[] = {
+ GET_XDG_CACHE_DIR_METHOD,
+ GET_XDG_CONFIG_DIR_METHOD,
+ GET_XDG_DATA_DIR_METHOD,
+ GET_XDG_STATE_DIR_METHOD,
+ GET_XDG_RUNTIME_DIR_METHOD,
+ { NULL }
+ };
+
+ module = get_access_to_python_module("pychrysalide.common");
+
+ result = register_python_module_methods(module, py_xdg_methods);
+
+ return result;
+
+}
diff --git a/plugins/pychrysalide/common/xdg.h b/plugins/pychrysalide/common/xdg.h
new file mode 100644
index 0000000..f1aa16a
--- /dev/null
+++ b/plugins/pychrysalide/common/xdg.h
@@ -0,0 +1,39 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * xdg.h - prototypes pour l'équivalent Python du fichier "common/xdg.c"
+ *
+ * Copyright (C) 2024 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
+ */
+
+
+#ifndef _PLUGINS_PYCHRYSALIDE_COMMON_XDG_H
+#define _PLUGINS_PYCHRYSALIDE_COMMON_XDG_H
+
+
+#include <Python.h>
+#include <stdbool.h>
+
+
+
+/* Définit une extension du module 'common' à compléter. */
+bool populate_common_module_with_xdg(void);
+
+
+
+#endif /* _PLUGINS_PYCHRYSALIDE_COMMON_XDG_H */
generated by cgit v0.11.2-87-g4458 at 2025-07-14 20:02:18 (GMT)