/******************************************************************* 
 * @(#)74	1.17  src/sysmgmt/ems/h/ems.h, sysmgmt.ems.src, os2dce21  12/21/95  08:58:29 
 *
 * PROGRAM NAME: src/sysmgmt/ems/h/ems.h
 *
 * OCO SOURCE MATERIALS
 *
 * IBM CONFIDENTIAL 
 *
 * 5747-SM3 (C) COPYRIGHT IBM CORP. 1995
 *
 * ABSTRACT: Event Management Service (EMS) header file
 *
 * FUNCTION: Defines the EMS API
 *
 * CHANGE ACTIVITY: AS FOLLOWS
 ********************************************************************
 *$MOD(xxxxxxxx),COMP(sysmgmt.ems.src),PROD(os2dce21): a descriptive comment
 *
 *	REASON	RLSE  DATE  ORIGIN   DESCRIPTION
 *	------- ---- ------ ------   -----------
 ********************************************************************/
#ifndef _DCE_EMS_H
#define _DCE_EMS_H

#ifdef IBMOS2			
#ifndef DCEAPI
#include <dce/dcedef.h>
#endif				/* ndef DCEAPI */
#else				/* not IBMOS2  */
#define DCEAPI 
#define DCEVAR
#endif				/* IBMOS2 	*/

#include <stdarg.h>
#include <dce/dce.h>
#include <dce/dce_svc.h>
#include <dce/utctypes.h>
#include <dce/emsif.h>
#include <dce/dceemsmsg.h>
#include <dce/dbif.h>

/*
**  Compilation controls.
*/
#define DCE_SVC_WANT__FILE__

#define EMS_COMPONENT_NAME	"ems"
/************************************************************************/
/* SVC severities							*/
/************************************************************************/
#define SVC_C_SEV_FATAL		 ((svc_c_sev_fatal&svc__c_mask)>>svc__c_shift)
#define SVC_C_SEV_ERROR		 ((svc_c_sev_error&svc__c_mask)>>svc__c_shift)
#define SVC_C_SEV_WARNING	 ((svc_c_sev_warning&svc__c_mask)>>svc__c_shift)
#define SVC_C_SEV_NOTICE	 ((svc_c_sev_notice&svc__c_mask)>>svc__c_shift)
#define SVC_C_SEV_NOTICE_VERBOSE ((svc_c_sev_notice_verbose&svc__c_mask)>>svc__c_shift)

/************************************************************************/
/* Event Handler 							*/
/************************************************************************/
typedef void   (*ems_handler_t) ( ems_event_t  *event,
			        error_status_t *status);

/************************************************************************/
/* Event Service Handle 						*/
/************************************************************************/
#ifndef _EMS_HANDLE_H
typedef struct ems_handle_priv_s_t {
  unsigned32 dummy;
};
#endif
typedef struct ems_handle_priv_s_t *	ems_handle_t;

/************************************************************************/
/*  External interfaces							*/
/************************************************************************/
#define EMS_C_EMSD_OBJECT_UUID \
		(unsigned char *)"84ff9d30-08a2-11cf-ba2a-10005a4f3556"

/************************************************************************/
/* Register with EMS (non consumer)					*/
/************************************************************************/
extern void DCEAPI
ems_register(
            ems_netname_t *        hostname,   /* DCE host name         */
	    ems_handle_t *	   handle,     /* ems handle		*/
            error_status_t *       status);    /* mgmt request status 	*/

/************************************************************************/
/* UnRegister with EMS (non consumer)					*/
/************************************************************************/
extern void DCEAPI
ems_unregister(
	    ems_handle_t *	   handle,     /* ems handle		*/
            error_status_t *       status);    /* unregister status 	*/

/********************************/
/* Event Type Interface 	*/
/********************************/
#define EMS_C_SVC_TYPE_UUID \
		(unsigned_char_t *)"7d18dd10-7807-11ce-bef6-000001758810"

