summaryrefslogtreecommitdiff
path: root/src/analysis/scan/exprs/access.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/analysis/scan/exprs/access.c')
-rw-r--r--src/analysis/scan/exprs/access.c471
1 files changed, 471 insertions, 0 deletions
diff --git a/src/analysis/scan/exprs/access.c b/src/analysis/scan/exprs/access.c
new file mode 100644
index 0000000..ad66f60
--- /dev/null
+++ b/src/analysis/scan/exprs/access.c
@@ -0,0 +1,471 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * access.c - accès à un élément d'expression sous-jacent
+ *
+ * Copyright (C) 2023 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 Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "access.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+#include "access-int.h"
+#include "../../../core/global.h"
+
+
+
+/* --------------------- INTRODUCTION D'UNE NOUVELLE EXPRESSION --------------------- */
+
+
+/* Initialise la classe des appels de fonction avec arguments. */
+static void g_named_access_class_init(GNamedAccessClass *);
+
+/* Initialise une instance d'appel de fonction avec arguments. */
+static void g_named_access_init(GNamedAccess *);
+
+/* Supprime toutes les références externes. */
+static void g_named_access_dispose(GNamedAccess *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_named_access_finalize(GNamedAccess *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Reproduit une expression en place dans une nouvelle instance. */
+static void g_named_access_copy(GNamedAccess *, const GNamedAccess *);
+
+/* Réduit une expression à une forme plus simple. */
+static bool g_named_access_reduce(GNamedAccess *, GScanContext *, GScanScope *, GScanExpression **);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* INTRODUCTION D'UNE NOUVELLE EXPRESSION */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un appel de fonction enregistrée. */
+G_DEFINE_TYPE(GNamedAccess, g_named_access, G_TYPE_SCAN_EXPRESSION);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des appels de fonction avec arguments. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_named_access_class_init(GNamedAccessClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+ GScanExpressionClass *expr; /* Version de classe parente */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_named_access_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_named_access_finalize;
+
+ expr = G_SCAN_EXPRESSION_CLASS(klass);
+
+ expr->cmp_rich = (compare_expr_rich_fc)NULL;
+ expr->copy = (copy_expr_fc)g_named_access_copy;
+ expr->reduce = (reduce_expr_fc)g_named_access_reduce;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : access = instance à initialiser. *
+* *
+* Description : Initialise une instance d'appel de fonction avec arguments. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_named_access_init(GNamedAccess *access)
+{
+ access->any = NULL;
+ access->target = NULL;
+
+ access->next = NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : access = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_named_access_dispose(GNamedAccess *access)
+{
+ g_clear_object(&access->any);
+
+ g_clear_object(&access->next);
+
+ G_OBJECT_CLASS(g_named_access_parent_class)->dispose(G_OBJECT(access));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : access = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_named_access_finalize(GNamedAccess *access)
+{
+ if (access->target != NULL)
+ free(access->target);
+
+ G_OBJECT_CLASS(g_named_access_parent_class)->finalize(G_OBJECT(access));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : target = désignation de l'objet d'appel à identifier. *
+* *
+* Description : Organise un accès à un élément d'expression sous-jacent. *
+* *
+* Retour : Fonction mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GScanExpression *g_named_access_new(const sized_string_t *target)
+{
+ GScanExpression *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_NAMED_ACCESS, NULL);
+
+ if (!g_named_access_create(G_NAMED_ACCESS(result), target))
+ g_clear_object(&result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : access = instance à initialiser pleinement. *
+* target = désignation de l'objet d'appel à identifier. *
+* *
+* Description : Met en place une expression d'accès. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_named_access_create(GNamedAccess *access, const sized_string_t *target)
+{
+ bool result; /* Bilan à retourner */
+
+ result = g_scan_expression_create(G_SCAN_EXPRESSION(access), EVT_PENDING);
+ if (!result) goto exit;
+
+ access->target = strndup(target->data, target->len);
+
+ exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : access = expression d'appel à actualiser. *
+* base = zone de recherche pour la résolution à venir. *
+* *
+* Description : Définit une base de recherche pour la cible d'accès. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_named_access_set_base(GNamedAccess *access, GRegisteredItem *base)
+{
+ g_clear_object(&access->base);
+
+ access->base = base;
+ g_object_ref(G_OBJECT(base));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : access = expression d'appel à compléter. *
+* next = expression d'appel suivante dans la chaîne. *
+* *
+* Description : Complète la chaine d'accès à des expressions. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_named_access_attach_next(GNamedAccess *access, GNamedAccess *next)
+{
+ if (access->next != NULL)
+ g_named_access_attach_next(access->next, next);
+
+ else
+ {
+ access->next = next;
+ g_object_ref(G_OBJECT(next));
+ }
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* IMPLEMENTATION DES FONCTIONS DE CLASSE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : dest = emplacement d'enregistrement à constituer. [OUT] *
+* src = expression source à copier. *
+* *
+* Description : Reproduit une expression en place dans une nouvelle instance.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_named_access_copy(GNamedAccess *dest, const GNamedAccess *src)
+{
+ GScanExpressionClass *class; /* Classe parente à solliciter */
+
+ class = G_SCAN_EXPRESSION_CLASS(g_named_access_parent_class);
+
+ class->copy(G_SCAN_EXPRESSION(dest), G_SCAN_EXPRESSION(src));
+
+ if (src->any != NULL)
+ {
+ dest->any = src->any;
+ g_object_ref(src->any);
+ }
+
+ if (src->target != NULL)
+ dest->target = strdup(src->target);
+
+ if (src->next != NULL)
+ dest->next = G_NAMED_ACCESS(g_scan_expression_duplicate(G_SCAN_EXPRESSION(src->next)));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : expr = expression à consulter. *
+* ctx = contexte de suivi de l'analyse courante. *
+* scope = portée courante des variables locales. *
+* out = zone d'enregistrement de la réduction opérée. [OUT] *
+* *
+* Description : Réduit une expression à une forme plus simple. *
+* *
+* Retour : Bilan de l'opération : false en cas d'erreur irrécupérable. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool _g_named_access_reduce(GNamedAccess *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
+{
+ bool result; /* Bilan à retourner */
+ GRegisteredItem *base; /* Base de recherche courante */
+ GRegisteredItem *resolved; /* Cible concrète obtenue */
+ GNamedAccess *new; /* Copie mise en place */
+
+ result = true;
+
+ if (expr->target != NULL)
+ {
+ if (expr->base != NULL)
+ {
+ base = expr->base;
+ g_object_ref(G_OBJECT(base));
+ }
+ else
+ base = G_REGISTERED_ITEM(get_rost_root_namespace());
+
+ result = g_registered_item_resolve(base, expr->target, ctx, scope, &resolved);
+
+ g_object_unref(G_OBJECT(base));
+
+ if (result && resolved != NULL)
+ {
+ new = G_NAMED_ACCESS(g_scan_expression_duplicate(G_SCAN_EXPRESSION(expr)));
+
+ g_clear_object(&new->base);
+
+ free(new->target);
+ new->target = NULL;
+
+ new->resolved = resolved;
+
+ *out = G_SCAN_EXPRESSION(new);
+
+ }
+
+ }
+
+ /**
+ * Si plus aucune indication n'est diponible pour avancer dans les réductions,
+ * c'est que l'opération est déjà conclue.
+ */
+ else
+ {
+ assert(expr->resolved != NULL);
+
+ *out = G_SCAN_EXPRESSION(expr);
+ g_object_ref(G_OBJECT(*out));
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : expr = expression à consulter. *
+* ctx = contexte de suivi de l'analyse courante. *
+* scope = portée courante des variables locales. *
+* out = zone d'enregistrement de la réduction opérée. [OUT] *
+* *
+* Description : Réduit une expression à une forme plus simple. *
+* *
+* Retour : Bilan de l'opération : false en cas d'erreur irrécupérable. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_named_access_reduce(GNamedAccess *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out)
+{
+ bool result; /* Bilan à retourner */
+ GNamedAccess *new; /* Eventuel étage suivant */
+ GScanExpression *final; /* Expression d'évaluation */
+ GScanExpression *new_next; /* Nouvelle version du suivant */
+
+ result = _g_named_access_reduce(expr, ctx, scope, out);
+
+ if (result && *out != NULL)
+ {
+ assert(G_IS_NAMED_ACCESS(*out));
+
+ new = G_NAMED_ACCESS(*out);
+ *out = NULL;
+
+ assert(new->target == NULL);
+ assert(G_IS_NAMED_ACCESS(new));
+ assert(G_IS_REGISTERED_ITEM(new->resolved));
+
+ /**
+ * Si l'élément résolu se trouve en fin de chaîne, alors cet élément
+ * est sollicité pour obtenir une expression d'évaluation classique.
+ * Le produit de cette réduction finale bénéficie d'une promotion et
+ * représente à lui seul la réduction produite pour la chaîne.
+ */
+ if (new->next == NULL)
+ {
+ result = g_registered_item_reduce(new->resolved, ctx, scope, &final);
+
+ if (result && final != NULL)
+ {
+ g_clear_object(out);
+ *out = final;
+ }
+
+ }
+
+ /**
+ * Sinon, l'élément résolu constitue une base pour l'étage suivant de
+ * la chaîne de résolution.
+ */
+ else
+ {
+ new_next = g_scan_expression_duplicate(G_SCAN_EXPRESSION(new->next));
+ assert(G_IS_NAMED_ACCESS(new_next));
+
+ g_named_access_set_base(G_NAMED_ACCESS(new_next), new->resolved);
+
+ g_clear_object(out);
+
+ result = g_scan_expression_reduce(new_next, ctx, scope, out);
+
+ if (result && *out == NULL)
+ *out = new_next;
+
+ }
+
+ g_object_unref(G_OBJECT(new));
+
+ }
+
+ return result;
+
+}
generated by cgit v0.11.2-87-g4458 at 2024-05-14 09:14:37 (GMT)