Created the first steps for a distributed storage.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@368 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

14 files changed, 2037 insertions, 0 deletions

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 */