#define EMS_C_AUDIT_TYPE_UUID \
		(unsigned_char_t *)"004ee1fc-c7f7-1fba-b23b-10005ab14004"
#define EMS_C_AUDIT_TYPE_NAME "Audit"

#define EMS_C_GENERIC_TYPE_UUID \
		(unsigned_char_t *)"632c65ee-911a-11ce-84ad-000001758810"
#define EMS_C_SVC_TYPE_NAME "SVC"
#define EMS_C_GENERIC_TYPE_NAME "Generic"

extern const DCEVAR ems_event_type_t 	       ems_c_svc_type;
extern const DCEVAR ems_event_type_t 	       ems_c_audit_type;
extern const DCEVAR ems_event_type_t 	       ems_c_generic_type;

/************************************************************************/
/* Get List of Available Event Types					*/
/************************************************************************/
extern void DCEAPI
ems_event_type_get_list(
	ems_handle_t		    handle, 	/* ems handle		*/
	ems_event_type_list_t **    type_list,	/* list of event types	*/
	error_status_t *	    status);	/* request status	*/

/************************************************************************/
/* Free Event Types List 						*/
/************************************************************************/
extern void DCEAPI
ems_event_type_free_list(
         ems_event_type_list_t **   type_list,  /* list of event types 	*/
         error_status_t *           status);    /* request status     	*/

/********************************/
/* Supplier Interface 		*/
/********************************/

/************************************************************************/
/* Supplier Send							*/
/************************************************************************/
extern void DCEAPI
ems_supplier_send(
	 ems_handle_t	   	 handle,     	/* handle to emsd	*/
	 ems_event_t *           event,   	/* Event data           */
         error_status_t *        status);  	/* send status 		*/

/********************************/
/* Filter Interface 		*/
/********************************/
/************************************************************************/
/* Add an Event Filter							*/
/************************************************************************/
extern void DCEAPI
ems_filter_add(
       ems_handle_t             handle,       /* ems handle 		*/
       ems_string_t             filter_name,  /* event filter name 	*/
       ems_event_type_t	        type,	      /* event type		*/
       ems_filter_exp_list_t *  exp_list,     /* filter exprs to add 	*/
       error_status_t *         status);      /* filter routine status  */

/************************************************************************/
/* Update an Event Filter						*/
/************************************************************************/
extern void DCEAPI
ems_filter_append(
        ems_handle_t             handle,       /* ems handle 		*/
        ems_string_t             filter_name,  /* Event Filter Name 	*/
        ems_filter_exp_list_t *  exp_list,     /* exp list to append	*/
        error_status_t *         status);      /* Filter routine status */

/************************************************************************/
/* Get an Event Filter							*/
/************************************************************************/
extern void DCEAPI
ems_filter_get(
	ems_handle_t             handle,       /* ems handle 		*/
	ems_string_t             filter_name,  /* event filter name 	*/
        ems_event_type_t*	 type,	       /* event type		*/
	ems_filter_exp_list_t ** filter_exprs, /* returned filter exprs */
	error_status_t *         status);      /* filter routine status	*/

/************************************************************************/
/* Free an Event Filter - free the filter expression list		*/
/************************************************************************/
extern void DCEAPI
ems_filter_free( 
	ems_filter_exp_list_t **  /* list   */,  /* filter exps to free	*/
	error_status_t *	  /* status */); /* return status	*/

/************************************************************************/
/* Delete an Event Filter						*/
/************************************************************************/
extern void DCEAPI
ems_filter_delete(
       ems_handle_t             handle,       /* ems handle 		*/
       ems_string_t             filter_name,  /* filter name to delete 	*/
       error_status_t *         status);      /* filter routine status  */

/************************************************************************/
/* List Event Filter Names						*/
/************************************************************************/
extern void DCEAPI
ems_filter_get_namelist(
	ems_handle_t		  handle,     /* ems handle 		*/
	ems_filtername_list_t **  name_list,  /* event filter name list	*/
	error_status_t *          status);    /* filter routine status  */

