Previous section.

Systems Management; Event Management Service (XEMS)
Copyright © 1997 The Open Group

DCE Implementation

This chapter describes the data structures, APIs, and command line interfaces required for a DCE implementation of the XEMS.

The XEMS generic APIs are described in XEMS Part 1.

The information provided here describes additional features and facilities provided by a DCE implementation to operate with DCE consumers and producers.

DCE XEMS Data Structure IDL File

/*  DCE IDL File  - XEMS Data structures  */
[
uuid(000b0e1e-c016-1ce3-b57e-10005ab14004),
pointer_default(ptr),
version(2.0)
]
interface  event_management
{
 import "dce/utctypes.idl";
 import "dce/aclbase.idl";

typedef [string] char *		ms_string_t;

/* XEMS delivery types */
typedef enum {
	ems_delivery_push=0,
	ems_delivery_pull
} ems_delivery_t;

/* Event Severity */
typedef enum {
	ems_sev_info,			/* information event */
	ems_sev_fatal,			/* fatal event */
	ems_sev_error,			/* alert event */
	ems_sev_warning,		/* warning event */
	ems_sev_notice,			/* notice event	*/
	ems_sev_notice_verbose,	/* notice verbose event */
	ems_sev_debug			/* debug event */
} ems_severity_t;

/* XEMS priority */
typedef  unsigned long int		ems_priority_t;

/* Event Attribute Types */
typedef unsigned16 ems_attr_type_t;
const ems_attr_type_t ems_c_attr_small_int	= 0;
const ems_attr_type_t ems_c_attr_short_int	= 1;
const ems_attr_type_t ems_c_attr_long_int	= 2;
const ems_attr_type_t ems_c_attr_hyper_int	= 3;
const ems_attr_type_t ems_c_attr_usmall_int	= 4;
const ems_attr_type_t ems_c_attr_ushort_int	= 5;
const ems_attr_type_t ems_c_attr_ulong_int	= 6;
const ems_attr_type_t ems_c_attr_uhyper_int	= 7;
const ems_attr_type_t ems_c_attr_short_float	= 8;
const ems_attr_type_t ems_c_attr_long_float	= 9;
const ems_attr_type_t ems_c_attr_boolean	= 10;
const ems_attr_type_t ems_c_attr_uuid		= 11;
const ems_attr_type_t ems_c_attr_utc		= 12;
const ems_attr_type_t ems_c_attr_severity	= 13;
const ems_attr_type_t ems_c_attr_acl		= 14;
const ems_attr_type_t ems_c_attr_byte_string	= 15;
const ems_attr_type_t ems_c_attr_char_string	= 16;
const ems_attr_type_t ems_c_attr_bytes		= 17;

/* Event Attribute Values */
typedef struct ems_bytes_s_t {
	unsigned32		  size;		/* size of byte data */
	[ptr, size_is(size)] byte *		data;		/* byte data */
} ems_bytes_t;

typedef union switch (ems_attr_type_t format) {
	case ems_c_attr_small_int:
		small int small_int;
	case ems_c_attr_short_int:
		short int short_int;
	case ems_c_attr_long_int:
		long int long_int;
	case ems_c_attr_hyper_int:
		hyper int hyper_int;
	case ems_c_attr_usmall_int:
		unsigned small int usmall_int;
	case ems_c_attr_ushort_int:
		unsigned short int ushort_int;
	case ems_c_attr_ulong_int:
		unsigned long int ulong_int;
	case ems_c_attr_uhyper_int:
		unsigned hyper int uhyper_int;
	case ems_c_attr_short_float:
		float short_float;
	case ems_c_attr_long_float:
		double long_float;
	case ems_c_attr_boolean:
		boolean bool;
	case ems_c_attr_uuid:
		uuid_t uuid;
	case ems_c_attr_utc:
		utc_t * utc;	
	case ems_c_attr_severity:
		ems_severity_t severity;
	case ems_c_attr_acl:
		sec_acl_t * acl;
	case ems_c_attr_byte_string:
		[string] byte * byte_string;
	case ems_c_attr_char_string:
		[string] char * char_string;
	case ems_c_attr_bytes:
		ems_bytes_t  bytes;
	default:
		;
} ems_attr_value_t;

/* Event Attribute */
typedef struct ems_attribute_s_t {
	ems_string_t		name;		/* event attribute name */
	ems_attr_value_t	value;		/* event attribute type */
} ems_attribute_t;

/* Event Types */
typedef uuid_t			ems_event_type_t;

/* Event Id */
typedef struct ems_eventid_s_t {
	ems_event_type_t	type;		/* event type */
	uuid_t			id;		/* unique event identifier */
} ems_eventid_t;

/* Network Name */
typedef enum {
	ems_ns_other,		/* name service other than listed */
	ems_ns_dns,		/* DNS name service*/
	ems_ns_dce,		/* DCE CDS name service */
	ems_ns_x500,		/* X500 */
	ems_ns_nis,		/* NIS */
	ems_ns_sna		/* SNA networkn */
} ems_nameservice_t;

typedef char ems_octet_t;
typedef struct ems_netaddr_s_t {
	unsigned long		len;		/* length of netaddr name */
	[size_is(len)]		char name[];	/* netaddr name */
} ems_netaddr_t;

typedef struct ems_netname_s_t {
   ems_nameservice_t		service;		/* netname name service */
   [ptr] ems_netaddr_t *		netaddr;		/* network name/address */
} ems_netname_t;

/* Event Origin */
typedef struct ems_origin_s_t {
	ems_netname_t		netname;	/* originator host network name */
	[string] char *		descname;	/* supplier descriptive name */
	unsigned32		pid;		/* originator process id */
	unsigned32		uid;		/* originator user id */
	unsigned32		gid;		/* originator group id */
} ems_origin_t;

/* Event Header */
typedef struct ems_hdr_s_t {
	ems_eventid_t		eventid;		/* event identifier */
	ems_origin_t		origin;		/* event origin */
	ems_severity_t		severity		/* event severity */
	utc_t			received;	/* event received timestamp */
	utc_t			delivered;	/* event received timestamp */
	ems_priority_t		priority;		/* event priority */
} ems_hdr_t;

/* Event */
typedef struct ems_event_s_t {
	ems_hdr_t		header;		/* fixed event header */
	unsigned32		count;		/* number of data items */
	[size_is(count)]
	ems_attribute_t		item[];		/* data items */
} ems_event_t;

/*  Event Schema */
typedef struct ems_event_schema_s_t {
	ems_event_type_t	type;		/* EMS event type */
	[string] char *		name;		/* event type name */
	long			size;		/* number of attributes */
	[size_is(size)]
	ems_attribute_t		attribute[];	/* event type attributes */
} ems_event_schema_t;

/* Event Type List */
typedef [ptr] ems_event_schema_t *  ems_schema_ptr_t;
typedef struct ems_event_type_list_s_t {
   long			size;		/* number of event types */
   [size_is(size)]
   ems_schema_ptr_t	schema[];	/* event type schemas */
} ems_event_type_list_t;

/* Event Filters */

/* Attribute Operators */
typedef unsigned16 ems_attr_op_t;
const ems_attr_op_t ems_c_attr_op_eq		= 0;
const ems_attr_op_t ems_c_attr_op_gt		= 1;
const ems_attr_op_t ems_c_attr_op_lt		= 2;
const ems_attr_op_t ems_c_attr_op_ge		= 3;
const ems_attr_op_t ems_c_attr_op_le		= 4;
const ems_attr_op_t ems_c_attr_op_ne		= 5;
const ems_attr_op_t ems_c_attr_op_bitand	= 6;
const ems_attr_op_t ems_c_attr_op_substr	= 7;  

/* XEMS filter expression grammars */
typedef unsigned16 ems_filter_grammar_t;
const ems_filter_grammar_t ems_c_fg_default	= 0;
const ems_filter_grammar_t ems_c_fg_OQL	= 1;
const ems_filter_grammar_t ems_c_fg_other	= 2;

typedef struct ems_default_fg_s_t {
	ems_string_t		attr_name;
	ems_attr_op_t		attr_operator;
	ems_attr_value_t	attr_value;
} ems_default_fg_t;

/* Event Filter Expressions */
typedef struct ems_filter_exp_s_t {		
	ems_filter_grammar_t	grammar;
	union  {
		/* case: ems_c_fg_default */
		ems_default_fg_t	def_filter;
		/* case: ems_c_fg_OQL */
		ems_string_t		oql_filter;
		/* case: ems_c_fg_other */
		ems_string_t		other_filter;
	} tagged_union;
} ems_filter_exp_t;

/* Event Filter Expression List */
typedef struct ems_filter_exp_list_s_t {
	long			size;		/* number of filter */
	[size_is(size)]				/* expressions */
	ems_filter_exp_t		filter_exps[];	/* filter expressions */
} ems_filter_exp_list_t;

/* Event Filter */
typedef struct ems_filter_s_t {
	ems_string_t		filter_name;	/* event filter name */
	ems_event_type_t	type;		/* event type */
	ems_filter_exp_list_t	filter_exp_list;	/* filter exp list */
} ems_filter_t;

/* Event Filter Name List */
typedef struct ems_filtername_list_s_t {
	long		size;		/* number of event filter   */
	[size_is(size)]			/* names in list */
	ems_string_t	filter_names[];	/* filter names */
} ems_filtername_list_t;

/* Event Filter List */
typedef [ptr] ems_filter_t *	ems_filter_ptr_t;
typedef struct ems_filter_list_s_t {
	long			size;	/* number of filters */
	[size_is(size)]
	ems_filter_ptr_t		filter[];	/* ptrs to the event filters */
} ems_filter_list_t;

/* Consumer Context Handle */
typedef [context_handle] void * cons_context_t;

/* Consumer */ 
typedef struct ems_consumer_s_t {
	[string] char *		name;		/* DCE name of consumer */
	[ptr] ems_netname_t *	hostname;	/* DCE hostname of consumer */
	uuid_t			uuid;		/* consumers uuid */
	ems_delivery_t		type;		/* consumer delivery type */
} ems_consumer_t;

/* Consumer List */
typedef struct ems_consumer_list_s_t {
	long			size;		/* # of consumers */
	[size_is(size)]
	ems_consumer_t	consumer[];	/* consumer info */
} ems_consumer_list_t;

/* Supplier */ 
typedef struct ems_supplier_s_t {
	ems_string_t		name;		/* DCE name of supplier */
	ems_netname_t		*hostname;	/* DCE hostname of supplier */
	uuid_t			uuid;		/* supplier UUID */
	ems_delivery_t		type;		/* supplier delivery type */
} ems_supplier_t;

/* Supplier List */ 
typedef struct ems_supplier_list_s_t {
	ems_long_int		size;		/* number of suppliers */
	[size-is(size)]
	ems_supplier_t		supplier[];	/* supplier info */
} ems_supplier_list_t;

/* Attribute List */
typedef struct ems_attrlist_s_t {
	long			size;		/* number of server */
	[size_is(size)]				/* attributes */
	ems_attribute_t		attr[];		/* server attributes */
} ems_attrlist_t;

/* XEMS event list */
typedef ems_event_t	*ems_event_ptr_t;
typedef struct ems_event_list_s_t {
	ems_long_int		size;
	ems_event_ptr_t		event[1];
ems_event_list_t
}

DCE XEMS API: <ems.h>

/* <ems.h> - DCE XEMS Interface */
#ifndef _DCE_EMS_H
#define _DCE_EMS_H
#include <stdarg.h>
#include <dce/dce.h>
#include <pthread.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)
edefine 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);

