Rx3/liblog-bdm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
liblog-bdm/lib/log.h

517 lines
26 KiB
C
Raw Permalink Normal View History

Première version
2000-07-31 15:15:35 +02:00
#ifndef _LIBLOG
#define _LIBLOG
#ifdef __cplusplus
extern "C" {
#endif
#include <node.h>
#include <shmem.h>
#include <datastr.h>
#include <msg.h>
/*********** Anciennes librairies **************
#include <logevt.h>
#include <GetEvt.h>
************************************************/
/* Codes retour des fonctions de l'API */
typedef int LOGT_Status;
#define LOGS_OK DSS_OK /* La fonction s'est correctement ex<65>cut<75>e et a produit un r<>sultat */
#define LOGS_KO DSS_KO /* La fonction s'est correctement ex<65>cut<75>e mais n'a pas produit de r<>sultat */
#define LOGS_ERRMEM MSGS_ERRMEM /* Probl<62>me d'allocation m<>moire */
#define LOGS_ERRAPI MSGS_ERRAPI /* Utilisation incorrecte des API */
#define LOGS_ERRSHM MSGS_ERRSHM /* Probl<62>me relatif aux segments de m<>moire partag<61>e */
#define LOGS_ERRSEM MSGS_ERRSEM /* Probl<62>me relatif <20> l'utilisation des s<>maphores */
#define LOGS_ERRSIG MSGS_ERRSIG /* Op<4F>ration sur s<>mpahore interrompue par un signal syst<73>me */
#define LOGS_ERRDLL MSGS_ERRDLL /* Probl<62>me de chargement dynamique de librairie */
#define LOG_ERROR(s) (s < 0) /* Tous les codes retour n<>gatifs correspondent <20> des erreurs */
/* Notion de routage (possibilit<69> 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<70>c<EFBFBD>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<69> (classe d'<27>v<EFBFBD>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<6E>e */
#define LOGD_RC_REJENR 7 /* Rejet de l'enregistrement */
#define LOGD_RC_WARNING 8 /* Ev<45>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 <20>v<EFBFBD>nements */
int Nb_Channel; /* Nombre de canaux auquels est rattach<63>e la table */
pid_t Pid; /* Processus propri<72>taire de la table de routage (utile au garbage collector) */
} LOGT_RTab;
#define LOGD_RTAB_DEFAULT 0 /* R<>f<EFBFBD>rence <20> la table de routage par d<>faut */
#define LOGD_RTAB_PREVIOUS 1 /* R<>f<EFBFBD>rence <20> la table de routage pr<70>c<EFBFBD>dente */
/* Notion de classe de r<>gle de s<>lection des <20>v<EFBFBD>nements */
typedef int LOGT_RuleClass;
#define LOGD_SELECT_ALL 1 /* R<>gle appliqu<71>e <20> tous les <20>v<EFBFBD>nements */
#define LOGD_SELECT_GRV 2 /* R<>gle appliqu<71>e aux <20>v<EFBFBD>nements d'une certaine gravit<69> */
#define LOGD_SELECT_RC 3 /* R<>gle appliqu<71>e aux <20>v<EFBFBD>nements associ<63>s <20> un certain code retour */
#define LOGD_SELECT_TYPE 4 /* R<>gle appliqu<71>e aux <20>v<EFBFBD>nements d'un certain type */
/* Notion de r<>gle de s<>lection des <20>v<EFBFBD>nements */
typedef void LOGT_Rule; /* Contient le code gravit<69>, code retour ou type d'<27>v<EFBFBD>nement selon la classe de la r<>gle */
/* Diff<66>rents indicateurs */
typedef int LOGT_Flags;
/* Modes d'ouverture et de fermeture */
#define LOGD_CREATE SMD_CREATE /* Cr<43>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<EFBFBD>r<EFBFBD> par les diverses librairies */
#define LOGD_DEBUG SMD_DEBUG /* pour afficher les messages g<>n<EFBFBD>r<EFBFBD>s par la librairie */
#define LOGD_DEBUG_ALL SMD_DEBUG_ALL /* pour afficher les messages g<>n<EFBFBD>r<EFBFBD>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<72>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<6F>s sur le channel */
NDT_Root * Event_Cpt_List; /* Liste de compteurs d'<27>v<EFBFBD>nements */
} LOGT_Channel;
/* Notion de trigger (ajout ou suppression dynamique de tables de routage) */
typedef struct LOGT_Trigger
{
char * Event_Name; /* Ev<45>nement d<>clencheur du trigger */
LOGT_RTab * RTab; /* Table de routage utilisateur concern<72>e */
LOGT_Flags Mode; /* Mode de fonctionnement du trigger */
LOGT_Channel * Channel; /* Channel auquel est rattach<63> le trigger */
} LOGT_Trigger;
/* Base syst<73>me de la librairie LIBLOG */
typedef struct {
NDT_Root * KMOD; /* Cache des modules */
NDT_Root * KFORMAT; /* Cache des formats d'<27>v<EFBFBD>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'<27>v<EFBFBD>nement */
typedef struct {
unsigned int Event_Type; /* Identifiant du type d'<27>v<EFBFBD>nement */
char * Event_Name; /* Nom du type d'<27>v<EFBFBD>n<EFBFBD>ment */
LOGT_Rooting Rooting; /* Routage associ<63> */
LOGT_Gravite Gravite; /* Code gravit<69> associ<63> */
LOGT_RC RC; /* Code retour associ<63> */
NDT_Root * Data_List; /* Liste des donn<6E>es du format de l'<27>v<EFBFBD>nement */
} LOGT_Info;
/* Format d'un type d'<27>v<EFBFBD>nement */
typedef struct {
unsigned int Event_Type; /* Type d'<27>v<EFBFBD>nement */
NDT_Root * Data_List; /* Liste des donn<6E>es du format */
} LOGT_Event_Format;
/* Message explicite des erreurs g<>n<EFBFBD>r<EFBFBD>es par la librairie LINLOG */
char LOG_Error_Msg [256];
/* Identifiant du port de messages pour l'envoi des <20>v<EFBFBD>nements */
#define LOGD_EVENT_PORT_NAME "EVENT_PORT"
/* Type des messages qui contiennent les <20>v<EFBFBD>nements */
#define LOGD_EVENT_MSG_TYPE 100
/*
Formatage des <EFBFBD>v<EFBFBD>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 <20>v<EFBFBD>nement */
#define EVENT_FORMAT_VERSION_SIZE 10 /* sur 10 caract<63>res max */
#define EVENT_FORMAT_VERSION "V1.0"
/* Zone de donn<6E>es du message :
- Version de format de message : 10 octets |
- Num<EFBFBD>ro de processus envoyeur : 4 octets | Ent<EFBFBD>te
- Identifiant du module envoyeur : 4 octets |
- Identifiant du module primaire : 4 octets |
- Identifiant du type d'<EFBFBD>v<EFBFBD>nement : 4 octets
- Taille du nom de l'<EFBFBD>v<EFBFBD>nement : 1 octet |
- Nom de l'<EFBFBD>v<EFBFBD>nement |
- Taille du code support : 1 octet |
- Code support |
- Taille du nom de la macro-donn<EFBFBD>e : 1 octet | Ev<EFBFBD>nement |
- Nom de la macro-donn<EFBFBD>e | |
- Taille de la valeur de la macro-donn<EFBFBD>e : 1 octet | | N fois
- Valeur de la macro-donn<EFBFBD>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<75>ro de l'instance <20> 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<43>ation d'un canal de communication */
/*------------------------------------------------------------------------------*/
/* (O) Channel : adresse du pointeur sur le canal cr<63><72> */
/* (I) Pid : num<75>ro du processus propri<72>taire du canal */
/* (I) Channel_Id : identifiant du canal au sein du processus */
/* (I) Module_Name : nom du module propri<72>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<74>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 <20> fermer */
/*------------------------------------------------------------------------------*/
LOGT_Status LOG_Channel_Close_I ( LOGT_Channel * Channel);
LOGT_Status LOG_Channel_Close_C ( LOGT_Channel * Channel);
/*------------------------------------------------------------------------------*/
/* Cr<43>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 <20> 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 <20> 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 <20> appliquer */
/* (I) Type_Evt : type d'<27>v<EFBFBD>nement d<>clencheur ( expression r<>guli<6C>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 <20>v<EFBFBD>nement */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur un canal de communication */
/* (O) RC : pointeur sur le code retour associ<63> <20> l'<27>v<EFBFBD>nement */
/* (I) Cd_Support : code du support source */
/* (I) Data : donn<6E>es de l'<27>v<EFBFBD>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 <20>v<EFBFBD>nement ( PL/SQL ou shell ) */
/*------------------------------------------------------------------------------*/
/* (I) Channel : identifiant du channel */
/* (I) Cd_Support : code du support source */
/* (I) Data : donn<6E>es de l'<27>v<EFBFBD>nement */
/*------------------------------------------------------------------------------*/
/* (O) Retourne le code retour associ<63> au type d'<27>v<EFBFBD>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 <20>v<EFBFBD>nement est r<>solu */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur un canal de communication */
/* (O) Info : pointeur sur les informations <20> r<>cup<75>rer */
/* (I) Event_Name : nom de l'<27>v<EFBFBD>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'<27>v<EFBFBD>nements envoy<6F>s par code retour */
/*------------------------------------------------------------------------------*/
/* (I) Channel : pointeur sur un canal de communication */
/* (O) Cpt : pointeur sur un tableau de compteurs d'<27>v<EFBFBD>nement */
/* (I) RegExpr : expression r<>guli<6C>re sur le nom d'<27>v<EFBFBD>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
Reference in New Issue Copy Permalink