/************************************************************************/
/* Free a filter namelist						*/
/************************************************************************/
extern void DCEAPI
ems_filter_free_namelist(
	ems_filtername_list_t **  /* name_list */,  /* namelist to free	*/
	error_status_t *          /* status */);		    /* status  		*/

/************************************************************************/
/* Get an Event Filter Database						*/
/************************************************************************/
extern void DCEAPI
ems_filter_get_list(
	 ems_handle_t          handle,        /* ems handle 		*/
	 ems_filter_list_t **  filter_list,   /* returned filter list 	*/
	 error_status_t *      status);       /* filter routine status	*/

/************************************************************************/
/* Free Event Filter List						*/
/************************************************************************/
extern void DCEAPI
ems_filter_free_list(
	 ems_filter_list_t **  filter_list,	/* list to free 	*/
	 error_status_t *      status);  	/* routine status	*/

/********************************/
/* Consumer Interface 		*/
/********************************/
/************************************************************************/
/* Consumer Start							*/
/************************************************************************/
extern void DCEAPI
ems_consumer_start(
         char *                consumer,  	/* consumer name      	*/
	 unsigned32	       flags,		/* consumer start flags */
         error_status_t *      status);   	/* start status       	*/

/************************************************************************/
/* Consumer Stop 							*/
/************************************************************************/
extern void DCEAPI
ems_consumer_stop(
         error_status_t        *status);   	/* stop status        	*/

/************************************************************************/
/* Consumer Event Handler Register					*/
/************************************************************************/
extern void DCEAPI
ems_consumer_handler_register(
         ems_handler_t         hfunc,     /* event handler function 	*/
         error_status_t *      status);   /* handler register status 	*/

/************************************************************************/
/* Consumer Register							*/
/************************************************************************/
extern void DCEAPI
ems_consumer_register(
         ems_netname_t *          hostname,       /* emsd hostname	*/
         ems_filtername_list_t * filter_group,    /* event filter group */
	 ems_handle_t *		 handle,	  /* ems handle		*/
         error_status_t *        status);         /* Register status    */

/************************************************************************/
/* Consumer Unregister							*/
/************************************************************************/
extern void DCEAPI
ems_consumer_unregister(
         ems_handle_t *         handle,    	/* EMS binding handle   */
         error_status_t *       status);   	/* unregister status    */

/************************************************************************/
/* Add Event Filter To Group						*/
/************************************************************************/
extern void DCEAPI
ems_add_filter_to_group(
       ems_handle_t            handle,        /* ems handle 		*/
       ems_filtername_list_t * event_filters, /* filter name list to add*/
       error_status_t *        status);       /* filter request status 	*/

/************************************************************************/
/* Delete an Event Filter From a Group					*/
/************************************************************************/
extern void DCEAPI
ems_delete_filter_from_group(
          ems_handle_t            handle,      /* ems handle 		*/
          ems_filtername_list_t * filter_name, /* event filter name(s) 	*/
          error_status_t *        status);     /* filter request status */

/************************************************************************/
/* Get a Consumers Event Filter Group					*/
/************************************************************************/
extern void DCEAPI
ems_get_filter_group(
       ems_handle_t              handle,        /* ems handle 		*/
       ems_filtername_list_t **  filter_group,  /* Event Filter Group 	*/
       error_status_t *          status);       /* filter request status*/

/********************************/
/* Management Interface		*/
/********************************/
/************************************************************************/
/* List EMS Hosts							*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_list_ems(
         char ***           host_list, 	/* list of hosts running ems	*/
         error_status_t *   status);  	/* mgmt request status 		*/

/************************************************************************/
/* Free EMS Hosts list							*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_free_ems(
         char ***           host_list, 	/* list of hosts running ems	*/
         error_status_t *   status);  	/* mgmt request status 		*/

/************************************************************************/
/* Management List Server Attributes					*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_list_attributes(
	ems_handle_t	   h,		/* ems handle		*/
	ems_attrlist_t **  list, 	/* returned attributes	*/
	error_status_t *   status); 	/* mgmt request status	*/

