summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Makefile.am2
-rwxr-xr-xsrc/analysis/Makefile.am3
-rw-r--r--src/analysis/binary-int.h12
-rw-r--r--src/analysis/binary.c444
-rw-r--r--src/analysis/binary.h32
-rwxr-xr-xsrc/analysis/db/Makefile.am22
-rw-r--r--src/analysis/db/bookmark.c69
-rw-r--r--src/analysis/db/bookmark.h41
-rw-r--r--src/analysis/db/cdb.c602
-rw-r--r--src/analysis/db/cdb.h62
-rw-r--r--src/analysis/db/client.c291
-rw-r--r--src/analysis/db/client.h61
-rw-r--r--src/analysis/db/collection.c26
-rw-r--r--src/analysis/db/collection.h30
-rw-r--r--src/analysis/db/core.c205
-rw-r--r--src/analysis/db/core.h70
-rw-r--r--src/analysis/db/protocol.h71
-rw-r--r--src/analysis/db/server.c426
-rw-r--r--src/analysis/db/server.h61
-rwxr-xr-xsrc/common/Makefile.am1
-rw-r--r--src/common/io.c27
-rw-r--r--src/common/io.h43
-rw-r--r--src/common/xml.c34
-rw-r--r--src/common/xml.h3
-rw-r--r--src/dialogs/Makefile.am3
-rw-r--r--src/dialogs/storage.c662
-rw-r--r--src/dialogs/storage.h40
-rw-r--r--src/gui/menus/binary.c51
-rw-r--r--src/main.c38
-rw-r--r--src/project.c2
30 files changed, 3421 insertions, 13 deletions
diff --git a/src/Makefile.am b/src/Makefile.am
index 623506e..e4a1e16 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -90,7 +90,7 @@ AM_CPPFLAGS =
AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
-chrysalide_LDFLAGS = $(LIBGTK_LIBS) -L/usr/X11R6/lib -ldl -lm $(LIBXML_LIBS) `pkg-config --libs gthread-2.0` $(LIBPYTHON_LIBS) \
+chrysalide_LDFLAGS = $(LIBGTK_LIBS) -L/usr/X11R6/lib -ldl -lm $(LIBXML_LIBS) `pkg-config --libs gthread-2.0` $(LIBPYTHON_LIBS) $(LIBARCHIVE_LIBS) $(LIBSQLITE_LIBS) \
-L.libs -lchrysaglibext -lchrysadisass -lchrysagtkext -lchrysagui \
-Lcommon/.libs -lcommon \
-Lplugins/.libs -lplugins
diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index 6409943..79aa9d1 100755
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -14,6 +14,7 @@ libanalysis_la_SOURCES = \
libanalysis_la_LIBADD = \
binaries/libanalysisbinaries.la \
blocks/libanalysisblocks.la \
+ db/libanalysisdb.la \
decomp/libanalysisdecomp.la \
disass/libanalysisdisass.la \
types/libanalysistypes.la
@@ -27,4 +28,4 @@ AM_CPPFLAGS =
AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
-SUBDIRS = binaries blocks decomp disass types
+SUBDIRS = binaries blocks db decomp disass types
diff --git a/src/analysis/binary-int.h b/src/analysis/binary-int.h
index f813aa8..788371a 100644
--- a/src/analysis/binary-int.h
+++ b/src/analysis/binary-int.h
@@ -28,6 +28,7 @@
#include "binary.h"
+#include "db/client.h"
#include "../format/format.h"
@@ -44,11 +45,22 @@ struct _GLoadedBinary
{
GObject parent; /* A laisser en premier */
+ char *username; /* Identifiant de l'utilisateur*/
+ bool username_changed; /* Mémorise les changements */
+ char *remote_host; /* Nom du serveur distant */
+ unsigned short remote_port; /* Port du serveur distant */
+ bool use_remote_server; /* Indique une utilisation */
+
+ GDbClient *local; /* Enregistrements locaux */
+ GDbClient *remote; /* Enregistrements distants */
+ DBStorage storages[DBF_COUNT]; /* Lieux d'enregistrement */
+
save_binary_fc save; /* Sauvegarde au format XML */
get_binary_filename_fc get_filename; /* Obtention d'une description */
off_t bin_length; /* Taille des données brutes */
bin_t *bin_data; /* Données binaires brutes */
+ GChecksum *checksum; /* Calcul de l'empreinte */
GExeFormat *format; /* Format du binaire */
GArchProcessor *proc; /* Architecture du binaire */
diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 05c4e99..31bd18b 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -39,6 +39,7 @@
#include "decomp/decompiler.h"
#include "disass/disassembler.h"
#include "../common/extstr.h"
+#include "../common/cpp.h"
@@ -69,6 +70,16 @@ static void ack_completed_disassembly(GDelayedDisassembly *, GLoadedBinary *);
+/* ------------------------- INFORMATIONS D'ENREGISTREMENTS ------------------------- */
+
+
+/* Charge en mémoire les formes d'enregistrement du XML. */
+static bool g_loaded_binary_load_storage(GLoadedBinary *, xmlXPathContextPtr, const char *);
+
+/* Ecrit les formes d'enregistrement du binaire dans du XML. */
+static bool g_loaded_binary_save_storage(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
+
+
@@ -122,6 +133,16 @@ static void g_loaded_binary_class_init(GLoadedBinaryClass *klass)
static void g_loaded_binary_init(GLoadedBinary *binary)
{
+ binary->username = strdup("default");
+
+ binary->remote_host = strdup("localhost");
+ binary->remote_port = 9999;
+ binary->use_remote_server = false;
+
+ binary->storages[DBF_COMMENTS] = DBS_ALL_LOCAL;
+ binary->storages[DBF_SEGMENTS_DISPLAY] = DBS_ALL_LOCAL;
+ binary->storages[DBF_BOOKMARKS] = DBS_ALL_LOCAL;
+
binary->text_display[BDT_ASM][0] = true;
binary->text_display[BDT_ASM][1] = true;
binary->text_display[BDT_GRAPH][0] = false;
@@ -146,14 +167,14 @@ static void g_loaded_binary_init(GLoadedBinary *binary)
static void g_loaded_binary_dispose(GLoadedBinary *binary)
{
+ if (binary->checksum != NULL)
+ g_checksum_free(binary->checksum);
+
if (binary->format != NULL)
g_object_unref(G_OBJECT(binary->format));
if (binary->proc != NULL)
g_object_unref(G_OBJECT(binary->proc));
- if (binary->bin_data != NULL)
- free(binary->bin_data);
-
/* TODO... */
G_OBJECT_CLASS(g_loaded_binary_parent_class)->dispose(G_OBJECT(binary));
@@ -175,7 +196,12 @@ static void g_loaded_binary_dispose(GLoadedBinary *binary)
static void g_loaded_binary_finalize(GLoadedBinary *binary)
{
- /* TODO */
+ free(binary->username);
+
+ if (binary->bin_data != NULL)
+ free(binary->bin_data);
+
+ /* TODO... */
G_OBJECT_CLASS(g_loaded_binary_parent_class)->finalize(G_OBJECT(binary));
@@ -198,22 +224,33 @@ static void g_loaded_binary_finalize(GLoadedBinary *binary)
GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr context, const char *path)
{
GLoadedBinary *result; /* Adresse à retourner */
- char *type; /* Tupe de binaire à charger */
+ char *type; /* Type de binaire à charger */
+ bool status; /* Etat de la connexion à la BD*/
result = NULL;
type = get_node_prop_value(context, path, "type");
if (strcmp(type, "file") == 0)
- result = g_loaded_binary_new_from_xml(context, path);
+ result = g_file_binary_new_from_xml(context, path);
free(type);
if (result == NULL)
return NULL;
+ if (!g_loaded_binary_load_storage(result, context, path))
+ goto glbnfx_error;
+
+ /*
if (!g_loaded_binary_load_parts_from_xml(result, context, path))
goto glbnfx_error;
+ */
+
+ result->local = g_db_client_new("localhost", 1337);
+ status = g_db_client_start(result->local);
+
+ printf("DB status :: %d\n", status);
return result;
@@ -247,6 +284,8 @@ bool g_loaded_binary_save(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathC
result = binary->save(binary, xdoc, context, path);
+ result = g_loaded_binary_save_storage(binary, xdoc, context, path);
+
/* Parties à désassembler */
result = g_loaded_binary_save_parts(binary, xdoc, context, path);
@@ -475,6 +514,368 @@ static bool g_loaded_binary_save_parts(const GLoadedBinary *binary, xmlDocPtr xd
}
+
+/* ---------------------------------------------------------------------------------- */
+/* INFORMATIONS D'ENREGISTREMENTS */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à traiter. *
+* context = contexte pour les recherches XPath. *
+* path = chemin d'accès au noeud XML à lire. *
+* *
+* Description : Charge en mémoire les formes d'enregistrement du XML. *
+* *
+* Retour : true si l'opération a bien tourné, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_loaded_binary_load_storage(GLoadedBinary *binary, xmlXPathContextPtr context, const char *path)
+{
+ bool result; /* Bilan à faire remonter */
+ char *storage_path; /* Partie "Enregistrement" */
+ char *access; /* Chemin d'accès à un élément */
+ char *value; /* Valeur lue à partie du XML */
+ unsigned short port; /* Port de communication */
+ bool use; /* Usage d'un serveur distant */
+ DBFeatures i; /* Boucle de parcours */
+
+ result = true;
+
+ storage_path = strdup(path);
+ storage_path = stradd(storage_path, "/Storage");
+
+ /* Nom d'utilisateur */
+
+ access = strdup(storage_path);
+ access = stradd(access, "/Username");
+
+ value = get_node_text_value(context, access);
+
+ if (value != NULL)
+ {
+ g_loaded_binary_set_username(binary, value);
+ free(value);
+ }
+
+ free(access);
+
+ /* Serveur distant */
+
+ access = strdup(storage_path);
+ access = stradd(access, "/RemoteServer");
+
+ value = get_node_prop_value(context, access, "port");
+ if (value == NULL) goto glbls_features;
+
+ port = atoi(value);
+
+ free(value);
+
+ value = get_node_prop_value(context, access, "use");
+ if (value == NULL) goto glbls_features;
+
+ use = (strcmp(value, "true") == 0);
+
+ free(value);
+
+ value = get_node_prop_value(context, access, "host");
+ if (value == NULL) goto glbls_features;
+
+ g_loaded_binary_set_remote_server(binary, value, port, use);
+
+ free(value);
+
+ glbls_features:
+
+ free(access);
+
+ /* Fonctionnalités */
+
+ for (i = 0; i < DBF_COUNT; i++)
+ {
+ access = strdup(storage_path);
+ access = stradd(access, "/Features/");
+
+ switch (i)
+ {
+ case DBF_COMMENTS:
+ access = stradd(access, "Comments");
+ break;
+ case DBF_SEGMENTS_DISPLAY:
+ access = stradd(access, "Segments");
+ break;
+ case DBF_BOOKMARKS:
+ access = stradd(access, "Bookmarks");
+ break;
+ case DBF_COUNT:
+ /* Pour GCC */
+ break;
+ }
+
+ value = get_node_text_value(context, access);
+
+ if (value != NULL)
+ {
+ if (atoi(value) <= DBS_MAX)
+ g_loaded_binary_set_storage(binary, i, atoi(value));
+
+ }
+
+ free(access);
+
+ }
+
+ free(storage_path);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à traiter. *
+* xdoc = structure XML en cours d'édition. *
+* context = contexte à utiliser pour les recherches. *
+* path = chemin d'accès réservé au binaire. *
+* *
+* Description : Ecrit les formes d'enregistrement du binaire dans du XML. *
+* *
+* Retour : true si l'opération a bien tourné, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_loaded_binary_save_storage(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
+{
+ bool result; /* Bilan à faire remonter */
+ char *storage_path; /* Partie "Enregistrement" */
+ char *access; /* Chemin d'accès à un élément */
+ char port_str[sizeof(STR(USHRT_MAX)) + 1]; /* Version chaînée */
+ DBFeatures i; /* Boucle de parcours */
+
+ result = true;
+
+ storage_path = strdup(path);
+ storage_path = stradd(storage_path, "/Storage");
+
+ /* Nom d'utilisateur */
+
+ access = strdup(storage_path);
+ access = stradd(access, "/Username");
+
+ result &= add_content_to_node(xdoc, context, access, binary->username);
+
+ free(access);
+
+ /* Serveur distant */
+
+ access = strdup(storage_path);
+ access = stradd(access, "/RemoteServer");
+
+ result &= add_string_attribute_to_node(xdoc, context, access, "host", binary->remote_host);
+
+ sprintf(port_str, "%hu", binary->remote_port);
+ result &= add_string_attribute_to_node(xdoc, context, access, "port", port_str);
+
+ result &= add_string_attribute_to_node(xdoc, context, access, "use",
+ binary->use_remote_server ? "true" : "false");
+
+ free(access);
+
+ /* Fonctionnalités */
+
+ for (i = 0; i < DBF_COUNT; i++)
+ {
+ access = strdup(storage_path);
+ access = stradd(access, "/Features/");
+
+ switch (i)
+ {
+ case DBF_COMMENTS:
+ access = stradd(access, "Comments");
+ break;
+ case DBF_SEGMENTS_DISPLAY:
+ access = stradd(access, "Segments");
+ break;
+ case DBF_BOOKMARKS:
+ access = stradd(access, "Bookmarks");
+ break;
+ case DBF_COUNT:
+ /* Pour GCC */
+ break;
+ }
+
+ result &= add_uint_content_to_node(xdoc, context, access, binary->storages[i]);
+
+ free(access);
+
+ }
+
+ free(storage_path);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à consulter. *
+* *
+* Description : Identifie l'utilisateur analysant le binaire courant. *
+* *
+* Retour : Nom de l'utilisateur manipulant le binaire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const char *g_loaded_binary_get_username(const GLoadedBinary *binary)
+{
+ return binary->username;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à consulter. *
+* username = nom de l'utilisateur manipulant le binaire. *
+* *
+* Description : Définit l'utilisateur analysant le binaire courant. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_loaded_binary_set_username(GLoadedBinary *binary, const char *username)
+{
+ bool changed; /* Note les changements */
+
+ changed = (strcmp(binary->username, username) != 0);
+
+ free(binary->username);
+ binary->username = strdup(username);
+
+ binary->username_changed = changed;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à consulter. *
+* host = nom du serveur distant à contacter. [OUT] *
+* port = port de communication avec le serveur distant. [OUT]*
+* *
+* Description : Identifie le serveur distant associé au binaire courant. *
+* *
+* Retour : Statut de l'utilisation du serveur distant. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_loaded_binary_get_remote_server(const GLoadedBinary *binary, const char **host, unsigned short *port)
+{
+ *host = binary->remote_host;
+ *port = binary->remote_port;
+
+ return binary->use_remote_server;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à consulter. *
+* host = nom du serveur distant à contacter. *
+* port = port de communication avec le serveur distant. *
+* use = statut de l'utilisation du serveur distant. *
+* *
+* Description : Définit le serveur distant associé au binaire courant. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_loaded_binary_set_remote_server(GLoadedBinary *binary, const char *host, unsigned short port, bool use)
+{
+ free(binary->remote_host);
+ binary->remote_host = strdup(host);
+
+ binary->remote_port = port;
+
+ binary->use_remote_server = use;
+
+ if (use)
+ /* TODO : reload conn ! */;
+ else
+ /* TODO : stop conn ! */;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à consulter. *
+* feature = fonctionnalité visée par la requête. *
+* *
+* Description : Indique la forme d'enregistrement d'une fonctionnalité. *
+* *
+* Retour : Type d'enregistrement sélectionné. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+DBStorage g_loaded_binary_get_storage(const GLoadedBinary *binary, DBFeatures feature)
+{
+ return binary->storages[feature];
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à consulter. *
+* feature = fonctionnalité visée par la requête. *
+* storage = type d'enregistrement sélectionné. *
+* *
+* Description : Définit la forme d'enregistrement d'une fonctionnalité. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_loaded_binary_set_storage(GLoadedBinary *binary, DBFeatures feature, DBStorage storage)
+{
+ binary->storages[feature] = storage;
+
+}
+
+
+
+
+
+
+
+
+
+
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
@@ -541,6 +942,18 @@ void g_loaded_binary_analyse(GLoadedBinary *binary)
GBinPart **parts; /* Parties d'élément binaire */
size_t parts_count; /* Nombre de ces parties */
+ /* Détermination de l'identifiant */
+
+ binary->checksum = g_checksum_new(G_CHECKSUM_SHA256);
+ g_checksum_update(binary->checksum, binary->bin_data, binary->bin_length);
+
+ /* Contacts avec les serveurs */
+
+
+
+
+
+
if (binary->parts_count[BPM_ROUTINES] > 0)
binary->model = BPM_ROUTINES;
@@ -597,6 +1010,25 @@ const char *g_loaded_binary_get_filename(const GLoadedBinary *binary, bool full)
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
+* *
+* Description : Fournit une empreinte unique (SHA256) pour le binaire. *
+* *
+* Retour : Chaîne représentant l'empreinte du binaire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const gchar *g_loaded_binary_get_cheksum(const GLoadedBinary *binary)
+{
+ return g_checksum_get_string(binary->checksum);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = élément binaire à consulter. *
* length = taille en octets des données chargées. [OUT] *
* *
* Description : Fournit les détails du contenu binaire chargé en mémoire. *
diff --git a/src/analysis/binary.h b/src/analysis/binary.h
index 073c546..d7bc3e2 100644
--- a/src/analysis/binary.h
+++ b/src/analysis/binary.h
@@ -29,6 +29,7 @@
#include <stdbool.h>
+#include "db/protocol.h"
#include "../arch/processor.h"
#include "../common/xml.h"
#include "../format/executable.h"
@@ -81,6 +82,34 @@ GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr, const char *);
/* Ecrit une sauvegarde du binaire dans un fichier XML. */
bool g_loaded_binary_save(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
+
+
+/* ------------------------- INFORMATIONS D'ENREGISTREMENTS ------------------------- */
+
+
+/* Identifie l'utilisateur analysant le binaire courant. */
+const char *g_loaded_binary_get_username(const GLoadedBinary *);
+
+/* Définit l'utilisateur analysant le binaire courant. */
+void g_loaded_binary_set_username(GLoadedBinary *, const char *);
+
+/* Identifie le serveur distant associé au binaire courant. */
+bool g_loaded_binary_get_remote_server(const GLoadedBinary *, const char **, unsigned short *);
+
+/* Définit le serveur distant associé au binaire courant. */
+void g_loaded_binary_set_remote_server(GLoadedBinary *, const char *, unsigned short, bool);
+
+/* Indique la forme d'enregistrement d'une fonctionnalité. */
+DBStorage g_loaded_binary_get_storage(const GLoadedBinary *, DBFeatures);
+
+/* Définit la forme d'enregistrement d'une fonctionnalité. */
+void g_loaded_binary_set_storage(GLoadedBinary *, DBFeatures, DBStorage);
+
+
+
+
+
+
/* Définit les parties de binaire à analyser. */
void g_loaded_binary_set_parts(GLoadedBinary *, BinaryPartModel, GBinPart **, size_t);
@@ -93,6 +122,9 @@ void g_loaded_binary_analyse(GLoadedBinary *);
/* Fournit le fichier correspondant à l'élément binaire. */
const char *g_loaded_binary_get_filename(const GLoadedBinary *, bool);
+/* Fournit une empreinte unique (SHA256) pour le binaire. */
+const gchar *g_loaded_binary_get_cheksum(const GLoadedBinary *);
+
/* Fournit les détails du contenu binaire chargé en mémoire. */
bin_t *g_loaded_binary_get_data(const GLoadedBinary *, off_t *);
diff --git a/src/analysis/db/Makefile.am b/src/analysis/db/Makefile.am
new file mode 100755
index 0000000..ef98a24
--- /dev/null
+++ b/src/analysis/db/Makefile.am
@@ -0,0 +1,22 @@
+
+noinst_LTLIBRARIES = libanalysisdb.la
+
+libanalysisdb_la_SOURCES = \
+ bookmark.h bookmark.c \
+ cdb.h cdb.c \
+ client.h client.c \
+ collection.h collection.c \
+ core.h core.c \
+ protocol.h \
+ server.h server.c
+
+libanalysisdb_la_LIBADD =
+
+libanalysisdb_la_LDFLAGS =
+
+
+AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) $(LIBARCHIVE_CFLAGS) $(LIBSQLITE_CFLAGS)
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS =
diff --git a/src/analysis/db/bookmark.c b/src/analysis/db/bookmark.c
new file mode 100644
index 0000000..6327338
--- /dev/null
+++ b/src/analysis/db/bookmark.c
@@ -0,0 +1,69 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * bookmark.h - prototypes pour la gestion des signets au sein d'un binaire
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "bookmark.h"
+
+
+#include <malloc.h>
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : db = accès à la base de données. *
+* *
+* Description : Crée la table des signets dans une base de données. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool create_bookmark_db_table(sqlite3 *db)
+{
+ char *sql; /* Requête à exécuter */
+ int ret; /* Bilan de la création */
+ char *msg; /* Message d'erreur */
+
+ sql = "CREATE TABLE Bookmarks (" \
+ "id INT PRIMARY KEY NOT NULL, " \
+ "user TEXT NOT NULL, " \
+ "created INT NOT NULL, " \
+ "address INT NOT NULL, " \
+ "comment TEXT" \
+ ");";
+
+ ret = sqlite3_exec(db, sql, NULL, NULL, &msg);
+ if (ret != SQLITE_OK)
+ {
+ fprintf(stderr, "sqlite3_exec(): %s\n", msg);
+ sqlite3_free(msg);
+ }
+
+ return (ret == SQLITE_OK);
+
+}
diff --git a/src/analysis/db/bookmark.h b/src/analysis/db/bookmark.h
new file mode 100644
index 0000000..f5a8b37
--- /dev/null
+++ b/src/analysis/db/bookmark.h
@@ -0,0 +1,41 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * bookmark.h - prototypes pour la gestion des signets au sein d'un binaire
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _ANALYSIS_DB_BOOKMARK_H
+#define _ANALYSIS_DB_BOOKMARK_H
+
+
+
+#include <sqlite3.h>
+#include <stdbool.h>
+
+
+
+/* Crée la table des signets dans une base de données. */
+bool create_bookmark_db_table(sqlite3 *);
+
+
+
+
+
+#endif /* _ANALYSIS_DB_BOOKMARK_H */
diff --git a/src/analysis/db/cdb.c b/src/analysis/db/cdb.c
new file mode 100644
index 0000000..67d4916
--- /dev/null
+++ b/src/analysis/db/cdb.c
@@ -0,0 +1,602 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cdb.h - prototypes pour la manipulation des archives au format CDB
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "cdb.h"
+
+
+#include <archive.h>
+#include <archive_entry.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <sqlite3.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+
+#include <config.h>
+
+
+#include "bookmark.h"
+#include "protocol.h"
+#include "../../common/cpp.h"
+#include "../../common/extstr.h"
+#include "../../common/io.h"
+#include "../../common/xdg.h"
+#include "../../common/xml.h"
+
+
+
+/* Fixe le tampon pour la lecture des fichiers à inclure */
+#define ARCHIVE_RBUF_SIZE 2048
+
+
+/* Description d'une archive d'éléments utilisateur (instance) */
+struct _GCdbArchive
+{
+ GObject parent; /* A laisser en premier */
+
+ char hash[65]; /* Empreinte SHA256 */
+
+
+ char *filename; /* Chemin d'accès à l'archive */
+
+ char *xml_desc; /* Fichier de description */
+ char *sql_db; /* Base de données SQLite */
+
+ xmlDocPtr xdoc; /* Document XML à créer */
+ xmlXPathContextPtr context; /* Contexte pour les recherches*/
+
+ sqlite3 *db; /* Base de données à manipuler */
+
+};
+
+/* Description d'une archive d'éléments utilisateur (classe) */
+struct _GCdbArchiveClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des archives d'éléments utilisateur. */
+static void g_cdb_archive_class_init(GCdbArchiveClass *);
+
+/* Initialise une archive d'éléments utilisateur. */
+static void g_cdb_archive_init(GCdbArchive *);
+
+/* Supprime toutes les références externes. */
+static void g_cdb_archive_dispose(GCdbArchive *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_cdb_archive_finalize(GCdbArchive *);
+
+/* Ouvre une archive avec tous les éléments à conserver. */
+static bool g_cdb_archive_read(GCdbArchive *);
+
+
+
+
+
+/* Crée la description XML correspondant à l'archive. */
+static bool g_cdb_archive_create_xml_desc(GCdbArchive *, const core_db_info *);
+
+
+
+/* ------------------------- ACCES A LA BASE DE DONNEES SQL ------------------------- */
+
+/* Crée la base de données correspondant à l'archive. */
+static bool g_cdb_archive_create_db(const GCdbArchive *, const core_db_info *);
+
+
+
+
+/* Indique le type défini pour une une archive d'éléments utilisateur. */
+G_DEFINE_TYPE(GCdbArchive, g_cdb_archive, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des archives d'éléments utilisateur. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_cdb_archive_class_init(GCdbArchiveClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_cdb_archive_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_cdb_archive_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : archive = instance à initialiser. *
+* *
+* Description : Initialise une archive d'éléments utilisateur. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_cdb_archive_init(GCdbArchive *archive)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : archive = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_cdb_archive_dispose(GCdbArchive *archive)
+{
+ G_OBJECT_CLASS(g_cdb_archive_parent_class)->dispose(G_OBJECT(archive));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : archive = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_cdb_archive_finalize(GCdbArchive *archive)
+{
+ //void close_xml_file(xmlDocPtr, xmlXPathContextPtr);
+
+
+
+ G_OBJECT_CLASS(g_cdb_archive_parent_class)->finalize(G_OBJECT(archive));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : local = indique si l'enregistrement est local ou non. *
+* client = flux ouvert en lecture pour les informations utiles.*
+* info = informations de base associées à la requête. *
+* *
+* Description : Définit ou ouvre une archive d'éléments utilisateur. *
+* *
+* Retour : Structure mise en plae ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GCdbArchive *g_cdb_archive_new(bool local, GDbClient *client, const core_db_info *info)
+{
+ GCdbArchive *result; /* Adresse à retourner */
+ char *suffix; /* Fin du nom de fichier */
+ struct stat finfo; /* Information sur l'archive */
+ int ret; /* Retour d'un appel */
+
+ result = g_object_new(G_TYPE_CDB_ARCHIVE, NULL);
+
+
+
+ strcpy(result->hash, info->hash);
+
+
+
+
+ /* Chemin de l'archive */
+
+ suffix = strdup("chrysalide" G_DIR_SEPARATOR_S);
+ suffix = stradd(suffix, local ? "local" : "server");
+ suffix = stradd(suffix, G_DIR_SEPARATOR_S);
+ suffix = stradd(suffix, result->hash);
+ suffix = stradd(suffix, ".tar.xz");
+
+ result->filename = get_xdg_config_dir(suffix);
+
+ free(suffix);
+
+ if (!mkpath(result->filename))
+ goto gcan_error;
+
+ /* Chemin des enregistrements temporaires */
+
+ result->xml_desc = strdup(g_get_tmp_dir());
+
+ if (result->xml_desc[strlen(result->xml_desc) - 1] != G_DIR_SEPARATOR)
+ result->xml_desc = stradd(result->xml_desc, G_DIR_SEPARATOR_S);
+
+ result->xml_desc = stradd(result->xml_desc, result->hash);
+ result->xml_desc = stradd(result->xml_desc, "_desc.xml");
+
+ result->sql_db = strdup(g_get_tmp_dir());
+
+ if (result->sql_db[strlen(result->sql_db) - 1] != G_DIR_SEPARATOR)
+ result->sql_db = stradd(result->sql_db, G_DIR_SEPARATOR_S);
+
+ result->sql_db = stradd(result->sql_db, result->hash);
+ result->sql_db = stradd(result->sql_db, "_db.sql");
+
+ /* Création de l'archive si elle n'existe pas */
+
+ ret = stat(result->filename, &finfo);
+
+ if (ret != 0)
+ {
+ /* Le soucis ne vient pas de l'absence du fichier... */
+ if (errno != ENOENT) goto gcan_error;
+
+ g_cdb_archive_create_xml_desc(result, info);
+ g_cdb_archive_create_db(result, info);
+
+ if (!g_cdb_archive_write(result))
+ goto gcan_error;
+
+ }
+ else if (!S_ISREG(finfo.st_mode))
+ goto gcan_error;
+
+ /* Ouverture de l'archive */
+
+ if (!g_cdb_archive_read(result) && 0)
+ goto gcan_error;
+
+ return result;
+
+ gcan_error:
+
+ g_object_unref(G_OBJECT(result));
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : archive = information quant à l'archive à interpréter. *
+* *
+* Description : Ouvre une archive avec tous les éléments à conserver. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_cdb_archive_read(GCdbArchive *archive)
+{
+ bool result; /* Conclusion à retourner */
+ struct archive *in; /* Archive à consulter */
+ int ret; /* Bilan d'un appel */
+ int flags; /* Propriétés à extraire */
+ struct archive *out; /* Extracteur générique */
+ struct archive_entry *entry; /* Elément de l'archive */
+ const char *path; /* Désignation d'un fichier */
+
+ result = false;
+
+ in = archive_read_new();
+ archive_read_support_filter_all(in);
+ archive_read_support_format_all(in);
+
+ ret = archive_read_open_filename(in, archive->filename, 10240 /* ?! */);
+ if (ret != ARCHIVE_OK) goto gcar_exit;
+
+ /* Propriétés à restaurer */
+ flags = ARCHIVE_EXTRACT_TIME;
+ flags |= ARCHIVE_EXTRACT_PERM;
+ flags |= ARCHIVE_EXTRACT_ACL;
+ flags |= ARCHIVE_EXTRACT_FFLAGS;
+
+ out = archive_write_disk_new();
+ archive_write_disk_set_options(out, flags);
+ archive_write_disk_set_standard_lookup(out);
+
+ for (ret = archive_read_next_header(in, &entry);
+ ret == ARCHIVE_OK;
+ ret = archive_read_next_header(in, &entry))
+ {
+ bool dump_arch_data(struct archive_entry *ent, struct archive *input, struct archive *output)
+ {
+ const void *buff; /* Tampon de copie */
+ size_t size; /* Quantité copiée */
+ __LA_INT64_T offset; /* Position de lecture */
+
+ ret = archive_write_header(output, entry);
+ if (ret != ARCHIVE_OK) return false;
+
+ for (ret = archive_read_data_block(input, &buff, &size, &offset);
+ ret == ARCHIVE_OK;
+ ret = archive_read_data_block(input, &buff, &size, &offset))
+ {
+ ret = archive_write_data_block(output, buff, size, offset);
+ if (ret != ARCHIVE_OK)
+ return false;
+ }
+
+ if (ret != ARCHIVE_EOF)
+ return false;
+
+ ret = archive_write_finish_entry(output);
+
+ return (ret == ARCHIVE_OK);
+
+ }
+
+ path = archive_entry_pathname(entry);
+
+ if (strcmp(path, "desc.xml") == 0)
+ {
+ archive_entry_set_pathname(entry, archive->xml_desc);
+
+ if (!dump_arch_data(entry, in, out))
+ goto gcar_exit;
+
+ if (!open_xml_file(archive->xml_desc, &archive->xdoc, &archive->context))
+ goto gcar_exit;
+
+ }
+ else if (strcmp(path, "sql.db") == 0)
+ {
+ archive_entry_set_pathname(entry, archive->sql_db);
+
+ if (!dump_arch_data(entry, in, out))
+ goto gcar_exit;
+
+ ret = sqlite3_open(archive->sql_db, &archive->db);
+ if (ret != SQLITE_OK)
+ goto gcar_exit;
+
+ }
+
+ }
+
+ archive_read_close(in);
+ archive_read_free(in);
+
+ archive_write_close(out);
+ archive_write_free(out);
+
+ result = true;
+
+ gcar_exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : archive = information quant à l'archive à créer. *
+* *
+* Description : Enregistre une archive avec tous les éléments à conserver. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_cdb_archive_write(const GCdbArchive *archive)
+{
+ bool result; /* Conclusion à retourner */
+ struct archive *out; /* Archive à constituer */
+ int ret; /* Bilan d'un appel */
+
+ result = false;
+
+ out = archive_write_new();
+ archive_write_add_filter_xz(out);
+ archive_write_set_format_gnutar(out);
+
+ ret = archive_write_open_filename(out, archive->filename);
+ if (ret != ARCHIVE_OK) goto gcaw_exit;
+
+ bool add_file_to_archive(struct archive *out, const char *src, const char *path)
+ {
+ struct stat info; /* Informations d'origine */
+ struct archive_entry *entry; /* Elément de l'archive */
+ int fd; /* Flux ouvert en lecture */
+ char buffer[ARCHIVE_RBUF_SIZE]; /* Tampon pour les transferts */
+ ssize_t len; /* Quantité de données lues */
+
+ ret = stat(src, &info);
+ if (ret != 0) return false;
+
+ entry = archive_entry_new();
+
+ archive_entry_copy_stat(entry, &info);
+ archive_entry_set_pathname(entry, path);
+
+ ret = archive_write_header(out, entry);
+ if (ret != 0) goto afta_error;
+
+ fd = open(src, O_RDONLY);
+ if (fd == -1) goto afta_error;
+
+ for (len = safe_read(fd, buffer, ARCHIVE_RBUF_SIZE);
+ len > 0;
+ len = safe_read(fd, buffer, ARCHIVE_RBUF_SIZE))
+ {
+ if (archive_write_data(out, buffer, len) != len)
+ goto afta_error;
+ }
+
+ close(fd);
+
+ archive_entry_free(entry);
+
+ return true;
+
+ afta_error:
+
+ archive_entry_free(entry);
+
+ return false;
+
+ }
+
+ result = add_file_to_archive(out, archive->xml_desc, "desc.xml");
+ result &= add_file_to_archive(out, archive->sql_db, "sql.db");
+
+ gcaw_exit:
+
+ archive_write_free(out);
+
+ return result;
+
+}
+
+
+
+
+
+
+
+
+
+/* --------------------- OPERATIONS DE LECTURE D'UN FICHIER XML --------------------- */
+/* --------------------- OPERATIONS DE LECTURE D'UN FICHIER XML --------------------- */
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : archive = archive à constituer. *
+* info = informations de base associées à la requête. *
+* *
+* Description : Crée la description XML correspondant à l'archive. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_cdb_archive_create_xml_desc(GCdbArchive *archive, const core_db_info *info)
+{
+ bool result; /* Bilan à retourner */
+ char tmp[sizeof(STR(ULLONG_MAX))]; /* Stockage temporaire */
+
+ result = create_new_xml_file(&archive->xdoc, &archive->context);
+ if (!result) return false;
+
+ result &= add_content_to_node(archive->xdoc, archive->context,
+ "/ChrysalideBinary/Version", PACKAGE_VERSION);
+
+ result &= add_content_to_node(archive->xdoc, archive->context,
+ "/ChrysalideBinary/Hash", archive->hash);
+
+ result &= add_content_to_node(archive->xdoc, archive->context,
+ "/ChrysalideBinary/Creation/Author", "**me**");
+
+ snprintf(tmp, sizeof(tmp), "%" PRIu64, (uint64_t)10ull);
+
+ result &= add_content_to_node(archive->xdoc, archive->context,
+ "/ChrysalideBinary/Creation/Date", tmp);
+
+ save_xml_file(archive->xdoc, archive->xml_desc);
+
+ return result;
+
+}
+
+
+
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* ACCES A LA BASE DE DONNEES SQL */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : archive = archive à constituer. *
+* info = informations de base associées à la requête. *
+* *
+* Description : Crée la base de données correspondant à l'archive. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_cdb_archive_create_db(const GCdbArchive *archive, const core_db_info *info)
+{
+ bool result; /* Bilan à retourner */
+ sqlite3 *db; /* Base de données à constituer*/
+ int ret; /* Bilan de la création */
+
+ ret = sqlite3_open(archive->sql_db, &db);
+
+ if (ret != SQLITE_OK)
+ {
+ fprintf(stderr, "sqlite3_open(): %s\n", sqlite3_errmsg(db));
+ return false;
+ }
+
+
+
+ result = create_bookmark_db_table(db);
+
+
+
+ sqlite3_close(db);
+
+ return result;
+
+}
diff --git a/src/analysis/db/cdb.h b/src/analysis/db/cdb.h
new file mode 100644
index 0000000..46d0f11
--- /dev/null
+++ b/src/analysis/db/cdb.h
@@ -0,0 +1,62 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * cdb.h - prototypes pour la manipulation des archives au format CDB
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _ANALYSIS_DB_CDB_H
+#define _ANALYSIS_DB_CDB_H
+
+
+#include <glib-object.h>
+#include <stdbool.h>
+
+
+#include "client.h"
+#include "core.h"
+
+
+
+#define G_TYPE_CDB_ARCHIVE g_cdb_archive_get_type()
+#define G_CDB_ARCHIVE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_cdb_archive_get_type(), GCdbArchive))
+#define G_IS_CDB_ARCHIVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_cdb_archive_get_type()))
+#define G_CDB_ARCHIVE_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_cdb_archive_get_type(), GCdbArchiveIface))
+#define G_CDB_ARCHIVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_CDB_ARCHIVE, GCdbArchiveClass))
+
+
+/* Description d'une archive d'éléments utilisateur (instance) */
+typedef struct _GCdbArchive GCdbArchive;
+
+/* Description d'une archive d'éléments utilisateur (classe) */
+typedef struct _GCdbArchiveClass GCdbArchiveClass;
+
+
+/* Indique le type défini pour une une archive d'éléments utilisateur. */
+GType g_cdb_archive_get_type(void);
+
+/* Prépare un client pour une connexion à une BD. */
+GCdbArchive *g_cdb_archive_new(bool, GDbClient *, const core_db_info *);
+
+/* Enregistre une archive avec tous les éléments à conserver. */
+bool g_cdb_archive_write(const GCdbArchive *);
+
+
+
+#endif /* _ANALYSIS_DB_CDB_H */
diff --git a/src/analysis/db/client.c b/src/analysis/db/client.c
new file mode 100644
index 0000000..64a4c31
--- /dev/null
+++ b/src/analysis/db/client.c
@@ -0,0 +1,291 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * client.c - connexion à un serveur Chrysalide
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "client.h"
+
+
+#include <netdb.h>
+#include <poll.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+
+
+#include "protocol.h"
+
+
+
+/* Description de client à l'écoute (instance) */
+struct _GDbClient
+{
+ GObject parent; /* A laisser en premier */
+
+ int fd;
+ struct sockaddr_in addr; /* Adresse d'écoute */
+
+ GThread *update; /* Procédure de traitement */
+
+};
+
+/* Description de client à l'écoute (classe) */
+struct _GDbClientClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des descriptions de fichier binaire. */
+static void g_db_client_class_init(GDbClientClass *);
+
+/* Initialise une description de fichier binaire. */
+static void g_db_client_init(GDbClient *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_db_client_finalize(GDbClient *);
+
+/* Assure l'accueil des nouvelles mises à jour. */
+static void *g_db_client_update(GDbClient *);
+
+
+
+/* Indique le type défini pour une description de client à l'écoute. */
+G_DEFINE_TYPE(GDbClient, g_db_client, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des descriptions de fichier binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_db_client_class_init(GDbClientClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->finalize = (GObjectFinalizeFunc)g_db_client_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : client = instance à initialiser. *
+* *
+* Description : Initialise une description de fichier binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_db_client_init(GDbClient *client)
+{
+ client->fd = -1;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_db_client_finalize(GDbClient *binary)
+{
+ //free(binary->filename);
+
+ G_OBJECT_CLASS(g_db_client_parent_class)->finalize(G_OBJECT(binary));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : host = hôte à représenter pour le service. *
+* port = port de connexion pour les clients. *
+* *
+* Description : Prépare un client pour une connexion à une BD. *
+* *
+* Retour : Structure mise en plae ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GDbClient *g_db_client_new(const char *host, short port)
+{
+ GDbClient *result; /* Adresse à retourner */
+ struct hostent *hp; /* Informations sur l'hôte */
+
+ result = g_object_new(G_TYPE_DB_CLIENT, NULL);
+
+ hp = gethostbyname(host);
+ if (hp == NULL) goto gdsn_error;
+
+ result->addr.sin_family = hp->h_addrtype;
+ memcpy(&result->addr.sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
+
+ result->addr.sin_port = htons(port);
+
+ return result;
+
+ gdsn_error:
+
+ g_object_unref(G_OBJECT(result));
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : client = client pour les accès distants à manipuler. *
+* *
+* Description : Assure l'accueil des nouvelles mises à jour. *
+* *
+* Retour : NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void *g_db_client_update(GDbClient *client)
+{
+ struct pollfd fds; /* Surveillance des flux */
+ int ret; /* Bilan d'un appel */
+
+ fds.fd = client->fd;
+ fds.events = POLLIN | POLLPRI;
+
+ while (1)
+ {
+ ret = poll(&fds, 1, -1);
+ if (ret != 1) continue;
+
+ printf("fds.revents :: %x\n", fds.revents);
+
+ /* Le canal est fermé, une sortie doit être demandée... */
+ if (fds.revents & POLLNVAL)
+ break;
+
+ if (fds.revents & (POLLIN | POLLPRI))
+ {
+
+ /* TODO */
+ pause();
+
+
+ }
+
+ }
+
+ g_db_client_stop(client);
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : client = client pour les accès distants à manipuler. *
+* *
+* Description : Démarre la connexion à la base de données. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_db_client_start(GDbClient *client)
+{
+ int ret; /* Bilan d'un appel */
+
+ client->fd = socket(AF_INET, SOCK_STREAM, 0);
+ if (client->fd == -1)
+ {
+ perror("socket");
+ return false;
+ }
+
+ ret = connect(client->fd, (struct sockaddr *)&client->addr, sizeof(struct sockaddr_in));
+ if (ret == -1)
+ {
+ perror("connect");
+ close(client->fd);
+ client->fd = -1;
+ return false;
+ }
+
+ //client->update = g_thread_new("cdb_listener", (GThreadFunc)g_db_client_update, client);
+
+ send(client->fd, "A", 1, 0);
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : client = client pour les accès distants à manipuler. *
+* *
+* Description : Arrête la connexion à la base de données. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_db_client_stop(GDbClient *client)
+{
+ if (client->fd != -1)
+ return;
+
+ close(client->fd);
+ client->fd = -1;
+
+ g_thread_join(client->update);
+
+}
diff --git a/src/analysis/db/client.h b/src/analysis/db/client.h
new file mode 100644
index 0000000..58faa23
--- /dev/null
+++ b/src/analysis/db/client.h
@@ -0,0 +1,61 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * client.h - prototypes pour la connexion à un serveur Chrysalide
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _ANALYSIS_DB_CLIENT_H
+#define _ANALYSIS_DB_CLIENT_H
+
+
+#include <glib-object.h>
+#include <stdbool.h>
+
+
+
+#define G_TYPE_DB_CLIENT g_db_client_get_type()
+#define G_DB_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_db_client_get_type(), GDbClient))
+#define G_IS_DB_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_db_client_get_type()))
+#define G_DB_CLIENT_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_db_client_get_type(), GDbClientIface))
+#define G_DB_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DB_CLIENT, GDbClientClass))
+
+
+/* Description de client à l'écoute (instance) */
+typedef struct _GDbClient GDbClient;
+
+/* Description de client à l'écoute (classe) */
+typedef struct _GDbClientClass GDbClientClass;
+
+
+/* Indique le type défini pour une description de client à l'écoute. */
+GType g_db_client_get_type(void);
+
+/* Prépare un client pour une connexion à une BD. */
+GDbClient *g_db_client_new(const char *, short);
+
+/* Démarre la connexion à la base de données. */
+bool g_db_client_start(GDbClient *);
+
+/* Arrête la connexion à la base de données. */
+void g_db_client_stop(GDbClient *);
+
+
+
+#endif /* _ANALYSIS_DB_CLIENT_H */
diff --git a/src/analysis/db/collection.c b/src/analysis/db/collection.c
new file mode 100644
index 0000000..a310365
--- /dev/null
+++ b/src/analysis/db/collection.c
@@ -0,0 +1,26 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * collection.c - gestion d'éléments ajoutés par collection
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "collection.h"
+
+
diff --git a/src/analysis/db/collection.h b/src/analysis/db/collection.h
new file mode 100644
index 0000000..32d1609
--- /dev/null
+++ b/src/analysis/db/collection.h
@@ -0,0 +1,30 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * collection.h - prototypes pour la gestion d'éléments ajoutés par collection
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _ANALYSIS_DB_COLLECTION_H
+#define _ANALYSIS_DB_COLLECTION_H
+
+
+
+
+#endif /* _ANALYSIS_DB_COLLECTION_H */
diff --git a/src/analysis/db/core.c b/src/analysis/db/core.c
new file mode 100644
index 0000000..8b06ac0
--- /dev/null
+++ b/src/analysis/db/core.c
@@ -0,0 +1,205 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * core.c - prototypes pour les informations de base pour tout élément ajouté
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "core.h"
+
+
+#include <endian.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+
+#include "../../common/io.h"
+
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Détermine une fois pour toute la désignation de l'usager. *
+* *
+* Retour : Nom statique déterminé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const char *get_local_author_name(void)
+{
+ static char result[MAX_DB_AUTHOR_LEN]; /* Désignation à retourner */
+ char *chrysalide_user; /* Eventuel nom spécifique */
+ char *logname; /* Nom depuis l'environnement */
+ char hostname[HOST_NAME_MAX]; /* Nom de la machine courante */
+ int ret; /* Bilan d'un appel */
+
+ if (result[0] == '\0')
+ {
+ chrysalide_user = getenv("CHRYSALIDE_USER");
+
+ if (chrysalide_user != NULL)
+ {
+ strncpy(result, chrysalide_user, MAX_DB_AUTHOR_LEN - 1);
+ result[MAX_DB_AUTHOR_LEN - 1] = '\0';
+ }
+ else
+ {
+ logname = getenv("LOGNAME");
+ if (logname == NULL)
+ logname = "";
+
+ ret = gethostname(hostname, HOST_NAME_MAX);
+ if (ret != 0)
+ hostname[0] = '\0';
+
+ if (logname != NULL && hostname[0] != '\0')
+ snprintf(result, MAX_DB_AUTHOR_LEN, "%s@%s", logname, hostname);
+
+ else if (logname != NULL && hostname[0] == '\0')
+ snprintf(result, MAX_DB_AUTHOR_LEN, "%s", logname);
+
+ else if (logname == NULL && hostname[0] != '\0')
+ snprintf(result, MAX_DB_AUTHOR_LEN, "@%s", hostname);
+
+ else
+ snprintf(result, MAX_DB_AUTHOR_LEN, "anonymous");
+
+ }
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : info = informations à constituer. [OUT] *
+* type = type de l'élément à mettre en place. *
+* user = provenance des informations ou NULL si machine. *
+* *
+* Description : Initialise le coeur des informations d'un élément ajouté. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void init_core_db_info(core_db_info *info, uint64_t type, const char *user)
+{
+ info->type = type;
+
+ strncpy(info->user, user, MAX_DB_AUTHOR_LEN - 1);
+ info->user[MAX_DB_AUTHOR_LEN - 1] = '\0';
+
+ info->created = time(NULL);
+ info->modified = info->created;
+
+ info->saved = 0;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : info = informations à constituer. [OUT] *
+* type = type de l'élément, lu en avance de phase. *
+* fd = flux ouvert en lecture pour l'importation. *
+* *
+* Description : Importe le coeur des informations d'un élément ajouté. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool load_core_db_info(core_db_info *info, uint64_t type, int fd)
+{
+ ssize_t got; /* Quantité de données reçues */
+ uint64_t val64; /* Valeur sur 64 bits */
+
+ info->type = type;
+
+ got = safe_recv(fd, info->user, MAX_DB_AUTHOR_LEN, MSG_WAITALL);
+ if (got != MAX_DB_AUTHOR_LEN) return false;
+
+ info->user[MAX_DB_AUTHOR_LEN - 1] = '\0';
+
+ got = safe_recv(fd, &val64, sizeof(uint64_t), MSG_WAITALL);
+ if (got != sizeof(uint64_t)) return false;
+
+ info->created = be64toh(val64);
+
+ got = safe_recv(fd, &val64, sizeof(uint64_t), MSG_WAITALL);
+ if (got != sizeof(uint64_t)) return false;
+
+ info->modified = be64toh(val64);
+
+ info->saved = info->modified;
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : info = informations à sauvegarer. *
+* fd = flux ouvert en écriture pour l'exportation. *
+* *
+* Description : Exporte le coeur des informations d'un élément ajouté. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool store_core_db_info(core_db_info *info, int fd)
+{
+ ssize_t got; /* Quantité de données reçues */
+
+ got = safe_send(fd, (uint64_t []) { htobe64(info->type) }, sizeof(uint64_t), MSG_WAITALL);
+ if (got != sizeof(uint64_t)) return false;
+
+ got = safe_send(fd, info->user, MAX_DB_AUTHOR_LEN, MSG_WAITALL);
+ if (got != MAX_DB_AUTHOR_LEN) return false;
+
+ got = safe_send(fd, (uint64_t []) { htobe64(info->created) }, sizeof(uint64_t), MSG_WAITALL);
+ if (got != sizeof(uint64_t)) return false;
+
+ got = safe_send(fd, (uint64_t []) { htobe64(info->modified) }, sizeof(uint64_t), MSG_WAITALL);
+ if (got != sizeof(uint64_t)) return false;
+
+ info->saved = time(NULL);
+
+ return true;
+
+}
diff --git a/src/analysis/db/core.h b/src/analysis/db/core.h
new file mode 100644
index 0000000..d3f4e3d
--- /dev/null
+++ b/src/analysis/db/core.h
@@ -0,0 +1,70 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * core.h - prototypes pour les informations de base pour tout élément ajouté
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _ANALYSIS_DB_CORE_H
+#define _ANALYSIS_DB_CORE_H
+
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+
+
+/**
+ * Taille maximale pour un nom d'auteur.
+ * On considère comme exemple large '"Nom Prénom" xxx@yyy.tld'
+ */
+#define MAX_DB_AUTHOR_LEN 128
+
+
+/* Informations de base pour tout élément ajouté */
+typedef struct _core_db_info
+{
+ uint64_t type; /* Type de l'élément */
+ char hash[65]; /* Empreinte SHA256 */
+
+ char user[MAX_DB_AUTHOR_LEN]; /* Auteur humain ou NULL */
+
+ uint64_t created; /* Date de création */
+ uint64_t modified; /* Date de modification */
+
+ uint64_t saved; /* Statut de l'élément */
+
+} core_db_info;
+
+
+/* Détermine une fois pour toute la désignation de l'usager. */
+const char *get_local_author_name(void);
+
+/* Initialise le coeur des informations d'un élément ajouté. */
+void init_core_db_info(core_db_info *, uint64_t, const char *);
+
+/* Importe le coeur des informations d'un élément ajouté. */
+bool load_core_db_info(core_db_info *, uint64_t, int);
+
+/* Exporte le coeur des informations d'un élément ajouté. */
+bool store_core_db_info(core_db_info *, int);
+
+
+
+#endif /* _ANALYSIS_DB_CORE_H */
diff --git a/src/analysis/db/protocol.h b/src/analysis/db/protocol.h
new file mode 100644
index 0000000..9614abc
--- /dev/null
+++ b/src/analysis/db/protocol.h
@@ -0,0 +1,71 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * protocol.h - prototypes pour la description du protocole impactant les BD Chrysalide
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _ANALYSIS_DB_PROTOCOL_H
+#define _ANALYSIS_DB_PROTOCOL_H
+
+
+
+/**
+ * Nombre maximal de connexions à un serveur.
+ * cf. listen().
+ */
+#define CDB_SEVER_BACKLOG 100
+
+/**
+ * Délai maximal de réaction pour les coupures de flux (en ms).
+ */
+#define CDB_CONN_TIMEOUT 1000
+
+
+
+
+
+/* Fonctionnalités offertes */
+typedef enum _DBFeatures
+{
+ DBF_COMMENTS, /* Commentaires ajoutés */
+ DBF_SEGMENTS_DISPLAY, /* Choix d'affichage */
+ DBF_BOOKMARKS, /* Signets dans le code */
+
+ DBF_COUNT
+
+} DBFeatures;
+
+/* Comportement vis à vis des éléments */
+typedef enum _DBStorage
+{
+ DBS_ALL_LOCAL = 0x01, /* Enregistrements locaux */
+ DBS_ALL_REMOTE = 0x02, /* Enregistrements distants */
+ DBS_LOCAL_AND_REMOTE = 0x03, /* Enreg. locaux + infos dists.*/
+
+ DBS_MAX = 3
+
+} DBStorage;
+
+
+
+
+
+
+#endif /* _ANALYSIS_DB_PROTOCOL_H */
diff --git a/src/analysis/db/server.c b/src/analysis/db/server.c
new file mode 100644
index 0000000..b636d02
--- /dev/null
+++ b/src/analysis/db/server.c
@@ -0,0 +1,426 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * server.c - mise en place d'un fournisseur d'éléments ajoutés
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "server.h"
+
+
+#include <malloc.h>
+#include <netdb.h>
+#include <poll.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+
+
+#include "protocol.h"
+
+
+
+/* Informations relatives à un client */
+typedef struct _cdb_client
+{
+ GDbServer *server; /* Accès facile en mémoire */
+
+ int fd; /* Canal de communication */
+ struct sockaddr_in peer; /* Adresse distante */
+
+ GThread *thread; /* Procédure de traitement */
+
+} cdb_client;
+
+/* Description de serveur à l'écoute (instance) */
+struct _GDbServer
+{
+ GObject parent; /* A laisser en premier */
+
+ int fd;
+ struct sockaddr_in addr; /* Adresse d'écoute */
+
+ GThread *listener; /* Procédure de traitement */
+
+ cdb_client **clients; /* Connexions en place */
+ size_t count; /* Quantité de clients */
+ GMutex mutex; /* Verrou pour l'accès */
+
+};
+
+/* Description de serveur à l'écoute (classe) */
+struct _GDbServerClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des descriptions de fichier binaire. */
+static void g_db_server_class_init(GDbServerClass *);
+
+/* Initialise une description de fichier binaire. */
+static void g_db_server_init(GDbServer *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_db_server_finalize(GDbServer *);
+
+/* Assure l'accueil des nouveaux clients. */
+static void *g_db_server_listener(GDbServer *);
+
+/* Assure le traitement des requêtes de clients. */
+static void *g_db_server_process(cdb_client **);
+
+
+
+/* Indique le type défini pour une description de serveur à l'écoute. */
+G_DEFINE_TYPE(GDbServer, g_db_server, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des descriptions de fichier binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_db_server_class_init(GDbServerClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->finalize = (GObjectFinalizeFunc)g_db_server_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : server = instance à initialiser. *
+* *
+* Description : Initialise une description de fichier binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_db_server_init(GDbServer *server)
+{
+ server->fd = -1;
+
+ g_mutex_init(&server->mutex);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_db_server_finalize(GDbServer *binary)
+{
+ //free(binary->filename);
+
+ G_OBJECT_CLASS(g_db_server_parent_class)->finalize(G_OBJECT(binary));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : host = hôte à représenter pour le service. *
+* port = port de connexion pour les clients. *
+* *
+* Description : Prépare un serveur de BD pour les clients. *
+* *
+* Retour : Structure mise en plae ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GDbServer *g_db_server_new(const char *host, short port)
+{
+ GDbServer *result; /* Adresse à retourner */
+ struct hostent *hp; /* Informations sur l'hôte */
+
+ result = g_object_new(G_TYPE_DB_SERVER, NULL);
+
+ hp = gethostbyname(host);
+ if (hp == NULL) goto gdsn_error;
+
+ result->addr.sin_family = hp->h_addrtype;
+ memcpy(&result->addr.sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
+
+ result->addr.sin_port = htons(port);
+
+ return result;
+
+ gdsn_error:
+
+ g_object_unref(G_OBJECT(result));
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : server = serveur pour les accès distants à manipuler. *
+* *
+* Description : Assure l'accueil des nouveaux clients. *
+* *
+* Retour : NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void *g_db_server_listener(GDbServer *server)
+{
+ struct pollfd fds; /* Surveillance des flux */
+ int ret; /* Bilan d'un appel */
+ struct sockaddr_in peer; /* Adresse cliente */
+ int fd; /* Canal établi vers un client */
+ cdb_client *client; /* Mémorisation pour poursuite */
+
+ fds.fd = server->fd;
+ fds.events = POLLIN | POLLPRI;
+
+ while (1)
+ {
+ ret = poll(&fds, 1, -1);
+ if (ret != 1) continue;
+
+ /* Le canal est fermé, une sortie doit être demandée... */
+ if (fds.revents & POLLNVAL)
+ break;
+
+ if (fds.revents & (POLLIN | POLLPRI))
+ {
+ fd = accept(server->fd, &peer, (socklen_t []) { sizeof(struct sockaddr_in) });
+ if (fd == -1) continue;
+
+ g_mutex_lock(&server->mutex);
+
+ client = (cdb_client *)calloc(1, sizeof(cdb_client));
+
+ g_object_ref(G_OBJECT(server));
+ client->server = server;
+
+ client->fd = fd;
+ client->peer = peer;
+
+ server->clients = (cdb_client **)realloc(server->clients,
+ ++server->count * sizeof(cdb_client *));
+ server->clients[server->count - 1] = client;
+
+ client->thread = g_thread_new("cdb_process", (GThreadFunc)g_db_server_process,
+ &server->clients[server->count - 1]);
+
+ g_mutex_unlock(&server->mutex);
+
+ }
+
+ }
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : client = informations sur une connexion établie à utiliser. *
+* *
+* Description : Assure le traitement des requêtes de clients. *
+* *
+* Retour : NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void *g_db_server_process(cdb_client **client)
+{
+ struct pollfd fds; /* Surveillance des flux */
+ int ret; /* Bilan d'un appel */
+ GDbServer *server; /* Accès facile en mémoire */
+ size_t index; /* Indice courant du client */
+ size_t remaining; /* Quantité à déplacer */
+
+ fds.fd = (*client)->fd;
+ fds.events = POLLIN | POLLPRI;
+
+ while (1)
+ {
+ ret = poll(&fds, 1, -1);
+ if (ret != 1) continue;
+
+ printf("fds.revents :: %x\n", fds.revents);
+
+ /* Le canal est fermé, une sortie doit être demandée... */
+ if (fds.revents & POLLNVAL)
+ break;
+
+ if (fds.revents & (POLLIN | POLLPRI))
+ {
+
+ /* TODO */
+ pause();
+
+
+ }
+
+ }
+
+ /* Retrait de la liste avant la terminaison */
+
+ server = (*client)->server;
+
+ g_mutex_lock(&server->mutex);
+
+ index = (client - server->clients);
+ remaining = server->count - index - 1;
+
+ if (remaining > 0)
+ memmove(&server->clients[index], &server->clients[index + 1],
+ remaining * sizeof(cdb_client *));
+
+ g_object_unref(G_OBJECT(server));
+
+ free(*client);
+
+ g_mutex_unlock(&server->mutex);
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : server = serveur pour les accès distants à manipuler. *
+* *
+* Description : Démarre le serveur de base de données. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_db_server_start(GDbServer *server)
+{
+ int ret; /* Bilan d'un appel */
+
+ server->fd = socket(AF_INET, SOCK_STREAM, 0);
+ if (server->fd == -1)
+ {
+ perror("socket");
+ return false;
+ }
+
+ ret = setsockopt(server->fd, SOL_SOCKET, SO_REUSEADDR, (int []) { 1 }, sizeof(int));
+ if (ret == -1)
+ {
+ perror("setsockopt");
+ close(server->fd);
+ server->fd = -1;
+ return false;
+ }
+
+ ret = bind(server->fd, (struct sockaddr *)&server->addr, sizeof(struct sockaddr_in));
+ if (ret == -1)
+ {
+ perror("bind");
+ close(server->fd);
+ server->fd = -1;
+ return false;
+ }
+
+ ret = listen(server->fd, CDB_SEVER_BACKLOG);
+ if (ret == -1)
+ {
+ perror("listen");
+ close(server->fd);
+ server->fd = -1;
+ return false;
+ }
+
+ server->listener = g_thread_new("cdb_listener", (GThreadFunc)g_db_server_listener, server);
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : server = serveur pour les accès distants à manipuler. *
+* *
+* Description : Arrête le serveur de base de données. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_db_server_stop(GDbServer *server)
+{
+ size_t i; /* Boucle de parcours */
+ GThread *thread; /* Procédure de traitement */
+
+ if (server->fd != -1)
+ return;
+
+ close(server->fd);
+ server->fd = -1;
+
+ g_thread_join(server->listener);
+
+ for (i = 0; i < server->count; i++)
+ {
+ /* Sauvegarde de la référene, qui peut disparaître */
+ thread = server->clients[i]->thread;
+
+ close(server->clients[i]->fd);
+ g_thread_join(thread);
+
+ }
+
+}
diff --git a/src/analysis/db/server.h b/src/analysis/db/server.h
new file mode 100644
index 0000000..e470a8f
--- /dev/null
+++ b/src/analysis/db/server.h
@@ -0,0 +1,61 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * server.h - prototypes pour la mise en place d'un fournisseur d'éléments ajoutés
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _ANALYSIS_DB_SERVER_H
+#define _ANALYSIS_DB_SERVER_H
+
+
+#include <glib-object.h>
+#include <stdbool.h>
+
+
+
+#define G_TYPE_DB_SERVER g_db_server_get_type()
+#define G_DB_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_db_server_get_type(), GDbServer))
+#define G_IS_DB_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_db_server_get_type()))
+#define G_DB_SERVER_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_db_server_get_type(), GDbServerIface))
+#define G_DB_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DB_SERVER, GDbServerClass))
+
+
+/* Description de serveur à l'écoute (instance) */
+typedef struct _GDbServer GDbServer;
+
+/* Description de serveur à l'écoute (classe) */
+typedef struct _GDbServerClass GDbServerClass;
+
+
+/* Indique le type défini pour une description de serveur à l'écoute. */
+GType g_db_server_get_type(void);
+
+/* Prépare un serveur de BD pour les clients. */
+GDbServer *g_db_server_new(const char *, short);
+
+/* Démarre le serveur de base de données. */
+bool g_db_server_start(GDbServer *);
+
+/* Arrête le serveur de base de données. */
+void g_db_server_stop(GDbServer *);
+
+
+
+#endif /* _ANALYSIS_DB_SERVER_H */
diff --git a/src/common/Makefile.am b/src/common/Makefile.am
index d074200..b5df3a4 100755
--- a/src/common/Makefile.am
+++ b/src/common/Makefile.am
@@ -7,6 +7,7 @@ libcommon_la_SOURCES = \
endianness.h endianness.c \
environment.h environment.c \
extstr.h extstr.c \
+ io.h io.c \
fnv1a.h fnv1a.c \
leb128.h leb128.c \
macros.h \
diff --git a/src/common/io.c b/src/common/io.c
new file mode 100644
index 0000000..c001449
--- /dev/null
+++ b/src/common/io.c
@@ -0,0 +1,27 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * io.c - entrées sorties fiables
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "io.h"
+
+
+
diff --git a/src/common/io.h b/src/common/io.h
new file mode 100644
index 0000000..e805067
--- /dev/null
+++ b/src/common/io.h
@@ -0,0 +1,43 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * io.h - prototypes pour des entrées sorties fiables
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _COMMON_IO_H
+#define _COMMON_IO_H
+
+
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+
+#define safe_recv recv
+
+#define safe_send send
+
+
+#define safe_read read
+
+#define safe_write write
+
+
+#endif /* _COMMON_IO_H */
diff --git a/src/common/xml.c b/src/common/xml.c
index 5612247..2d38f96 100644
--- a/src/common/xml.c
+++ b/src/common/xml.c
@@ -30,6 +30,7 @@
#include <string.h>
+#include "cpp.h"
#include "extstr.h"
@@ -868,6 +869,39 @@ bool add_content_to_node(xmlDocPtr xdoc, xmlXPathContextPtr context, const char
/******************************************************************************
* *
+* Paramètres : xdoc = structure XML chargée. *
+* context = contexte à utiliser pour les recherches. *
+* path = chemin d'accès au noeud visé. *
+* value = nombre à inscrire en contenu. *
+* *
+* Description : Ajoute un noeud avec contenu numérique au document. *
+* *
+* Retour : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool add_uint_content_to_node(xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path, unsigned int value)
+{
+ xmlNodePtr node; /* Noeud à modifier */
+ char content[sizeof(STR(UINT_MAX)) + 1];/* Valeur en chaîne */
+
+ if (content == NULL) return true;
+
+ node = ensure_node_exist(xdoc, context, path);
+ if (node == NULL) return false;
+
+ sprintf(content, "%u", value);
+ xmlNodeSetContent(node, BAD_CAST content);
+
+ return true;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : node = noeud dont le contenu est à mettre à jour. *
* name = nom de la propriété à créer. *
* value = chaîne de caractère à placer. *
diff --git a/src/common/xml.h b/src/common/xml.h
index c637235..eb7703e 100644
--- a/src/common/xml.h
+++ b/src/common/xml.h
@@ -123,6 +123,9 @@ xmlNodePtr ensure_node_exist(xmlDocPtr, xmlXPathContextPtr, const char *);
/* S'assure qu'un noeud donné est bien présent dans le document. */
bool add_content_to_node(xmlDocPtr, xmlXPathContextPtr, const char *, const char *);
+/* Ajoute un noeud avec contenu numérique au document. */
+bool add_uint_content_to_node(xmlDocPtr, xmlXPathContextPtr, const char *, unsigned int);
+
/* Ajoute une propriété à un noeud existant donné. */
bool _add_string_attribute_to_node(xmlNodePtr, const char *, const char *);
diff --git a/src/dialogs/Makefile.am b/src/dialogs/Makefile.am
index 05bd50e..20812fc 100644
--- a/src/dialogs/Makefile.am
+++ b/src/dialogs/Makefile.am
@@ -7,7 +7,8 @@ libdialogs_la_SOURCES = \
export.h export.c \
goto.h goto.c \
plugins.h plugins.c \
- shellcode.h shellcode.c
+ shellcode.h shellcode.c \
+ storage.h storage.c
libdialogs_la_LDFLAGS =
diff --git a/src/dialogs/storage.c b/src/dialogs/storage.c
new file mode 100644
index 0000000..f5fa802
--- /dev/null
+++ b/src/dialogs/storage.c
@@ -0,0 +1,662 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * storage.c - définition des modes d'enregistrement pour binaires
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 "storage.h"
+
+
+#include <i18n.h>
+
+
+#include "../analysis/db/protocol.h"
+#include "../common/cpp.h"
+#include "../gtkext/easygtk.h"
+
+
+
+/* --------------------------- CORPS PRINCIPAL DU CONTENU --------------------------- */
+
+
+/* Enumération des colonnes de la liste affichée */
+typedef enum StorageColumnTypes
+{
+ SCT_FEATURE_ID, /* Désignation interne */
+ SCT_FEATURE_NAME, /* Désignation humaine */
+ SCT_FEATURE_STORAGE, /* Type d'enregistrement */
+ SCT_COMBO_COLUMN, /* Fonctionnement du combo */
+
+ SCT_COUNT
+
+} StorageColumnTypes;
+
+
+/* Construit l'affichage en liste des enregistrements. */
+static GtkWidget *build_features_list(void);
+
+/* Sauvegarde l'état des enregistrements et clôt la fenêtre. */
+static void save_storage_params(GtkButton *, GObject *);
+
+
+
+/* ---------------------- NOM D'UTILISATEUR ASSOCIE AU BINAIRE ---------------------- */
+
+
+/* Charge le nom de l'utilisateur associé au binaire. */
+static void load_storage_username(GLoadedBinary *, GObject *);
+
+/* Sauvegarde le nom de l'utilisateur associé au binaire. */
+static void save_storage_username(GLoadedBinary *, GObject *);
+
+
+
+/* ----------------------- SERVEUR DISTANT ASSOCIE AU BINAIRE ----------------------- */
+
+
+/* Charge la définition du serveur distant associé au binaire. */
+static void load_storage_remote_server(GLoadedBinary *, GObject *);
+
+/* Sauvegarde la définition du serveur distant du binaire. */
+static void save_storage_remote_server(GLoadedBinary *, GObject *);
+
+/* Met à jour l'accès aux paramètres du serveur distant. */
+static void on_server_usage_toggle(GtkToggleButton *, GObject *);
+
+
+
+/* ------------------------- TRAITEMENT DES FONCTIONNALITES ------------------------- */
+
+
+/* Remplit la vue présentant les fonctionnalités à traiter. */
+static void fill_storage_features(GtkTreeView *, GLoadedBinary *);
+
+/* Sauvegarde les statuts d'enregistrement des fonctionnalités. */
+static void save_storage_features(GLoadedBinary *, GObject *);
+
+/* Met à jour un type d'enregistrement. */
+static void storage_combo_edited_cb(GtkCellRendererText *, const gchar *, const gchar *, GtkListStore *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* CORPS PRINCIPAL DU CONTENU */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Construit l'affichage en liste des enregistrements. *
+* *
+* Retour : Composant graphique prêt à emploi. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GtkWidget *build_features_list(void)
+{
+ GtkListStore *store;
+ GtkWidget *view;
+ GtkCellRenderer *renderer;
+ GtkListStore *combo_store;
+ GtkTreeIter iter;
+
+ store = gtk_list_store_new(SCT_COUNT,
+ G_TYPE_UINT,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_UINT);
+
+ view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
+
+ g_object_unref(store);
+
+ /* Intitulé des fonctionnalités */
+
+ renderer = gtk_cell_renderer_text_new();
+
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1,
+ _("Features"), renderer,
+ "text", SCT_FEATURE_NAME,
+ NULL);
+
+ /* Type d'enregistrement associé */
+
+ renderer = gtk_cell_renderer_combo_new();
+
+ combo_store = gtk_list_store_new(1, G_TYPE_STRING);
+ gtk_list_store_append(combo_store, &iter);
+ gtk_list_store_set(combo_store, &iter, 0, _("Local storage"), -1);
+ gtk_list_store_append(combo_store, &iter);
+ gtk_list_store_set(combo_store, &iter, 0, _("Remote storage"), -1);
+ gtk_list_store_append(combo_store, &iter);
+ gtk_list_store_set(combo_store, &iter, 0, _("Local storage with remote access"), -1);
+
+ g_object_set(G_OBJECT(renderer), "model", combo_store,
+ "editable", TRUE, "has-entry", FALSE, NULL);
+ g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(storage_combo_edited_cb), store);
+
+ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1,
+ _("Storage"), renderer,
+ "text", SCT_FEATURE_STORAGE,
+ "text-column", SCT_COMBO_COLUMN,
+ NULL);
+
+ return view;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = binaire chargé en mémoire à traiter. *
+* parent = fenêtre principale de l'éditeur. *
+* *
+* Description : Propose une définition des propriétés d'enregistrement. *
+* *
+* Retour : Adresse de la fenêtre mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GtkWidget *create_storage_dialog(GLoadedBinary *binary, GtkWindow *parent)
+{
+ GtkWidget *result; /* Fenêtre à renvoyer */
+ GtkWidget *content; /* Zone principale de la boîte */
+ GtkWidget *vbox; /* Support à construire #1 */
+ GtkWidget *frame; /* Support avec encadrement */
+ GtkWidget *subalign; /* Disposition des options */
+ GtkWidget *hbox; /* Support à construire #2 */
+ GtkWidget *label; /* Etiquette d'indication */
+ GtkWidget *entry; /* Zone de saisie de texte */
+ GtkWidget *checkbutton; /* Activation de la distance */
+ GtkWidget *subvbox; /* Support à construire #3 */
+ GtkWidget *scrolledwindow; /* Zone de défilement */
+ GtkWidget *treeview; /* Liste des fonctionnalités */
+ GtkWidget *action_area; /* Zone de contrôle inférieure */
+ GtkWidget *button; /* Bouton de contrôle */
+
+ result = gtk_dialog_new();
+ gtk_window_set_title(GTK_WINDOW(result), _("Storage"));
+ gtk_widget_set_size_request(result, 400, 360);
+ gtk_window_set_position(GTK_WINDOW(result), GTK_WIN_POS_CENTER);
+ gtk_window_set_type_hint(GTK_WINDOW(result), GDK_WINDOW_TYPE_HINT_DIALOG);
+
+ gtk_window_set_modal(GTK_WINDOW(result), TRUE);
+ gtk_window_set_transient_for(GTK_WINDOW(result), parent);
+
+ g_object_ref(G_OBJECT(binary));
+ g_object_set_data_full(G_OBJECT(result), "binary", binary, g_object_unref);
+
+ content = gtk_dialog_get_content_area(GTK_DIALOG(result));
+ gtk_widget_show(content);
+
+ vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
+ gtk_widget_show(vbox);
+ gtk_box_pack_start(GTK_BOX(content), vbox, TRUE, TRUE, 0);
+ gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
+
+ /* Définition de l'identité de l'utilisateur */
+
+ frame = qck_create_frame(_("<b>Identity</b>"), &subalign, 0, 0, 12, 0);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, TRUE, 0);
+
+ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
+ gtk_widget_show(hbox);
+ gtk_container_add(GTK_CONTAINER(subalign), hbox);
+
+ label = qck_create_label(NULL, NULL, _("Username: "));
+ gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+
+ entry = qck_create_entry(G_OBJECT(result), "username", NULL);
+ gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
+
+ /* Définition du serveur distant */
+
+ frame = qck_create_frame(_("<b>Server to contact</b>"), &subalign, 0, 0, 12, 0);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, TRUE, 0);
+
+ subvbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+ gtk_widget_show(subvbox);
+ gtk_container_add(GTK_CONTAINER(subalign), subvbox);
+
+ checkbutton = qck_create_check_button(G_OBJECT(result), "use_remote",
+ _("Use a remote server:"),
+ G_CALLBACK(on_server_usage_toggle), result);
+ gtk_widget_show(checkbutton);
+ gtk_box_pack_start(GTK_BOX(subvbox), checkbutton, FALSE, FALSE, 0);
+
+ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
+ gtk_widget_show(hbox);
+ gtk_box_pack_start(GTK_BOX(subvbox), hbox, TRUE, TRUE, 0);
+
+ label = qck_create_label(G_OBJECT(result), "host", _("Host: "));
+ gtk_widget_show(label);
+ gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+
+ entry = qck_create_entry(G_OBJECT(result), "remote_host", NULL);
+ gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
+
+ label = qck_create_label(G_OBJECT(result), "port", _("Port:"));
+ gtk_widget_show(label);
+ gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+
+ entry = qck_create_entry(G_OBJECT(result), "remote_port", NULL);
+ gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, TRUE, 0);
+
+ /* Affichage des propriétés */
+
+ scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
+ gtk_widget_show(scrolledwindow);
+ gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
+ gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_IN);
+
+ treeview = build_features_list();
+ g_object_set_data(G_OBJECT(result), "treeview", treeview);
+ gtk_widget_show(treeview);
+ gtk_container_add(GTK_CONTAINER(scrolledwindow), treeview);
+
+ /* Zone de contrôle */
+
+ action_area = gtk_dialog_get_action_area(GTK_DIALOG(result));
+ gtk_widget_show(action_area);
+ gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_END);
+
+
+ button = qck_create_button_from_stock(NULL, NULL, "gtk-cancel", NULL, NULL);
+ gtk_dialog_add_action_widget(GTK_DIALOG(result), button, GTK_RESPONSE_CANCEL);
+
+ button = qck_create_button_from_stock(NULL, NULL, "gtk-ok",
+ G_CALLBACK(save_storage_params), result);
+ gtk_dialog_add_action_widget(GTK_DIALOG(result), button, GTK_RESPONSE_OK);
+
+ /* Chargement des données actuelles */
+
+ load_storage_username(binary, G_OBJECT(result));
+
+ load_storage_remote_server(binary, G_OBJECT(result));
+
+ fill_storage_features(GTK_TREE_VIEW(treeview), binary);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : button = bouton 'OK'. *
+* ref = espace de référencement principal. *
+* *
+* Description : Sauvegarde l'état des enregistrements et clôt la fenêtre. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void save_storage_params(GtkButton *button, GObject *ref)
+{
+ GLoadedBinary *binary; /* Binaire en cours d'édition */
+
+ binary = G_LOADED_BINARY(g_object_get_data(ref, "binary"));
+
+ save_storage_username(binary, ref);
+
+ save_storage_remote_server(binary, ref);
+
+ save_storage_features(binary, ref);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* NOM D'UTILISATEUR ASSOCIE AU BINAIRE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = binaire chargé en mémoire à traiter. *
+* ref = espace de référencement global. *
+* *
+* Description : Charge le nom de l'utilisateur associé au binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void load_storage_username(GLoadedBinary *binary, GObject *ref)
+{
+ GtkEntry *entry; /* Zone de saisie de texte */
+
+ entry = GTK_ENTRY(g_object_get_data(ref, "username"));
+
+ gtk_entry_set_text(entry, g_loaded_binary_get_username(binary));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = binaire chargé en mémoire à traiter. *
+* ref = espace de référencement global. *
+* *
+* Description : Sauvegarde le nom de l'utilisateur associé au binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void save_storage_username(GLoadedBinary *binary, GObject *ref)
+{
+ GtkEntry *entry; /* Zone de saisie de texte */
+ const gchar *text; /* Texte à récupérer */
+
+ entry = GTK_ENTRY(g_object_get_data(ref, "username"));
+ text = gtk_entry_get_text(entry);
+
+ g_loaded_binary_set_username(binary, text);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* SERVEUR DISTANT ASSOCIE AU BINAIRE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = binaire chargé en mémoire à traiter. *
+* ref = espace de référencement global. *
+* *
+* Description : Charge la définition du serveur distant associé au binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void load_storage_remote_server(GLoadedBinary *binary, GObject *ref)
+{
+ const char *host; /* Hôte à contacter */
+ unsigned short port; /* Port de connexion */
+ char port_str[sizeof(STR(USHRT_MAX)) + 1]; /* Version chaînée */
+ bool use_remote; /* Utilisation du serveur ? */
+ GtkEntry *entry; /* Zone de saisie de texte */
+ GtkToggleButton *checkbutton; /* Activation de la distance */
+
+ use_remote = g_loaded_binary_get_remote_server(binary, &host, &port);
+ sprintf(port_str, "%hu", port);
+
+ entry = GTK_ENTRY(g_object_get_data(ref, "remote_host"));
+
+ gtk_entry_set_text(entry, host);
+
+ entry = GTK_ENTRY(g_object_get_data(ref, "remote_port"));
+
+ gtk_entry_set_text(entry, port_str);
+
+ checkbutton = GTK_TOGGLE_BUTTON(g_object_get_data(ref, "use_remote"));
+
+ gtk_toggle_button_set_active(checkbutton, !use_remote);
+ gtk_toggle_button_set_active(checkbutton, use_remote);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = binaire chargé en mémoire à traiter. *
+* ref = espace de référencement global. *
+* *
+* Description : Sauvegarde la définition du serveur distant du binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void save_storage_remote_server(GLoadedBinary *binary, GObject *ref)
+{
+ GtkEntry *entry; /* Zone de saisie de texte */
+ const gchar *text; /* Texte à récupérer */
+ unsigned short port; /* Port de connexion */
+ GtkToggleButton *checkbutton; /* Activation de la distance */
+
+ entry = GTK_ENTRY(g_object_get_data(ref, "remote_port"));
+ text = gtk_entry_get_text(entry);
+ port = atoi(text);
+
+ entry = GTK_ENTRY(g_object_get_data(ref, "remote_host"));
+ text = gtk_entry_get_text(entry);
+
+ checkbutton = GTK_TOGGLE_BUTTON(g_object_get_data(ref, "use_remote"));
+
+ g_loaded_binary_set_remote_server(binary, text, port,
+ gtk_toggle_button_get_active(checkbutton));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : button = oche dont le status vient de changer. *
+* ref = espace de référencement global. *
+* *
+* Description : Met à jour l'accès aux paramètres du serveur distant. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void on_server_usage_toggle(GtkToggleButton *button, GObject *ref)
+{
+ gboolean state; /* Etat du bouton courant */
+ GtkWidget *widget; /* Element dont l'accès change */
+
+ state = gtk_toggle_button_get_active(button);
+
+ widget = GTK_WIDGET(g_object_get_data(ref, "host"));
+ if (widget != NULL)
+ gtk_widget_set_sensitive(widget, state);
+
+ widget = GTK_WIDGET(g_object_get_data(ref, "remote_host"));
+ if (widget != NULL)
+ gtk_widget_set_sensitive(widget, state);
+
+ widget = GTK_WIDGET(g_object_get_data(ref, "port"));
+ if (widget != NULL)
+ gtk_widget_set_sensitive(widget, state);
+
+ widget = GTK_WIDGET(g_object_get_data(ref, "remote_port"));
+ if (widget != NULL)
+ gtk_widget_set_sensitive(widget, state);
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* TRAITEMENT DES FONCTIONNALITES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : treeview = vue à compléter. *
+* binary = binaire à manipuler. *
+* *
+* Description : Remplit la vue présentant les fonctionnalités à traiter. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void fill_storage_features(GtkTreeView *treeview, GLoadedBinary *binary)
+{
+ GtkListStore *store; /* Gestionnaire de liste */
+ DBFeatures i; /* Boucle de parcours */
+ DBStorage storage; /* Type d'enregistrement */
+ char *human_feature; /* Description humaine #1 */
+ char *human_value; /* Description humaine #2 */
+ GtkTreeIter iter; /* Point d'insertion */
+
+ store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
+
+ for (i = 0; i < DBF_COUNT; i++)
+ {
+ storage = g_loaded_binary_get_storage(binary, i);
+
+ switch (i)
+ {
+ case DBF_COMMENTS:
+ human_feature = _("Comments");
+ break;
+ case DBF_SEGMENTS_DISPLAY:
+ human_feature = _("Segments display");
+ break;
+ case DBF_BOOKMARKS:
+ human_feature = _("Bookmarks");
+ break;
+ default: /* Pour GCC... */
+ break;
+ }
+
+ switch (storage)
+ {
+ case DBS_ALL_LOCAL:
+ human_value = _("Local storage");
+ break;
+ case DBS_ALL_REMOTE:
+ human_value = _("Remote storage");
+ break;
+ case DBS_LOCAL_AND_REMOTE:
+ human_value = _("Local storage with remote access");
+ break;
+ }
+
+ gtk_list_store_append(store, &iter);
+ gtk_list_store_set(store, &iter,
+ SCT_FEATURE_ID, i,
+ SCT_FEATURE_NAME, human_feature,
+ SCT_FEATURE_STORAGE, human_value,
+ -1);
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : binary = binaire chargé en mémoire à traiter. *
+* ref = espace de référencement global. *
+* *
+* Description : Sauvegarde les statuts d'enregistrement des fonctionnalités. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void save_storage_features(GLoadedBinary *binary, GObject *ref)
+{
+ GtkTreeView *treeview; /* Liste des fonctionnalités */
+ GtkTreeModel *store; /* Gestionnaire de liste */
+ GtkTreeIter iter; /* Point de lecture */
+ gboolean valid; /* Point courant valide ? */
+ DBFeatures feature; /* Fonctionnalité traitée */
+ char *human_value; /* Description humaine */
+ DBStorage storage; /* Type d'enregistrement */
+
+ treeview = GTK_TREE_VIEW(g_object_get_data(ref, "treeview"));
+ store = GTK_TREE_MODEL(gtk_tree_view_get_model(treeview));
+
+ for (valid = gtk_tree_model_get_iter_first(store, &iter);
+ valid;
+ valid = gtk_tree_model_iter_next(store, &iter))
+ {
+ gtk_tree_model_get(store, &iter,
+ SCT_FEATURE_ID, &feature,
+ SCT_FEATURE_STORAGE, &human_value,
+ -1);
+
+ if (g_strcmp0(human_value, _("Remote storage")) == 0)
+ storage = DBS_ALL_REMOTE;
+ else if (g_strcmp0(human_value, _("Local storage with remote access")) == 0)
+ storage = DBS_LOCAL_AND_REMOTE;
+ else
+ storage = DBS_ALL_LOCAL;
+
+ g_loaded_binary_set_storage(binary, feature, storage);
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : cell = cellule du tableau à mettre à jour. *
+* path = chemin d'accès à l'élément concerné. *
+* value = nouvelle valeur à prendre en compte. *
+* store = gestionnaire de liste sur lequel s'appuyer. *
+* *
+* Description : Met à jour un type d'enregistrement. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void storage_combo_edited_cb(GtkCellRendererText *cell, const gchar *path, const gchar *value, GtkListStore *store)
+{
+ GtkTreePath *tpath; /* Chemin instancié */
+ GtkTreeIter iter; /* Point d'accès pour la maj */
+
+ tpath = gtk_tree_path_new_from_string(path);
+
+ if (gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, tpath))
+ gtk_list_store_set(store, &iter, SCT_FEATURE_STORAGE, value, -1);
+
+ gtk_tree_path_free(tpath);
+
+}
diff --git a/src/dialogs/storage.h b/src/dialogs/storage.h
new file mode 100644
index 0000000..c15fe17
--- /dev/null
+++ b/src/dialogs/storage.h
@@ -0,0 +1,40 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * storage.h - prototypes pour la définition des modes d'enregistrement pour binaires
+ *
+ * Copyright (C) 2014 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * 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 _DIALOGS_STORAGE_H
+#define _DIALOGS_STORAGE_H
+
+
+#include <gtk/gtk.h>
+
+
+#include "../analysis/binary.h"
+
+
+
+/* Propose une définition des propriétés d'enregistrement. */
+GtkWidget *create_storage_dialog(GLoadedBinary *, GtkWindow *);
+
+
+
+#endif /* _DIALOGS_STORAGE_H */
diff --git a/src/gui/menus/binary.c b/src/gui/menus/binary.c
index 8699c02..114e90d 100644
--- a/src/gui/menus/binary.c
+++ b/src/gui/menus/binary.c
@@ -30,10 +30,14 @@
#include "../editem-int.h"
#include "../../dialogs/export.h"
+#include "../../dialogs/storage.h"
#include "../../gtkext/easygtk.h"
+/* Réagit au menu "Binaire -> Enregistrements...". */
+static void mcb_binary_storage(GtkMenuItem *, GMenuBar *);
+
/* Réagit au menu "Binaire -> Exporter...". */
static void mcb_binary_export(GtkMenuItem *, GMenuBar *);
@@ -65,6 +69,10 @@ GtkWidget *build_menu_binary(GObject *ref, GtkAccelGroup *accgroup, GMenuBar *ba
menubar = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(result), menubar);
+ submenuitem = qck_create_menu_item(ref, "mnu_binary_storage", _("Storage..."),
+ G_CALLBACK(mcb_binary_storage), bar);
+ gtk_container_add(GTK_CONTAINER(menubar), submenuitem);
+
submenuitem = qck_create_menu_item(ref, "mnu_binary_export", _("Export..."),
G_CALLBACK(mcb_binary_export), bar);
gtk_container_add(GTK_CONTAINER(menubar), submenuitem);
@@ -79,6 +87,49 @@ GtkWidget *build_menu_binary(GObject *ref, GtkAccelGroup *accgroup, GMenuBar *ba
* Paramètres : menuitem = élément de menu sélectionné. *
* bar = barre de menu parente. *
* *
+* Description : Réagit au menu "Binaire -> Enregistrements...". *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void mcb_binary_storage(GtkMenuItem *menuitem, GMenuBar *bar)
+{
+ GLoadedBinary *binary; /* Edition courante */
+ GObject *ref; /* Espace de référencements */
+ GtkWidget *dialog; /* Boîte de dialogue à montrer */
+
+ binary = g_editor_item_get_current_binary(G_EDITOR_ITEM(bar));
+ ref = g_editor_item_get_global_ref(G_EDITOR_ITEM(bar));
+
+ dialog = create_storage_dialog(binary, GTK_WINDOW(ref));
+
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
+ {
+ /* TODO */
+
+
+ /*
+ addr = get_address_from_goto_dialog(dialog);
+
+ vpanel = g_editor_item_get_current_view(G_EDITOR_ITEM(bar));
+ gtk_view_panel_scroll_to_address(vpanel, addr);
+ */
+
+ }
+
+ gtk_widget_destroy(dialog);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : menuitem = élément de menu sélectionné. *
+* bar = barre de menu parente. *
+* *
* Description : Réagit au menu "Binaire -> Exporter...". *
* *
* Retour : - *
diff --git a/src/main.c b/src/main.c
index ca7be49..b966437 100644
--- a/src/main.c
+++ b/src/main.c
@@ -32,6 +32,7 @@
#include "editor.h"
#include "params.h"
#include "project.h"
+#include "analysis/db/server.h"
#include "arch/processor.h"
#include "format/format.h"
#include "glibext/delayed.h"
@@ -78,7 +79,7 @@ static void show_version(void)
printf("\n");
}
-
+#include "analysis/db/cdb.h"
/******************************************************************************
* *
@@ -97,6 +98,7 @@ int main(int argc, char **argv)
{
configuration *config; /* Configuration principale */
GtkWidget *editor; /* Fenêtre graphique */
+ GDbServer *server; /* Enregistrements locaux */
const char *filename; /* Chemin du dernier projet */
GStudyProject *project; /* Nouveau projet courant */
@@ -143,12 +145,40 @@ int main(int argc, char **argv)
//test_itanium();
//exit(-1);
+
+#if 0
+ do
+ {
+ core_db_info info;
+
+ strcpy(info.hash, "47cd68c5c46f36a5d48ebf347d6558a8eee23e11f9420227935658c3e97b6e27");
+
+
+
+
+ GCdbArchive *archive = g_cdb_archive_new(true, NULL, &info);
+
+ printf("written ? %d\n",
+ g_cdb_archive_write(archive)
+ );
+
+
+ exit(0);
+
+ }
+ while (0);
+#endif
+
+
editor = create_editor();
gtk_widget_show(editor);
init_work_queue(G_OBJECT(editor));
- init_all_plugins(G_OBJECT(editor));
+ //init_all_plugins(G_OBJECT(editor));
+
+ server = g_db_server_new("localhost", 1337);
+ g_db_server_start(server);
/* Charge le dernier projet */
@@ -164,7 +194,9 @@ int main(int argc, char **argv)
gtk_main();
gdk_threads_leave();
- exit_all_plugins();
+ g_db_server_stop(server);
+
+ //exit_all_plugins();
exit_global_pango_context();
exit_binary_portion_colors();
diff --git a/src/project.c b/src/project.c
index cf50ef9..b5157d2 100644
--- a/src/project.c
+++ b/src/project.c
@@ -203,7 +203,7 @@ GStudyProject *g_study_project_open(GObject *ref, const char *filename)
access = calloc(access_len, sizeof(char));
snprintf(access, access_len, "/OpenIDAProject/Binaries/Binary[position()=%u]", i + 1);
- binary = g_file_binary_new_from_xml(context, access);
+ binary = g_loaded_binary_new_from_xml(context, access);
free(access);