1 files changed, 56 insertions, 7 deletions

diff --git a/src/analysis/scan/patterns/tokens/atom.c b/src/analysis/scan/patterns/tokens/atom.c
index fcb585d..52f239c 100644
--- a/src/analysis/scan/patterns/tokens/atom.c
+++ b/src/analysis/scan/patterns/tokens/atom.c
@@ -251,6 +251,7 @@ void find_best_atom(const sized_binary_t *raw, size_t maxsize, tracked_scan_atom
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : src   = chaîne ed référence à dupliquer.                     *
+*                atom  = préselection opérée en amont.                        *
 *                count = nombre de lettres présentes.                         *
 *                                                                             *
 *  Description : Etablit la liste des cas de figures ignorant la casse.       *
@@ -261,7 +262,7 @@ void find_best_atom(const sized_binary_t *raw, size_t maxsize, tracked_scan_atom
 *                                                                             *
 ******************************************************************************/
 
-sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t count)
+sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, const tracked_scan_atom_t *atom, size_t count)
 {
     sized_binary_t *result;                 /* Liste à retourner           */
     size_t i;                               /* Boucle de parcours #1       */
@@ -274,16 +275,20 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
     size_t divisor;                         /* Taille de la découpe        */
     size_t quotient;                        /* Reste de la position        */
 
-    count *= 2;
-
     /* Création du réceptacle */
 
     result = malloc(count * sizeof(tracked_scan_atom_t));
 
+    assert(src->len == (atom->pos + atom->len + atom->rem));
+
     for (i = 0; i < count; i++)
     {
         result[i].data = malloc(src->len);
         result[i].len = src->len;
+
+        memcpy(result[i].data, src->data, atom->pos);
+        memcpy(&result[i].data[atom->pos + atom->len], &src->data[atom->pos + atom->len], atom->rem);
+
     }
 
     /* Remplissage */
@@ -294,7 +299,7 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
     check = 1;
 #endif
 
-    for (i = 0; i < src->len; i++)
+    for (i = atom->pos; i < (atom->pos + atom->len); i++)
     {
         ch = src->data[i];
 
@@ -315,8 +320,8 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
             replaced *= 2;
 
 #ifndef NDEBUG
-            check++;
-            assert((check - 1) <= count);
+            check *= 2;
+            assert(check <= count);
 #endif
 
         }
@@ -326,7 +331,51 @@ sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t co
 
     }
 
-    assert((check - 1) == count);
+    assert(check == count);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : byte     = octet partiel à interpréter.                      *
+*                mask     = valeur du masque à appliquer.                     *
+*                produced = nombre de contenus générés. [OUT]                 *
+*                                                                             *
+*  Description : Etablit la liste des cas de figures avec un octet partiel.   *
+*                                                                             *
+*  Retour      : Liste de toutes les combinaisons possibles.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+sized_binary_t *make_atoms_from_masked_byte(bin_t value, bin_t mask, size_t *produced)
+{
+    sized_binary_t *result;                 /* Liste à retourner           */
+    size_t i;                               /* Boucle de parcours #1       */
+
+    *produced = 16;
+
+    /* Création du réceptacle */
+
+    result = malloc(16 * sizeof(tracked_scan_atom_t));
+
+    /* Remplissage */
+
+    for (i = 0; i < 16; i++)
+    {
+        result[i].data = malloc(1);
+        result[i].len = 1;
+
+        if (mask == 0x0f)
+            result[i].data[0] = value | (i << 4);
+        else
+            result[i].data[0] = value | i;
+
+    }
 
     return result;