summaryrefslogtreecommitdiff
path: root/src/common
diff options
context:
space:
mode:
Diffstat (limited to 'src/common')
-rw-r--r--src/common/Makefile.am17
-rw-r--r--src/common/bits.c132
-rw-r--r--src/common/bits.h9
-rw-r--r--src/common/compiler.h16
-rw-r--r--src/common/cpp.h17
-rw-r--r--src/common/datatypes.h30
-rw-r--r--src/common/entropy.c88
-rw-r--r--src/common/entropy.h41
-rw-r--r--src/common/fnv1a.c33
-rw-r--r--src/common/fnv1a.h6
-rw-r--r--src/common/io.h57
-rw-r--r--src/common/leb128.c252
-rw-r--r--src/common/leb128.h17
-rw-r--r--src/common/pathname.c23
-rw-r--r--src/common/pathname.h2
-rw-r--r--src/common/sort.h3
-rw-r--r--src/common/szbin.h248
17 files changed, 910 insertions, 81 deletions
diff --git a/src/common/Makefile.am b/src/common/Makefile.am
index 7f0fe4e..1056cb2 100644
--- a/src/common/Makefile.am
+++ b/src/common/Makefile.am
@@ -47,16 +47,18 @@ endif
libcommon4_la_SOURCES = \
+ array.h array.c \
asm.h asm.c \
bits.h bits.c \
compiler.h \
+ cpp.h \
datatypes.h \
dllist.h dllist.c \
+ entropy.h entropy.c \
environment.h environment.c \
extstr.h extstr.c \
fnv1a.h fnv1a.c \
io.h io.c \
- json.h json.c \
leb128.h leb128.c \
macros.h \
packed.h packed.c \
@@ -73,6 +75,13 @@ libcommon4_la_SOURCES += \
endif
+if BUILD_JSONGLIB_SUPPORT
+
+libcommon4_la_SOURCES += \
+ json.h json.c
+
+endif
+
libcommon4_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBSSL_CFLAGS) $(LIBJSONGLIB_CFLAGS)
if BUILD_CURL_SUPPORT
@@ -81,6 +90,12 @@ libcommon4_la_CFLAGS += $(LIBCURL_CFLAGS)
endif
+if BUILD_JSONGLIB_SUPPORT
+
+libcommon4_la_CFLAGS += $(LIBJSONGLIB_CFLAGS)
+
+endif
+
devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
diff --git a/src/common/bits.c b/src/common/bits.c
index f730c66..27296f2 100644
--- a/src/common/bits.c
+++ b/src/common/bits.c
@@ -31,6 +31,8 @@
#include "asm.h"
+#include "io.h"
+#include "leb128.h"
@@ -1291,3 +1293,133 @@ void output_bit_field(const bitfield_t *field)
}
#endif
+
+
+/******************************************************************************
+* *
+* Paramètres : fd = flux ouvert en lecture. *
+* length = éventuelle indication de la taille du champ ? *
+* def_state = éventuelle indication de l'état par défaut ? *
+* endian = ordre des bits dans la source. *
+* *
+* Description : Restaure un champ de bits depuis un flux ouvert. *
+* *
+* Retour : Adresse du champs de bits mis en place, NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bitfield_t *load_bit_field(int fd, const size_t *length, const bool *def_state, SourceEndian endian)
+{
+ bitfield_t *result; /* Structure à retourner */
+ size_t final_length; /* Nombre de bits représentés */
+ uleb128_t leb128_value; /* Valeur LEB128 chargée */
+ bool status; /* Bilan d'une lecture */
+ bool final_default_state; /* Etat d'initialisation */
+ uint8_t u8_value; /* Valeur sur 8 bits chargée */
+ size_t i; /* Boucle de parcours */
+
+ result = NULL;
+
+ if (length != NULL)
+ final_length = *length;
+ else
+ {
+ status = load_uleb128(&leb128_value, fd);
+ if (!status) goto exit;
+
+ final_length = leb128_value;
+
+ }
+
+ if (def_state != NULL)
+ final_default_state = *def_state;
+
+ else
+ {
+ status = load_u8(fd, &u8_value);
+ if (!status) goto exit;
+
+ final_default_state = !!u8_value;
+
+ }
+
+ result = _create_bit_field(final_length);
+
+ result->default_state = final_default_state;
+
+ for (i = 0; i < result->used_words; i++)
+ {
+ status = load_uleb128(&leb128_value, fd);
+
+ if (status)
+ result->bits[i] = leb128_value;
+
+ else
+ {
+ delete_bit_field(result);
+ result = NULL;
+ break;
+ }
+
+ }
+
+ exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : field = champ de bits à consulter. *
+* fd = flux ouvert en écriture. *
+* skip_len = saute la sauvegarde de la taille du champ ? *
+* skip_def = saute la sauvegarde de l'état par défaut ? *
+* endian = ordre des bits dans la source. *
+* *
+* Description : Sauvegarde un champ de bits dans un flux ouvert. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool store_bit_field(const bitfield_t *field, int fd, bool skip_len, bool skip_def, SourceEndian endian)
+{
+ bool result; /* Bilan à retourner */
+ size_t i; /* Boucle de parcours */
+
+ if (skip_len)
+ result = true;
+ else
+ {
+ result = store_uleb128((const uleb128_t []) { field->length }, fd);
+ if (!result) goto exit;
+ }
+
+ if (skip_def)
+ result = true;
+ else
+ {
+ result = store_u8(fd, field->default_state);
+ if (!result) goto exit;
+ }
+
+ for (i = 0; i < field->used_words; i++)
+ {
+ result = store_uleb128((const uleb128_t []) { field->bits[i] }, fd);
+
+ if (!result)
+ break;
+
+ }
+
+ exit:
+
+ return result;
+
+}
diff --git a/src/common/bits.h b/src/common/bits.h
index 3898c73..d9c83c8 100644
--- a/src/common/bits.h
+++ b/src/common/bits.h
@@ -29,6 +29,9 @@
#include <sys/types.h>
+#include "datatypes.h"
+
+
/* Champ de bits simple */
typedef struct _bitfield_t bitfield_t;
@@ -119,6 +122,12 @@ void output_bit_field(const bitfield_t *);
#endif
+/* Restaure un champ de bits depuis un flux ouvert. */
+bitfield_t *load_bit_field(int, const size_t *, const bool *, SourceEndian);
+
+/* Sauvegarde un champ de bits dans un flux ouvert. */
+bool store_bit_field(const bitfield_t *, int, bool, bool, SourceEndian);
+
#endif /* _COMMON_BITS_H */
diff --git a/src/common/compiler.h b/src/common/compiler.h
index 2585e47..65df8a4 100644
--- a/src/common/compiler.h
+++ b/src/common/compiler.h
@@ -2,7 +2,7 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
* compiler.h - prototypes pour le regroupement d'astuces à destination du compilateur
*
- * Copyright (C) 2024 Cyrille Bagard
+ * Copyright (C) 2024-2025 Cyrille Bagard
*
* This file is part of Chrysalide.
*
@@ -34,5 +34,19 @@
#define __weak __attribute__((weak))
+/**
+ * Contournement des avertissements de la forme suivante :
+ *
+ * assignment to 'const char * const*' from incompatible pointer type 'char **' [-Wincompatible-pointer-types]
+ *
+ * Références :
+ * - https://www.reddit.com/r/C_Programming/comments/qa2231/const_char_const_and_char_are_incompatible/
+ * - https://stackoverflow.com/questions/78125/why-cant-i-convert-char-to-a-const-char-const-in-c
+ * - https://c-faq.com/ansi/constmismatch.html
+ */
+
+#define CONST_ARRAY_CAST(a, tp) (const tp **)a
+
+
#endif /* _COMMON_COMPILER_H */
diff --git a/src/common/cpp.h b/src/common/cpp.h
index 39e7676..4ebad82 100644
--- a/src/common/cpp.h
+++ b/src/common/cpp.h
@@ -2,7 +2,7 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
* cpp.h - prototypes pour avoir à disposition un langage C plus plus mieux
*
- * Copyright (C) 2010-2020 Cyrille Bagard
+ * Copyright (C) 2010-2025 Cyrille Bagard
*
* This file is part of Chrysalide.
*
@@ -31,12 +31,27 @@
/**
+ * Fournit la taille d'une chaîne statique.
+ */
+#define STATIC_STR_SIZE(s) (sizeof(s) - 1)
+
+
+/**
* Fournit la taille d'un tableau statique.
*/
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
/**
+ * Facilite la transmission d'arguement pour des fonctions
+ * comme strncmp() et Cie.
+ */
+#define SL(str) str, strlen(str)
+
+#define STCSL(str) str, STATIC_STR_SIZE(str)
+
+
+/**
* Détermine la taille de la plus longue chaîne de caractères
* correspondant à un type donné.
*/
diff --git a/src/common/datatypes.h b/src/common/datatypes.h
index 3983267..248f4a1 100644
--- a/src/common/datatypes.h
+++ b/src/common/datatypes.h
@@ -52,5 +52,35 @@ typedef enum _SourceEndian
} SourceEndian;
+/* Taille des données intégrées */
+typedef enum _MemoryDataSize
+{
+ MDS_UNDEFINED = 0x0, /* Taille non définie */
+
+ MDS_4_BITS_UNSIGNED = 0x1, /* Opérande sur 4 bits n.-s. */
+ MDS_8_BITS_UNSIGNED = 0x2, /* Opérande sur 8 bits n.-s. */
+ MDS_16_BITS_UNSIGNED = 0x3, /* Opérande sur 16 bits n.-s. */
+ MDS_32_BITS_UNSIGNED = 0x4, /* Opérande sur 32 bits n.-s. */
+ MDS_64_BITS_UNSIGNED = 0x5, /* Opérande sur 64 bits n.-s. */
+
+ MDS_4_BITS_SIGNED = 0x8 | 0x1, /* Opérande sur 4 bits signés */
+ MDS_8_BITS_SIGNED = 0x8 | 0x2, /* Opérande sur 8 bits signés */
+ MDS_16_BITS_SIGNED = 0x8 | 0x3, /* Opérande sur 16 bits signés */
+ MDS_32_BITS_SIGNED = 0x8 | 0x4, /* Opérande sur 32 bits signés */
+ MDS_64_BITS_SIGNED = 0x8 | 0x5 /* Opérande sur 64 bits signés */
+
+} MemoryDataSize;
+
+#define MDS_RANGE(mds) ((mds & 0x7) - 1)
+#define MDS_SIGN 0x8
+#define MDS_IS_SIGNED(mds) (mds & MDS_SIGN)
+
+#define MDS_4_BITS MDS_4_BITS_UNSIGNED
+#define MDS_8_BITS MDS_8_BITS_UNSIGNED
+#define MDS_16_BITS MDS_16_BITS_UNSIGNED
+#define MDS_32_BITS MDS_32_BITS_UNSIGNED
+#define MDS_64_BITS MDS_64_BITS_UNSIGNED
+
+
#endif /* _COMMON_DATATYPES_H */
diff --git a/src/common/entropy.c b/src/common/entropy.c
new file mode 100644
index 0000000..8dae698
--- /dev/null
+++ b/src/common/entropy.c
@@ -0,0 +1,88 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * entropy.c - calcul de l'entropie d'un contenu binaire
+ *
+ * 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 Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "entropy.h"
+
+
+#include <math.h>
+#include <string.h>
+
+
+
+/******************************************************************************
+* *
+* Paramètres : data = séquence d'octets à traiter. *
+* len = quantité de ces octets. *
+* bits = calcul en concidérant les bits et non les octets ? *
+* *
+* Description : Détermine l'entropie d'un contenu binaire. *
+* *
+* Retour : Valeur d'entropie du contenu fourni. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+double compute_entropy(const bin_t *data, size_t len, bool bits)
+{
+ double result; /* Valeur calculée à renvoyer */
+ unsigned long counters[256]; /* Décompte des valeurs */
+ const bin_t *d_max; /* Borne de fin de parcours #1 */
+ const bin_t *d_iter; /* Boucle de parcours #1 */
+ double log_2; /* Valeur constante de log2 */
+ unsigned long *c_max; /* Borne de fin de parcours #2 */
+ unsigned long *c_iter; /* Boucle de parcours #2 */
+ double freq; /* Fréquence liée à une valeur */
+
+ result = 0.0;
+
+ memset(counters, 0, sizeof(counters));
+
+ d_max = data + len;
+
+ for (d_iter = data; d_iter < d_max; d_iter++)
+ counters[*d_iter]++;
+
+ /**
+ * Explication du choix de log :
+ * https://stackoverflow.com/questions/990477/how-to-calculate-the-entropy-of-a-file/990646#990646
+ */
+
+ log_2 = log(bits ? 2.0 : 256.0);
+
+ c_max = counters + 256;
+
+ for (c_iter = counters; c_iter < c_max; c_iter++)
+ {
+ if (*c_iter == 0lu)
+ continue;
+
+ freq = ((double)*c_iter) / ((double)len);
+
+ result -= freq * (log(freq) / log_2);
+
+ }
+
+ return result;
+
+}
diff --git a/src/common/entropy.h b/src/common/entropy.h
new file mode 100644
index 0000000..cfd51ef
--- /dev/null
+++ b/src/common/entropy.h
@@ -0,0 +1,41 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * entropy.h - prototypes pour le calcul de l'entropie d'un contenu binaire
+ *
+ * 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 Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _COMMON_ENTROPY_H
+#define _COMMON_ENTROPY_H
+
+
+#include <stdbool.h>
+#include <stddef.h>
+
+
+#include "../common/datatypes.h"
+
+
+
+/* Détermine l'entropie d'un contenu binaire. */
+double compute_entropy(const bin_t *, size_t, bool);
+
+
+
+#endif /* _COMMON_ENTROPY_H */
diff --git a/src/common/fnv1a.c b/src/common/fnv1a.c
index a8afd0a..057d6c9 100644
--- a/src/common/fnv1a.c
+++ b/src/common/fnv1a.c
@@ -2,7 +2,7 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
* fnv1a.c - implémentaton du calcul rapide d'empreintes de chaînes
*
- * Copyright (C) 2012-2018 Cyrille Bagard
+ * Copyright (C) 2012-2024 Cyrille Bagard
*
* This file is part of Chrysalide.
*
@@ -87,3 +87,34 @@ fnv64_t fnv_64a_hash(const char *str)
return result;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : data = données binaires à traiter. *
+* size = quantité de ces données. *
+* *
+* Description : Détermine l'empreinte FNV1a d'une séquence d'octets. *
+* *
+* Retour : Valeur calculée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+fnv64_t fnv_64a_hash_data(const uint8_t *data, size_t size)
+{
+ fnv64_t result; /* Valeur à retourner */
+ size_t i; /* Boucle de parcours */
+
+ result = FNV1A_64_INIT;
+
+ for (i = 0; i < size; i++)
+ {
+ result ^= (fnv64_t)data[i];
+ result *= FNV_64_PRIME;
+ }
+
+ return result;
+
+}
diff --git a/src/common/fnv1a.h b/src/common/fnv1a.h
index eec1460..4da3108 100644
--- a/src/common/fnv1a.h
+++ b/src/common/fnv1a.h
@@ -2,7 +2,7 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
* fnv1a.h - prototypes pour l'implémentaton du calcul rapide d'empreintes de chaînes
*
- * Copyright (C) 2012-2018 Cyrille Bagard
+ * Copyright (C) 2012-2024 Cyrille Bagard
*
* This file is part of Chrysalide.
*
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
+#include <sys/types.h>
/**
@@ -46,6 +47,9 @@ int cmp_fnv_64a(fnv64_t, fnv64_t);
/* Détermine l'empreinte FNV1a d'une chaîne de caractères. */
fnv64_t fnv_64a_hash(const char *);
+/* Détermine l'empreinte FNV1a d'une séquence d'octets. */
+fnv64_t fnv_64a_hash_data(const uint8_t *, size_t);
+
#endif /* _COMMON_FNV1A_H */
diff --git a/src/common/io.h b/src/common/io.h
index 7fe9d9d..1932b12 100644
--- a/src/common/io.h
+++ b/src/common/io.h
@@ -39,12 +39,69 @@
/* Lit des données depuis un flux local. */
bool safe_read(int, void *, size_t);
+#define load_u8(f, v) \
+ safe_read(f, v, sizeof(uint8_t));
+
+#define load_u16(f, v, e) \
+ ({ \
+ bool __ret; \
+ uint16_t __val; \
+ __ret = safe_read(f, &__val, sizeof(uint16_t)); \
+ __val = swap_u16(&__val, e); \
+ *(v) = __val; \
+ __ret; \
+ })
+
+#define load_u32(f, v, e) \
+ ({ \
+ bool __ret; \
+ uint32_t __val; \
+ __ret = safe_read(f, &__val, sizeof(uint32_t)); \
+ __val = swap_u32(&__val, e); \
+ *(v) = __val; \
+ __ret; \
+ })
+
+#define load_u64(f, v, e) \
+ ({ \
+ bool __ret; \
+ uint64_t __val; \
+ __ret = safe_read(f, &__val, sizeof(uint64_t)); \
+ __val = swap_u64(&__val, e); \
+ *(v) = __val; \
+ __ret; \
+ })
+
/* Lit des données depuis un flux local. */
ssize_t safe_read_partial(int, void *, size_t);
/* Ecrit des données dans un flux local. */
bool safe_write(int, const void *, size_t);
+#define store_u8(f, v) \
+ safe_write(f, (const uint8_t []){ v }, sizeof(uint8_t));
+
+#define store_u16(f, v, e) \
+ ({ \
+ uint16_t __val; \
+ __val = swap_u16((const uint16_t []){ v }, e); \
+ safe_write(f, &__val, sizeof(uint16_t)); \
+ })
+
+#define store_u32(f, v, e) \
+ ({ \
+ uint32_t __val; \
+ __val = swap_u32((const uint32_t []){ v }, e); \
+ safe_write(f, &__val, sizeof(uint32_t)); \
+ })
+
+#define store_u64(f, v, e) \
+ ({ \
+ uint64_t __val; \
+ __val = swap_u64((const uint64_t []){ v }, e); \
+ safe_write(f, &__val, sizeof(uint64_t)); \
+ })
+
/* Réceptionne des données depuis un flux réseau. */
bool safe_recv(int, void *, size_t, int);
diff --git a/src/common/leb128.c b/src/common/leb128.c
index c8d2ace..7fae4d0 100644
--- a/src/common/leb128.c
+++ b/src/common/leb128.c
@@ -24,6 +24,20 @@
#include "leb128.h"
+#include <malloc.h>
+
+
+#include "io.h"
+
+
+/**
+ * Quantité maximale d'octets de représentation.
+ *
+ * sizeof([u]leb128_t) / 7 = 9.142857142857142
+ *
+ */
+#define MAX_LEB128_BYTES 9
+
/******************************************************************************
* *
@@ -113,10 +127,63 @@ bool read_leb128(leb128_t *target, const bin_t *data, phys_t *pos, phys_t len)
/******************************************************************************
* *
+* Paramètres : value = valeur à constituer. [OUT] *
+* fd = flux ouvert en lecture à consulter. *
+* *
+* Description : Restaure un nombre non signé encodé au format LEB128. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool load_uleb128(uleb128_t *value, int fd)
+{
+ bool result; /* Bilan à retourner */
+ unsigned int shift; /* Décalage à appliquer */
+ uint8_t byte; /* Octet à transposer */
+
+ result = false;
+
+ *value = 0;
+
+ shift = 0;
+
+ while (true)
+ {
+ /* Encodage sur trop d'octets ? */
+ if (shift > (7 * MAX_LEB128_BYTES))
+ {
+ result = false;
+ break;
+ }
+
+ result = safe_read(fd, &byte, sizeof(uint8_t));
+ if (!result) break;
+
+ *value |= ((byte & 0x7f) << shift);
+
+ result = true;
+
+ if ((byte & 0x80) == 0x00)
+ break;
+
+ shift += 7;
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : value = valeur à consigner. *
-* pbuf = tampon de données à constituer. [OUT] *
+* fd = flux ouvert en écriture. *
* *
-* Description : Encode un nombre non signé encodé au format LEB128. *
+* Description : Sauvegarde un nombre non signé encodé au format LEB128. *
* *
* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
* *
@@ -124,7 +191,7 @@ bool read_leb128(leb128_t *target, const bin_t *data, phys_t *pos, phys_t len)
* *
******************************************************************************/
-bool pack_uleb128(const uleb128_t *value, packed_buffer_t *pbuf)
+bool store_uleb128(const uleb128_t *value, int fd)
{
bool result; /* Bilan à retourner */
uleb128_t tmp; /* Valeur modifiable */
@@ -140,7 +207,7 @@ bool pack_uleb128(const uleb128_t *value, packed_buffer_t *pbuf)
if (tmp != 0)
byte |= 0x80;
- result = extend_packed_buffer(pbuf, &byte, sizeof(uint8_t), false);
+ result = safe_write(fd, &byte, sizeof(uint8_t));
}
while (result && tmp != 0);
@@ -153,9 +220,9 @@ bool pack_uleb128(const uleb128_t *value, packed_buffer_t *pbuf)
/******************************************************************************
* *
* Paramètres : value = valeur à consigner. *
-* pbuf = tampon de données à constituer. [OUT] *
+* len = taille du tampon de données à constitué. [OUT] *
* *
-* Description : Encode un nombre signé encodé au format LEB128. *
+* Description : Encode un nombre non signé encodé au format LEB128. *
* *
* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
* *
@@ -163,19 +230,81 @@ bool pack_uleb128(const uleb128_t *value, packed_buffer_t *pbuf)
* *
******************************************************************************/
-bool pack_leb128(const leb128_t *value, packed_buffer_t *pbuf)
+void *pack_uleb128(const uleb128_t *value, size_t *len)
{
+ uint8_t *result; /* Données à retourner */
+ uleb128_t tmp; /* Valeur modifiable */
+ uint8_t *byte; /* Octet à transposer */
- bool result; /* Bilan à retourner */
+ /* Calcul de la quantité d'octets nécessaires */
+
+ *len = 0;
+
+ tmp = *value;
+
+ do
+ {
+ tmp >>= 7;
+ (*len)++;
+ }
+ while (tmp != 0);
+
+ /* Exportation */
+
+ result = malloc(*len * sizeof(uint8_t));
+ byte = result;
+
+ tmp = *value;
+
+ do
+ {
+ *byte = (tmp & 0x7f);
+ tmp >>= 7;
+
+ if (tmp != 0)
+ *byte |= 0x80;
+
+ byte++;
+
+ }
+ while (tmp != 0);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : value = valeur à consigner. *
+* len = taille du tampon de données à constitué. [OUT] *
+* *
+* Description : Encode un nombre signé encodé au format LEB128. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void *pack_leb128(const leb128_t *value, size_t *len)
+{
+ uint8_t *result; /* Données à retourner */
+ bool negative; /* Nature de la valeur */
uleb128_t tmp; /* Valeur modifiable */
bool more; /* Poursuite des traitements */
- bool negative; /* Nature de la valeur */
uint8_t byte; /* Octet à transposer */
+ uint8_t *iter; /* Boucle de parcours */
+
+ negative = (*value < 0);
+
+ /* Calcul de la quantité d'octets nécessaires */
+
+ *len = 0;
tmp = *value;
more = true;
- negative = (*value < 0);
while (more)
{
@@ -198,10 +327,44 @@ bool pack_leb128(const leb128_t *value, packed_buffer_t *pbuf)
if ((tmp == 0 && (byte & 0x40) == 0x00) || (tmp == -1 && (byte & 0x40) == 0x40))
more = false;
+ (*len)++;
+
+ }
+
+ /* Exportation */
+
+ result = malloc(*len * sizeof(uint8_t));
+ iter = result;
+
+ tmp = *value;
+
+ more = true;
+
+ while (more)
+ {
+ *iter = (tmp & 0x7f);
+ tmp >>= 7;
+
+ /**
+ * Propagation forcée du bit de signe pour les implémentations de
+ * décalage basées sur une opération logique et non arithmétique.
+ */
+
+ if (negative)
+ tmp |= (~0llu << (LEB128_BITS_COUNT - 7));
+
+ /**
+ * Le bit de signe n'est pas le bit de poids fort ici :
+ * On travaille sur 7 bits, donc le masque est 0x40 !
+ */
+
+ if ((tmp == 0 && (*iter & 0x40) == 0x00) || (tmp == -1 && (*iter & 0x40) == 0x40))
+ more = false;
+
else
- byte |= 0x80;
+ *iter |= 0x80;
- result = extend_packed_buffer(pbuf, &byte, sizeof(uint8_t), false);
+ iter++;
}
@@ -213,7 +376,8 @@ bool pack_leb128(const leb128_t *value, packed_buffer_t *pbuf)
/******************************************************************************
* *
* Paramètres : value = valeur à constituer. [OUT] *
-* pbuf = tampon de données à consulter. *
+* pos = tête de lecture à faire évoluer. [OUT] *
+* max = position maximale liée à la fin des données. *
* *
* Description : Décode un nombre non signé encodé au format LEB128. *
* *
@@ -223,38 +387,45 @@ bool pack_leb128(const leb128_t *value, packed_buffer_t *pbuf)
* *
******************************************************************************/
-bool unpack_uleb128(uleb128_t *value, packed_buffer_t *pbuf)
+bool unpack_uleb128(uleb128_t *value, const void **pos, const void *max)
{
bool result; /* Bilan à retourner */
unsigned int shift; /* Décalage à appliquer */
- uint8_t byte; /* Octet à transposer */
+ uint8_t *byte; /* Octet à transposer */
- result = true;
+ result = false;
*value = 0;
shift = 0;
+ byte = *(uint8_t **)pos;
- while (true)
+ do
{
/* Encodage sur trop d'octets ? */
- if (shift > (7 * sizeof(uleb128_t)))
+ if (shift > (7 * MAX_LEB128_BYTES))
{
result = false;
break;
}
- result = extract_packed_buffer(pbuf, &byte, sizeof(uint8_t), false);
- if (!result) break;
+ /* Atteinte de la fin des données ? */
+ if ((void *)byte >= max)
+ {
+ result = false;
+ break;
+ }
- *value |= ((byte & 0x7f) << shift);
+ *value |= ((*byte & 0x7f) << shift);
- if ((byte & 0x80) == 0x00)
- break;
+ result = true;
shift += 7;
}
+ while ((*byte++ & 0x80) == 0x80);
+
+ *pos = byte;
return result;
@@ -264,7 +435,8 @@ bool unpack_uleb128(uleb128_t *value, packed_buffer_t *pbuf)
/******************************************************************************
* *
* Paramètres : value = valeur à constituer. [OUT] *
-* pbuf = tampon de données à consulter. *
+* pos = tête de lecture à faire évoluer. [OUT] *
+* max = position maximale liée à la fin des données. *
* *
* Description : Décode un nombre signé encodé au format LEB128. *
* *
@@ -274,44 +446,56 @@ bool unpack_uleb128(uleb128_t *value, packed_buffer_t *pbuf)
* *
******************************************************************************/
-bool unpack_leb128(leb128_t *value, packed_buffer_t *pbuf)
+bool unpack_leb128(leb128_t *value, const void **pos, const void *max)
{
bool result; /* Bilan à retourner */
unsigned int shift; /* Décalage à appliquer */
- uint8_t byte; /* Octet à transposer */
+ uint8_t *byte; /* Octet à transposer */
- result = true;
+ result = false;
*value = 0;
shift = 0;
+ byte = *(uint8_t **)pos;
do
{
/* Encodage sur trop d'octets ? */
- if (shift > (7 * sizeof(leb128_t)))
+ if (shift > (7 * MAX_LEB128_BYTES))
{
result = false;
break;
}
- result = extract_packed_buffer(pbuf, &byte, sizeof(uint8_t), false);
- if (!result) break;
+ /* Atteinte de la fin des données ? */
+ if ((void *)byte >= max)
+ {
+ result = false;
+ break;
+ }
- *value |= ((byte & 0x7f) << shift);
+ *value |= ((*byte & 0x7f) << shift);
+
+ result = true;
shift += 7;
}
- while ((byte & 0x80) == 0x80);
+ while ((*byte++ & 0x80) == 0x80);
/**
* Le bit de signe n'est pas le bit de poids fort ici :
* On travaille sur 7 bits, donc le masque est 0x40 !
*/
- if (shift < LEB128_BITS_COUNT && (byte & 0x40) == 0x40)
- *value |= (~0llu << shift);
+ if (result)
+ {
+ if (shift < LEB128_BITS_COUNT && (byte[-1] & 0x40) == 0x40)
+ *value |= (~0llu << shift);
+ }
+
+ *pos = byte;
return result;
diff --git a/src/common/leb128.h b/src/common/leb128.h
index f438068..cb712a3 100644
--- a/src/common/leb128.h
+++ b/src/common/leb128.h
@@ -30,7 +30,6 @@
#include "datatypes.h"
-#include "packed.h"
@@ -58,17 +57,23 @@ bool read_uleb128(uleb128_t *, const bin_t *, phys_t *, phys_t);
/* Lit un nombre signé encodé au format LEB128. */
bool read_leb128(leb128_t *, const bin_t *, phys_t *, phys_t);
+/* Charge un nombre non signé encodé au format LEB128. */
+bool load_uleb128(uleb128_t *, int);
+
+/* Sauvegarde un nombre non signé encodé au format LEB128. */
+bool store_uleb128(const uleb128_t *, int);
+
/* Encode un nombre non signé encodé au format LEB128. */
-bool pack_uleb128(const uleb128_t *, packed_buffer_t *);
+void *pack_uleb128(const uleb128_t *, size_t *);
/* Encode un nombre signé encodé au format LEB128. */
-bool pack_leb128(const leb128_t *, packed_buffer_t *);
+void *pack_leb128(const leb128_t *, size_t *);
-/* Décode un nombre non signé encodé au format LEB128. */
-bool unpack_uleb128(uleb128_t *, packed_buffer_t *);
+/* Encode un nombre non signé encodé au format LEB128. */
+bool unpack_uleb128(uleb128_t *, const void **, const void *);
/* Décode un nombre signé encodé au format LEB128. */
-bool unpack_leb128(leb128_t *, packed_buffer_t *);
+bool unpack_leb128(leb128_t *, const void **, const void *);
diff --git a/src/common/pathname.c b/src/common/pathname.c
index dd3ec9e..81dc1e3 100644
--- a/src/common/pathname.c
+++ b/src/common/pathname.c
@@ -33,13 +33,13 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <gio/gio.h>
#include <sys/stat.h>
#include "extstr.h"
#include "io.h"
#include "../core/logs.h"
-//#include "../core/params.h" // TODO : config
@@ -316,16 +316,19 @@ int ensure_path_exists(const char *path)
* Remarques : - *
* *
******************************************************************************/
-#if 0 // TODO
+
int make_tmp_file(const char *prefix, const char *suffix, char **filename)
{
int result; /* Flux ou code à retourner */
- const char *tmpdir; /* Répertoire d'accueil */
- bool status; /* Bilan d'un consultation */
+ GSettings *settings; /* Configuration sollicitée */
+ gchar *tmpdir; /* Répertoire d'accueil */
size_t slen; /* Taille du suffixe */
- status = g_generic_config_get_value(get_main_configuration(), MPK_TMPDIR, &tmpdir);
- if (!status) return -1;
+ /* Récupération d'un répertoire de travail temporaire */
+
+ settings = g_settings_new("re.chrysalide.framework.paths");
+
+ tmpdir = g_settings_get_string(settings, "tmp-work-dir");
slen = strlen(suffix);
@@ -334,6 +337,12 @@ int make_tmp_file(const char *prefix, const char *suffix, char **filename)
else
asprintf(filename, "%s" G_DIR_SEPARATOR_S "%s-%d.XXXXXX", tmpdir, prefix, getpid());
+ g_free(tmpdir);
+
+ g_clear_object(&settings);
+
+ /* Mise en place d'un fichier temporaire */
+
result = ensure_path_exists(*filename);
if (result == 0)
@@ -356,7 +365,7 @@ int make_tmp_file(const char *prefix, const char *suffix, char **filename)
return result;
}
-#endif
+
/******************************************************************************
* *
diff --git a/src/common/pathname.h b/src/common/pathname.h
index 1b6624c..104833b 100644
--- a/src/common/pathname.h
+++ b/src/common/pathname.h
@@ -42,9 +42,7 @@ bool mkpath(const char *);
int ensure_path_exists(const char *);
/* Met en place un fichier temporaire. */
-#if 0 // TODO
int make_tmp_file(const char *, const char *, char **);
-#endif
/* Copie un fichier. */
bool copy_file(const char *, const char *);
diff --git a/src/common/sort.h b/src/common/sort.h
index 39a6f33..27e3739 100644
--- a/src/common/sort.h
+++ b/src/common/sort.h
@@ -37,6 +37,9 @@ int sort_boolean(bool, bool);
/* Compare une valeur avec une autre. */
int sort_unsigned_long(unsigned long, unsigned long);
+#define sort_size(v1, v2) \
+ sort_unsigned_long(v1, v2)
+
/* Compare une valeur avec une autre. */
int sort_signed_long_long(signed long long, signed long long);
diff --git a/src/common/szbin.h b/src/common/szbin.h
index ac938ab..8524ae3 100644
--- a/src/common/szbin.h
+++ b/src/common/szbin.h
@@ -25,10 +25,17 @@
#define _COMMON_SZBIN_H
+#include <assert.h>
#include <malloc.h>
#include <string.h>
+#include "datatypes.h"
+#include "io.h"
+#include "leb128.h"
+#include "sort.h"
+
+
/* Structure associant données et taille */
typedef struct _sized_binary_t
@@ -38,6 +45,9 @@ typedef struct _sized_binary_t
const char *static_data; /* Données non modifiées */
char *data; /* Chaîne de caractères */
+ const bin_t *static_bin_data; /* Données brutes non modifiées*/
+ bin_t *bin_data; /* Données brutes */
+
};
size_t size; /* Taille correspondante */
@@ -45,44 +55,228 @@ typedef struct _sized_binary_t
} sized_binary_t;
-#define init_sized_binary(sb) \
- do \
- { \
- (sb)->data = NULL; \
- (sb)->size = 0; \
- } \
+#define init_sized_binary(sb) \
+ do \
+ { \
+ (sb)->data = NULL; \
+ (sb)->size = 0; \
+ } \
+ while (0)
+
+
+#define setup_sized_binary(sb, s) \
+ do \
+ { \
+ (sb)->data = malloc(s); \
+ (sb)->size = s; \
+ } \
while (0)
-#define setup_sized_binary(sb, s) \
- do \
- { \
- (sb)->data = malloc(s); \
- (sb)->size = s; \
- } \
+#define setup_sized_binary_from_static_string(sb, s) \
+ do \
+ { \
+ (sb)->static_data = s; \
+ (sb)->size = strlen(s) + 1; \
+ } \
while (0)
-#define dup_into_sized_binary(sb, d, s) \
- do \
- { \
- setup_sized_binary(sb, s); \
- memcpy((sb)->data, d, s); \
- } \
+#define dup_into_sized_binary(sb, d, s) \
+ do \
+ { \
+ size_t __size_once; \
+ __size_once = s; \
+ setup_sized_binary(sb, __size_once);\
+ memcpy((sb)->data, d, __size_once); \
+ } \
while (0)
-#define exit_sized_binary(sb) \
- do \
- { \
- if ((sb)->data != NULL) \
- { \
- free((sb)->data); \
- init_sized_binary(sb); \
- } \
- } \
+#define dup_sized_binary(dst, src) \
+ dup_into_sized_binary((dst), (src)->static_data, (src)->size)
+
+
+#define exit_sized_binary(sb) \
+ do \
+ { \
+ if ((sb)->data != NULL) \
+ { \
+ free((sb)->data); \
+ init_sized_binary(sb); \
+ } \
+ } \
while (0)
+#define resize_sized_binary(sb, s) \
+ do \
+ { \
+ (sb)->size = s; \
+ (sb)->data = realloc((sb)->data, \
+ (sb)->size); \
+ } \
+ while (0)
+
+
+#define add_to_sized_binary(sb, d, s) \
+ do \
+ { \
+ size_t __old_size; \
+ __old_size = (sb)->size; \
+ (sb)->size += s; \
+ (sb)->data = realloc((sb)->data, \
+ (sb)->size); \
+ memcpy((sb)->data + __old_size, \
+ d, s); \
+ } \
+ while (0)
+
+
+#define add_static_to_sized_binary(sb, d) \
+ do \
+ { \
+ size_t __len; \
+ __len = sizeof(d) - 1; \
+ add_to_sized_binary(sb, d, __len); \
+ } \
+ while (0)
+
+
+#define memcmp_sized_binary(s1, s2) \
+ ({ \
+ int __ret; \
+ __ret = sort_size((s1)->size, (s2)->size); \
+ if (__ret == 0) \
+ __ret = memcmp((s1)->data, (s2)->data, (s1)->size); \
+ __ret; \
+ })
+
+
+
+/**
+ * Conservations et rechargements.
+ */
+
+#define load_sized_binary(sb, f) \
+ ({ \
+ uleb128_t __sz; \
+ bool __ret; \
+ __ret = load_uleb128(&__sz, f); \
+ if (__ret) \
+ { \
+ setup_sized_binary(sb, __sz); \
+ __ret = safe_read(f, (sb)->data, (sb)->size); \
+ if (!__ret) \
+ exit_sized_binary(sb); \
+ } \
+ __ret; \
+ })
+
+
+#define load_sized_binary_as_string(sb, f) \
+ ({ \
+ uleb128_t __sz; \
+ bool __ret; \
+ __ret = load_uleb128(&__sz, f); \
+ if (__ret) \
+ { \
+ setup_sized_binary(sb, __sz + 1); \
+ __ret = safe_read(f, (sb)->data, __sz); \
+ if (!__ret) \
+ exit_sized_binary(sb); \
+ (sb)->data[__sz] = '\0'; \
+ } \
+ __ret; \
+ })
+
+
+#define store_sized_binary(sb, f) \
+ ({ \
+ bool __ret; \
+ __ret = store_uleb128((const uleb128_t []){ (sb)->size }, f); \
+ if (__ret) \
+ __ret = safe_write(f, (sb)->static_data, (sb)->size); \
+ __ret; \
+ })
+
+
+#define store_sized_binary_as_string(sb, f) \
+ ({ \
+ bool __ret; \
+ size_t __length; \
+ assert((sb)->size >= 1); \
+ __length = (sb)->size - 1; \
+ assert((sb)->static_data[__length] == '\0'); \
+ __ret = store_uleb128((const uleb128_t []){ __length }, f); \
+ if (__ret) \
+ __ret = safe_write(f, (sb)->static_data, __length); \
+ __ret; \
+ })
+
+
+#define unpack_sized_binary(sb, p, m) \
+ ({ \
+ uleb128_t __sz; \
+ bool __ret; \
+ __ret = unpack_uleb128(&__sz, p, m); \
+ if (__ret) \
+ { \
+ setup_sized_binary(sb, __sz); \
+ memcpy((sb)->data, *p, (sb)->size); \
+ *((uint8_t **)p) += __sz; \
+ } \
+ __ret; \
+ })
+
+
+#define unpack_sized_binary_as_string(sb, p, m) \
+ ({ \
+ uleb128_t __sz; \
+ bool __ret; \
+ __ret = unpack_uleb128(&__sz, p, m); \
+ if (__ret) \
+ { \
+ setup_sized_binary(sb, __sz + 1); \
+ memcpy((sb)->data, *p, __sz); \
+ (sb)->data[__sz] = '\0'; \
+ *((uint8_t **)p) += __sz; \
+ } \
+ __ret; \
+ })
+
+
+#define pack_sized_binary(sb, l) \
+ ({ \
+ uint8_t *__result; \
+ size_t __pos; \
+ __result = pack_uleb128((const uleb128_t []){ (sb)->size }, l); \
+ __pos = *(l); \
+ *(l) += (sb)->size; \
+ __result = realloc(__result, *(l) * sizeof(uint8_t)); \
+ memcpy(&__result[__pos], (sb)->static_data, \
+ ((sb)->size * sizeof(uint8_t))); \
+ __result; \
+ })
+
+
+#define pack_sized_binary_as_string(sb, l) \
+ ({ \
+ uint8_t *__result; \
+ size_t __length; \
+ size_t __pos; \
+ assert((sb)->size >= 1); \
+ __length = (sb)->size - 1; \
+ assert((sb)->static_data[__length] == '\0'); \
+ __result = pack_uleb128((const uleb128_t []){ __length }, l); \
+ __pos = *(l); \
+ *(l) += __length; \
+ __result = realloc(__result, *(l) * sizeof(uint8_t)); \
+ memcpy(&__result[__pos], (sb)->static_data, \
+ (__length * sizeof(uint8_t))); \
+ __result; \
+ })
+
+
#endif /* _COMMON_SZBIN_H */
generated by cgit v0.11.2-87-g4458 at 2025-07-12 16:19:42 (GMT)