typedef void (*ems_supplier_count_handler_t)(
	ems_event_type_t type
	long int	count,
	error_status_t * error);

/* Event Service Handle */
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 XEMS (non consumer) */
extern void ems_register(
	ems_netname_t *	hostname,	/* DCE host name */
	ems_handle_t *		handle,		/* ems handle */
	error_status_t *		status);		/* mgmt request status */

/* UnRegister with XEMS (non consumer) */
extern void 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_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 ems_event_type_t		ems_c_svc_type;
extern const ems_event_type_t		ems_c_generic_type;

/* Add an Event Type */
extern void ems_event_type_add(
	ems_handle_t		handle,		/* ems handle */
	ems_event_schema_t *	schema,		/* event type schema to add */
	error_status_t *		status);		/* request status */

/* Delete an Event Type */
extern void ems_event_type_delete(
	ems_handle_t		handle,		/* ems handle */
	char *			type_name,	/* event type name to delete */
	error_status_t *		status);		/* request status */

/* Get an Event Type */
extern 
void ems_event_type_get(
	ems_handle_t		handle,		/* XEMS handle */
	ems_string_t		type_name,	/* event type name to get */
	ems_event_type_t *	type,		/* event type id to get */
	ems_event_schema_t **	schema,		/* event type schema */
	error_status_t *		status);		/* request status */

