path: root/src/analysis/db/collection.c

/* Chrysalide - 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 Chrysalide.
 *
 *  OpenIDA is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  OpenIDA is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "collection.h"


#include <assert.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>


#include "collection-int.h"
#include "misc/rlestr.h"
#include "../../common/extstr.h"
#include "../../common/io.h"
#include "../../glibext/chrysamarshal.h"







/* Initialise la classe des collections génériques d'éléments. */
static void g_db_collection_class_init(GDbCollectionClass *);

/* Initialise une collection générique d'éléments. */
static void g_db_collection_init(GDbCollection *);

/* Supprime toutes les références externes. */
static void g_db_collection_dispose(GDbCollection *);

/* Procède à la libération totale de la mémoire. */
static void g_db_collection_finalize(GDbCollection *);



/* --------------------- MANIPULATIONS AVEC UNE BASE DE DONNEES --------------------- */


/* Décrit les colonnes utiles à un chargement de données. */
static bool _g_db_collection_setup_load(GDbCollection *, bound_value **, size_t *);

/* Décrit les colonnes utiles à un chargement de données. */
static bool g_db_collection_setup_load(GDbCollection *, bound_value **, size_t *);

/* Enregistre un élément de collection dans une base de données. */
static bool g_db_collection_store_item(const GDbCollection *, const GDbItem *, sqlite3 *);

/* Met à jour un élément de collection dans une base de données. */
static bool g_db_collection_store_updated_item(const GDbCollection *, const GDbItem *, sqlite3 *);




/* Indique le type défini pour une collection générique d'éléments. */
G_DEFINE_TYPE(GDbCollection, g_db_collection, G_TYPE_OBJECT);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des collections génériques d'éléments.  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_db_collection_class_init(GDbCollectionClass *klass)
{
    GObjectClass *object;                   /* Autre version de la classe  */

    object = G_OBJECT_CLASS(klass);

    object->dispose = (GObjectFinalizeFunc/* ! */)g_db_collection_dispose;
    object->finalize = (GObjectFinalizeFunc)g_db_collection_finalize;

    klass->setup_load = (collec_setup_load_fc)_g_db_collection_setup_load;

    g_signal_new("content-changed",
                 G_TYPE_DB_COLLECTION,
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GDbCollectionClass, content_changed),
                 NULL, NULL,
                 g_cclosure_user_marshal_VOID__ENUM_OBJECT,
                 G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_OBJECT);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = instance à initialiser.                             *