/************************************************************************/
/* Management Free Server Attributes list				*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_free_attributes(
	ems_attrlist_t **    list,		/* attribute list 	*/
	error_status_t *     status);		/* mgmt request status	*/

/************************************************************************/
/* List Registered consumers						*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_list_consumers(
         ems_handle_t            handle,      /* ems handle		*/
         ems_consumer_list_t **  list,        /* returned consumer list	*/
         error_status_t *        status);     /* mgmt request status	*/

/************************************************************************/
/* Free Consumer list							*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_free_consumers( 
         ems_consumer_list_t **	  list,      /* consumer list to free	*/
         error_status_t *      	  status);   /* mgmt request status 	*/

/************************************************************************/
/* Delete Registered consumer from EMS					*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_delete_consumer(
          ems_handle_t          handle,		/* ems handle		*/
          char *                consumer,	/* Consumer's name	*/
	  uuid_t *	        uuid,		/* Consumer UUID	*/
          error_status_t *      status);	/* mgmt request status	*/

/************************************************************************/
/* Delete an Event Filter from a Consumer's Filter Group		*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_delete_filter_from_group(
        ems_handle_t              handle,    	/* ems handle		*/
        char *                    consumer,    	/* Consumer's name 	*/
	uuid_t *		  uuid,	   	/* Consumer UUID	*/
        ems_filtername_list_t *   filter_name, 	/* names to delete 	*/
        error_status_t *          status);   	/* mgmt req status 	*/

/************************************************************************/
/* Add an Event Filter to a Consumer's Event Filter Group		*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_add_filter_to_group(
        ems_handle_t            handle,       /* ems handle             */
        char *                  consumer,     /* Consumer's name        */
	uuid_t *		uuid,	      /* Consumer UUID	*/
        ems_filtername_list_t * filter_name,  /* name of filter to add  */
        error_status_t *        status);      /* mgmt request status    */

/************************************************************************/
/* EMS Management - Get a filter group					*/
/************************************************************************/
extern void DCEAPI
ems_mgmt_get_filter_group(
         ems_handle_t               handle,       /* ems handle         */
         char *                     consumer,     /* name of consumer   */
	 uuid_t *		    uuid,	  /* Consumer UUID	*/
         ems_filtername_list_t **   filter_group, /* event filter group */
         error_status_t *           status);      /* mgmt request status*/

#ifndef _EMS_LOG_H
typedef struct ems_log_file_priv_s_t {
  unsigned32 dummy;
};
#endif
typedef struct ems_log_file_priv_s_t *  ems_log_file_t;
/************************************************************************/
/* Open an event log.							*/
/************************************************************************/
extern void DCEAPI
ems_log_open(
            ems_log_file_t *    log_file,     /* log file handle	*/
	    char *		dir_name,     /* log directory name	*/
            error_status_t *    status);      /* log function status 	*/

/************************************************************************/
/* Read an event from the EMS event log.				*/
/************************************************************************/
extern void DCEAPI
ems_log_read(
         ems_log_file_t       handle,    /* log file handle to read 	*/
         ems_event_t **       event,     /* return event value      	*/
         error_status_t *     status);   /* log function status     	*/

/************************************************************************/
/* Close an event log file.						*/
/************************************************************************/
extern void DCEAPI
ems_log_close(
         ems_log_file_t *      handle,     /* log file handle to close 	*/
         error_status_t *      status);    /* log function status     	*/
                 
/************************************************************************/
/* Rewind an event log. 						*/
/************************************************************************/
extern void DCEAPI
ems_log_rewind(
         ems_log_file_t       handle,     /* log file handle to rewind 	*/
         error_status_t *     status);    /* log function status      	*/

/************************************************************************/
/* Free an EMS Event							*/
/************************************************************************/
extern void DCEAPI
ems_event_free(
       ems_event_t **            event,         /* pointer to event	*/
       error_status_t *          status);       /* event free status	*/
#endif /* _EMS_H */