/* Get List of Available Event Types */
extern void 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 ems_event_type_free_list(
	ems_event_type_list_t **	type_list,	/* list of event types */
	error_status_t *		status);		/* request status */

/* Supplier Interface */

/* Pull Supplier Register */
extern void ems_pull_supplier_register(
	ems_netname_t *	hostname,	/* event service hostname */
	ems_ushort_int		interval;		/* recommended poll interval */
	ems_handle_t *		handle,		/* XEMS handle */
	error_status_t *		status);		/* register status */

/* Push Supplier Register */
extern void ems_push_supplier_register(
	 ems_netname_t *	hostname,	/* event Service hostname */
	 ems_handle_t *		handle,		/* XEMS handle */
	 error_status_t *		status);		/* Register status */

/* Push Supplier Register Handler */
extern void ems_supplier_register_handler(
	ems_event_type_t		type,		/* event type for handler */
	ems_supplier_count_handler_t	handler,		/* handler function */
	ems_handle_t *			handle,		/* XEMS handle*/
	error_status_t *			status);		/* register status */

/* Supplier Unregister */
extern void ems_supplier_unregister(
	ems_handle_t *		handle,		/* XEMS handle */
	error_status_t		*status);	/* unregister status */

/* Supplier Send */
extern void 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 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 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 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 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 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 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 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 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 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 ems_consumer_start(
	char *			consumer,	/* consumer name */
	unsigned32		flags,		/* consumer start flags */
	ems_handler_t		hfunc[],		/* handler functions */
	uuid_t **		uuid,		/* unique consumer id */
	ems_handle_t *		handle[],	/* array of consumer handles */
	error_status_t *		status);		/* start status */

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

