/*
    Utilisation des API de la LIBDATASTR en mode optimisé :
        - pas de vérif systématique des arguments
        - pas de verrouillage systématique des data structures
*/

#define DS_MODE 2

/* Utilisation des API de la LIBLOG en mode optimisé */

#define LOG_MODE 1

#include <libtool.h>

VER_INFO_EXPORT (libtool, "$Revision: 1.1 $", "$Name:  $", __FILE__, "$Author: smas $")

EXEC SQL INCLUDE SQLCA;
EXEC SQL INCLUDE ORACA;
EXEC ORACLE OPTION (ORACA=YES);

/*------------------------------------------------------------------------------*/
/* Définition de la sortie standard des messages d'erreur de la librairie       */
/*------------------------------------------------------------------------------*/
/* (I) Out : flux de sortie des messages d'erreur                               */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Library_Stderr_Set ( FILE * Out )
{
    TL_stderr = Out;
    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Chargement des caches de la librairie LIBLOG                                 */
/*------------------------------------------------------------------------------*/
/* (I) ToLoad : liste des caches de données à charger                           */
/*              (combinaison de TLD_KMOD, TLD_KFORMAT et TLD_GDRT)              */
/*------------------------------------------------------------------------------*/
TLT_Status TL_LIBLOG_Load ( TLT_Cache ToLoad )
{
    int Locked;

    if (!LOG_Base)
    {
        sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : the LIBLOG library is not open");
        TL_Error_Print ();
        return TLS_KO;
    }

    if (TL_Param_Get () != TLS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to retrieve parameters from KUNF");
        TL_Error_Print ();
        return TLS_KO;
    }

    /* Connexion à la base de données du suivi */

    if (TL_Database_Connect () != LOGS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to connect to database");
        TL_Error_Print ();
        return TLS_KO;
    }

    if (ToLoad & TLD_KMOD)
    {
        /* Verrouillage du cache des modules */

        if (DS_DataStruct_Lock (LOG_Base->KMOD, DSD_WRITE, &Locked) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to lock the KMOD data structure for writing");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Conversion du cache des modules en liste FIFO pour faciliter les insertions */

        if (DS_DataStruct_Convert (LOG_Base->KMOD, NDD_DS_LIST|NDD_MN_FIFO) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to convert the KMOD data structure to a FIFO list");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Chargement du cache des modules */

        if (TL_KMOD_Load () != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to load KMOD data structure from database");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Conversion du cache des modules en arbre auto-équilibré pour faciliter les recherches */

        if (DS_DataStruct_Convert (LOG_Base->KMOD, NDD_DS_TREE|NDD_MN_AUTO_EQU) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to convert the KMOD data structure to a tree");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Déverrouillage du cache des modules */

        if (DS_DataStruct_Unlock (LOG_Base->KMOD) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to unlock the KMODdata structure");
            TL_Error_Print ();
            return TLS_KO;
        }
    }

    if (ToLoad & TLD_KFORMAT)
    {
        /* Verrouillage du cache des formats d'événement */

        if (DS_DataStruct_Lock (LOG_Base->KFORMAT, DSD_WRITE, &Locked) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to lock the KFORMAT data structure for writing");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Conversion du cache des formats d'événement en liste FIFO pour faciliter les insertions */

        if (DS_DataStruct_Convert (LOG_Base->KFORMAT, NDD_DS_LIST|NDD_MN_FIFO) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to convert the KFORMAT data structure to a FIFO list");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Chargement du cache des formats d'événement */

        if (TL_KFORMAT_Load () != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to load KFORMAT data structure from database");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Conversion du cache des formats d'événement en arbre auto-équilibré pour faciliter les recherches */

        if (DS_DataStruct_Convert (LOG_Base->KFORMAT, NDD_DS_TREE|NDD_MN_AUTO_EQU) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to convert the KFORMAT data structure to a tree");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Déverrouillage du cache des formats d'événement */

        if (DS_DataStruct_Unlock (LOG_Base->KFORMAT) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to unlock the KFORMAT data structure");
            TL_Error_Print ();
            return TLS_KO;
        }
    }

    if (ToLoad & TLD_GDRT)
    {
        /* Verrouillage de la table de routage GDRT en écriture */

        if (DS_DataStruct_Lock (LOG_Base->GDRT->Root, DSD_WRITE, &Locked) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to lock the GDRT data structure for writing");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Conversion de la table de routage GDRT en liste FIFO pour faciliter les insertions */

        if (DS_DataStruct_Convert (LOG_Base->GDRT->Root, NDD_DS_LIST|NDD_MN_FIFO) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to convert the GDRT data structure to a FIFO list");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Chargement de la table de routage GDRT */

        if (TL_GDRT_Load () != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to load the GDRT data structure from database");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Conversion de la table de routage GDRT en arbre auto-équilibré pour faciliter les recherches */

        if (DS_DataStruct_Convert (LOG_Base->GDRT->Root, NDD_DS_TREE|NDD_MN_AUTO_EQU) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to convert the GDRT data structure to a tree");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Déverrouillage de la table de routage GDRT */

        if (DS_DataStruct_Unlock (LOG_Base->GDRT->Root) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Load : unable to unlock the GDRT data structure");
            TL_Error_Print ();
            return TLS_KO;
        }
    }

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Déchargement des caches de la librairie LIBLOG                               */
/*------------------------------------------------------------------------------*/
/* (I) ToUnload : liste des caches de données à décharger                       */
/*                (combinaison de TLD_KMOD, TLD_KFORMAT et TLD_GDRT)            */
/*------------------------------------------------------------------------------*/
TLT_Status TL_LIBLOG_Unload (TLT_Cache ToUnload)
{
    SMT_Heap * Heap;
    size_t Size;
    int Locked;

    if (!LOG_Base)
    {
        sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : the LIBLOG library is not open");
        TL_Error_Print ();
        return TLS_KO;
    }

    if (ToUnload & TLD_KMOD)
    {
        /* Verrouillage du cache des modules */

        if (DS_DataStruct_Lock (LOG_Base->KMOD, DSD_WRITE, &Locked) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to lock the KMOD data structure for writing");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Déchargement du cache des modules */

        if (TL_KMOD_Unload () != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to unload KMOD data structure");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Compression du heap sous-jacent */

        if (SM_Heap_IsOpen (( (DST_RootDesc *)(LOG_Base->KMOD->User))->Heap_Name, &Heap) == SMS_OK)
            SM_Heap_Compress (Heap, &Size);

        /* Déverrouillage du cache des modules */

        if (DS_DataStruct_Unlock (LOG_Base->KMOD) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to unlock the KMOD data structure");
            TL_Error_Print ();
            return TLS_KO;
        }
    }

    if (ToUnload & TLD_KFORMAT)
    {
        /* Verrouillage du cache des formats d'événement en écriture */

        if (DS_DataStruct_Lock (LOG_Base->KFORMAT, DSD_WRITE, &Locked) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to lock the KFORMAT data structure for writing");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Déchargement du cache des formats d'événement */

        if (TL_KFORMAT_Unload () != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to unload KFORMAT data structure");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Compression du heap sous-jacent */

        if (SM_Heap_IsOpen (( (DST_RootDesc *)(LOG_Base->KFORMAT->User))->Heap_Name, &Heap) == SMS_OK)
            SM_Heap_Compress (Heap, &Size);

        /* Déverrouillage du cache des formats d'événement */

        if (DS_DataStruct_Unlock (LOG_Base->KFORMAT) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to unlock the KFORMAT data structure");
            TL_Error_Print ();
            return TLS_KO;
        }
    }

    if (ToUnload & TLD_GDRT)
    {
        /* Verrouillage de la table de routage GDRT en écriture */

        if (DS_DataStruct_Lock (LOG_Base->GDRT->Root, DSD_WRITE, &Locked) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to lock the GDRT data structure for writing");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Déchargement de la table GDRT */

        if (TL_GDRT_Unload () != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to unload GDRT data structure");
            TL_Error_Print ();
            return TLS_KO;
        }

        /* Compression du heap sous-jacent */

        if (SM_Heap_IsOpen (( (DST_RootDesc *)(LOG_Base->GDRT->Root->User))->Heap_Name, &Heap) == SMS_OK)
            SM_Heap_Compress (Heap, &Size);

        /* Déverrouillage de la table de routage GDRT */

        if (DS_DataStruct_Unlock (LOG_Base->GDRT->Root) != DSS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_LIBLOG_Unload : unable to unlock the GDRT data structure");
            TL_Error_Print ();
            return TLS_KO;
        }
    }

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Affectation de toutes les tables de routage d'une section KUNF à un channel  */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le channel                                        */
/* (I) Kunf_Name : nom de la section KUNF                                       */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Channel_RTab_Add (LOGT_Channel * My_Channel, const char * Kunf_Name)
{
    KITEM * Item;

    if (!My_Channel)
    {
        sprintf (TL_Error_Msg, "Error TL_Channel_RTab_Add : the channel is null");
        TL_Error_Print ();
        return TLS_KO;
    }

    kunfig_open (NULL, KUNFIG_OPEN_SIMPLEACCESS|KUNFIG_OPEN_OVERRIDINGENV);

    /* Recherche de la section KUNF passée en paramètre */

    Item = kunfig_directfindentry (Kunf_Name);

    if (!Item)
    {
        sprintf (TL_Error_Msg, "Error TL_Channel_RTab_Add : unable to find section \"%s\"", Kunf_Name);
        TL_Error_Print ();

        kunfig_close ();

        return TLS_KO;
    }

    /* On descend dans l'arborescence de la section pour récupérer la liste des tables de routage */

    Item = kunfig_down (Item, KUNFIG_LOCAL);

    while (Item)
    {
        char * Table_Name = kunfig_getname (Item);
        char Name [256];

        sprintf (Name, "%s:%s", Kunf_Name, Table_Name);

        if (TL_RTab_Add (My_Channel, Name) != TLS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_Channel_RTab_Add : unable to add rooting table %s to the channel", Table_Name);
            TL_Error_Print ();

            kunfig_close ();

            return TLS_KO;
        }

        Item = kunfig_next (Item, KUNFIG_LOCAL);
    }

    kunfig_close ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Affectation de tous les triggers d'une section KUNF à un channel             */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le channel                                        */
/* (I) Kunf_Name : nom de la section KUNF                                       */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Channel_Trigger_Add (LOGT_Channel * My_Channel, const char * Kunf_Name)
{
    KITEM * Item;

    if (!My_Channel)
    {
        sprintf (TL_Error_Msg, "Error TL_Channel_Trigger_Add : the channel is null");
        TL_Error_Print ();
        return TLS_KO;
    }

    kunfig_open (NULL, KUNFIG_OPEN_SIMPLEACCESS|KUNFIG_OPEN_OVERRIDINGENV);

    /* Recherche de la section KUNF passée en paramètre */

    Item = kunfig_directfindentry (Kunf_Name);

    if (!Item)
    {
        sprintf (TL_Error_Msg, "Error TL_Channel_Trigger_Add : unable to find section \"%s\"", Kunf_Name);
        TL_Error_Print ();

        kunfig_close ();

        return TLS_KO;
    }

    /* On descend dans l'arborescence de la section pour récupérer la liste des triggers */

    Item = kunfig_down (Item, KUNFIG_LOCAL);

    while (Item)
    {
        char * Trigger_Name = kunfig_getname (Item);
        char Name [256];

        sprintf (Name, "%s:%s", Kunf_Name, Trigger_Name);

        if (TL_Trigger_Add (My_Channel, Name) != TLS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_Channel_Trigger_Add : unable to add trigger %s to the channel", Trigger_Name);
            TL_Error_Print ();

            kunfig_close ();

            return TLS_KO;
        }

        Item = kunfig_next (Item, KUNFIG_LOCAL);
    }

    kunfig_close ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
/*                              Fonctions privées                               */
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------*/
/* Chargement du cache des modules                                              */
/*------------------------------------------------------------------------------*/
TLT_Status TL_KMOD_Load ( void )
{
    int Id_Module;
    char Cd_Module [81];

    int Nb_Modules = 0;

    /* Récupération des modules */

    EXEC SQL DECLARE cursor_module CURSOR FOR SELECT ID_MODULE, CD_MODULE FROM TB_MODULE WHERE DAT_FIN_EFFET IS NOT NULL;

    EXEC SQL OPEN cursor_module;

    if (sqlca.sqlcode != SQL_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_KMOD_Load : unable to open cursor to retrieve modules from the database (%s)", Oracle_Message_Get ());
        TL_Error_Print ();
        EXEC SQL CLOSE cursor_module;
        return TLS_KO;
    }

    EXEC SQL FETCH cursor_module INTO :Id_Module, :Cd_Module;

    while (sqlca.sqlcode == SQL_OK || sqlca.sqlcode == SQL_FETCHED_COLUMN_NULL)
    {
        void * Value;

        if (DS_Value_Alloc (LOG_Base->KMOD, &Value, trim (Cd_Module), Id_Module) != NDS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_KMOD_Load : unable to create a module for the KMOD data structure");
            TL_Error_Print ();
            return TLS_KO;
        }

        if (DS_Value_Add (LOG_Base->KMOD, Value) != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_KMOD_Load : unable to add a module to the KMOD data structure");
            TL_Error_Print ();
            EXEC SQL CLOSE cursor_module;
            return TLS_KO;
        }

        Nb_Modules++;

        EXEC SQL FETCH cursor_module INTO :Id_Module, :Cd_Module;
    }

    if (sqlca.sqlcode != SQL_NO_DATA_FOUND)
    {
        sprintf (TL_Error_Msg, "Error TL_KMOD_Load : unable to fetch cursor to retrieve modules from the database (%s)", Oracle_Message_Get ());
        TL_Error_Print ();
        EXEC SQL CLOSE cursor_module;
        return TLS_KO;
    }

    EXEC SQL CLOSE cursor_module;

    sprintf (TL_Info_Msg, "TL_KMOD_Load : %d module(s) loaded in the KMOD data structure", Nb_Modules);
    TL_Info_Print ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Déchargement du cache des modules                                            */
/*------------------------------------------------------------------------------*/
TLT_Status TL_KMOD_Unload ( void )
{
    if (DS_DataStruct_Traverse (LOG_Base->KMOD, NDD_CMD_DELETE_VALUE, NULL) != DSS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_KMOD_Unload : unable to delete all values from the KMOD data structure");
        TL_Error_Print ();
        return TLS_KO;
    }

    sprintf (TL_Info_Msg, "The KMOD data structure has been successfully unloaded");
    TL_Info_Print ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Chargement du cache des formats d'événement                                  */
/*------------------------------------------------------------------------------*/
TLT_Status TL_KFORMAT_Load ( void )
{
    char Data [81];
    unsigned int Event_Type;
    LOGT_Event_Format * Format;
    NDT_Node * Node;
    char * Format_Data;
    int Nb_Event_Format = 0;
    int Nb_Event_Data = 0;

    /* Récupération des formats d'événement */

    EXEC SQL DECLARE cursor_format CURSOR FOR
        SELECT TB_TYPE_EVEN.CD_TYPE_EVEN, TB_DONNEE.CD_DONNEE
        FROM TB_TYPE_EVEN, TA_DONNEE_FORMAT, TB_DONNEE
        WHERE TB_TYPE_EVEN.ID_FORMAT = TA_DONNEE_FORMAT.ID_FORMAT
            AND TA_DONNEE_FORMAT.DAT_EFFET_FORMAT <= SYSDATE
            AND TA_DONNEE_FORMAT.DAT_EFFET <= SYSDATE
            AND TB_DONNEE.CD_DONNEE = TA_DONNEE_FORMAT.CD_DONNEE
            AND TB_DONNEE.DAT_EFFET = TA_DONNEE_FORMAT.DAT_EFFET_DONNEE;

    EXEC SQL OPEN cursor_format;

    if (sqlca.sqlcode != SQL_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_KFORMAT_Load : unable to open cursor to retrieve event formats from the database (%s)", Oracle_Message_Get ());
        TL_Error_Print ();
        EXEC SQL CLOSE cursor_format;
        return TLS_KO;
    }

    EXEC SQL FETCH cursor_format INTO :Event_Type, :Data;

    while (sqlca.sqlcode == SQL_OK || sqlca.sqlcode == SQL_FETCHED_COLUMN_NULL)
    {
        LOGT_Event_Format Tmp_Event_Format;

        Tmp_Event_Format.Event_Type = Event_Type;

        if (ND_Node_Find (LOG_Base->KFORMAT, &Node, (void *)(&Tmp_Event_Format), NULL) != NDS_OK)
        {
            /* Création du format de l'événement */

            if (DS_Value_Alloc (LOG_Base->KFORMAT, (void **)&Format, Event_Type) != NDS_OK)
            {
                sprintf (TL_Error_Msg, "Error TL_KFORMAT_Load : unable to create a value for the KFORMAT data structure");
                TL_Error_Print ();
                EXEC SQL CLOSE cursor_format;
                return TLS_KO;
            }

            if (DS_Value_Add (LOG_Base->KFORMAT, (void *)Format) != LOGS_OK)
            {
                sprintf (TL_Error_Msg, "Error TL_KFORMAT_Load : unable to add an event format to the KFORMAT data structure");
                TL_Error_Print ();
                EXEC SQL CLOSE cursor_format;
                return TLS_KO;
            }

            Nb_Event_Format++;
        }
        else
            Format = (LOGT_Event_Format *)(Node->Value);

        /* Création de la donnée du format */

        if (DS_Value_Alloc (Format->Data_List, (void **)&Format_Data, trim (Data)) != NDS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_KFORMAT_Load : unable to create a data for the event format data list");
            TL_Error_Print ();
            EXEC SQL CLOSE cursor_format;
            return TLS_KO;
        }

        if (DS_Value_Add (Format->Data_List, (void *)Format_Data) != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_KFORMAT_Load : unable to add a data to the event format data list");
            TL_Error_Print ();
            EXEC SQL CLOSE cursor_format;
            return TLS_KO;
        }

        Nb_Event_Data++;

        EXEC SQL FETCH cursor_format INTO :Event_Type, :Data;
    }

    if (sqlca.sqlcode != SQL_NO_DATA_FOUND)
    {
        sprintf (TL_Error_Msg, "Error TL_KFORMAT_Load : unable to fetch cursor to retrieve formats from the database (%s)", Oracle_Message_Get ());
        TL_Error_Print ();
        EXEC SQL CLOSE cursor_format;
        return TLS_KO;
    }

    EXEC SQL CLOSE cursor_format;

    sprintf (TL_Info_Msg, "TL_KFORMAT_Load : %d format(s) and %d data(s) loaded in the KFORMAT data structure", Nb_Event_Format, Nb_Event_Data);
    TL_Info_Print ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Déchargement du cache des formats d'événement                                */
/*------------------------------------------------------------------------------*/
TLT_Status TL_KFORMAT_Unload ( void )
{
    if (DS_DataStruct_Traverse (LOG_Base->KFORMAT, NDD_CMD_DELETE_VALUE, NULL) != DSS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_KFORMAT_Unload : unable to delete all values from the KFORMAT data structure");
        TL_Error_Print ();
        return TLS_KO;
    }

    sprintf (TL_Info_Msg, "The KFORMAT data structure has been successfully unloaded");
    TL_Info_Print ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Chargement de la table de routage par défaut (GDRT)                          */
/*------------------------------------------------------------------------------*/
TLT_Status TL_GDRT_Load ( void )
{
    int cd_type_even;
    int cd_retour;
    char cd_gravite [2];
    int rooting;
    char nom_type_even [81];
    int Nb_Event = 0;
    int Nb_Tree = 0;

    /* Sélection des types d'événement correspondant à la règle */

    EXEC SQL DECLARE cursor_evt CURSOR FOR
        SELECT CD_TYPE_EVEN, NOM_TYPE_EVEN, TB_TYPE_EVEN.CD_GRAVITE, CD_RETOUR, NIV_SORTIE FROM TB_TYPE_EVEN, TB_GRAVITE WHERE TB_TYPE_EVEN.CD_GRAVITE = TB_GRAVITE.CD_GRAVITE;

    EXEC SQL OPEN cursor_evt;

    if (sqlca.sqlcode != SQL_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_GDRT_Load : unable to open cursor to retrieve event types from the database (%s)", Oracle_Message_Get ());
        TL_Error_Print ();
        EXEC SQL CLOSE cursor_evt;
        return TLS_KO;
    }

    EXEC SQL FETCH cursor_evt INTO :cd_type_even, :nom_type_even, :cd_gravite, :cd_retour, :rooting;

    while (sqlca.sqlcode == SQL_OK || sqlca.sqlcode == SQL_FETCHED_COLUMN_NULL)
    {
        if (ND_Manager_Exec (LOG_Base->GDRT->Root->Manager, NDD_CMD_MAKE_VALUE, trim (nom_type_even), cd_type_even, (LOGT_Gravite)cd_gravite [0], (LOGT_RC)cd_retour, (LOGT_Rooting)rooting, &Nb_Tree) != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_GDRT_Load : unable to add event \"%s\" to the GDRT data structure", trim (nom_type_even));
            TL_Error_Print ();
            EXEC SQL CLOSE cursor_evt;
            return TLS_KO;
        }

        Nb_Event++;

        EXEC SQL FETCH cursor_evt INTO :cd_type_even, :nom_type_even, :cd_gravite, :cd_retour, :rooting;
    }

    if (sqlca.sqlcode != SQL_NO_DATA_FOUND)
    {
        sprintf (TL_Error_Msg, "Error TL_GDRT_Load : unable to fetch cursor to retrieve event types from the database (%s)", Oracle_Message_Get ());
        TL_Error_Print ();
        EXEC SQL CLOSE cursor_evt;
        return TLS_KO;
    }

    EXEC SQL CLOSE cursor_evt;

    sprintf (TL_Info_Msg, "TL_GDRT_Load : %d event(s) loaded (%d tree(s) created) in the GDRT data structure", Nb_Event, Nb_Tree);
    TL_Info_Print ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Déchargement de la table de routage GDRT                                     */
/*------------------------------------------------------------------------------*/
TLT_Status TL_GDRT_Unload ( void )
{
    if (DS_DataStruct_Traverse (LOG_Base->GDRT->Root, NDD_CMD_DELETE_VALUE, NULL) != DSS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_GDRT_Unload : unable to delete all values from the GDRT data structure");
        TL_Error_Print ();
        return TLS_KO;
    }

    sprintf (TL_Info_Msg, "The GDRT data structure has been successfully unloaded");
    TL_Info_Print ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Connexion à la base de suivi                                                 */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Database_Connect ( void )
{
    EXEC SQL CONNECT :oracx;

    if (sqlca.sqlcode != SQL_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_Database_Connect %s", Oracle_Message_Get ());
        TL_Error_Print ();
        return TLS_KO;
    }

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Ajout d'une table de routage utilisateur à un channel                        */
/*------------------------------------------------------------------------------*/
/* (I) Channel   : pointeur sur le channel                                      */
/* (I) Kunf_Name : nom de la section kunf de la table de routage                */
/*------------------------------------------------------------------------------*/
TLT_Status TL_RTab_Add (LOGT_Channel * My_Channel, char * Kunf_Name)
{
    KITEM * Item;
    LOGT_RuleClass RuleClass;
    LOGT_Rule * Rule;
    LOGT_Rooting Rooting;
    LOGT_RTab * RTab;
    char * ptr;
    char RTab_Name [100];
    char sRule [256];

    /* Recherche de la section relative à la table de routage */

    Item = kunfig_directfindentry (Kunf_Name);

    if (!Item)
    {
        sprintf (TL_Error_Msg, "Error TL_RTab_Add : unable to find section \"%s\"", Kunf_Name);
        TL_Error_Print ();
        return TLS_KO;
    }

    /* Création de la table de routage utilisateur */

    if ((ptr = strrchr (Kunf_Name, ':')) ) ptr ++;
    else ptr = Kunf_Name;

    sprintf (RTab_Name, "%s_%d_%ld_%d", ptr, My_Channel->ModuleId, My_Channel->Pid, My_Channel->Id);

    if (LOG_RTab_Alloc (&RTab, RTab_Name) != LOGS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_RTab_Add : unable to allocate memory for rooting table %s", RTab_Name);
        TL_Error_Print ();

        return TLS_KO;
    }

    /* On descend dans l'arborescence de la table de routage pour récupérer les règles associées */

    Item = kunfig_down (Item, KUNFIG_LOCAL);

    while (Item)
    {
        char Name [256];
        char * Value;
        char * Rule_Name = kunfig_getname (Item);

        /* Récupération de la classe de la règle */

        sprintf (Name, "%s:%s:class", Kunf_Name, Rule_Name);
        Value = kunfig_directfindvalue (KUNFIG_LOCAL, Name);

        if (!Value)
        {
            sprintf (TL_Error_Msg, "Error TL_RTab_Add : class is missing in section \"%s\"", Name);
            TL_Error_Print ();

            LOG_RTab_Free (RTab);

            return TLS_KO;
        }

        if (!strcmp (Value, "ALL"))
            RuleClass = LOGD_SELECT_ALL;
        else if (!strcmp (Value, "GRV"))
            RuleClass = LOGD_SELECT_GRV;
        else if (!strcmp (Value, "RC"))
            RuleClass = LOGD_SELECT_RC;
        else if (!strcmp (Value, "TYPE"))
            RuleClass = LOGD_SELECT_TYPE;
        else
        {
            sprintf (TL_Error_Msg, "Error TL_RTab_Add : unknown class \"%s\" in section \"%s\"", Value, Name);
            TL_Error_Print ();

            LOG_RTab_Free (RTab);

            return TLS_KO;
        }

        /* Récupération de la règle */

        if (RuleClass != LOGD_SELECT_ALL)
        {
            sprintf (Name, "%s:%s:rule", Kunf_Name, Rule_Name);
            Value = kunfig_directfindvalue (KUNFIG_LOCAL, Name);

            if (!Value)
            {
                sprintf (TL_Error_Msg, "Error TL_RTab_Add : rule is missing in section \"%s\"", Name);
                TL_Error_Print ();

                LOG_RTab_Free (RTab);

                return TLS_KO;
            }
        }

        /* Vérifications d'usage sur la règle */

        if (RuleClass == LOGD_SELECT_GRV)
        {
            LOGT_Gravite Gravite;

            if (!strcmp (Value, "INFO"))
            {
                Gravite = LOGD_GRV_INFO;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "TRACE"))
            {
                Gravite = LOGD_GRV_TRACE;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "FONCT"))
            {
                Gravite = LOGD_GRV_FONCT;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "DETAIL"))
            {
                Gravite = LOGD_GRV_DETAIL;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "STAT"))
            {
                Gravite = LOGD_GRV_STAT;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "ERR"))
            {
                Gravite = LOGD_GRV_ERR;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "REJDON"))
            {
                Gravite = LOGD_GRV_REJDON;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "REJENR"))
            {
                Gravite = LOGD_GRV_REJENR;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "WARNING"))
            {
                Gravite = LOGD_GRV_WARNING;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "RECYCLE"))
            {
                Gravite = LOGD_GRV_RECYCLE;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "EXIT"))
            {
                Gravite = LOGD_GRV_EXIT;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else if (!strcmp (Value, "ABEND"))
            {
                Gravite = LOGD_GRV_ABEND;
                Rule = (LOGT_Rule *)(&Gravite);
            }
            else
            {
                sprintf (TL_Error_Msg, "Error TL_RTab_Add : bad rule \"%s\" in section \"%s\"", Value, Name);
                TL_Error_Print ();

                LOG_RTab_Free (RTab);

                return TLS_KO;
            }
        }
        else if (RuleClass == LOGD_SELECT_RC)
        {
            LOGT_RC RC;

            if (!strcmp (Value, "OK"))
            {
                RC = LOGD_RC_OK;
                Rule = (LOGT_Rule *)(&RC);
            }
            else if (!strcmp (Value, "ANOERR"))
            {
                RC = LOGD_RC_ANOERR;
                Rule = (LOGT_Rule *)(&RC);
            }
            else if (!strcmp (Value, "REJDON"))
            {
                RC = LOGD_RC_REJDON;
                Rule = (LOGT_Rule *)(&RC);
            }
            else if (!strcmp (Value, "REJENR"))
            {
                RC = LOGD_RC_REJENR;
                Rule = (LOGT_Rule *)(&RC);
            }
            else if (!strcmp (Value, "WARNING"))
            {
                RC = LOGD_RC_WARNING;
                Rule = (LOGT_Rule *)(&RC);
            }
            else if (!strcmp (Value, "RECYCLE"))
            {
                RC = LOGD_RC_RECYCLE;
                Rule = (LOGT_Rule *)(&RC);
            }
            else if (!strcmp (Value, "EXIT"))
            {
                RC = LOGD_RC_EXIT;
                Rule = (LOGT_Rule *)(&RC);
            }
            else if (!strcmp (Value, "ABEND"))
            {
                RC = LOGD_RC_ABEND;
                Rule = (LOGT_Rule *)(&RC);
            }
            else
            {
                sprintf (TL_Error_Msg, "Error TL_RTab_Add : bad rule \"%s\" in section \"%s\"", Value, Name);
                TL_Error_Print ();

                LOG_RTab_Free (RTab);

                return TLS_KO;
            }
        }
        else if (RuleClass == LOGD_SELECT_TYPE)
        {
            /* La section kunf ne peut pas comporter le caractère ':' qui a donc été remplacé par "{2pts}" */

            strcpy (sRule, Value);

            while ((ptr = strstr (sRule, "{2pts}")) )
            {
                char Tmp [256];

                strcpy (Tmp, ptr + 6);

                *ptr = ':';
                ptr++;
                *ptr = (char)0;
                strcat (sRule, Tmp);
            }

            Rule = (LOGT_Rule *)sRule;
        }

        /* Récupération du routage de la règle */

        sprintf (Name, "%s:%s:rooting", Kunf_Name, Rule_Name);
        Value = kunfig_directfindvalue (KUNFIG_LOCAL, Name);

        if (!Value)
        {
            sprintf (TL_Error_Msg, "Error TL_RTab_Add : rooting is missing in section \"%s\"", Name);
            TL_Error_Print ();

            LOG_RTab_Free (RTab);

            return TLS_KO;
        }

        Rooting = 0;

        if (strstr (Value, "DATABASE")) Rooting += LOGD_ROOTING_DATABASE;

        if (strstr (Value, "NULL")) Rooting += LOGD_ROOTING_NULL;

        if (strstr (Value, "STDERR")) Rooting += LOGD_ROOTING_STDERR;

        if (strstr (Value, "PREVIOUS")) Rooting += LOGD_ROOTING_PREVIOUS;

        if (strstr (Value, "DEFAULT")) Rooting += LOGD_ROOTING_DEFAULT;

        if (Rooting == 0)
        {
            sprintf (TL_Error_Msg, "Error TL_RTab_Add : bad rooting \"%s\" in section \"%s\"", Value, Name);
            TL_Error_Print ();

            LOG_RTab_Free (RTab);

            return TLS_KO;
        }

        /* Mise à jour de la table de routage */

        if (LOG_RTab_Setup (RTab, RuleClass, Rule, Rooting) != LOGS_OK)
        {
            sprintf (TL_Error_Msg, "Error TL_RTab_Add : unable to apply rule %s to the rooting table", Rule_Name);
            TL_Error_Print ();

            LOG_RTab_Free (RTab);

            return TLS_KO;
        }

        Item = kunfig_next (Item, KUNFIG_LOCAL);
    }

    /* Ajout de la table de routage au channel */

    if (LOG_RTab_Add (My_Channel, RTab) != LOGS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_RTab_Add : unable to add rooting table %s to the channel", RTab_Name);
        TL_Error_Print ();

        LOG_RTab_Free (RTab);

        return TLS_KO;
    }

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Ajout d'un trigger à un channel                                              */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur le channel                                        */
/* (I) Kunf_Name : nom de la section kunf du trigger                            */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Trigger_Add (LOGT_Channel * My_Channel, char * Kunf_Name)
{
    LOGT_Trigger * Trigger;
    LOGT_RTab * RTab;
    char Type_Evt [256];
    LOGT_Flags Mode;
    LOGT_Flags Type;
    LOGT_RTab Tmp_RTab;
    NDT_Node * Node;
    char Name [256];
    char * Value;

    /* Récupération du type d'événement déclencheur du trigger (expression régulière) */

    sprintf (Name, "%s:event", Kunf_Name);
    Value = kunfig_directfindvalue (KUNFIG_LOCAL, Name);

    if (!Value)
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : missing trigger event type in section \"%s\"", Kunf_Name);
        TL_Error_Print ();

        return TLS_KO;
    }
    else
    {
        char * ptr;

        /* La section kunf ne peut pas comporter le caractère ':' qui a donc été remplacé par "{2pts}" */

        strcpy (Type_Evt, Value);

        while ((ptr = strstr (Type_Evt, "{2pts}")) )
        {
            char Tmp [256];

            strcpy (Tmp, ptr + 6);

            *ptr = ':';
            ptr++;
            *ptr = (char)0;
            strcat (Type_Evt, Tmp);
        }
    }

    /* Récupération du type du trigger */

    sprintf (Name, "%s:type", Kunf_Name);
    Value = kunfig_directfindvalue (KUNFIG_LOCAL, Name);
    if (!Value)
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : missing trigger type in section \"%s\"", Kunf_Name);
        TL_Error_Print ();

        return TLS_KO;
    }

    /* Vérifications d'usage sur le type */

    if (!strcmp (Value, "ADD"))
        Type = LOGD_ADD;
    else if (!strcmp (Value, "REMOVE"))
        Type = LOGD_REMOVE;
    else
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : bad trigger type \"%s\" in section \"%s\"", Value, Kunf_Name);
        TL_Error_Print ();

        return TLS_KO;
    }

    /* Récupération du mode de fonctionnement du trigger */

    sprintf (Name, "%s:mode", Kunf_Name);
    Value = kunfig_directfindvalue (KUNFIG_LOCAL, Name);
    if (!Value)
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : missing trigger mode in section \"%s\"", Kunf_Name);
        TL_Error_Print ();

        return TLS_KO;
    }

    /* Vérifications d'usage sur le mode */

    if (!strcmp (Value, "ONE_SHOT"))
        Mode = LOGD_ONE_SHOT;
    else if (!strcmp (Value, "PERMANENT"))
        Mode = LOGD_PERMANENT;
    else
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : bad trigger mode \"%s\" in section \"%s\"", Value, Kunf_Name);
        TL_Error_Print ();

        return TLS_KO;
    }

    /* Récupération de la table de routage concernée */

    sprintf (Name, "%s:rooting_table", Kunf_Name);
    Value = kunfig_directfindvalue (KUNFIG_LOCAL, Name);

    if (!Value)
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : missing trigger rooting table in section \"%s\"", Kunf_Name);
        TL_Error_Print ();
    }

    sprintf (Name, "%s_%d_%ld_%d", Value, My_Channel->ModuleId, My_Channel->Pid, My_Channel->Id);
    Tmp_RTab.Name = Name;

    /* Recherche de la table de routage dans la liste de la base */

    if (DS_Node_Find (LOG_Base->URT_List, &Node, (void *)(&Tmp_RTab), NULL) != DSS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : rooting table \"%s\" is undefined", Value);
        TL_Error_Print ();

        return TLS_KO;
    }

    RTab = (LOGT_RTab *)(Node->Value);

    /* Création du trigger */

    if (LOG_Trigger_Add (&Trigger, My_Channel, RTab, Type_Evt, Type | Mode) != LOGS_OK)
    {
        sprintf (TL_Error_Msg, "Error TL_Trigger_Add : unable to create trigger %s", Kunf_Name);
        TL_Error_Print ();
        return TLS_KO;
    }

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Routine d'affichage d'un message d'erreur                                    */
/*------------------------------------------------------------------------------*/
void TL_Error_Print ( void )
{
    if (TL_stderr) fprintf (TL_stderr, "%s\n", TL_Error_Msg);
}

/*------------------------------------------------------------------------------*/
/* Routine d'affichage d'un message d'information                               */
/*------------------------------------------------------------------------------*/
void TL_Info_Print ( void )
{
    fprintf (stdout, "%s\n", TL_Info_Msg);
}

/*------------------------------------------------------------------------------*/
/* Récupération des paramétres                                                  */
/*------------------------------------------------------------------------------*/
TLT_Status TL_Param_Get ( void )
{
    char * Login, * Pwd, * Sid, * Kunf_Name, * Env;
    char Name [256];

    if (kunfig_open (NULL, KUNFIG_OPEN_SIMPLEACCESS|KUNFIG_OPEN_OVERRIDINGENV) != KUNFIG_ERROR_NONE)
    {
        sprintf (TL_Error_Msg, "Error TL_Param_Get : unable to open kunfig file");
        TL_Error_Print ();
        return TLS_KO;
    }

    if ((Env = getenv ("BDM_PROFILE")) )
    {
        Kunf_Name = (char * )malloc ( strlen ("ADMIN:INSTALL_SUIVI") + strlen (Env) + 2);
        sprintf (Kunf_Name, "ADMIN:INSTALL_SUIVI:%s", Env);
    }
    else
        Kunf_Name = strdup ("ADMIN:INSTALL_SUIVI");

    /* Récupération des paramètres de connexion à la base de suivi */

    sprintf (Name, "%s:login", Kunf_Name);
    if ((Login = kunfig_directfindvalue (KUNFIG_INHERIT, Name)) == NULL)
    {
        sprintf (TL_Error_Msg, "Error TL_Param_Get : unable to find %s in KUNF", Name);
        TL_Error_Print ();
        free (Kunf_Name);
        return TLS_KO;
    }

    sprintf (Name, "%s:password", Kunf_Name);
    if ((Pwd = kunfig_directfindvalue (KUNFIG_INHERIT, Name)) == NULL)
    {
        sprintf (TL_Error_Msg, "Error TL_Param_Get : unable to find %s in KUNF", Name);
        TL_Error_Print ();
        free (Kunf_Name);
        return TLS_KO;
    }

    if (oracx) free (oracx);

    sprintf (Name, "%s:instance", Kunf_Name);
    if ((Sid = kunfig_directfindvalue (KUNFIG_INHERIT, Name)) )
    {
      oracx = (char * )malloc (strlen (Login) + strlen (Pwd) + strlen (Sid) + 3);
      sprintf (oracx, "%s/%s@%s", Login, Pwd, Sid);
    }
    else
    {
      oracx = (char * )malloc (strlen (Login) + strlen (Pwd) + 2);
      sprintf (oracx, "%s/%s", Login, Pwd);
    }

    free (Kunf_Name);

    kunfig_close ();

    return TLS_OK;
}

/*------------------------------------------------------------------------------*/
/* Suppression des espaces en début et fin de chaîne des caractères             */
/*------------------------------------------------------------------------------*/
char * trim (char * str)
{
    char * ptr1, * ptr2;

    ptr1 = ptr2 = str;

    while (*ptr1 == ' ') ptr1++;

    if (ptr1 != str)
    {
        while (*ptr1 != '\0')
        {
            *ptr2 = *ptr1;
            ptr2++;
            ptr1++;
        }

        *ptr2 = *ptr1;
    }
    else
    {
        while (*ptr1 != '\0') ptr1++;
        ptr2 = ptr1;
    }

    if (ptr2 > str)
    {
        ptr2--;
        while (*ptr2 == ' ') ptr2--;
        ptr2++;
        *ptr2 = '\0';
    }

    return (str);
}

/*------------------------------------------------------------------------------*/
/* Récupération du message Oracle                                               */
/*------------------------------------------------------------------------------*/
char * Oracle_Message_Get ( void )
{
    size_t buf_len, oracle_text_len;
    static char oracle_text [200];

    buf_len = sizeof (oracle_text);
    sqlglm (oracle_text, &buf_len, &oracle_text_len);

    trim (oracle_text);

    return oracle_text;
}