summaryrefslogtreecommitdiff
path: root/src/analysis/contents/memory.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/analysis/contents/memory.c')
-rw-r--r--src/analysis/contents/memory.c568
1 files changed, 382 insertions, 186 deletions
diff --git a/src/analysis/contents/memory.c b/src/analysis/contents/memory.c
index a37a7d4..f8ff863 100644
--- a/src/analysis/contents/memory.c
+++ b/src/analysis/contents/memory.c
@@ -33,29 +33,16 @@
#include <i18n.h>
-#include "file.h"
+#include "memory-int.h"
#include "../content-int.h"
+#include "../db/misc/rlestr.h"
+#include "../storage/serialize-int.h"
#include "../../common/extstr.h"
-#include "../../common/io.h"
+#include "../../core/logs.h"
-/* Contenu de données binaires résidant en mémoire (instance) */
-struct _GMemoryContent
-{
- GObject parent; /* A laisser en premier */
-
- char *storage; /* Conservation des données */
- GBinContent *backend; /* Exploitation des données */
-
-};
-
-/* Contenu de données binaires résidant en mémoire (classe) */
-struct _GMemoryContentClass
-{
- GObjectClass parent; /* A laisser en premier */
-
-};
+/* -------------------------- ENSEMBLE DE DONNEES BINAIRES -------------------------- */
/* Initialise la classe des contenus de données en mémoire. */
@@ -64,24 +51,29 @@ static void g_memory_content_class_init(GMemoryContentClass *);
/* Initialise une instance de contenu de données en mémoire. */
static void g_memory_content_init(GMemoryContent *);
-/* Procède à l'initialisation de l'interface de lecture. */
-static void g_memory_content_interface_init(GBinContentInterface *);
-
/* Supprime toutes les références externes. */
static void g_memory_content_dispose(GMemoryContent *);
/* Procède à la libération totale de la mémoire. */
static void g_memory_content_finalize(GMemoryContent *);
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Associe un ensemble d'attributs au contenu binaire. */
+static void g_memory_content_set_attributes(GMemoryContent *, GContentAttributes *);
+
+/* Fournit l'ensemble des attributs associés à un contenu. */
+static GContentAttributes *g_memory_content_get_attributes(const GMemoryContent *);
+
/* Donne l'origine d'un contenu binaire. */
static GBinContent *g_memory_content_get_root(GMemoryContent *);
/* Fournit le nom associé au contenu binaire. */
static char *g_memory_content_describe(const GMemoryContent *, bool);
-/* Ecrit une sauvegarde de contenu binaire dans un fichier XML. */
-static bool g_memory_content_save(const GMemoryContent *, xmlDocPtr, xmlXPathContextPtr, const char *, const char *);
-
/* Fournit une empreinte unique (SHA256) pour les données. */
static void g_memory_content_compute_checksum(GMemoryContent *, GChecksum *);
@@ -124,11 +116,21 @@ static bool g_memory_content_read_uleb128(const GMemoryContent *, vmpa2t *, uleb
/* Lit un nombre signé encodé au format LEB128. */
static bool g_memory_content_read_leb128(const GMemoryContent *, vmpa2t *, leb128_t *);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_memory_content_load(GMemoryContent *, GObjectStorage *, packed_buffer_t *);
+
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_memory_content_store(const GMemoryContent *, GObjectStorage *, packed_buffer_t *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* ENSEMBLE DE DONNEES BINAIRES */
+/* ---------------------------------------------------------------------------------- */
/* Indique le type défini par la GLib pour les contenus de données en mémoire. */
-G_DEFINE_TYPE_WITH_CODE(GMemoryContent, g_memory_content, G_TYPE_OBJECT,
- G_IMPLEMENT_INTERFACE(G_TYPE_BIN_CONTENT, g_memory_content_interface_init));
+G_DEFINE_TYPE(GMemoryContent, g_memory_content, G_TYPE_BIN_CONTENT);
/******************************************************************************
@@ -146,40 +148,53 @@ G_DEFINE_TYPE_WITH_CODE(GMemoryContent, g_memory_content, G_TYPE_OBJECT,
static void g_memory_content_class_init(GMemoryContentClass *klass)
{
GObjectClass *object; /* Autre version de la classe */
+ GBinContentClass *content; /* Version parente de la classe*/
object = G_OBJECT_CLASS(klass);
object->dispose = (GObjectFinalizeFunc/* ! */)g_memory_content_dispose;
object->finalize = (GObjectFinalizeFunc)g_memory_content_finalize;
-}
+ content = G_BIN_CONTENT_CLASS(klass);
+ content->set_attribs = (set_content_attributes)g_memory_content_set_attributes;
+ content->get_attribs = (get_content_attributes)g_memory_content_get_attributes;
-/******************************************************************************
-* *
-* Paramètres : content = instance à initialiser. *
-* *
-* Description : Initialise une instance de contenu de données en mémoire. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
+ content->get_root = (get_content_root_fc)g_memory_content_get_root;
-static void g_memory_content_init(GMemoryContent *content)
-{
- content->storage = NULL;
- content->backend = NULL;
+ content->describe = (describe_content_fc)g_memory_content_describe;
+
+ content->compute_checksum = (compute_checksum_fc)g_memory_content_compute_checksum;
+
+ content->compute_size = (compute_size_fc)g_memory_content_compute_size;
+ content->compute_start_pos = (compute_start_pos_fc)g_memory_content_compute_start_pos;
+ content->compute_end_pos = (compute_end_pos_fc)g_memory_content_compute_end_pos;
+
+ content->seek = (seek_fc)g_memory_content_seek;
+
+ content->get_raw_access = (get_raw_access_fc)g_memory_content_get_raw_access;
+
+ content->read_raw = (read_raw_fc)g_memory_content_read_raw;
+ content->read_u4 = (read_u4_fc)g_memory_content_read_u4;
+ content->read_u8 = (read_u8_fc)g_memory_content_read_u8;
+ content->read_u16 = (read_u16_fc)g_memory_content_read_u16;
+ content->read_u32 = (read_u32_fc)g_memory_content_read_u32;
+ content->read_u64 = (read_u64_fc)g_memory_content_read_u64;
+
+ content->read_uleb128 = (read_uleb128_fc)g_memory_content_read_uleb128;
+ content->read_leb128 = (read_leb128_fc)g_memory_content_read_leb128;
+
+ content->load = (load_content_cb)g_memory_content_load;
+ content->store = (store_content_cb)g_memory_content_store;
}
/******************************************************************************
* *
-* Paramètres : iface = interface GLib à initialiser. *
+* Paramètres : content = instance à initialiser. *
* *
-* Description : Procède à l'initialisation de l'interface de lecture. *
+* Description : Initialise une instance de contenu de données en mémoire. *
* *
* Retour : - *
* *
@@ -187,33 +202,24 @@ static void g_memory_content_init(GMemoryContent *content)
* *
******************************************************************************/
-static void g_memory_content_interface_init(GBinContentInterface *iface)
+static void g_memory_content_init(GMemoryContent *content)
{
- iface->get_root = (get_content_root_fc)g_memory_content_get_root;
-
- iface->describe = (describe_content_fc)g_memory_content_describe;
+ GContentAttributes *empty; /* Jeu d'attributs vide */
- iface->save = (save_content_fc)g_memory_content_save;
+ content->attribs = NULL;
- iface->compute_checksum = (compute_checksum_fc)g_memory_content_compute_checksum;
+ empty = g_content_attributes_new("", NULL);
- iface->compute_size = (compute_size_fc)g_memory_content_compute_size;
- iface->compute_start_pos = (compute_start_pos_fc)g_memory_content_compute_start_pos;
- iface->compute_end_pos = (compute_end_pos_fc)g_memory_content_compute_end_pos;
+ g_binary_content_set_attributes(G_BIN_CONTENT(content), empty);
- iface->seek = (seek_fc)g_memory_content_seek;
+ g_object_unref(G_OBJECT(empty));
- iface->get_raw_access = (get_raw_access_fc)g_memory_content_get_raw_access;
+ content->data = NULL;
+ content->length = 0;
+ content->allocated = false;
- iface->read_raw = (read_raw_fc)g_memory_content_read_raw;
- iface->read_u4 = (read_u4_fc)g_memory_content_read_u4;
- iface->read_u8 = (read_u8_fc)g_memory_content_read_u8;
- iface->read_u16 = (read_u16_fc)g_memory_content_read_u16;
- iface->read_u32 = (read_u32_fc)g_memory_content_read_u32;
- iface->read_u64 = (read_u64_fc)g_memory_content_read_u64;
-
- iface->read_uleb128 = (read_uleb128_fc)g_memory_content_read_uleb128;
- iface->read_leb128 = (read_leb128_fc)g_memory_content_read_leb128;
+ content->full_desc = strdup("In-memory content");
+ content->desc = strdup("In-memory content");
}
@@ -232,8 +238,7 @@ static void g_memory_content_interface_init(GBinContentInterface *iface)
static void g_memory_content_dispose(GMemoryContent *content)
{
- if (content->backend)
- g_object_unref(G_OBJECT(content->backend));
+ g_clear_object(&content->attribs);
G_OBJECT_CLASS(g_memory_content_parent_class)->dispose(G_OBJECT(content));
@@ -254,12 +259,18 @@ static void g_memory_content_dispose(GMemoryContent *content)
static void g_memory_content_finalize(GMemoryContent *content)
{
- if (content->storage != NULL)
+ if (content->allocated)
{
- unlink(content->storage);
- free(content->storage);
+ if (content->data != NULL)
+ free(content->data);
}
+ if (content->desc != NULL)
+ free(content->desc);
+
+ if (content->full_desc != NULL)
+ free(content->full_desc);
+
G_OBJECT_CLASS(g_memory_content_parent_class)->finalize(G_OBJECT(content));
}
@@ -280,108 +291,84 @@ static void g_memory_content_finalize(GMemoryContent *content)
GBinContent *g_memory_content_new(const bin_t *data, phys_t size)
{
- GMemoryContent *result; /* Structure à retourner */
- int fd; /* Descripteur du fichier */
- bool status; /* Bilan des écritures */
+ GBinContent *result; /* Structure à retourner */
result = g_object_new(G_TYPE_MEMORY_CONTENT, NULL);
- fd = make_tmp_file("memcnt", "bin", &result->storage);
- if (fd == -1) goto gmcn_error;
-
- status = safe_write(fd, data, size);
-
- close(fd);
+ if (!g_memory_content_create(G_MEMORY_CONTENT(result), data, size))
+ g_clear_object(&result);
- if (!status) goto gmcn_error;
-
- result->backend = g_file_content_new(result->storage);
- if (result->backend == NULL) goto gmcn_error;
-
- return G_BIN_CONTENT(result);
-
- gmcn_error:
-
- g_object_unref(G_OBJECT(result));
-
- return NULL;
+ return result;
}
/******************************************************************************
* *
-* Paramètres : context = contexte pour les recherches XPath. *
-* path = chemin d'accès au noeud XML à lire. *
-* base = référence au lieu d'enregistrement du projet. *
+* Paramètres : content = instance à initialiser pleinement. *
+* data = données du contenu volatile. *
+* size = quantité de ces données. *
* *
-* Description : Charge des données à laisser en mémoire à partir d'XML. *
+* Description : Met en place un contenu de données brutes depuis la mémoire. *
* *
-* Retour : Adresse de la représentation ou NULL en cas d'échec. *
+* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
-GBinContent *g_memory_content_new_from_xml(xmlXPathContextPtr context, const char *path, const char *base)
+bool g_memory_content_create(GMemoryContent *content, const bin_t *data, phys_t size)
{
- GBinContent *result; /* Adresse à retourner */
- char *access; /* Chemin pour une sous-config.*/
- char *encoded; /* Données encodées à charger */
- guchar *data; /* Données brutes à charger */
- gsize size; /* Quantité de ces données */
-
- result = NULL;
-
- /* Chemin du fichier à retrouver */
+ bool result; /* Bilan à retourner */
+ bin_t *allocated; /* Zone de réception */
- access = strdup(path);
- access = stradd(access, "/Data");
+ allocated = malloc(size);
+ if (allocated == NULL)
+ {
+ LOG_ERROR_N("malloc");
+ goto exit;
+ }
- encoded = get_node_text_value(context, access);
+ memcpy(allocated, data, size);
- free(access);
+ content->data = allocated;
+ content->length = size;
+ content->allocated = true;
- /* Chargement */
+ result = true;
- if (encoded != NULL)
- {
- data = g_base64_decode(encoded, &size);
+ exit:
- free(encoded);
+ return result;
- if (data != NULL)
- {
- result = g_memory_content_new(data, size);
- g_free(data);
- }
+}
- }
- return result;
-}
+/* ---------------------------------------------------------------------------------- */
+/* IMPLEMENTATION DES FONCTIONS DE CLASSE */
+/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
-* Paramètres : content = contenu binaire à consulter. *
+* Paramètres : content = contenu binaire à actualiser. *
+* attribs = jeu d'attributs à lier au contenu courant. *
* *
-* Description : Donne l'origine d'un contenu binaire. *
+* Description : Associe un ensemble d'attributs au contenu binaire. *
* *
-* Retour : Contenu à l'origine du contenu courant. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-static GBinContent *g_memory_content_get_root(GMemoryContent *content)
+static void g_memory_content_set_attributes(GMemoryContent *content, GContentAttributes *attribs)
{
- GBinContent *result; /* Contenu en place à renvoyer */
+ g_clear_object(&content->attribs);
- result = G_BIN_CONTENT(content);
-
- return result;
+ content->attribs = attribs;
+ g_object_ref(G_OBJECT(attribs));
}
@@ -389,21 +376,23 @@ static GBinContent *g_memory_content_get_root(GMemoryContent *content)
/******************************************************************************
* *
* Paramètres : content = contenu binaire à consulter. *
-* full = précise s'il s'agit d'une version longue ou non. *
* *
-* Description : Fournit le nom associé au contenu binaire. *
+* Description : Fournit l'ensemble des attributs associés à un contenu. *
* *
-* Retour : Nom de fichier avec chemin absolu au besoin. *
+* Retour : Jeu d'attributs liés au contenu courant. *
* *
* Remarques : - *
* *
******************************************************************************/
-static char *g_memory_content_describe(const GMemoryContent *content, bool full)
+static GContentAttributes *g_memory_content_get_attributes(const GMemoryContent *content)
{
- char *result; /* Description à retourner */
+ GContentAttributes *result; /* Instance à retourner */
+
+ result = content->attribs;
- result = strdup("In-memory content");
+ if (result != NULL)
+ g_object_ref(G_OBJECT(result));
return result;
@@ -412,55 +401,50 @@ static char *g_memory_content_describe(const GMemoryContent *content, bool full)
/******************************************************************************
* *
-* Paramètres : content = contenu binaire à traiter. *
-* xdoc = structure XML en cours d'édition. *
-* context = contexte à utiliser pour les recherches. *
-* path = chemin d'accès réservé au binaire. *
-* base = référence au lieu d'enregistrement du projet. *
+* Paramètres : content = contenu binaire à consulter. *
* *
-* Description : Ecrit une sauvegarde de contenu binaire dans un fichier XML. *
+* Description : Donne l'origine d'un contenu binaire. *
* *
-* Retour : true si l'opération a bien tourné, false sinon. *
+* Retour : Contenu à l'origine du contenu courant. *
* *
* Remarques : - *
* *
******************************************************************************/
-static bool g_memory_content_save(const GMemoryContent *content, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path, const char *base)
+static GBinContent *g_memory_content_get_root(GMemoryContent *content)
{
- bool result; /* Bilan à faire remonter */
- char *access; /* Chemin d'accès à un élément */
- vmpa2t start; /* Tête de lecture initiale */
- phys_t length; /* Nombre d'octets disponibles */
- const bin_t *data; /* Données brutes à sauvegarder*/
- gchar *encoded; /* Données encodées à écrire */
-
- /* Type */
-
- result = add_string_attribute_to_node(xdoc, context, path, "type", "memory");
- if (!result) goto gmcs_exit;
+ GBinContent *result; /* Contenu en place à renvoyer */
- /* Données en mémoire associées */
+ result = G_BIN_CONTENT(content);
- access = strdup(path);
- access = stradd(access, "/Data");
+ g_object_ref(G_OBJECT(result));
- init_vmpa(&start, 0, VMPA_NO_VIRTUAL);
+ return result;
- length = g_binary_content_compute_size(content->backend);
+}
- data = g_binary_content_get_raw_access(content->backend, &start, length);
- assert(data != NULL);
- encoded = g_base64_encode((const guchar *)data, length);
- assert(encoded != NULL);
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à consulter. *
+* full = précise s'il s'agit d'une version longue ou non. *
+* *
+* Description : Fournit le nom associé au contenu binaire. *
+* *
+* Retour : Nom de fichier avec chemin absolu au besoin. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- result = add_content_to_node(xdoc, context, access, encoded);
+static char *g_memory_content_describe(const GMemoryContent *content, bool full)
+{
+ char *result; /* Description à retourner */
- g_free(encoded);
- free(access);
+ result = (full ? content->full_desc : content->desc);
- gmcs_exit:
+ if (result != NULL)
+ result = strdup(result);
return result;
@@ -482,11 +466,7 @@ static bool g_memory_content_save(const GMemoryContent *content, xmlDocPtr xdoc,
static void g_memory_content_compute_checksum(GMemoryContent *content, GChecksum *checksum)
{
- GBinContentIface *iface; /* Interface utilisée */
-
- iface = G_BIN_CONTENT_GET_IFACE(content->backend);
-
- iface->compute_checksum(content->backend, checksum);
+ g_checksum_update(checksum, content->data, content->length);
}
@@ -507,7 +487,7 @@ static phys_t g_memory_content_compute_size(const GMemoryContent *content)
{
phys_t result; /* Quantité trouvée à retourner*/
- result = g_binary_content_compute_size(content->backend);
+ result = content->length;
return result;
@@ -529,7 +509,7 @@ static phys_t g_memory_content_compute_size(const GMemoryContent *content)
static void g_memory_content_compute_start_pos(const GMemoryContent *content, vmpa2t *pos)
{
- g_binary_content_compute_start_pos(content->backend, pos);
+ init_vmpa(pos, 0, VMPA_NO_VIRTUAL);
}
@@ -549,7 +529,9 @@ static void g_memory_content_compute_start_pos(const GMemoryContent *content, vm
static void g_memory_content_compute_end_pos(const GMemoryContent *content, vmpa2t *pos)
{
- g_binary_content_compute_end_pos(content->backend, pos);
+ g_memory_content_compute_start_pos(content, pos);
+
+ advance_vmpa(pos, content->length);
}
@@ -571,8 +553,23 @@ static void g_memory_content_compute_end_pos(const GMemoryContent *content, vmpa
static bool g_memory_content_seek(const GMemoryContent *content, vmpa2t *addr, phys_t length)
{
bool result; /* Bilan à retourner */
+ phys_t offset; /* Emplacement de départ */
+
+ result = false;
+
+ offset = get_phy_addr(addr);
+
+ if (length > content->length)
+ goto done;
+
+ if (offset > (content->length - length))
+ goto done;
+
+ advance_vmpa(addr, length);
+
+ result = true;
- result = g_binary_content_seek(content->backend, addr, length);
+ done:
return result;
@@ -596,8 +593,14 @@ static bool g_memory_content_seek(const GMemoryContent *content, vmpa2t *addr, p
static const bin_t *g_memory_content_get_raw_access(const GMemoryContent *content, vmpa2t *addr, phys_t length)
{
const bin_t *result; /* Données utiles à renvoyer */
+ phys_t offset; /* Emplacement de départ */
+ bool allowed; /* Capacité d'avancer ? */
- result = g_binary_content_get_raw_access(content->backend, addr, length);
+ offset = get_phy_addr(addr);
+
+ allowed = g_memory_content_seek(content, addr, length);
+
+ result = (allowed ? &content->data[offset] : NULL);
return result;
@@ -622,8 +625,17 @@ static const bin_t *g_memory_content_get_raw_access(const GMemoryContent *conten
static bool g_memory_content_read_raw(const GMemoryContent *content, vmpa2t *addr, phys_t length, bin_t *out)
{
bool result; /* Bilan à remonter */
+ const bin_t *data; /* Pointeur vers données utiles*/
- result = g_binary_content_read_raw(content->backend, addr, length, out);
+ data = g_memory_content_get_raw_access(content, addr, length);
+
+ if (data != NULL)
+ {
+ result = true;
+ memcpy(out, data, length);
+ }
+ else
+ result = false;
return result;
@@ -648,8 +660,17 @@ static bool g_memory_content_read_raw(const GMemoryContent *content, vmpa2t *add
static bool g_memory_content_read_u4(const GMemoryContent *content, vmpa2t *addr, bool *low, uint8_t *val)
{
bool result; /* Bilan de lecture à renvoyer */
+ phys_t pos; /* Tête de lecture courante */
+
+ pos = get_phy_addr(addr);
+
+ if (pos == VMPA_NO_PHYSICAL)
+ return false;
- result = g_binary_content_read_u4(content->backend, addr, low, val);
+ result = read_u4(val, content->data, &pos, content->length, low);
+
+ if (result)
+ advance_vmpa(addr, pos - get_phy_addr(addr));
return result;
@@ -674,8 +695,17 @@ static bool g_memory_content_read_u4(const GMemoryContent *content, vmpa2t *addr
static bool g_memory_content_read_u8(const GMemoryContent *content, vmpa2t *addr, uint8_t *val)
{
bool result; /* Bilan de lecture à renvoyer */
+ phys_t pos; /* Tête de lecture courante */
+
+ pos = get_phy_addr(addr);
+
+ if (pos == VMPA_NO_PHYSICAL)
+ return false;
+
+ result = read_u8(val, content->data, &pos, content->length);
- result = g_binary_content_read_u8(content->backend, addr, val);
+ if (result)
+ advance_vmpa(addr, pos - get_phy_addr(addr));
return result;
@@ -700,8 +730,17 @@ static bool g_memory_content_read_u8(const GMemoryContent *content, vmpa2t *addr
static bool g_memory_content_read_u16(const GMemoryContent *content, vmpa2t *addr, SourceEndian endian, uint16_t *val)
{
bool result; /* Bilan de lecture à renvoyer */
+ phys_t pos; /* Tête de lecture courante */
+
+ pos = get_phy_addr(addr);
+
+ if (pos == VMPA_NO_PHYSICAL)
+ return false;
+
+ result = read_u16(val, content->data, &pos, content->length, endian);
- result = g_binary_content_read_u16(content->backend, addr, endian, val);
+ if (result)
+ advance_vmpa(addr, pos - get_phy_addr(addr));
return result;
@@ -726,8 +765,17 @@ static bool g_memory_content_read_u16(const GMemoryContent *content, vmpa2t *add
static bool g_memory_content_read_u32(const GMemoryContent *content, vmpa2t *addr, SourceEndian endian, uint32_t *val)
{
bool result; /* Bilan de lecture à renvoyer */
+ phys_t pos; /* Tête de lecture courante */
- result = g_binary_content_read_u32(content->backend, addr, endian, val);
+ pos = get_phy_addr(addr);
+
+ if (pos == VMPA_NO_PHYSICAL)
+ return false;
+
+ result = read_u32(val, content->data, &pos, content->length, endian);
+
+ if (result)
+ advance_vmpa(addr, pos - get_phy_addr(addr));
return result;
@@ -752,8 +800,17 @@ static bool g_memory_content_read_u32(const GMemoryContent *content, vmpa2t *add
static bool g_memory_content_read_u64(const GMemoryContent *content, vmpa2t *addr, SourceEndian endian, uint64_t *val)
{
bool result; /* Bilan de lecture à renvoyer */
+ phys_t pos; /* Tête de lecture courante */
+
+ pos = get_phy_addr(addr);
+
+ if (pos == VMPA_NO_PHYSICAL)
+ return false;
+
+ result = read_u64(val, content->data, &pos, content->length, endian);
- result = g_binary_content_read_u64(content->backend, addr, endian, val);
+ if (result)
+ advance_vmpa(addr, pos - get_phy_addr(addr));
return result;
@@ -777,8 +834,17 @@ static bool g_memory_content_read_u64(const GMemoryContent *content, vmpa2t *add
static bool g_memory_content_read_uleb128(const GMemoryContent *content, vmpa2t *addr, uleb128_t *val)
{
bool result; /* Bilan de lecture à renvoyer */
+ phys_t pos; /* Tête de lecture courante */
- result = g_binary_content_read_uleb128(content->backend, addr, val);
+ pos = get_phy_addr(addr);
+
+ if (pos == VMPA_NO_PHYSICAL)
+ return false;
+
+ result = read_uleb128(val, content->data, &pos, content->length);
+
+ if (result)
+ advance_vmpa(addr, pos - get_phy_addr(addr));
return result;
@@ -802,8 +868,138 @@ static bool g_memory_content_read_uleb128(const GMemoryContent *content, vmpa2t
static bool g_memory_content_read_leb128(const GMemoryContent *content, vmpa2t *addr, leb128_t *val)
{
bool result; /* Bilan de lecture à renvoyer */
+ phys_t pos; /* Tête de lecture courante */
+
+ pos = get_phy_addr(addr);
+
+ if (pos == VMPA_NO_PHYSICAL)
+ return false;
+
+ result = read_leb128(val, content->data, &pos, content->length);
+
+ if (result)
+ advance_vmpa(addr, pos - get_phy_addr(addr));
- result = g_binary_content_read_leb128(content->backend, addr, val);
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = élément GLib à constuire. *
+* storage = conservateur de données à manipuler ou NULL. *
+* pbuf = zone tampon à lire. *
+* *
+* Description : Charge un contenu depuis une mémoire tampon. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_load(GMemoryContent *content, GObjectStorage *storage, packed_buffer_t *pbuf)
+{
+ bool result; /* Bilan à retourner */
+ uleb128_t length; /* Quantité de données à suivre*/
+ rle_string str; /* Chaîne à charger */
+
+ result = unpack_uleb128(&length, pbuf);
+
+ if (result)
+ {
+ content->data = malloc(length);
+ result = (content->data != NULL);
+
+ content->allocated = true;
+
+ }
+
+ if (result)
+ {
+ content->length = length;
+ result = extract_packed_buffer(pbuf, content->data, length, false);
+ }
+
+ setup_empty_rle_string(&str);
+
+ if (result)
+ result = unpack_rle_string(&str, pbuf);
+
+ if (result)
+ {
+ result = (get_rle_string(&str) != NULL);
+
+ if (result)
+ content->full_desc = strdup(get_rle_string(&str));
+
+ exit_rle_string(&str);
+
+ }
+
+ if (result)
+ result = unpack_rle_string(&str, pbuf);
+
+ if (result)
+ {
+ result = (get_rle_string(&str) != NULL);
+
+ if (result)
+ content->desc = strdup(get_rle_string(&str));
+
+ exit_rle_string(&str);
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = élément GLib à consulter. *
+* storage = conservateur de données à manipuler ou NULL. *
+* pbuf = zone tampon à remplir. *
+* *
+* Description : Sauvegarde un contenu dans une mémoire tampon. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_store(const GMemoryContent *content, GObjectStorage *storage, packed_buffer_t *pbuf)
+{
+ bool result; /* Bilan à retourner */
+ rle_string str; /* Chaîne à conserver */
+
+ result = pack_uleb128((uleb128_t []){ content->length }, pbuf);
+
+ if (result)
+ result = extend_packed_buffer(pbuf, content->data, content->length, false);
+
+ if (result)
+ {
+ init_static_rle_string(&str, content->full_desc);
+
+ result = pack_rle_string(&str, pbuf);
+
+ exit_rle_string(&str);
+
+ }
+
+ if (result)
+ {
+ init_static_rle_string(&str, content->desc);
+
+ result = pack_rle_string(&str, pbuf);
+
+ exit_rle_string(&str);
+
+ }
return result;
generated by cgit v0.11.2-87-g4458 at 2024-05-14 08:50:21 (GMT)