/* Push Consumer Register */
extern void ems_push_consumer_register(
	ems_netname_t *	hostname,	/* emsd hostname */
	ems_filtername_list_t *	filter_group,	/* event filter group */
	int			hfunc_index,	/* index of handler function */
	ems_handle_t *		handle,		/* ems handle */
	error_status_t *		status);		/* register status */

/* Pull Consumer Register */
extern void ems_pull_consumer_register(
	ems_netname_t *	hostname,	/* event service hostname */
	ems_filtername_list_t *	filter_group,	/* event filter group */
	ems_handle_t *		handle,		/* XEMS handle */
	error_status_t *		status);		/* register status */

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

/* Add Event Filter To Group */
extern void 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 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 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 */

/* Get Consumer Registration */
extern void ems_consumer_get_registration(
	ems_handle_t		handle,		/* XEMS handle */
	ems_netname_t **	hostname,	/* hostname of the assoc XEMS */
	ems_filtername_list_t **  filter_group,	/* event filter group */
	int *			hfunc_index,	/*associated handler index */
	error_status_t *		status);		/* filter request status */

/* Consumer Pull */
extern void ems_consumer_pull(
	ems_handle_t		handle,		/* XEMS handle */
	ems_event_t *		event,		/* received event */
	error_status_t *		status);		/* filter request status */

/* Consumer Try Pull */
extern void ems_consumer_try_pull(
	ems_handle_t		handle,		/* XEMS handle */
	ems_event_t *		event,		/* received event */
	error_status_t *		status);		/* filter request status */

