summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--plugins/pychrysalide/analysis/storage/tpmem.c52
-rw-r--r--src/analysis/storage/tpmem.c91
-rw-r--r--src/analysis/storage/tpmem.h8
3 files changed, 59 insertions, 92 deletions
diff --git a/plugins/pychrysalide/analysis/storage/tpmem.c b/plugins/pychrysalide/analysis/storage/tpmem.c
index 8df20b2..491ee68 100644
--- a/plugins/pychrysalide/analysis/storage/tpmem.c
+++ b/plugins/pychrysalide/analysis/storage/tpmem.c
@@ -52,8 +52,8 @@ static int py_type_memory_init(PyObject *, PyObject *, PyObject *);
/* -------------------------- TAMPON POUR CODE DESASSEMBLE -------------------------- */
-/* Apprend tous les types mémorisés dans un flux. */
-static PyObject *py_type_memory_read_types(PyObject *, PyObject *);
+/* Apprend tous les types mémorisés dans un tampon. */
+static PyObject *py_type_memory_load_types(PyObject *, PyObject *);
/* Crée une nouvelle instance d'objet à partir de son type. */
static PyObject *py_type_memory_create_object(PyObject *, PyObject *);
@@ -61,8 +61,8 @@ static PyObject *py_type_memory_create_object(PyObject *, PyObject *);
/* Sauvegarde le type d'un objet instancié. */
static PyObject *py_type_memory_store_object_gtype(PyObject *, PyObject *);
-/* Enregistre tous les types mémorisés dans un flux. */
-static PyObject *py_type_memory_write_types(PyObject *, PyObject *);
+/* Enregistre tous les types mémorisés dans un tampon. */
+static PyObject *py_type_memory_store_types(PyObject *, PyObject *);
@@ -178,7 +178,7 @@ static int py_type_memory_init(PyObject *self, PyObject *args, PyObject *kwds)
* Paramètres : self = classe représentant une mémorisation de types. *
* args = arguments fournis à l'appel. *
* *
-* Description : Apprend tous les types mémorisés dans un flux. *
+* Description : Apprend tous les types mémorisés dans un tampon. *
* *
* Retour : Bilan de l'opération. *
* *
@@ -186,36 +186,36 @@ static int py_type_memory_init(PyObject *self, PyObject *args, PyObject *kwds)
* *
******************************************************************************/
-static PyObject *py_type_memory_read_types(PyObject *self, PyObject *args)
+static PyObject *py_type_memory_load_types(PyObject *self, PyObject *args)
{
PyObject *result; /* Bilan à retourner */
- int fd; /* Flux ouvert en lecture */
+ packed_buffer_t *pbuf; /* Tampon à consulter */
int ret; /* Bilan de lecture des args. */
GTypeMemory *tpmem; /* Mémorisation native */
bool status; /* Bilan de l'opération */
-#define TYPE_MEMORY_READ_TYPES_METHOD PYTHON_METHOD_DEF \
+#define TYPE_MEMORY_LOAD_TYPES_METHOD PYTHON_METHOD_DEF \
( \
- read_types, "$self, fd", \
+ load_types, "$self, pbuf", \
METH_VARARGS, py_type_memory, \
- "Read types from a stream.\n" \
+ "Read types from a buffer.\n" \
"\n" \
"This operation is usually handled internally by the" \
" Chrysalide's core.\n" \
"\n" \
- "The *fd* parameter is an integer representing a valid" \
- " identifier for a file descriptor opened for reading." \
+ "The *pbuf* parameter is a pychrysalide.common.PackedBuffer"\
+ " instance providing buffered data to read." \
"\n" \
"The result is a boolean value indicating the status of" \
" the operation: True for success, False for failure." \
)
- ret = PyArg_ParseTuple(args, "i", &fd);
+ ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf);
if (!ret) return NULL;
tpmem = G_TYPE_MEMORY(pygobject_get(self));
- status = g_type_memory_read_types(tpmem, fd);
+ status = g_type_memory_load_types(tpmem, pbuf);
result = status ? Py_True : Py_False;
Py_INCREF(result);
@@ -330,7 +330,7 @@ static PyObject *py_type_memory_store_object_gtype(PyObject *self, PyObject *arg
* Paramètres : self = classe représentant une mémorisation de types. *
* args = arguments fournis à l'appel. *
* *
-* Description : Enregistre tous les types mémorisés dans un flux. *
+* Description : Enregistre tous les types mémorisés dans un tampon. *
* *
* Retour : Bilan de l'opération. *
* *
@@ -338,36 +338,36 @@ static PyObject *py_type_memory_store_object_gtype(PyObject *self, PyObject *arg
* *
******************************************************************************/
-static PyObject *py_type_memory_write_types(PyObject *self, PyObject *args)
+static PyObject *py_type_memory_store_types(PyObject *self, PyObject *args)
{
PyObject *result; /* Bilan à retourner */
- int fd; /* Flux ouvert en lecture */
+ packed_buffer_t *pbuf; /* Tampon à consulter */
int ret; /* Bilan de lecture des args. */
GTypeMemory *tpmem; /* Mémorisation native */
bool status; /* Bilan de l'opération */
-#define TYPE_MEMORY_WRITE_TYPES_METHOD PYTHON_METHOD_DEF \
+#define TYPE_MEMORY_STORE_TYPES_METHOD PYTHON_METHOD_DEF \
( \
- write_types, "$self, fd", \
+ store_types, "$self, pbuf", \
METH_VARARGS, py_type_memory, \
- "Write types into a stream.\n" \
+ "Write types into a buffer.\n" \
"\n" \
"This operation is usually handled internally by the" \
" Chrysalide's core.\n" \
"\n" \
- "The *fd* parameter is an integer representing a valid" \
- " identifier for a file descriptor opened for writing." \
+ "The *pbuf* parameter is a pychrysalide.common.PackedBuffer"\
+ " instance providing buffered data to read." \
"\n" \
"The result is a boolean value indicating the status of" \
" the operation: True for success, False for failure." \
)
- ret = PyArg_ParseTuple(args, "i", &fd);
+ ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf);
if (!ret) return NULL;
tpmem = G_TYPE_MEMORY(pygobject_get(self));
- status = g_type_memory_write_types(tpmem, fd);
+ status = g_type_memory_store_types(tpmem, pbuf);
result = status ? Py_True : Py_False;
Py_INCREF(result);
@@ -392,10 +392,10 @@ static PyObject *py_type_memory_write_types(PyObject *self, PyObject *args)
PyTypeObject *get_python_type_memory_type(void)
{
static PyMethodDef py_type_memory_methods[] = {
- TYPE_MEMORY_READ_TYPES_METHOD,
+ TYPE_MEMORY_LOAD_TYPES_METHOD,
TYPE_MEMORY_CREATE_OBJECT_METHOD,
TYPE_MEMORY_STORE_OBJECT_GTYPE_METHOD,
- TYPE_MEMORY_WRITE_TYPES_METHOD,
+ TYPE_MEMORY_STORE_TYPES_METHOD,
{ NULL }
};
diff --git a/src/analysis/storage/tpmem.c b/src/analysis/storage/tpmem.c
index 58585cd..cda8223 100644
--- a/src/analysis/storage/tpmem.c
+++ b/src/analysis/storage/tpmem.c
@@ -28,6 +28,7 @@
#include <stdint.h>
+#include "../db/misc/rlestr.h"
#include "../../arch/operands/target.h"
#include "../../core/logs.h"
@@ -219,9 +220,9 @@ GTypeMemory *g_type_memory_new(void)
/******************************************************************************
* *
* Paramètres : tpmem = mémoire à compléter. *
-* fd = flux ouvert en lecture. *
+* pbuf = zone tampon à lire. *
* *
-* Description : Apprend tous les types mémorisés dans un flux. *
+* Description : Apprend tous les types mémorisés dans un tampon. *
* *
* Retour : Bilan de l'opération. *
* *
@@ -229,64 +230,45 @@ GTypeMemory *g_type_memory_new(void)
* *
******************************************************************************/
-bool g_type_memory_read_types(GTypeMemory *tpmem, int fd)
+bool g_type_memory_load_types(GTypeMemory *tpmem, packed_buffer_t *pbuf)
{
bool result; /* Bilan à enregistrer */
- packed_buffer_t pbuf; /* Tampon des données à écrire */
- uint64_t i; /* Boucle de parcours */
- unsigned char len; /* Taille d'un nom de type */
- char *name; /* Désignation d'un type */
-
- init_packed_buffer(&pbuf);
+ uleb128_t count; /* Nombre d'éléments détectés */
+ uleb128_t i; /* Boucle de parcours */
+ rle_string str; /* Chaîne à charger */
- result = read_packed_buffer(&pbuf, fd);
+ result = unpack_uleb128(&count, pbuf);
if (result)
{
g_mutex_lock(&tpmem->mutex);
- result = extract_packed_buffer(&pbuf, &tpmem->count, sizeof(uint64_t), true);
+ tpmem->count = count;
- if (result)
- {
- assert(tpmem->gtypes == NULL);
- tpmem->gtypes = calloc(tpmem->count, sizeof(gtype_ref_info_t));
- }
+ assert(tpmem->gtypes == NULL);
+ tpmem->gtypes = calloc(count, sizeof(gtype_ref_info_t));
for (i = 0; i < tpmem->count && result; i++)
{
- result = extract_packed_buffer(&pbuf, &len, sizeof(unsigned char), false);
-
- if (result)
- {
- name = malloc(len);
+ result = unpack_rle_string(&str, pbuf);
+ if (!result) break;
- result = extract_packed_buffer(&pbuf, name, len, false);
+ tpmem->gtypes[i].gtype = g_type_from_name(get_rle_string(&str));
+ result = (tpmem->gtypes[i].gtype != 0);
- if (result)
- {
- tpmem->gtypes[i].gtype = g_type_from_name(name);
- result = (tpmem->gtypes[i].gtype != 0);
+ if (!result)
+ log_variadic_message(LMT_ERROR, "Unknown type: '%s'", get_rle_string(&str));
- if (!result)
- log_variadic_message(LMT_ERROR, "Unknown type: '%s'", name);
+ else
+ tpmem->gtypes[i].gclass = g_type_class_ref(tpmem->gtypes[i].gtype);
- }
-
- if (result)
- tpmem->gtypes[i].gclass = g_type_class_ref(tpmem->gtypes[i].gtype);
-
- free(name);
-
- }
+ exit_rle_string(&str);
}
- g_mutex_unlock(&tpmem->mutex);
-
}
- exit_packed_buffer(&pbuf);
+ g_mutex_unlock(&tpmem->mutex);
return result;
@@ -399,9 +381,9 @@ bool g_type_memory_store_object_gtype(GTypeMemory *tpmem, GObject *obj, packed_b
/******************************************************************************
* *
* Paramètres : tpmem = mémoire à consulter. *
-* fd = flux ouvert en écriture. *
+* pbuf = zone tampon à remplir. *
* *
-* Description : Enregistre tous les types mémorisés dans un flux. *
+* Description : Enregistre tous les types mémorisés dans un tampon. *
* *
* Retour : Bilan de l'opération. *
* *
@@ -409,46 +391,31 @@ bool g_type_memory_store_object_gtype(GTypeMemory *tpmem, GObject *obj, packed_b
* *
******************************************************************************/
-bool g_type_memory_write_types(GTypeMemory *tpmem, int fd)
+bool g_type_memory_store_types(GTypeMemory *tpmem, packed_buffer_t *pbuf)
{
bool result; /* Bilan à enregistrer */
- packed_buffer_t pbuf; /* Tampon des données à écrire */
uint64_t i; /* Boucle de parcours */
const gchar *name; /* Désignation d'un type */
- size_t len; /* Taille de ce nom */
-
- init_packed_buffer(&pbuf);
+ rle_string str; /* Chaîne à conserver */
g_mutex_lock(&tpmem->mutex);
- result = extend_packed_buffer(&pbuf, &tpmem->count, sizeof(uint64_t), true);
+ result = pack_uleb128((uleb128_t []){ tpmem->count }, pbuf);
for (i = 0; i < tpmem->count && result; i++)
{
name = g_type_name(tpmem->gtypes[i].gtype);
- len = strlen(name) + 1;
- if (len > (2 << (sizeof(unsigned char) * 8 - 1)))
- {
- log_variadic_message(LMT_ERROR, "Type name too long: '%s' (%zu bytes)", name, len);
- result = false;
- break;
- }
+ init_static_rle_string(&str, name);
- result = extend_packed_buffer(&pbuf, (unsigned char []) { len }, sizeof(unsigned char), false);
+ result = pack_rle_string(&str, pbuf);
- if (result)
- result = extend_packed_buffer(&pbuf, name, len, false);
+ exit_rle_string(&str);
}
- if (result)
- result = write_packed_buffer(&pbuf, fd);
-
g_mutex_unlock(&tpmem->mutex);
- exit_packed_buffer(&pbuf);
-
return result;
}
diff --git a/src/analysis/storage/tpmem.h b/src/analysis/storage/tpmem.h
index ff14265..34cbde6 100644
--- a/src/analysis/storage/tpmem.h
+++ b/src/analysis/storage/tpmem.h
@@ -53,8 +53,8 @@ GType g_type_memory_get_type(void);
/* Crée une mémoire pour types d'objets. */
GTypeMemory *g_type_memory_new(void);
-/* Apprend tous les types mémorisés dans un flux. */
-bool g_type_memory_read_types(GTypeMemory *, int);
+/* Apprend tous les types mémorisés dans un tampon. */
+bool g_type_memory_load_types(GTypeMemory *, packed_buffer_t *);
/* Crée une nouvelle instance d'objet à partir de son type. */
GObject *g_type_memory_create_object(GTypeMemory *, packed_buffer_t *);
@@ -62,8 +62,8 @@ GObject *g_type_memory_create_object(GTypeMemory *, packed_buffer_t *);
/* Sauvegarde le type d'un objet instancié. */
bool g_type_memory_store_object_gtype(GTypeMemory *, GObject *, packed_buffer_t *);
-/* Enregistre tous les types mémorisés dans un flux. */
-bool g_type_memory_write_types(GTypeMemory *, int);
+/* Enregistre tous les types mémorisés dans un tampon. */
+bool g_type_memory_store_types(GTypeMemory *, packed_buffer_t *);
generated by cgit v0.11.2-87-g4458 at 2024-04-19 13:42:18 (GMT)