summaryrefslogtreecommitdiff
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rwxr-xr-xsrc/core/Makefile.am3
-rw-r--r--src/core/core.c22
-rw-r--r--src/core/processors.c254
-rw-r--r--src/core/processors.h53
4 files changed, 326 insertions, 6 deletions
diff --git a/src/core/Makefile.am b/src/core/Makefile.am
index 02b6877..0d6d754 100755
--- a/src/core/Makefile.am
+++ b/src/core/Makefile.am
@@ -4,7 +4,8 @@ noinst_LTLIBRARIES = libcore.la
libcore_la_SOURCES = \
collections.h collections.c \
core.h core.c \
- params.h params.c
+ params.h params.c \
+ processors.h processors.c
libcore_la_LDFLAGS = $(LIBGTK_LIBS) $(LIBXML_LIBS)
diff --git a/src/core/core.c b/src/core/core.c
index d7e7755..36428d7 100644
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -26,6 +26,7 @@
#include "collections.h"
#include "params.h"
+#include "processors.h"
@@ -43,15 +44,24 @@
bool load_all_basic_components(void)
{
- bool result; /* Bilan à retourner */
+ static bool result = false; /* Bilan à retourner */
- result = true;
+ /**
+ * On mémorise les passages réussis.
+ */
+ if (!result)
+ {
+ result = true;
- result &= load_main_config_parameters();
+ result &= load_main_config_parameters();
- result &= g_generic_config_read(get_main_configuration());
+ result &= g_generic_config_read(get_main_configuration());
- result &= load_hard_coded_collection_definitions();
+ result &= load_hard_coded_processors_definitions();
+
+ result &= load_hard_coded_collection_definitions();
+
+ }
return result;
@@ -74,6 +84,8 @@ void unload_all_basic_components(void)
{
unload_collection_definitions();
+ unload_processors_definitions();
+
g_generic_config_write(get_main_configuration());
unload_main_config_parameters();
diff --git a/src/core/processors.c b/src/core/processors.c
new file mode 100644
index 0000000..7489614
--- /dev/null
+++ b/src/core/processors.c
@@ -0,0 +1,254 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * processors.c - enregistrement et fourniture des architectures supportées
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * OpenIDA 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.
+ *
+ * OpenIDA 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 "processors.h"
+
+
+#include <malloc.h>
+#include <pthread.h>
+#include <string.h>
+
+
+#include "../arch/arm/v7/processor.h"
+#include "../arch/dalvik/processor.h"
+#include "../arch/jvm/processor.h"
+
+
+
+/* Caractéristiques d'un processeur */
+typedef struct _proc_t
+{
+ char *key; /* Clef pour un accès rapide */
+ char *name; /* Désignation humaine */
+ GType instance; /* Type à manipuler en interne */
+
+} proc_t;
+
+
+/* Mémorisation des types de processeurs enregistrés */
+static proc_t *_processors_definitions = NULL;
+static size_t _processors_definitions_count = 0;
+
+/* Verrou pour des accès atomiques */
+/* ... */
+
+
+/* Retrouve l'enregistrement correspondant à une architecture. */
+static proc_t *find_processor_by_key(const char *);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : key = désignation rapide et interne d'un processeur. *
+* name = désignation humaine de l'architecture. *
+* instance = type GLib représentant le type à instancier. *
+* *
+* Description : Enregistre un processeur pour une architecture donnée. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool register_processor_type(const char *key, const char *name, GType instance)
+{
+ proc_t *new; /* Nouvel élément à définir */
+
+ /* TODO : if find()... -> unref(), ret false */
+
+ /* TODO : lock */
+
+ _processors_definitions = (proc_t *)realloc(_processors_definitions,
+ ++_processors_definitions_count * sizeof(proc_t));
+
+ new = &_processors_definitions[_processors_definitions_count - 1];
+
+ new->key = strdup(key);
+ new->name = strdup(name);
+ new->instance = instance;
+
+ /* TODO : unlock */
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Charge les définitions de processeurs "natifs". *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool load_hard_coded_processors_definitions(void)
+{
+ bool result; /* Bilan à retourner */
+
+ result = true;
+
+ result &= register_processor_type("armv7", "ARM v7", G_TYPE_ARMV7_PROCESSOR);
+
+ result &= register_processor_type("dalvik", "Dalvik Virtual Machine", G_TYPE_DALVIK_PROCESSOR);
+
+ //result &= register_processor_type("jvm", "Java Virtual Machine", G_TYPE_JVM_PROCESSOR);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Décharge toutes les définitions de processeurs. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void unload_processors_definitions(void)
+{
+ size_t i; /* Boucle de parcours */
+
+ for (i = 0; i < _processors_definitions_count; i++)
+ {
+ free(_processors_definitions[i].key);
+ free(_processors_definitions[i].name);
+ }
+
+ if (_processors_definitions != NULL)
+ free(_processors_definitions);
+
+ _processors_definitions = NULL;
+ _processors_definitions_count = 0;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : key = nom technique du processeur recherché. *
+* *
+* Description : Retrouve l'enregistrement correspondant à une architecture. *
+* *
+* Retour : Définition trouvée ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static proc_t *find_processor_by_key(const char *key)
+{
+ proc_t *result; /* Trouvaille à retourner */
+ size_t i; /* Boucle de parcours */
+
+ /**
+ * Le verrou d'accès global doit être posé !
+ */
+
+ result = NULL;
+
+ for (i = 0; i < _processors_definitions_count; i++)
+ if (strcmp(_processors_definitions[i].key, key) == 0)
+ result = &_processors_definitions[i];
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : key = nom technique du processeur recherché. *
+* *
+* Description : Fournit le nom humain de l'architecture visée. *
+* *
+* Retour : Désignation humaine trouvée ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const char *get_arch_processor_name(const char *key)
+{
+ const char *result; /* Description à retourner */
+ proc_t *def; /* Définition d'architecture */
+
+ /* TODO : lock */
+
+ def = find_processor_by_key(key);
+
+ if (def == NULL)
+ result = NULL;
+ else
+ result = def->name;
+
+ /* TODO : unlock */
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : key = nom technique du processeur recherché. *
+* *
+* Description : Fournit le processeur d'architecture correspondant à un type.*
+* *
+* Retour : Processeur d'architecture trouvé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GArchProcessor *get_arch_processor_for_type(const char *key)
+{
+ GArchProcessor *result; /* Instance à retourner */
+ proc_t *def; /* Définition d'architecture */
+
+ /* TODO : lock */
+
+ def = find_processor_by_key(key);
+
+ if (def == NULL)
+ result = NULL;
+ else
+ result = g_object_new(def->instance, NULL);
+
+ /* TODO : unlock */
+
+ return result;
+
+}
diff --git a/src/core/processors.h b/src/core/processors.h
new file mode 100644
index 0000000..f25a8a3
--- /dev/null
+++ b/src/core/processors.h
@@ -0,0 +1,53 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * processors.h - prototypes pour l'enregistrement et la fourniture des architectures supportées
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * OpenIDA 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.
+ *
+ * OpenIDA 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/>.
+ */
+
+
+#ifndef _CORE_PROCESSORS_H
+#define _CORE_PROCESSORS_H
+
+
+#include <glib-object.h>
+#include <stdbool.h>
+
+
+#include "../arch/processor.h"
+
+
+
+/* Enregistre un processeur pour une architecture donnée. */
+bool register_processor_type(const char *, const char *, GType);
+
+/* Charge les définitions de processeurs "natifs". */
+bool load_hard_coded_processors_definitions(void);
+
+/* Décharge toutes les définitions de processeurs. */
+void unload_processors_definitions(void);
+
+/* Fournit le nom humain de l'architecture visée. */
+const char *get_arch_processor_name(const char *);
+
+/* Fournit le processeur d'architecture correspondant à un type. */
+GArchProcessor *get_arch_processor_for_type(const char *);
+
+
+
+#endif /* _ANALYSIS_DB_COLLECTION_H */
generated by cgit v0.11.2-87-g4458 at 2024-12-26 03:58:38 (GMT)