*                                                                             *
*  Description : Initialise une collection générique d'éléments.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_db_collection_init(GDbCollection *collec)
{
    collec->binary = NULL;

    g_rw_lock_init(&collec->params_access);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = instance d'objet GLib à traiter.                    *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_db_collection_dispose(GDbCollection *collec)
{
    G_OBJECT_CLASS(g_db_collection_parent_class)->dispose(G_OBJECT(collec));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = instance d'objet GLib à traiter.                    *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_db_collection_finalize(GDbCollection *collec)
{
    g_rw_lock_clear(&collec->params_access);

    G_OBJECT_CLASS(g_db_collection_parent_class)->finalize(G_OBJECT(collec));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : id   = identifiant réseau des éléments à traiter.            *
*                type = type GLib des éléments à placer dans la collection.   *
*                name = indique le nom désignant la table associée.           *
*                                                                             *
*  Description : Prépare la mise en place d'une nouvelle collection.          *
*                                                                             *
*  Retour      : Adresse de l'instance ou NULL en cas d'échec.                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GDbCollection *g_db_collection_new(uint32_t id, GType type, const char *name)
{
    GDbCollection *result;                  /* Adresse à retourner         */

    result = g_object_new(G_TYPE_DB_COLLECTION, NULL);

    result->featuring = id;
    result->type = type;
    result->name = name;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = collection générique d'éléments à compléter.        *
*                binary = binaire sur lequel appliquer les éléments.          *
*                                                                             *
*  Description : Attache à une collection un binaire pour les éléments listés.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_db_collection_link_to_binary(GDbCollection *collec, GLoadedBinary *binary)
{
    g_object_ref(G_OBJECT(binary));

    collec->binary = binary;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = collection générique d'éléments à consulter.        *
*                                                                             *
*  Description : Décrit le type des éléments rassemblées dans une collection. *
*                                                                             *
*  Retour      : Identifiant interne des éléments collectionés.               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

uint32_t g_db_collection_get_feature(const GDbCollection *collec)
{
    return collec->featuring;

}














/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                fd     = flux ouvert en lecture pour la réception de données.*
*                db     = base de données à mettre à jour.                    *
*                                                                             *
*  Description : Réceptionne et traite une requête réseau pour collection.    *
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : Cette fonction est uniquement destinée aux appels depuis     *
*                la fonction g_cdb_archive_process() ; une partie des         *
*                informations ont déjà été tirées des échanges protocolaires. *
*                                                                             *
******************************************************************************/

bool g_db_collection_recv(GDbCollection *collec, int fd, sqlite3 *db)
{
    bool result;                            /* Bilan à faire remonter      */
    uint32_t val32;                         /* Valeur sur 32 bits          */
    bool status;                            /* Bilan de lecture initiale   */
    DBAction action;                        /* Commande de la requête      */
    GDbItem *item;                          /* Définition d'élément visé   */
    GList *found;                           /* Test de présence existante  */
    timestamp_t inactive;                   /* Horodatage de désactivation */

    status = safe_recv(fd, &val32, sizeof(uint32_t), 0);
    if (!status) return false;

    action = be32toh(val32);
    if (action < 0 || action >= DBA_COUNT) return false;

    item = g_object_new(collec->type, NULL);

    status = g_db_item_recv(item, fd, 0);
    if (!status) return false;

    result = false;

    switch (action)
    {
        case DBA_ADD_ITEM:

            /* Ecrasement des horodatages par les valeurs communes du serveur */
            if (db != NULL)
                g_db_item_set_server_side(item);

            result = g_db_collection_add_item(collec, item);

            if (result)
            {
                if (collec->binary != NULL && g_db_item_is_active(item))
                    result = g_db_item_apply(item, collec->binary);
                if (db != NULL)
                    result &= g_db_collection_store_item(collec, item, db);
            }

            if (!result)
                /* TODO : retirer l'élément */;

            break;

        case DBA_REM_ITEM:

            g_db_collection_wlock(collec);

            found = g_list_find_custom(collec->items, item, (GCompareFunc)g_db_item_compare_with_timestamp);

            result = (found != NULL);

            if (result)
            {
                /* Côté client */
                if (db == NULL)
                    result = _g_db_collection_remove_item(collec, item, false);

                /* Côté serveur */
                else
                {
                    if (g_db_item_is_active(G_DB_ITEM(found->data)))
                    {
                        inactive = _g_db_collection_compute_inactivity_timestamp(collec, false);
                        result = _g_db_collection_update_item_activity(collec, item, &inactive, false);
                    }
                }

            }

            g_db_collection_wunlock(collec);

            break;

        case DBA_CHANGE_STATE:

            if (db == NULL)
            {
                if (g_db_item_is_active(item))
                    result = g_db_collection_update_item_activity(collec, item, NULL);
                else
                {
                    inactive = g_db_item_get_timestamp(item) + 1;
                    result = g_db_collection_update_item_activity(collec, item, &inactive);
                }
            }
            else
                result = false;

            break;

        default:
            /* Pour GCC : DBA_COUNT */
            break;

    }

    g_object_unref(G_OBJECT(item));

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                fd     = flux ouvert en écriture pour l'émission de données. *
*                action = avenir de l'élément fourni.                         *
*                item   = élément de collection à sérialiser.                 *
*                                                                             *
*  Description : Envoie pour traitement une requête réseau pour collection.   *
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_db_collection_send(GDbCollection *collec, int fd, DBAction action, GDbItem *item)
{
    bool status;                            /* Bilan de lecture initiale   */

    status = safe_send(fd, (uint32_t []) { htobe32(DBC_COLLECTION) }, sizeof(uint32_t), MSG_MORE);
    if (!status) return false;

    status = safe_send(fd, (uint32_t []) { htobe32(collec->featuring) }, sizeof(uint32_t), MSG_MORE);
    if (!status) return false;

    status = safe_send(fd, (uint32_t []) { htobe32(action) }, sizeof(uint32_t), MSG_MORE);
    if (!status) return false;

    status = g_db_item_send(item, fd, 0);
    if (!status) return false;

    return true;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                fd     = flux ouvert en écriture pour l'émission de données. *
*                                                                             *
*  Description : Envoie pour mise à jour tous les éléments courants.          *
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_db_collection_send_all_updates(GDbCollection *collec, int fd)
{
    bool result;                            /* Bilan à renvoyer            */
    GList *iter;                            /* Boucle de parcours          */

    result = true;

    /* TODO : lock ? */

    for (iter = g_list_first(collec->items);
         iter != NULL && result;
         iter = g_list_next(iter))
    {
        result = g_db_collection_send(collec, fd, DBA_ADD_ITEM, G_DB_ITEM(iter->data));

    }

    return result;

}







/******************************************************************************
*                                                                             *
*  Paramètres  : collec = collection à mettre à jour.                         *
*                write  = précise le type d'accès prévu (lecture/écriture).   *
*                lock   = indique le sens du verrouillage à mener.            *
*                                                                             *
*  Description : Met à disposition un encadrement des accès aux éléments.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_db_collection_lock_unlock(GDbCollection *collec, bool write, bool lock)
{
    if (write)
    {
        if (lock) g_rw_lock_writer_lock(&collec->params_access);
        else g_rw_lock_writer_unlock(&collec->params_access);
    }
    else
    {
        if (lock) g_rw_lock_reader_lock(&collec->params_access);
        else g_rw_lock_reader_unlock(&collec->params_access);
    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à consulter.                    *
*                                                                             *
*  Description : Renvoie la liste des éléments rassemblés.                    *
*                                                                             *
*  Retour      : Liste d'éléments à parcourir.                                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GList *g_db_collection_list_items(const GDbCollection *collec)
{
    /**
     * Un verrou doit être posé !
     * Il n'y a pas d'assert() possible pour le vérifier...
     */

    return collec->items;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à consulter.                    *
*                ...    = clef identifiant de manière unique un élément.      *
*                                                                             *
*  Description : Détermine si un élément est déjà présent ou non.             *
*                                                                             *
*  Retour      : Elément trouvé ou NULL si aucun.                             *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GDbItem *g_db_collection_has_key(GDbCollection *collec, ...)
{
    GDbItem *result;                        /* Bilan à retourner           */
    va_list ap;                             /* Liste d'arguments en plus   */

    va_start(ap, collec);

    result = G_DB_COLLECTION_GET_CLASS(collec)->has_key(collec, ap);

    va_end(ap);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à consulter.                    *
*                item   = élément complet dont un double est à rechercher.    *
*                                                                             *
*  Description : Détermine si un élément est déjà présent ou non.             *
*                                                                             *
*  Retour      : true si un élément similaire est présent dans la collection. *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_db_collection_has_item(GDbCollection *collec, GDbItem *item)
{
    bool result;                            /* Bilan à retourner           */
    GList *found;                           /* Test de présence existante  */

    /**
     * Un verrou doit être posé !
     * Il n'y a pas d'assert() possible pour le vérifier...
     */

    found = g_list_find_custom(collec->items, item, (GCompareFunc)g_db_item_compare_with_timestamp);

    result = (found != NULL);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                item   = élément de collection à manipuler.                  *
*                lock   = indique si le verrou d'écriture doit être posé.     *
*                                                                             *
*  Description : Procède à l'ajout d'un nouvel élément dans la collection.    *
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : L'appelant reste le propriétaire de l'object transféré.      *
*                                                                             *
******************************************************************************/

bool _g_db_collection_add_item(GDbCollection *collec, GDbItem *item, bool lock)
{
    bool result;                            /* Bilan à faire remonter      */

    result = true;

    if (lock)
        g_db_collection_wlock(collec);

    g_object_ref(G_OBJECT(item));
    collec->items = g_list_append(collec->items, item);

    g_object_ref(G_OBJECT(item));
    collec->sorted = g_list_insert_sorted(collec->sorted, item, (GCompareFunc)g_db_item_compare_with_timestamp);

    g_signal_emit_by_name(collec, "content-changed", DBA_ADD_ITEM, item);

    if (lock)
        g_db_collection_wunlock(collec);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                item   = élément de collection à manipuler.                  *
*                lock   = indique si le verrou d'écriture doit être posé.     *
*                                                                             *
*  Description : Procède au retrait d'un nouvel élément dans la collection.   *
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : L'appelant reste le propriétaire de l'object transféré.      *
*                                                                             *
******************************************************************************/

bool _g_db_collection_remove_item(GDbCollection *collec, GDbItem *item, bool lock)
{
    bool result;                            /* Bilan à faire remonter      */
    GList *found;                           /* Test de présence existante  */
    GDbItem *internal;                      /* Elément interne à modifier  */

    result = true;

    if (lock)
        g_db_collection_wlock(collec);

    found = g_list_find_custom(collec->items, item, (GCompareFunc)g_db_item_compare_with_timestamp);

    result = (found != NULL);

    if (result)
    {
        internal = G_DB_ITEM(found->data);

        collec->items = g_list_delete_link(collec->items, found);

        g_signal_emit_by_name(collec, "content-changed", DBA_REM_ITEM, internal);

        g_object_unref(G_OBJECT(internal));

    }

    if (lock)
        g_db_collection_wunlock(collec);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                lock   = indique si le verrou d'écriture doit être posé.     *
*                                                                             *
*  Description : Détermine l'horodatage le plus jeune pour une désactivation. *
*                                                                             *
*  Retour      : Horodatage à utiliser pour une phase de désactivation.       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

timestamp_t _g_db_collection_compute_inactivity_timestamp(GDbCollection *collec, bool lock)
{
    timestamp_t result;                     /* Horodatage à retourner      */
    GList *iter;                            /* Boucle de parcours          */
    GDbItem *item;                          /* Elément interne à consulter */
    timestamp_t stamp;                      /* Horodatage de l'élément     */

    result = TIMESTAMP_ALL_ACTIVE;

    if (lock)
        g_db_collection_wlock(collec);

    for (iter = g_list_first(collec->items);
         iter != NULL;
         iter = g_list_next(iter))
    {
        item = G_DB_ITEM(iter->data);

        if (!g_db_item_is_active(item))
        {
            stamp = g_db_item_get_timestamp(item);

            if (timestamp_is_younger(stamp, result))
                result = stamp;

        }

    }

    if (lock)
        g_db_collection_wunlock(collec);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                item   = élément de collection à manipuler.                  *
*                lock   = indique si le verrou d'écriture doit être posé.     *
*                                                                             *
*  Description : Met à jour le statut d'activité d'un élément de collection.  *
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : L'appelant reste le propriétaire de l'object transféré.      *
*                                                                             *
******************************************************************************/

bool _g_db_collection_update_item_activity(GDbCollection *collec, GDbItem *item, timestamp_t *timestamp, bool lock)
{
    bool result;                            /* Bilan à faire remonter      */
    GList *found;                           /* Test de présence existante  */
    GDbItem *internal;                      /* Elément interne à modifier  */

    if (lock)
        g_db_collection_wlock(collec);

    found = g_list_find_custom(collec->items, item, (GCompareFunc)g_db_item_compare_without_timestamp);

    result = (found != NULL);

    if (result)
    {
        internal = G_DB_ITEM(found->data);

        result = g_db_item_set_activity(internal, collec->binary, timestamp);

        g_signal_emit_by_name(collec, "content-changed", DBA_CHANGE_STATE, internal);

    }

    if (lock)
        g_db_collection_wunlock(collec);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec    = ensemble d'éléments à considérer.                *
*                timestamp = date du dernier élément à garder comme actif.    *
*                inactive  = date du premier élément inactif rencontré. [OUT] *
*                db        = base de données à mettre à jour.                 *
*                                                                             *
*  Description : Active les éléments en amont d'un horodatage donné.          *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GList *g_db_collection_set_last_active(GDbCollection *collec, timestamp_t timestamp, timestamp_t *inactive, sqlite3 *db)
{
    GList *result;                          /* Liste d'inactifs à renvoyer */
    GList *i;                               /* Parcours des éléments       */
    GDbItem *item;                          /* Elément à traiter           */
    timestamp_t stamp;                      /* Horodatage de l'élément     */

    result = NULL;

    for (i = g_list_first(collec->items); i != NULL; i = g_list_next(i))
    {
        item = G_DB_ITEM(i->data);
        stamp = g_db_item_get_timestamp(item);

        if (timestamp_is_younger(stamp, timestamp))
        {
            if (!g_db_item_is_active(item))
            {
                /* ... */g_db_item_set_activity(item, collec->binary, NULL);
                /* ... */g_db_collection_store_updated_item(collec, item, db);
                g_signal_emit_by_name(collec, "content-changed", DBA_CHANGE_STATE, item);
            }

        }

        else
        {
            if (!g_db_item_is_active(item))
            {
                if (timestamp_is_younger(stamp, *inactive))
                    *inactive = stamp;
            }

            else
                result = g_list_append(result, item);

        }

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec    = ensemble d'éléments à considérer.                *
*                item      = élément à désactiver.                            *
*                timestamp = date du premier élément inactif rencontré. [OUT] *
*                                                                             *
*  Description : Désactive les éléments en aval d'un horodatage donné.        *
*                                                                             *
*  Retour      : true si l'élément a été traité, false sinon.                 *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_db_collection_set_inactive(GDbCollection *collec, GDbItem *item, timestamp_t *timestamp)
{
    bool result;                            /* Bilan à retourner           */

    /* Si cette collection n'est pas concernée, on ne bouge pas ! */
    if (G_OBJECT_TYPE(G_OBJECT(item)) != collec->type) return false;

    result = g_db_item_set_activity(item, collec->binary, timestamp);

    g_signal_emit_by_name(collec, "content-changed", DBA_CHANGE_STATE, item);

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                       MANIPULATIONS AVEC UNE BASE DE DONNEES                       */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments spectateur des opérations.      *
*                db     = accès à la base de données.                         *
*                                                                             *
*  Description : Crée la table d'élément dans une base de données.            *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_db_collection_create_db_table(const GDbCollection *collec, sqlite3 *db)
{
    return G_DB_COLLECTION_GET_CLASS(collec)->create_table(collec, db);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à consulter.                    *
*                values = tableau d'éléments à compléter. [OUT]               *
*                count  = nombre de descriptions renseignées. [OUT]           *
*                                                                             *
*  Description : Décrit les colonnes utiles à un chargement de données.       *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool _g_db_collection_setup_load(GDbCollection *collec, bound_value **values, size_t *count)
{
    if (!setup_load_of_timestamp(NULL, "created", values, count))
        return false;

    if (!setup_load_of_timestamp(NULL, "timestamp", values, count))
        return false;

    if (!setup_load_of_rle_string(NULL, "author", values, count))
        return false;

    if (!setup_load_of_rle_string(NULL, "tool", values, count))
        return false;

    return true;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à consulter.                    *
*                values = tableau d'éléments à compléter. [OUT]               *
*                count  = nombre de descriptions renseignées. [OUT]           *
*                                                                             *
*  Description : Décrit les colonnes utiles à un chargement de données.       *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool g_db_collection_setup_load(GDbCollection *collec, bound_value **values, size_t *count)
{
    *values = NULL;
    *count = 0;
    
    return G_DB_COLLECTION_GET_CLASS(collec)->setup_load(collec, values, count);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à peupler.                      *
*                db     = base de données repondant aux requêtes.             *
*                                                                             *
*  Description : Charge un ensemble d'éléments à partir d'une base de données.*
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_db_collection_load_all_items(GDbCollection *collec, sqlite3 *db)
{
    bool result;                            /* Conclusion à faire remonter */
    bound_value *values;                    /* Champs de table à inclure   */
    size_t count;                           /* Nombre de ces champs        */
    char *sql;                              /* Requête SQL à construire    */
    size_t i;                               /* Boucle de parcours          */
    sqlite3_stmt *stmt;                     /* Déclaration mise en place   */
    int ret;                                /* Bilan d'un appel à SQLite   */
    int native_type;                        /* Type de valeur dans la base */
    GDbItem *new;                           /* Nouvel élément à insérer    */

    result = false;

    if (!g_db_collection_setup_load(collec, &values, &count))
        goto gdclai_building_values;

    /* Préparation de la requête */

    sql = strdup("SELECT ");

    for (i = 0; i < count; i++)
    {
        if (i > 0) sql = stradd(sql, ", ");

        sql = stradd(sql, values[i].name);

    }

    sql = stradd(sql, " FROM ");
    sql = stradd(sql, collec->name);
    sql = stradd(sql, ";");

    ret = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
	if (ret != SQLITE_OK)
    {
		fprintf(stderr, "Can't prepare SELECT statment '%s' (ret=%d): %s\n", sql, ret, sqlite3_errmsg(db));
        goto gdclai_exit;
	}

    /* Chargement des valeurs existantes */

    result = true;

    for (ret = sqlite3_step(stmt); ret == SQLITE_ROW && result; ret = sqlite3_step(stmt))
    {
        /* Conversion des valeurs */

        for (i = 0; i < count; i++)
        {
            native_type = sqlite3_column_type(stmt, i);

            /**
             * On réalise une petite conversion selon le champ.
             *
             * Le filtre SQLITE_NATIVE est destiné à conserver le type choisi par
             * SQLite. Typiquement, une chaîne peut être à SQLITE_NULL ou SQLITE_TEXT
             * selon la valeur conservée dans la base.
             *
             * D'autres éléments, comme les localisations en mémoire, peuvent aussi
             * avoir un champ éventuellement nul, donc la définition à partir des
             * indications de la base de données reste importante.
             *
             * En ce qui concerne les valeurs numériques, SQLite ne fait pas de
             * distinction : tout passe par la fonction sqlite3VdbeIntValue(),
             * qui effectue des transtypages au besoin pour tout ce qui n'est
             * pas numérique.
             *
             * Pour les types internes SQLITE_INTEGER et SQLITE_BOOLEAN,
             * il est donc nécessaire d'ajuster en interne.
             */

            if (native_type == SQLITE_INTEGER)
                native_type = SQLITE_INT64;

            if (values[i].type == SQLITE_NATIVE)
                values[i].type = native_type;

            else
                assert(values[i].type == native_type
                       || values[i].type == SQLITE_INTEGER
                       || values[i].type == SQLITE_BOOLEAN);

            switch (values[i].type)
            {
                case SQLITE_BOOLEAN:
                    values[i].boolean = (bool)sqlite3_column_int(stmt, i);
                    break;

                case SQLITE_INTEGER:
                    values[i].integer = sqlite3_column_int(stmt, i);
                    break;

                case SQLITE_INT64:
                    values[i].integer64 = sqlite3_column_int64(stmt, i);
                    break;

                case SQLITE_FLOAT:
                    assert(0); /* TODO */
                    break;

                case SQLITE_TEXT:
                    values[i].cstring = (const char *)sqlite3_column_text(stmt, i);
                    break;

                case SQLITE_BLOB:
                    assert(0); /* TODO */
                    break;

                case SQLITE_NULL:
                    break;

                default:
                    assert(0);
                    break;

            }

        }

        /* Chargement d'un nouvel élément */

        new = g_object_new(G_DB_COLLECTION(collec)->type, NULL);

        result = g_db_item_load(new, values, count);
        result &= g_db_collection_add_item(G_DB_COLLECTION(collec), new);

    }

    /* Sortie propre */

    sqlite3_finalize(stmt);

 gdclai_exit:

    free(sql);

 gdclai_building_values:

    free_all_bound_values(values, count);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                item   = élément de collection à enregistrer.                *
*                db     = base de données à mettre à jour.                    *
*                                                                             *
*  Description : Enregistre un élément de collection dans une base de données.*
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool g_db_collection_store_item(const GDbCollection *collec, const GDbItem *item, sqlite3 *db)
{
    bool result;                            /* Conclusion à faire remonter */
    bound_value *values;                    /* Champs de table à inclure   */
    size_t count;                           /* Nombre de ces champs        */
    char *sql;                              /* Requête SQL à construire    */
    size_t i;                               /* Boucle de parcours          */
    sqlite3_stmt *stmt;                     /* Déclaration mise en place   */
    int ret;                                /* Bilan d'un appel à SQLite   */
    int index;                              /* Indice de valeur attachée   */

    result = false;

    if (!g_db_item_prepare_db_statement(item, &values, &count))
        goto gdcsi_building_values;

    /* Préparation de la requête */

    sql = strdup("INSERT INTO ");
    sql = stradd(sql, collec->name);
    sql = stradd(sql, " (");

    for (i = 0; i < count; i++)
    {
        if (i > 0) sql = stradd(sql, ", ");

        sql = stradd(sql, values[i].name);

    }

    sql = stradd(sql, ") VALUES (");

    for (i = 0; i < count; i++)
    {
        if (i > 0) sql = stradd(sql, ", ");

        if (values[i].type == SQLITE_RAW)
            sql = stradd(sql, values[i].cstring);
        else
            sql = stradd(sql, "?");

    }

    sql = stradd(sql, ");");

	ret = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
	if (ret != SQLITE_OK)
    {
		fprintf(stderr, "Can't prepare INSERT statment '%s' (ret=%d): %s\n", sql, ret, sqlite3_errmsg(db));
        goto gdcsi_exit;
	}

    /* Attribution des valeurs */

    index = 1;

    for (i = 0; i < count; i++)
    {
        switch (values[i].type)
        {
            case SQLITE_BOOLEAN:
                ret = sqlite3_bind_int(stmt, index, values[i].boolean);
                index++;
                break;

            case SQLITE_INTEGER:
                ret = sqlite3_bind_int(stmt, index, values[i].integer);
                index++;
                break;

            case SQLITE_INT64:
                ret = sqlite3_bind_int64(stmt, index, values[i].integer64);
                index++;
                break;

            case SQLITE_TEXT:
                ret = sqlite3_bind_text(stmt, index, values[i].string, -1, values[i].delete);
                index++;
                break;

            case SQLITE_NULL:
                ret = sqlite3_bind_null(stmt, index);
                index++;
                break;

            default:
                assert(false);
                ret = SQLITE_ERROR;
                break;

        }

        if (ret != SQLITE_OK)
        {
            fprintf(stderr, "Can't bind value for parameter nb %d in '%s' (ret=%d): %s\n",
                    index - 1, sql, ret, sqlite3_errmsg(db));
            goto gdcsi_exit;
        }

    }

    /* Exécution finale */

	ret = sqlite3_step(stmt);

    if (ret != SQLITE_DONE)
    {
		fprintf(stderr, "INSERT statement '%s' didn't return DONE (ret=%d): %s\n", sql, ret, sqlite3_errmsg(db));
        goto gdcsi_exit;
    }

    sqlite3_finalize(stmt);

    result = true;

 gdcsi_exit:

    free(sql);

 gdcsi_building_values:

    free_all_bound_values(values, count);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : collec = ensemble d'éléments à considérer.                   *
*                item   = élément de collection à enregistrer.                *
*                db     = base de données à mettre à jour.                    *
*                                                                             *
*  Description : Met à jour un élément de collection dans une base de données.*
*                                                                             *
*  Retour      : Bilan de l'exécution de l'opération.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool g_db_collection_store_updated_item(const GDbCollection *collec, const GDbItem *item, sqlite3 *db)
{
    bool result;                            /* Conclusion à faire remonter */
    bound_value *values;                    /* Champs de table à inclure   */
    size_t count;                           /* Nombre de ces champs        */
    char *sql;                              /* Requête SQL à construire    */
    bool first;                             /* Première valeur ?           */
    size_t i;                               /* Boucle de parcours          */
    sqlite3_stmt *stmt;                     /* Déclaration mise en place   */
    int ret;                                /* Bilan d'un appel à SQLite   */
    int index;                              /* Indice de valeur attachée   */
    const bound_value *timestamp;           /* Valeur de l'horodatage      */

    result = false;

    if (!g_db_item_prepare_db_statement(item, &values, &count))
        goto gdcsui_building_values;

    /* Préparation de la requête */

    sql = strdup("UPDATE ");
    sql = stradd(sql, collec->name);

    sql = stradd(sql, " SET timestamp = ? ");

    sql = stradd(sql, "WHERE ");

    first = true;

    for (i = 0; i < count; i++)
    {
        if (strcmp(values[i].name, "timestamp") == 0)
            continue;

        if (first)
            first = false;
        else
            sql = stradd(sql, " AND ");

        sql = stradd(sql, values[i].name);

        if (values[i].type == SQLITE_NULL)
            sql = stradd(sql, " IS ");
        else
            sql = stradd(sql, " = ");

        if (values[i].type == SQLITE_RAW)
            sql = stradd(sql, values[i].cstring);
        else
            sql = stradd(sql, "?");

    }

    sql = stradd(sql, ";");

	ret = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
	if (ret != SQLITE_OK)
    {
		fprintf(stderr, "Can't prepare UPDATE statment '%s' (ret=%d): %s\n", sql, ret, sqlite3_errmsg(db));
        goto gdcsui_exit;
	}

    /* Attribution des valeurs */

    index = 1;

    timestamp = find_bound_value(values, count, "timestamp");
    assert(timestamp->type == SQLITE_INT64);

    ret = sqlite3_bind_int64(stmt, index, timestamp->integer64);
    index++;

    if (ret != SQLITE_OK)
    {
        fprintf(stderr, "Can't bind value for parameter nb %d in '%s' (ret=%d): %s\n",
                index - 1, sql, ret, sqlite3_errmsg(db));
        goto gdcsui_exit;
    }

    for (i = 0; i < count; i++)
    {
        if (strcmp(values[i].name, "timestamp") == 0)
            continue;

        switch (values[i].type)
        {
            case SQLITE_BOOLEAN:
                ret = sqlite3_bind_int(stmt, index, values[i].boolean);
                index++;
                break;

            case SQLITE_INTEGER:
                ret = sqlite3_bind_int(stmt, index, values[i].integer);
                index++;
                break;

            case SQLITE_INT64:
                ret = sqlite3_bind_int64(stmt, index, values[i].integer64);
                index++;
                break;

            case SQLITE_TEXT:
                ret = sqlite3_bind_text(stmt, index, values[i].string, -1, values[i].delete);
                index++;
                break;

            case SQLITE_NULL:
                ret = sqlite3_bind_null(stmt, index);
                index++;
                break;

            default:
                assert(false);
                ret = SQLITE_ERROR;
                break;

        }

        if (ret != SQLITE_OK)
        {
            fprintf(stderr, "Can't bind value for parameter nb %d in '%s' (ret=%d): %s\n",
                    index - 1, sql, ret, sqlite3_errmsg(db));
            goto gdcsui_exit;
        }

    }

    /* Exécution finale */

	ret = sqlite3_step(stmt);

    if (ret != SQLITE_DONE)
    {
		fprintf(stderr, "UPDATE statement '%s' didn't return DONE (ret=%d): %s\n", sql, ret, sqlite3_errmsg(db));
        goto gdcsui_exit;
    }

    sqlite3_finalize(stmt);

    result = true;

 gdcsui_exit:

    free(sql);

 gdcsui_building_values:

    free_all_bound_values(values, count);

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                     CREATION DE L'ABSTRACTION POUR COLLECTIONS                     */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : list   = ensemble de collectons à parcourir.                 *
*                binary = binaire sur lequel appliquer les éléments.          *
*                                                                             *
*  Description : Attache un binaire à une série de collections.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void attach_binary_to_collections(GList *list, GLoadedBinary *binary)
{
    GList *iter;                            /* Boucle de parcours          */

    for (iter = g_list_first(list);
         iter != NULL;
         iter = g_list_next(iter))
    {
        g_db_collection_link_to_binary(G_DB_COLLECTION(iter->data), binary);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : list = ensemble de collectons à parcourir.                   *
*                id   = identifiant interne du type d'éléments groupés.       *
*                                                                             *
*  Description : Recherche une collection correspondant à un type donné.      *
*                                                                             *
*  Retour      : Collection trouvée ou NULL en cas d'échec.                   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GDbCollection *find_collection_in_list(GList *list, uint32_t id)
{
    GDbCollection *result;                  /* Collection trouvée renvoyée */
    GList *iter;                            /* Boucle de parcours          */

    result = NULL;

    for (iter = g_list_first(list);
         iter != NULL;
         iter = g_list_next(iter))
    {
        result = G_DB_COLLECTION(iter->data);

        if (g_db_collection_get_feature(result) == id)
            break;

    }

    return (iter != NULL ? result : NULL);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : list  = ensemble de collectons à parcourir.                  *
*                write = précise le type d'accès prévu (lecture/écriture).    *
*                lock  = indique le sens du verrouillage à mener.             *
*                                                                             *
*  Description : Met à disposition un encadrement des accès aux éléments.     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void lock_unlock_collections(GList *list, bool write, bool lock)
{
    GList *iter;                            /* Boucle de parcours          */

    for (iter = g_list_first(list);
         iter != NULL;
         iter = g_list_next(iter))
    {
        g_db_collection_lock_unlock(G_DB_COLLECTION(iter->data), write, lock);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : list = ensemble de collectons à traiter.                     *
*                fd   = canal de communication ouvert en lecture.             *
*                db   = base de données à mettre à jour.                      *
*                                                                             *
*  Description : Met à jour les statuts d'activité des éléments.              *
*                                                                             *
*  Retour      : Bilan du déroulement des opérations.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool update_activity_in_collections(GList *list, int fd, sqlite3 *db)
{
    bool result;                            /* Résultat global à renvoyer  */
    bool status;                            /* Bilan de lecture initiale   */
    timestamp_t timestamp;                  /* Horodatage de limite        */
    timestamp_t inactive;                   /* Date du premier inactif     */
    GList *remaining;                       /* Eléments restants à traiter */
    GList *c;                               /* Boucle de parcours #1       */
    GDbCollection *collec;                  /* Collection à manipuler      */
    GList *got;                             /* Eléments restants à traiter */
    GList *i;                               /* Boucle de parcours #2       */
    GDbItem *item;                          /* Elément collecté à manipuler*/

    /* TODO : lock ? */

    status = recv_timestamp(&timestamp, fd, 0);
    if (!status) return false;

    inactive = TIMESTAMP_ALL_ACTIVE;

    remaining = NULL;

    wlock_collections(list);

    for (c = g_list_first(list); c != NULL; c = g_list_next(c))
    {
        collec = G_DB_COLLECTION(c->data);

        got = g_db_collection_set_last_active(collec, timestamp, &inactive, db);
        remaining = g_list_concat(remaining, got);

    }

    gint sort_with_timestamp(GDbItem *a, GDbItem *b)
    {
        return g_db_item_cmp(a, b, false);
    }

    remaining = g_list_sort(remaining, (GCompareFunc)sort_with_timestamp);

    result = true;

    for (i = g_list_last(remaining); i != NULL && result; i = g_list_previous(i))
    {
        item = G_DB_ITEM(i->data);

        for (c = g_list_first(list); c != NULL && result; c = g_list_next(c))
        {
            collec = G_DB_COLLECTION(c->data);

            if (g_db_collection_set_inactive(collec, item, &inactive))
            {
                result = g_db_collection_store_updated_item(collec, item, db);
                break;
            }

        }

    }

    wunlock_collections(list);

    g_list_free(remaining);

    return result;

}