/* Management Interface */

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

/* Free XEMS Hosts List */
extern void 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 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 ems_mgmt_free_attributes(
	ems_attrlist_t **		list,		/* attribute list */
	error_status_t *		status);		/* mgmt request status */

/* List Registered Consumers */
extern void 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 ems_mgmt_free_consumers( 
	ems_consumer_list_t **	list,		/* consumer list to free */
	error_status_t *		status);		/* mgmt request status */

/* The following APIs are not required for the DCE implementation, and */
/* handled by the DCE Registry and ACL Management */
/*	ems_mgmt_add_consumer */
/*	ems_mgmt_add_consumer_of_event */
/*	ems_mgmt_delete_consumer_of_event */

/* Delete Registered Consumer from XEMS */
extern void 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 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 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 */

/* XEMS Management - Get a Filter Group */
extern void 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 */

/* The following APIs are not required for the DCE implementation, and  */
/* handled by the DCE Registry and ACL Management */
/*	ems_mgmt_add_supplier */
/*	ems_mgmt_add_supplier_of_event */
/*	ems_mgmt_delete_supplier_of_event */

/* List Registered Suppliers */
extern 
void ems_mgmt_list_suppliers(
	ems_handle_t		handle,		/* XEMS handle */
	ems_supplier_list_t **	list,		/* returned supplier list */
	error_status_t *		status);		/* mgmt request status */

/* Free Consumer List */
extern 
void ems_mgmt_free_suppliers( 
	ems_supplier_list_t **	list,		/* supplier list to free  */
	error_status_t *		status);		/* mgmt request status */

/* Delete Registered Supplier from XEMS */
extern void ems_mgmt_delete_supplier(
	ems_handle_t		handle,		/* XEMS handle */
	ems_string_t		supplier,	/* supplier's name */
	ems_uuid_t *		uuid,		/* supplier's UUID */
	error_status_t *		status);		/* mgmt request status */

/* Get Undelivered Events */
extern void ems_mgmt_get_undelivered_events(
	ems_handle_t		handle,		/* XEMS handle */
	ems_event_list_t **	event,		/* undelivered events */
	error_status_t *		status);		/* event get status */

/* Free Undelivered Events */
extern void ems_mgmt_free_undelivered_events(
	ems_event_list_t **	event,		/* undelivered events */
	error_status_t *		status);		/* event get status */

/* Delete Undelivered Events */
extern void ems_mgmt_delete_undelivered_event(
	ems_handle_t		handle,		/* XEMS handle */
	ems_eventid_t *		event_id,	/* event id to delete */
	error_status_t *		status);		/* event delete status */

/* Management Forward Events */
extern void ems_mgmt_forward(
	ems_handle_t		handle,		/* XEMS handle */
	ems_filtername_list_t *	filter_group,	/* list of event filter names */
	ems_netname_t *	hostname,	/* receiver of events */
	ems_string_t *		name,		/* assoc consumer name */
	uuid_t *			uuid,		/* consumer uuid */
	error_status_t *		status);		/* event delete status */

#endif /* _EMS_H */

DCE dcecp commands for XEMS

Event Service Object

ems catalog
ems show [-host hostname]
ems modify [-host hostname] [-add attr_name:attr_value
	-change attr_name:attr_value |
	-delete attr_name] 

Consumer Object

emsconsumer catalog [-host hostname]
emsconsumer show <consumer_name> [-uuid consumer_uuid][-host hostname]
emsconsumer delete <consumer_name> [-uuid consumer_uuid][-host hostname]
emsconsumer modify <consumer_name> [-uuid consumer_uuid][-host hostname]
	-add filter_name | -delete filter_name

Filter Object

emsfilter catalog [-host hostname]
emsfilter show <filter_name> [-host hostname]
emsfilter delete <filter_name>[-host hostname]
emsfilter modify <filter_name> [-host hostname] [-append filter_exp]


Why not acquire a nicely bound hard copy?
Click here to return to the publication details or order a copy of this publication.

Contents Next section Index