#ifndef _LIBLOG #define _LIBLOG #ifdef __cplusplus extern "C" { #endif #include #include #include #include /*********** Anciennes librairies ************** #include #include ************************************************/ /* Codes retour des fonctions de l'API */ typedef int LOGT_Status; #define LOGS_OK DSS_OK /* La fonction s'est correctement exécutée et a produit un résultat */ #define LOGS_KO DSS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */ #define LOGS_ERRMEM MSGS_ERRMEM /* Problème d'allocation mémoire */ #define LOGS_ERRAPI MSGS_ERRAPI /* Utilisation incorrecte des API */ #define LOGS_ERRSHM MSGS_ERRSHM /* Problème relatif aux segments de mémoire partagée */ #define LOGS_ERRSEM MSGS_ERRSEM /* Problème relatif à l'utilisation des sémaphores */ #define LOGS_ERRSIG MSGS_ERRSIG /* Opération sur sémpahore interrompue par un signal système */ #define LOGS_ERRDLL MSGS_ERRDLL /* Problème de chargement dynamique de librairie */ #define LOG_ERROR(s) (s < 0) /* Tous les codes retour négatifs correspondent à des erreurs */ /* Notion de routage (possibilité de les combiner par addition binaire) */ typedef int LOGT_Rooting; #define LOGD_ROOTING_DATABASE 0x01 /* Routage vers la base de suivi */ #define LOGD_ROOTING_STDERR 0x02 /* Routage vers la sortie standard d'erreur */ #define LOGD_ROOTING_DEFAULT 0x04 /* Routage de la table de routage par défaut */ #define LOGD_ROOTING_PREVIOUS 0x08 /* Routage de la table de routage précédente */ #define LOGD_ROOTING_NULL 0x10 /* Routage vers /dev/null */ #define LOGD_ROOTING_DATABASE_MSK(a) (LOGD_ROOTING_DATABASE & a) #define LOGD_ROOTING_STDERR_MSK(a) (LOGD_ROOTING_STDERR & a) /* Notion de gravité (classe d'événement) */ typedef int LOGT_Gravite; #define LOGD_GRV_INFO 'I' #define LOGD_GRV_TRACE 'T' #define LOGD_GRV_FONCT 'F' #define LOGD_GRV_DETAIL 'L' #define LOGD_GRV_STAT 'S' #define LOGD_GRV_ERR 'E' #define LOGD_GRV_REJDON 'D' #define LOGD_GRV_REJENR 'R' #define LOGD_GRV_WARNING 'W' #define LOGD_GRV_RECYCLE 'Y' #define LOGD_GRV_EXIT 'X' #define LOGD_GRV_ABEND 'A' /* Notion de code retour (pour le pilotage) */ typedef int LOGT_RC; #define LOGD_RC_OK 0 /* Continuation */ #define LOGD_RC_ANOERR 4 /* Anomalie */ #define LOGD_RC_REJDON 6 /* Rejet de la donnée */ #define LOGD_RC_REJENR 7 /* Rejet de l'enregistrement */ #define LOGD_RC_WARNING 8 /* Evénement inconnu */ #define LOGD_RC_RECYCLE 10 /* Recyclage de l'enregistrement */ #define LOGD_RC_EXIT 14 /* Sortie du traitement */ #define LOGD_RC_ABEND 16 /* Interruption du traitement */ #define LOGD_RC_SIZE 17 /* Taille des tableaux de codes retour (voir fonction LOG_Event_Cpt_Get) */ /* Type de table de routage */ typedef int LOGT_RTType; #define LOGD_GMRT 0 /* Global Master Rooting Table */ #define LOGD_LMRT 1 /* Local Master Rooting Table */ #define LOGD_URT 2 /* User Rooting Table */ #define LOGD_LDRT 3 /* Local Default Rooting Table */ #define LOGD_GDRT 4 /* Global Default Rooting Table */ /* Notion de table de routage */ typedef struct { char * Name; /* Nom de la table de routage */ LOGT_RTType Type; /* Type de la table de routage */ NDT_Root * Root; /* Pointeur sur la structure contenant les événements */ int Nb_Channel; /* Nombre de canaux auquels est rattachée la table */ pid_t Pid; /* Processus propriétaire de la table de routage (utile au garbage collector) */ } LOGT_RTab; #define LOGD_RTAB_DEFAULT 0 /* Référence à la table de routage par défaut */ #define LOGD_RTAB_PREVIOUS 1 /* Référence à la table de routage précédente */ /* Notion de classe de règle de sélection des événements */ typedef int LOGT_RuleClass; #define LOGD_SELECT_ALL 1 /* Règle appliquée à tous les événements */ #define LOGD_SELECT_GRV 2 /* Règle appliquée aux événements d'une certaine gravité */ #define LOGD_SELECT_RC 3 /* Règle appliquée aux événements associés à un certain code retour */ #define LOGD_SELECT_TYPE 4 /* Règle appliquée aux événements d'un certain type */ /* Notion de règle de sélection des événements */ typedef void LOGT_Rule; /* Contient le code gravité, code retour ou type d'événement selon la classe de la règle */ /* Différents indicateurs */ typedef int LOGT_Flags; /* Modes d'ouverture et de fermeture */ #define LOGD_CREATE SMD_CREATE /* Création */ #define LOGD_OPEN SMD_OPEN /* Ouverture simple */ #define LOGD_DESTROY SMD_DESTROY /* Destruction */ #define LOGD_CLOSE SMD_CLOSE /* Fermeture simple */ /* Flags de debug sur l'ouverture de la librairie */ #define LOGD_DEBUG_NONE SMD_DEBUG_NONE /* pour n'afficher aucun message généré par les diverses librairies */ #define LOGD_DEBUG SMD_DEBUG /* pour afficher les messages générés par la librairie */ #define LOGD_DEBUG_ALL SMD_DEBUG_ALL /* pour afficher les messages générés par toutes les librairies sous-jacentes */ #define LOGD_DEBUG_MSK (MSGD_DEBUG & MSGD_DEBUG_ALL) /* Mode de fonctionnement d'un trigger */ #define LOGD_ADD 0x01 /* Trigger d'ajout de table de routage */ #define LOGD_REMOVE 0x02 /* Trigger de suppression de table de routage */ #define LOGD_ONE_SHOT 0x04 /* Trigger actif une seul fois */ #define LOGD_PERMANENT 0x08 /* Trigger actif en permanence */ #define LOGD_ADD_MSK(a) (LOGD_ADD & a) #define LOGD_REMOVE_MSK(a) (LOGD_REMOVE & a) #define LOGD_ONE_SHOT_MSK(a) (LOGD_ONE_SHOT & a) #define LOGD_PERMANENT_MSK(a) (LOGD_PERMANENT & a) /* Notion de channel */ typedef struct { pid_t Pid; /* Processus propriétaire du channel */ int Id; /* Identifiant du channel */ int ModuleId; /* Identifiant du module envoyeur */ int Master_ModuleId; /* Identifiant du module primaire */ NDT_Root * RTab_List; /* Liste de tables de routage */ NDT_Root * SubModule_List; /* Liste des sous-modules */ NDT_Root * Trigger_List; /* Liste des triggers posés sur le channel */ NDT_Root * Event_Cpt_List; /* Liste de compteurs d'événements */ } LOGT_Channel; /* Notion de trigger (ajout ou suppression dynamique de tables de routage) */ typedef struct LOGT_Trigger { char * Event_Name; /* Evénement déclencheur du trigger */ LOGT_RTab * RTab; /* Table de routage utilisateur concernée */ LOGT_Flags Mode; /* Mode de fonctionnement du trigger */ LOGT_Channel * Channel; /* Channel auquel est rattaché le trigger */ } LOGT_Trigger; /* Base système de la librairie LIBLOG */ typedef struct { NDT_Root * KMOD; /* Cache des modules */ NDT_Root * KFORMAT; /* Cache des formats d'événement */ LOGT_RTab * GDRT; /* Table GDRT */ LOGT_RTab * GMRT; /* Table GMRT */ NDT_Root * LMRT_List; /* Liste des LMRT */ NDT_Root * LDRT_List; /* Liste des LDRT */ NDT_Root * URT_List; /* Liste des URT */ NDT_Root * Channel_List; /* Liste des channels */ } LOGT_Base; LOGT_Base * LOG_Base = NULL; /* Informations sur un type d'événement */ typedef struct { unsigned int Event_Type; /* Identifiant du type d'événement */ char * Event_Name; /* Nom du type d'événément */ LOGT_Rooting Rooting; /* Routage associé */ LOGT_Gravite Gravite; /* Code gravité associé */ LOGT_RC RC; /* Code retour associé */ NDT_Root * Data_List; /* Liste des données du format de l'événement */ } LOGT_Info; /* Format d'un type d'événement */ typedef struct { unsigned int Event_Type; /* Type d'événement */ NDT_Root * Data_List; /* Liste des données du format */ } LOGT_Event_Format; /* Message explicite des erreurs générées par la librairie LINLOG */ char LOG_Error_Msg [256]; /* Identifiant du port de messages pour l'envoi des événements */ #define LOGD_EVENT_PORT_NAME "EVENT_PORT" /* Type des messages qui contiennent les événements */ #define LOGD_EVENT_MSG_TYPE 100 /* Formatage des événements par les clients de la LIBLOG : EVEN1[.EVEN2[.EVEN3]]@[MODULE1[.MODULE2[.MODULE3]]]:[MODE1[.MODE2[.MODE3]]]:[GEO1[.GEO2[.GEO3]]] */ #define EVEN1 0x00000101 #define EVEN2 0x00000102 #define EVEN3 0x00000103 #define MODULE1 0x00000201 #define MODULE2 0x00000202 #define MODULE3 0x00000203 #define MODE1 0x00000301 #define MODE2 0x00000302 #define MODE3 0x00000303 #define GEO1 0x00000401 #define GEO2 0x00000402 #define GEO3 0x00000403 #define DEFAULT -1L #define CHAR 0L #define STRING 1L #define SHORT 2L #define INT 3L #define LONG 4L #define FLOAT 5L #define DOUBLE 6L #define END_NAME -1 #define END_DATA "END_DATA" /* Format d'un message contenant un événement */ #define EVENT_FORMAT_VERSION_SIZE 10 /* sur 10 caractères max */ #define EVENT_FORMAT_VERSION "V1.0" /* Zone de données du message : - Version de format de message : 10 octets | - Numéro de processus envoyeur : 4 octets | Entête - Identifiant du module envoyeur : 4 octets | - Identifiant du module primaire : 4 octets | - Identifiant du type d'événement : 4 octets - Taille du nom de l'événement : 1 octet | - Nom de l'événement | - Taille du code support : 1 octet | - Code support | - Taille du nom de la macro-donnée : 1 octet | Evénement | - Nom de la macro-donnée | | - Taille de la valeur de la macro-donnée : 1 octet | | N fois - Valeur de la macro-donnée | | */ typedef struct { char Version [EVENT_FORMAT_VERSION_SIZE]; unsigned int Sending_Pid; unsigned int ModuleId; unsigned int Master_ModuleId; } LOGT_Event_Msg_Header; typedef struct { LOGT_Event_Msg_Header Header; unsigned int Event_Type; size_t Data_Size; char Event_Data; } LOGT_Event_Msg_Data; /* Définition des alias de l'API */ #ifndef LOG_MODE #define LOG_MODE 0 #endif #if LOG_MODE == 1 /* API sans vérification des arguments */ # define LOG_Library_Open LOG_Library_Open_I # define LOG_Library_Close LOG_Library_Close_I # define LOG_Library_Stderr_Set LOG_Library_Stderr_Set_I # define LOG_Channel_Open LOG_Channel_Open_I # define LOG_Channel_Enter LOG_Channel_Enter_I # define LOG_Channel_Leave LOG_Channel_Leave_I # define LOG_Channel_Close LOG_Channel_Close_I # define LOG_RTab_Alloc LOG_RTab_Alloc_I # define LOG_RTab_Setup LOG_RTab_Setup_I # define LOG_RTab_Add LOG_RTab_Add_I # define LOG_RTab_Remove LOG_RTab_Remove_I # define LOG_RTab_Free LOG_RTab_Free_I # define LOG_Trigger_Add LOG_Trigger_Add_I # define LOG_Trigger_Remove LOG_Trigger_Remove_I # define LOG_Event_Send LOG_Event_Send_I # define LOG_Event_External_Send LOG_Event_External_Send_I # define LOG_Event_Info_Get LOG_Event_Info_Get_I # define LOG_Event_Cpt_Get LOG_Event_Cpt_Get_I #else /* API avec vérification des arguments */ # define LOG_Library_Open LOG_Library_Open_C # define LOG_Library_Close LOG_Library_Close_C # define LOG_Library_Stderr_Set LOG_Library_Stderr_Set_C # define LOG_Channel_Open LOG_Channel_Open_C # define LOG_Channel_Enter LOG_Channel_Enter_C # define LOG_Channel_Leave LOG_Channel_Leave_C # define LOG_Channel_Close LOG_Channel_Close_C # define LOG_RTab_Alloc LOG_RTab_Alloc_C # define LOG_RTab_Setup LOG_RTab_Setup_C # define LOG_RTab_Add LOG_RTab_Add_C # define LOG_RTab_Remove LOG_RTab_Remove_C # define LOG_RTab_Free LOG_RTab_Free_C # define LOG_Trigger_Add LOG_Trigger_Add_C # define LOG_Trigger_Remove LOG_Trigger_Remove_C # define LOG_Event_Send LOG_Event_Send_C # define LOG_Event_External_Send LOG_Event_External_Send_C # define LOG_Event_Info_Get LOG_Event_Info_Get_C # define LOG_Event_Cpt_Get LOG_Event_Cpt_Get_C #endif /*------------------------------------------------------------------------------*/ /* Ouverture de la librairie */ /*------------------------------------------------------------------------------*/ /* (I) Instance : numéro de l'instance à ouvrir */ /* (I) Context : contexte d'utilisation de la librairie */ /* (I) Open_Mode : mode d'ouverture de la librairie */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Library_Open_I ( int Instance, const char * Context, LOGT_Flags Open_Mode ); LOGT_Status LOG_Library_Open_C ( int Instance, const char * Context, LOGT_Flags Open_Mode ); /*------------------------------------------------------------------------------*/ /* Fermeture de l'instance de la librairie */ /*------------------------------------------------------------------------------*/ /* (I) Close_Mode : mode de fermeture de la librairie */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Library_Close_I ( LOGT_Flags Close_Mode ); LOGT_Status LOG_Library_Close_C ( LOGT_Flags Close_Mode ); /*------------------------------------------------------------------------------*/ /* Définition de la sortie standard des messages d'erreur de la librairie */ /*------------------------------------------------------------------------------*/ /* (I) Out : flux de sortie des messages d'erreur */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Library_Stderr_Set_I ( FILE * Out ); LOGT_Status LOG_Library_Stderr_Set_C ( FILE * Out ); /*------------------------------------------------------------------------------*/ /* Création d'un canal de communication */ /*------------------------------------------------------------------------------*/ /* (O) Channel : adresse du pointeur sur le canal créé */ /* (I) Pid : numéro du processus propriétaire du canal */ /* (I) Channel_Id : identifiant du canal au sein du processus */ /* (I) Module_Name : nom du module propriétaire du canal */ /* (I) Master_Module_Name : nom du module primaire */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Channel_Open_I (LOGT_Channel ** Channel, int Pid, int Channel_Id, const char * Module_Name, const char * Master_Module_Name); LOGT_Status LOG_Channel_Open_C (LOGT_Channel ** Channel, int Pid, int Channel_Id, const char * Module_Name, const char * Master_Module_Name); /*------------------------------------------------------------------------------*/ /* Entrée dans un sous-module pour un canal de communication */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur le canal */ /* (I) SubModule_Name : nom du sous-module */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Channel_Enter_I ( LOGT_Channel * Channel, const char * SubModule_Name ); LOGT_Status LOG_Channel_Enter_C ( LOGT_Channel * Channel, const char * SubModule_Name ); /*------------------------------------------------------------------------------*/ /* Sortie d'un sous-module pour un canal de communication */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur le canal */ /* (I) SubModule_Name : nom du sous-module */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Channel_Leave_I ( LOGT_Channel * Channel, const char * SubModule_Name ); LOGT_Status LOG_Channel_Leave_C ( LOGT_Channel * Channel, const char * SubModule_Name ); /*------------------------------------------------------------------------------*/ /* Fermeture d'un canal de communication */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur le canal à fermer */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Channel_Close_I ( LOGT_Channel * Channel); LOGT_Status LOG_Channel_Close_C ( LOGT_Channel * Channel); /*------------------------------------------------------------------------------*/ /* Création d'une table de routage utilisateur */ /*------------------------------------------------------------------------------*/ /* (O) RTab : adresse du pointeur sur la table de routage */ /* (I) Name : nom de la table de routage */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_RTab_Alloc_I ( LOGT_RTab ** RTab, char * Name ); LOGT_Status LOG_RTab_Alloc_C ( LOGT_RTab ** RTab, char * Name ); /*------------------------------------------------------------------------------*/ /* Ajout d'une règle à une table de routage */ /*------------------------------------------------------------------------------*/ /* (I) RTab : pointeur sur la table de routage */ /* (I) RuleClass : classe de la nouvelle règle */ /* (I) Rule : pointeur sur la nouvelle règle */ /* (I) Value : valeur de la nouvelle règle */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_RTab_Setup_I ( LOGT_RTab * RTab, LOGT_RuleClass RuleClass, LOGT_Rule * Rule, LOGT_Rooting Value ); LOGT_Status LOG_RTab_Setup_C ( LOGT_RTab * RTab, LOGT_RuleClass RuleClass, LOGT_Rule * Rule, LOGT_Rooting Value ); /*------------------------------------------------------------------------------*/ /* Ajout d'une table de routage à un canal de communication */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur le canal de communication */ /* (I) RTab : pointeur sur la table de routage */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_RTab_Add_I ( LOGT_Channel * Channel, LOGT_RTab * RTab ); LOGT_Status LOG_RTab_Add_C ( LOGT_Channel * Channel, LOGT_RTab * RTab ); /*------------------------------------------------------------------------------*/ /* Suppression d'une table de routage d'un canal de communication */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur le canal de communication */ /* (I) RTab : pointeur sur la table de routage */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_RTab_Remove_I ( LOGT_Channel * Channel, LOGT_RTab * RTab ); LOGT_Status LOG_RTab_Remove_C ( LOGT_Channel * Channel, LOGT_RTab * RTab ); /*------------------------------------------------------------------------------*/ /* Destruction d'une table de routage */ /*------------------------------------------------------------------------------*/ /* (I) RTab : pointeur sur la table de routage */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_RTab_Free_I ( LOGT_RTab * RTab ); LOGT_Status LOG_RTab_Free_C ( LOGT_RTab * RTab ); /*------------------------------------------------------------------------------*/ /* Ajout d'un trigger */ /*------------------------------------------------------------------------------*/ /* (O) Trigger : adresse du pointeur sur le trigger mis en place */ /* (I) Channel : pointeur sur le canal de communication */ /* (I) RTab : pointeur sur la table de routage à appliquer */ /* (I) Type_Evt : type d'événement déclencheur ( expression régulière ) */ /* (I) Mode : mode de fonctionnement du trigger */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Trigger_Add_I ( LOGT_Trigger ** Trigger, LOGT_Channel * Channel, LOGT_RTab * RTab, char * Type_Evt, LOGT_Flags Mode ); LOGT_Status LOG_Trigger_Add_C ( LOGT_Trigger ** Trigger, LOGT_Channel * Channel, LOGT_RTab * RTab, char * Type_Evt, LOGT_Flags Mode ); /*------------------------------------------------------------------------------*/ /* Suppression d'un trigger */ /*------------------------------------------------------------------------------*/ /* (I) Trigger : pointeur sur le trigger mis en place */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Trigger_Remove_I ( LOGT_Trigger * Trigger ); LOGT_Status LOG_Trigger_Remove_C ( LOGT_Trigger * Trigger ); /*------------------------------------------------------------------------------*/ /* Envoi d'un événement */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur un canal de communication */ /* (O) RC : pointeur sur le code retour associé à l'événement */ /* (I) Cd_Support : code du support source */ /* (I) Data : données de l'événement */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Event_Send_I ( LOGT_Channel * Channel, LOGT_RC * RC, char * Cd_Support, va_list Data ); LOGT_Status LOG_Event_Send_C ( LOGT_Channel * Channel, LOGT_RC * RC, char * Cd_Support, va_list Data ); /*------------------------------------------------------------------------------*/ /* Envoi d'un événement ( PL/SQL ou shell ) */ /*------------------------------------------------------------------------------*/ /* (I) Channel : identifiant du channel */ /* (I) Cd_Support : code du support source */ /* (I) Data : données de l'événement */ /*------------------------------------------------------------------------------*/ /* (O) Retourne le code retour associé au type d'événement */ /*------------------------------------------------------------------------------*/ LOGT_RC LOG_Event_External_Send_I ( LOGT_Channel * Channel, char * Cd_Support, char * Data ); LOGT_RC LOG_Event_External_Send_C ( LOGT_Channel * Channel, char * Cd_Support, char * Data ); /*------------------------------------------------------------------------------*/ /* Retourne les informations du type par lequel un événement est résolu */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur un canal de communication */ /* (O) Info : pointeur sur les informations à récupérer */ /* (I) Event_Name : nom de l'événement */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Event_Info_Get_I ( LOGT_Channel * Channel, LOGT_Info ** Info, char * Event_Name ); LOGT_Status LOG_Event_Info_Get_C ( LOGT_Channel * Channel, LOGT_Info ** Info, char * Event_Name ); /*------------------------------------------------------------------------------*/ /* Retourne le nombre d'événements envoyés par code retour */ /*------------------------------------------------------------------------------*/ /* (I) Channel : pointeur sur un canal de communication */ /* (O) Cpt : pointeur sur un tableau de compteurs d'événement */ /* (I) RegExpr : expression régulière sur le nom d'événement */ /*------------------------------------------------------------------------------*/ LOGT_Status LOG_Event_Cpt_Get_I ( LOGT_Channel * Channel, int * Cpt [LOGD_RC_SIZE], char * RegExpr ); LOGT_Status LOG_Event_Cpt_Get_C ( LOGT_Channel * Channel, int * Cpt [LOGD_RC_SIZE], char * RegExpr ); #ifdef __cplusplus } #endif #endif