diff options
Diffstat (limited to 'agent/mibgroup/Rmon/event.c')
| -rw-r--r-- | agent/mibgroup/Rmon/event.c | 819 |
1 files changed, 819 insertions, 0 deletions
diff --git a/agent/mibgroup/Rmon/event.c b/agent/mibgroup/Rmon/event.c new file mode 100644 index 0000000..bb87bfe --- /dev/null +++ b/agent/mibgroup/Rmon/event.c @@ -0,0 +1,819 @@ +/************************************************************** + * Copyright (C) 2001 Alex Rozin, Optical Access + * + * All Rights Reserved + * + * Permission to use, copy, modify and distribute this software and its + * documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notice appear in all copies and that + * both that copyright notice and this permission notice appear in + * supporting documentation. + * + * ALEX ROZIN DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING + * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL + * ALEX ROZIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR + * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS + * SOFTWARE. + ******************************************************************/ + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-features.h> + +#if HAVE_STDLIB_H +#include <stdlib.h> +#endif +#if TIME_WITH_SYS_TIME +# include <sys/time.h> +# include <time.h> +#else +# if HAVE_SYS_TIME_H +# include <sys/time.h> +# else +# include <time.h> +# endif +#endif +#if HAVE_UNISTD_H +#include <unistd.h> +#endif +#include <ctype.h> + +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +#include "event.h" + +/* + * Implementation headers + */ +#include "agutil_api.h" +#include "row_api.h" + +netsnmp_feature_require(snprint_objid) + +/* + * File scope definitions section + */ + +/* + * from MIB compilation + */ +#define eventEntryFirstIndexBegin 11 + +#define EVENTINDEX 3 +#define EVENTDESCRIPTION 4 +#define EVENTTYPE 5 +#define EVENTCOMMUNITY 6 +#define EVENTLASTTIMESENT 7 +#define EVENTOWNER 8 +#define EVENTSTATUS 9 + +#define Leaf_event_index 1 +#define Leaf_event_description 2 +#define MIN_event_description 0 +#define MAX_event_description 127 +#define Leaf_event_type 3 +#define Leaf_event_community 4 +#define MIN_event_community 0 +#define MAX_event_community 127 +#define Leaf_event_last_time_sent 5 +#define Leaf_eventOwner 6 +#define Leaf_eventStatus 7 + + +#define LOGEVENTINDEX 3 +#define LOGINDEX 4 +#define LOGTIME 5 +#define LOGDESCRIPTION 6 + + +/* + * defaults & limitations + */ + +#define MAX_LOG_ENTRIES_PER_CTRL 200 + +typedef struct data_struct_t { + struct data_struct_t *next; + u_long data_index; + u_long log_time; + char *log_description; +} DATA_ENTRY_T; + +typedef enum { + EVENT_NONE = 1, + EVENT_LOG, + EVENT_TRAP, + EVENT_LOG_AND_TRAP +} EVENT_TYPE_T; + +typedef struct { + char *event_description; + char *event_community; + EVENT_TYPE_T event_type; + u_long event_last_time_sent; + + SCROLLER_T scrlr; +#if 0 + u_long event_last_logged_index; + u_long event_number_of_log_entries; + DATA_ENTRY_T *log_list; + DATA_ENTRY_T *last_log_ptr; +#endif +} CRTL_ENTRY_T; + +/* + * Main section + */ + +static TABLE_DEFINTION_T EventCtrlTable; +static TABLE_DEFINTION_T *table_ptr = &EventCtrlTable; +static unsigned char zero_octet_string[1]; + +/* + * Control Table RowApi Callbacks + */ + +static int +data_destructor(SCROLLER_T * scrlr, void *free_me) +{ + DATA_ENTRY_T *lptr = free_me; + + if (lptr->log_description) + AGFREE(lptr->log_description); + + return 0; +} + +int +event_Create(RMON_ENTRY_T * eptr) +{ /* create the body: alloc it and set defaults */ + CRTL_ENTRY_T *body; + + eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T)); + if (!eptr->body) + return -3; + body = (CRTL_ENTRY_T *) eptr->body; + + /* + * set defaults + */ + + body->event_description = NULL; + body->event_community = AGSTRDUP("public"); + /* + * ag_trace ("Dbg: created event_community=<%s>", body->event_community); + */ + body->event_type = EVENT_NONE; + ROWDATAAPI_init(&body->scrlr, + MAX_LOG_ENTRIES_PER_CTRL, + MAX_LOG_ENTRIES_PER_CTRL, + sizeof(DATA_ENTRY_T), &data_destructor); + + + return 0; +} + +int +event_Clone(RMON_ENTRY_T * eptr) +{ /* copy entry_bod -> clone */ + CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body; + CRTL_ENTRY_T *clone = (CRTL_ENTRY_T *) eptr->tmp; + + if (body->event_description) + clone->event_description = AGSTRDUP(body->event_description); + + if (body->event_community) + clone->event_community = AGSTRDUP(body->event_community); + return 0; +} + +int +event_Copy(RMON_ENTRY_T * eptr) +{ + CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body; + CRTL_ENTRY_T *clone = (CRTL_ENTRY_T *) eptr->tmp; + + if (body->event_type != clone->event_type) { + body->event_type = clone->event_type; + } + + if (clone->event_description) { + if (body->event_description) + AGFREE(body->event_description); + body->event_description = AGSTRDUP(clone->event_description); + } + + if (clone->event_community) { + if (body->event_community) + AGFREE(body->event_community); + body->event_community = AGSTRDUP(clone->event_community); + } + + return 0; +} + +int +event_Delete(RMON_ENTRY_T * eptr) +{ + CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr; + + if (body->event_description) + AGFREE(body->event_description); + + if (body->event_community) + AGFREE(body->event_community); + + return 0; +} + +int +event_Activate(RMON_ENTRY_T * eptr) +{ /* init logTable */ + CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body; + + ROWDATAAPI_set_size(&body->scrlr, + body->scrlr.data_requested, + (u_char)(RMON1_ENTRY_VALID == eptr->status) ); + + return 0; +} + +int +event_Deactivate(RMON_ENTRY_T * eptr) +{ /* free logTable */ + CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body; + + /* + * free data list + */ + ROWDATAAPI_descructor(&body->scrlr); + + return 0; +} + +static int +write_eventControl(int action, u_char * var_val, u_char var_val_type, + size_t var_val_len, u_char * statP, + oid * name, size_t name_len) +{ + long long_temp; + char *char_temp; + int leaf_id, snmp_status; + static int prev_action = COMMIT; + RMON_ENTRY_T *hdr; + CRTL_ENTRY_T *cloned_body; + + switch (action) { + case RESERVE1: + case FREE: + case UNDO: + case ACTION: + case COMMIT: + default: + return ROWAPI_do_another_action(name, eventEntryFirstIndexBegin, + action, &prev_action, + table_ptr, sizeof(CRTL_ENTRY_T)); + + case RESERVE2: + /* + * get values from PDU, check them and save them in the cloned entry + */ + long_temp = name[eventEntryFirstIndexBegin]; + leaf_id = (int) name[eventEntryFirstIndexBegin - 1]; + hdr = ROWAPI_find(table_ptr, long_temp); /* it MUST be OK */ + cloned_body = (CRTL_ENTRY_T *) hdr->tmp; + switch (leaf_id) { + case Leaf_event_index: + return SNMP_ERR_NOTWRITABLE; + case Leaf_event_description: + char_temp = AGMALLOC(1 + MAX_event_description); + if (!char_temp) + return SNMP_ERR_TOOBIG; + snmp_status = AGUTIL_get_string_value(var_val, var_val_type, + var_val_len, + MAX_event_description, + 1, NULL, char_temp); + if (SNMP_ERR_NOERROR != snmp_status) { + AGFREE(char_temp); + return snmp_status; + } + + if (cloned_body->event_description) + AGFREE(cloned_body->event_description); + + cloned_body->event_description = AGSTRDUP(char_temp); + /* + * ag_trace ("rx: event_description=<%s>", cloned_body->event_description); + */ + AGFREE(char_temp); + + break; + case Leaf_event_type: + snmp_status = AGUTIL_get_int_value(var_val, var_val_type, + var_val_len, + EVENT_NONE, + EVENT_LOG_AND_TRAP, + &long_temp); + if (SNMP_ERR_NOERROR != snmp_status) { + return snmp_status; + } + cloned_body->event_type = long_temp; + break; + case Leaf_event_last_time_sent: + return SNMP_ERR_NOTWRITABLE; + case Leaf_event_community: + char_temp = AGMALLOC(1 + MAX_event_community); + if (!char_temp) + return SNMP_ERR_TOOBIG; + snmp_status = AGUTIL_get_string_value(var_val, var_val_type, + var_val_len, + MAX_event_community, + 1, NULL, char_temp); + if (SNMP_ERR_NOERROR != snmp_status) { + AGFREE(char_temp); + return snmp_status; + } + + if (cloned_body->event_community) + AGFREE(cloned_body->event_community); + + cloned_body->event_community = AGSTRDUP(char_temp); + AGFREE(char_temp); + + break; + case Leaf_eventOwner: + if (hdr->new_owner) + AGFREE(hdr->new_owner); + hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);; + if (!hdr->new_owner) + return SNMP_ERR_TOOBIG; + snmp_status = AGUTIL_get_string_value(var_val, var_val_type, + var_val_len, + MAX_OWNERSTRING, + 1, NULL, hdr->new_owner); + if (SNMP_ERR_NOERROR != snmp_status) { + return snmp_status; + } + + break; + case Leaf_eventStatus: + snmp_status = AGUTIL_get_int_value(var_val, var_val_type, + var_val_len, + RMON1_ENTRY_VALID, + RMON1_ENTRY_INVALID, + &long_temp); + if (SNMP_ERR_NOERROR != snmp_status) { + return snmp_status; + } + hdr->new_status = long_temp; + break; + default: + ag_trace("%s:unknown leaf_id=%d\n", table_ptr->name, + (int) leaf_id); + return SNMP_ERR_NOSUCHNAME; + } /* of switch by 'leaf_id' */ + break; + } /* of switch by actions */ + + prev_action = action; + return SNMP_ERR_NOERROR; +} + +unsigned char * +var_eventTable(struct variable *vp, + oid * name, + size_t * length, + int exact, size_t * var_len, WriteMethod ** write_method) +{ + static long long_ret; + static CRTL_ENTRY_T theEntry; + RMON_ENTRY_T *hdr; + + *write_method = write_eventControl; + hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len, + table_ptr, + &theEntry, sizeof(CRTL_ENTRY_T)); + if (!hdr) + return NULL; + + *var_len = sizeof(long); /* default */ + + switch (vp->magic) { + case EVENTINDEX: + long_ret = hdr->ctrl_index; + return (unsigned char *) &long_ret; + case EVENTDESCRIPTION: + if (theEntry.event_description) { + *var_len = strlen(theEntry.event_description); + return (unsigned char *) theEntry.event_description; + } else { + *var_len = 0; + return zero_octet_string; + } + case EVENTTYPE: + long_ret = theEntry.event_type; + return (unsigned char *) &long_ret; + case EVENTCOMMUNITY: + if (theEntry.event_community) { + *var_len = strlen(theEntry.event_community); + return (unsigned char *) theEntry.event_community; + } else { + *var_len = 0; + return zero_octet_string; + } + case EVENTLASTTIMESENT: + long_ret = theEntry.event_last_time_sent; + return (unsigned char *) &long_ret; + case EVENTOWNER: + if (hdr->owner) { + *var_len = strlen(hdr->owner); + return (unsigned char *) hdr->owner; + } else { + *var_len = 0; + return zero_octet_string; + } + case EVENTSTATUS: + long_ret = hdr->status; + return (unsigned char *) &long_ret; + default: + ag_trace("EventControlTable: unknown vp->magic=%d", + (int) vp->magic); + ERROR_MSG(""); + } + return NULL; +} + +static SCROLLER_T * +event_extract_scroller(void *v_body) +{ + CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) v_body; + return &body->scrlr; +} + +unsigned char * +var_logTable(struct variable *vp, + oid * name, + size_t * length, + int exact, size_t * var_len, WriteMethod ** write_method) +{ + static long long_ret; + static DATA_ENTRY_T theEntry; + RMON_ENTRY_T *hdr; + + *write_method = NULL; + hdr = ROWDATAAPI_header_DataEntry(vp, name, length, exact, var_len, + table_ptr, + &event_extract_scroller, + sizeof(DATA_ENTRY_T), &theEntry); + if (!hdr) + return NULL; + + *var_len = sizeof(long); /* default */ + + switch (vp->magic) { + case LOGEVENTINDEX: + long_ret = hdr->ctrl_index; + return (unsigned char *) &long_ret; + case LOGINDEX: + long_ret = theEntry.data_index; + return (unsigned char *) &long_ret; + case LOGTIME: + long_ret = theEntry.log_time; + return (unsigned char *) &long_ret; + case LOGDESCRIPTION: + if (theEntry.log_description) { + *var_len = strlen(theEntry.log_description); + return (unsigned char *) theEntry.log_description; + } else { + *var_len = 0; + return zero_octet_string; + } + default: + ERROR_MSG(""); + } + + return NULL; +} + +/* + * External API section + */ + +static char * +create_explanaition(CRTL_ENTRY_T * evptr, u_char is_rising, + u_long alarm_index, u_long event_index, + oid * alarmed_var, + size_t alarmed_var_length, + u_long value, u_long the_threshold, + u_long sample_type, char *alarm_descr) +{ +#define UNEQ_LENGTH (1 + 11 + 4 + 11 + 1 + 20) + char expl[UNEQ_LENGTH]; + static char c_oid[SPRINT_MAX_LEN]; + size_t sz; + char *descr; + register char *pch; + register char *tmp; + + + snprint_objid(c_oid, sizeof(c_oid)-1, alarmed_var, alarmed_var_length); + c_oid[sizeof(c_oid)-1] = '\0'; + for (pch = c_oid;;) { + tmp = strchr(pch, '.'); + if (!tmp) + break; + if (isdigit(tmp[1]) || '"' == tmp[1]) + break; + pch = tmp + 1; + } + + snprintf(expl, UNEQ_LENGTH, "=%ld %s= %ld :%ld, %ld", + (unsigned long) value, + is_rising ? ">" : "<", + (unsigned long) the_threshold, + (long) alarm_index, (long) event_index); + sz = 3 + strlen(expl) + strlen(pch); + if (alarm_descr) + sz += strlen(alarm_descr); + + descr = AGMALLOC(sz); + if (!descr) { + ag_trace("Can't allocate event description"); + return NULL; + } + + if (alarm_descr) { + strcpy(descr, alarm_descr); + strcat(descr, ":"); + } else + *descr = '\0'; + + strcat(descr, pch); + strcat(descr, expl); + return descr; +} + +static void +event_send_trap(CRTL_ENTRY_T * evptr, u_char is_rising, + u_int alarm_index, + u_int value, u_int the_threshold, + oid * alarmed_var, size_t alarmed_var_length, + u_int sample_type) +{ + static oid objid_snmptrap[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 }; + static oid rmon1_trap_oid[] = { 1, 3, 6, 1, 2, 1, 16, 0, 0 }; + static oid alarm_index_oid[] = + { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 1, 0 }; + static oid alarmed_var_oid[] = + { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 3, 0 }; + static oid sample_type_oid[] = + { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 4, 0 }; + static oid value_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 5, 0 }; + static oid threshold_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 7, 0 }; /* rising case */ + netsnmp_variable_list *var_list = NULL; + + /* + * set the last 'oid' : risingAlarm or fallingAlarm + */ + if (is_rising) { + rmon1_trap_oid[8] = 1; + threshold_oid[10] = 7; + } else { + rmon1_trap_oid[8] = 2; + threshold_oid[10] = 8; + } + alarm_index_oid[11] = alarm_index; + alarmed_var_oid[11] = alarm_index; + sample_type_oid[11] = alarm_index; + value_oid[11] = alarm_index; + threshold_oid[11] = alarm_index; + + /* + * build the var list + */ + snmp_varlist_add_variable(&var_list, objid_snmptrap, + OID_LENGTH(objid_snmptrap), + ASN_OBJECT_ID, (u_char *) rmon1_trap_oid, + sizeof(rmon1_trap_oid)); + snmp_varlist_add_variable(&var_list, alarm_index_oid, + OID_LENGTH(alarm_index_oid), + ASN_INTEGER, (u_char *) &alarm_index, + sizeof(u_int)); + snmp_varlist_add_variable(&var_list, alarmed_var_oid, + OID_LENGTH(alarmed_var_oid), + ASN_OBJECT_ID, (u_char *) alarmed_var, + alarmed_var_length * sizeof(oid)); + snmp_varlist_add_variable(&var_list, sample_type_oid, + OID_LENGTH(sample_type_oid), + ASN_INTEGER, (u_char *) &sample_type, + sizeof(u_int)); + snmp_varlist_add_variable(&var_list, value_oid, + OID_LENGTH(value_oid), + ASN_INTEGER, (u_char *) &value, + sizeof(u_int)); + snmp_varlist_add_variable(&var_list, threshold_oid, + OID_LENGTH(threshold_oid), + ASN_INTEGER, (u_char *) &the_threshold, + sizeof(u_int)); + + send_v2trap(var_list); + ag_trace("rmon trap has been sent"); + snmp_free_varbind(var_list); +} + + +static void +event_save_log(CRTL_ENTRY_T * body, char *event_descr) +{ + register DATA_ENTRY_T *lptr; + + lptr = ROWDATAAPI_locate_new_data(&body->scrlr); + if (!lptr) { + ag_trace("Err: event_save_log:cannot locate ?"); + return; + } + + lptr->log_time = body->event_last_time_sent; + if (lptr->log_description) + AGFREE(lptr->log_description); + lptr->log_description = AGSTRDUP(event_descr); + lptr->data_index = ROWDATAAPI_get_total_number(&body->scrlr); + + /* + * ag_trace ("log has been saved, data_index=%d", (int) lptr->data_index); + */ +} + +int +event_api_send_alarm(u_char is_rising, + u_long alarm_index, + u_long event_index, + oid * alarmed_var, + size_t alarmed_var_length, + u_long sample_type, + u_long value, u_long the_threshold, char *alarm_descr) +{ + RMON_ENTRY_T *eptr; + CRTL_ENTRY_T *evptr; + + if (!event_index) + return SNMP_ERR_NOERROR; + +#if 0 + ag_trace("event_api_send_alarm(%d,%d,%d,'%s')", + (int) is_rising, (int) alarm_index, (int) event_index, + alarm_descr); +#endif + eptr = ROWAPI_find(table_ptr, event_index); + if (!eptr) { + /* + * ag_trace ("event cannot find entry %ld", event_index); + */ + return SNMP_ERR_NOSUCHNAME; + } + + evptr = (CRTL_ENTRY_T *) eptr->body; + evptr->event_last_time_sent = AGUTIL_sys_up_time(); + + + if (EVENT_TRAP == evptr->event_type + || EVENT_LOG_AND_TRAP == evptr->event_type) { + event_send_trap(evptr, is_rising, alarm_index, value, + the_threshold, alarmed_var, alarmed_var_length, + sample_type); + } + + if (EVENT_LOG == evptr->event_type + || EVENT_LOG_AND_TRAP == evptr->event_type) { + register char *explain; + + explain = create_explanaition(evptr, is_rising, + alarm_index, event_index, + alarmed_var, alarmed_var_length, + value, the_threshold, + sample_type, alarm_descr); + /* + * if (explain) ag_trace ("Dbg:'%s'", explain); + */ + event_save_log(evptr, explain); + if (explain) + AGFREE(explain); + } + + return SNMP_ERR_NOERROR; +} + +#if 1 /* debug, but may be used for init. TBD: may be token snmpd.conf ? */ +int +add_event_entry(int ctrl_index, + char *event_description, + EVENT_TYPE_T event_type, char *event_community) +{ + register RMON_ENTRY_T *eptr; + register CRTL_ENTRY_T *body; + int ierr; + + ierr = ROWAPI_new(table_ptr, ctrl_index); + if (ierr) { + ag_trace("ROWAPI_new failed with %d", ierr); + return ierr; + } + + eptr = ROWAPI_find(table_ptr, ctrl_index); + if (!eptr) { + ag_trace("ROWAPI_find failed"); + return -4; + } + + body = (CRTL_ENTRY_T *) eptr->body; + + /* + * set parameters + */ + + if (event_description) { + if (body->event_description) + AGFREE(body->event_description); + body->event_description = AGSTRDUP(event_description); + } + + if (event_community) { + if (body->event_community) + AGFREE(body->event_community); + body->event_community = AGSTRDUP(event_community); + } + + body->event_type = event_type; + + eptr->new_status = RMON1_ENTRY_VALID; + ierr = ROWAPI_commit(table_ptr, ctrl_index); + if (ierr) { + ag_trace("ROWAPI_commit failed with %d", ierr); + } + + return ierr; +} +#endif + +/* + * Registration & Initializatio section + */ + +oid eventTable_variables_oid[] = + { 1, 3, 6, 1, 2, 1, 16, 9, 1 }; +oid logTable_variables_oid[] = { 1, 3, 6, 1, 2, 1, 16, 9, 2 }; + +struct variable2 eventTable_variables[] = { + /* + * magic number , variable type, ro/rw , callback fn , L, oidsuffix + */ + {EVENTINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, + var_eventTable, 2, {1, 1}}, + {EVENTDESCRIPTION, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE, + var_eventTable, 2, {1, 2}}, + {EVENTTYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE, + var_eventTable, 2, {1, 3}}, + {EVENTCOMMUNITY, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE, + var_eventTable, 2, {1, 4}}, + {EVENTLASTTIMESENT, ASN_TIMETICKS, NETSNMP_OLDAPI_RONLY, + var_eventTable, 2, {1, 5}}, + {EVENTOWNER, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE, + var_eventTable, 2, {1, 6}}, + {EVENTSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE, + var_eventTable, 2, {1, 7}} +}; + +struct variable2 logTable_variables[] = { + /* + * magic number , variable type, ro/rw , callback fn , L, oidsuffix + */ + {LOGEVENTINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, + var_logTable, 2, {1, 1}}, + {LOGINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, + var_logTable, 2, {1, 2}}, + {LOGTIME, ASN_TIMETICKS, NETSNMP_OLDAPI_RONLY, + var_logTable, 2, {1, 3}}, + {LOGDESCRIPTION, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, + var_logTable, 2, {1, 4}} + +}; + +void +init_event(void) +{ + REGISTER_MIB("eventTable", eventTable_variables, variable2, + eventTable_variables_oid); + REGISTER_MIB("logTable", logTable_variables, variable2, + logTable_variables_oid); + + ROWAPI_init_table(&EventCtrlTable, "Event", 0, &event_Create, &event_Clone, &event_Delete, NULL, /* &event_Validate, */ + &event_Activate, &event_Deactivate, &event_Copy); +#if 0 + add_event_entry(3, "Alarm", EVENT_LOG_AND_TRAP, NULL); + /* + * add_event_entry (5, ">=", EVENT_LOG_AND_TRAP, NULL); + */ +#endif +} |