| /*--------------------------------------------------------------------------+ |
| | Edition History: | |
| | # Date Comments By | |
| | --- -------- -------------------------------------------------------- --- | |
| | 1 07/05/18 Created. emi | |
| +--------------------------------------------------------------------------*/ |
| /* |
| * Note: this file originally auto-generated by mib2c using |
| * : mib2c.table_data.conf,v 1.11.2.1 2006/01/11 15:17:47 dts12 Exp $ |
| */ |
| |
| #include <net-snmp/net-snmp-config.h> |
| #include <net-snmp/net-snmp-features.h> |
| #include <net-snmp/net-snmp-includes.h> |
| #include <net-snmp/agent/net-snmp-agent-includes.h> |
| #include "utilities/iquery.h" |
| #include "alarmTable.h" |
| |
| netsnmp_feature_require(iquery) |
| netsnmp_feature_require(query_set_default_session) |
| netsnmp_feature_require(table_tdata) |
| netsnmp_feature_require(check_vb_type_and_max_size) |
| netsnmp_feature_require(table_tdata_extract_table) |
| #ifndef NETSNMP_NO_WRITE_SUPPORT |
| netsnmp_feature_require(table_tdata_insert_row) |
| netsnmp_feature_require(iquery_pdu_session) |
| #endif /* NETSNMP_NO_WRITE_SUPPORT */ |
| |
| /** Initializes the alarmTable module */ |
| void |
| init_alarmTable(void) |
| { |
| /* |
| * here we initialize all the tables we're planning on supporting |
| */ |
| initialize_table_alarmTable(); |
| } |
| |
| /** Initialize the alarmTable table by defining its contents and how it's structured */ |
| void |
| initialize_table_alarmTable(void) |
| { |
| static oid alarmTable_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1 }; |
| size_t alarmTable_oid_len = OID_LENGTH(alarmTable_oid); |
| netsnmp_handler_registration *reg; |
| netsnmp_tdata *table_data; |
| netsnmp_table_registration_info *table_info; |
| |
| DEBUGMSGTL(( "rmon:alarmTable", "initialize_table_alarmTable called.\n")); |
| reg = |
| netsnmp_create_handler_registration("alarmTable", |
| alarmTable_handler, |
| alarmTable_oid, |
| alarmTable_oid_len, |
| HANDLER_CAN_RWRITE); |
| |
| table_data = netsnmp_tdata_create_table("alarmTable", 0); |
| table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); |
| netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, /* index: alarmIndex */ |
| 0); |
| |
| table_info->min_column = COLUMN_ALARMINDEX; |
| table_info->max_column = COLUMN_ALARMSTATUS; |
| |
| netsnmp_tdata_register(reg, table_data, table_info); |
| |
| /* |
| * Initialise the contents of the table here |
| */ |
| } |
| |
| extern 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, const char *alarm_descr); |
| |
| #define ALARM_STR1_LEN 32 |
| typedef enum { |
| RMON1_ENTRY_VALID = 1, |
| RMON1_ENTRY_CREATE_REQUEST, |
| RMON1_ENTRY_UNDER_CREATION, |
| RMON1_ENTRY_INVALID |
| } RMON1_ENTRY_STATUS_T; |
| |
| typedef enum { |
| SAMPLE_TYPE_ABSOLUTE = |
| 1, |
| SAMPLE_TYPE_DELTE |
| } SAMPLE_TYPE_T; |
| |
| typedef enum { |
| ALARM_NOTHING = |
| 0, |
| ALARM_RISING, |
| ALARM_FALLING, |
| ALARM_BOTH |
| } ALARM_TYPE_T; |
| /* |
| * Typical data structure for a row entry |
| */ |
| struct alarmTable_entry { |
| /* |
| * Index values |
| */ |
| long alarmIndex; |
| |
| /* |
| * Column values |
| */ |
| long alarmInterval; |
| long old_alarmInterval; |
| oid alarmVariable[ALARM_STR1_LEN]; |
| size_t alarmVariable_len; |
| oid old_alarmVariable[ALARM_STR1_LEN]; |
| size_t old_alarmVariable_len; |
| long alarmSampleType; |
| long old_alarmSampleType; |
| long alarmValue; |
| long alarmStartupAlarm; |
| long old_alarmStartupAlarm; |
| long alarmRisingThreshold; |
| long old_alarmRisingThreshold; |
| long alarmFallingThreshold; |
| long old_alarmFallingThreshold; |
| long alarmRisingEventIndex; |
| long old_alarmRisingEventIndex; |
| long alarmFallingEventIndex; |
| long old_alarmFallingEventIndex; |
| char alarmOwner[ALARM_STR1_LEN]; |
| size_t alarmOwner_len; |
| char old_alarmOwner[ALARM_STR1_LEN]; |
| size_t old_alarmOwner_len; |
| long alarmStatus; |
| long old_alarmStatus; |
| |
| int valid; |
| unsigned int alarm_reg; |
| netsnmp_session *session; |
| u_long last_abs_value; |
| ALARM_TYPE_T prev_alarm; /* NOTHING | RISING | FALLING */ |
| }; |
| |
| |
| void |
| alarmTable_run( unsigned int reg, void *clientarg) |
| { |
| struct alarmTable_entry *entry = (struct alarmTable_entry *)clientarg; |
| netsnmp_variable_list *var; |
| u_long new_value; |
| int rc; |
| |
| if (!entry) { |
| snmp_alarm_unregister( reg ); |
| return; |
| } |
| /* |
| * Retrieve the requested MIB value(s)... |
| */ |
| DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_run called\n")); |
| var = (netsnmp_variable_list *)SNMP_MALLOC_TYPEDEF( netsnmp_variable_list ); |
| if (!var) { |
| snmp_log(LOG_ERR,"failed to create alarmTable query varbind"); |
| return; |
| } |
| snmp_set_var_objid( var, entry->alarmVariable, |
| entry->alarmVariable_len ); |
| |
| rc = netsnmp_query_get( var, entry->session ); |
| if ( rc != SNMP_ERR_NOERROR ) { |
| DEBUGMSGTL(( "rmon:alarmTable", "alarmVariable query failed (%d)\n", rc)); |
| snmp_free_varbind(var); |
| return; |
| } |
| |
| switch (var->type) { |
| case ASN_INTEGER: |
| case ASN_COUNTER: |
| case ASN_TIMETICKS: |
| case ASN_GAUGE: |
| case ASN_COUNTER64: |
| new_value = *var->val.integer; |
| break; |
| default: |
| DEBUGMSGTL(("rmon:alarmTable", "invalid type (%d)\n", var->type)); |
| snmp_free_varbind(var); |
| return ; |
| } |
| |
| DEBUGMSGTL(("rmon:alarmTable", "alarmIndex.%ld last value (%ld)\n", entry->alarmIndex, entry->last_abs_value)); |
| DEBUGMSGTL(("rmon:alarmTable", "alarmIndex.%ld new_value (%ld)\n", entry->alarmIndex, new_value)); |
| |
| entry->alarmValue = (SAMPLE_TYPE_ABSOLUTE == entry->alarmSampleType) ? |
| new_value : new_value - entry->last_abs_value; |
| entry->last_abs_value = new_value; |
| |
| if (ALARM_RISING != entry->prev_alarm && |
| entry->alarmValue >= entry->alarmRisingThreshold) { |
| if (SNMP_ERR_NOERROR == event_api_send_alarm(1, entry->alarmIndex, |
| entry->alarmRisingEventIndex, |
| entry->alarmVariable, |
| entry->alarmVariable_len, |
| entry->alarmSampleType, |
| entry->alarmValue, |
| entry->alarmRisingThreshold, |
| "Rising")) |
| entry->prev_alarm = ALARM_RISING; |
| else |
| snmp_log(LOG_ERR,"failed to send rising alarm\n"); |
| } |
| else if (ALARM_FALLING != entry->prev_alarm && |
| entry->alarmValue <= entry->alarmFallingThreshold) { |
| if (SNMP_ERR_NOERROR == event_api_send_alarm(0, entry->alarmIndex, |
| entry->alarmFallingEventIndex, |
| entry->alarmVariable, |
| entry->alarmVariable_len, |
| entry->alarmSampleType, |
| entry->alarmValue, |
| entry->alarmFallingThreshold, |
| "Falling")) |
| entry->prev_alarm = ALARM_FALLING; |
| else |
| snmp_log(LOG_ERR,"failed to send falling alarm\n"); |
| } |
| else |
| DEBUGMSGTL(("rmon:alarmTable", "no alarm sent\n")); |
| |
| snmp_free_varbind(var); |
| } |
| |
| void |
| alarmTable_enable( struct alarmTable_entry *entry ) |
| { |
| if (!entry) |
| return; |
| |
| DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_enable called.\n")); |
| if (entry->alarm_reg) { |
| snmp_alarm_unregister( entry->alarm_reg ); |
| entry->alarm_reg = 0; |
| } |
| |
| if (entry->alarmInterval) { |
| /* |
| * register once to run ASAP, and another to run |
| * at the trigger frequency |
| */ |
| snmp_alarm_register(0, 0, alarmTable_run, entry ); |
| entry->alarm_reg = snmp_alarm_register( |
| entry->alarmInterval, SA_REPEAT, |
| alarmTable_run, entry ); |
| } |
| } |
| |
| void |
| alarmTable_disable( struct alarmTable_entry *entry ) |
| { |
| if (!entry) |
| return; |
| |
| DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_disable called.\n")); |
| if (entry->alarm_reg) { |
| snmp_alarm_unregister( entry->alarm_reg ); |
| entry->alarm_reg = 0; |
| /* XXX - perhaps release any previous results */ |
| } |
| } |
| |
| /* |
| * create a new row in the table |
| */ |
| netsnmp_tdata_row * |
| alarmTable_createEntry(netsnmp_tdata * table_data, long alarmIndex) |
| { |
| struct alarmTable_entry *entry; |
| netsnmp_tdata_row *row; |
| |
| DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_createEntry called.\n")); |
| entry = SNMP_MALLOC_TYPEDEF(struct alarmTable_entry); |
| if (!entry) |
| return NULL; |
| |
| row = netsnmp_tdata_create_row(); |
| if (!row) { |
| SNMP_FREE(entry); |
| return NULL; |
| } |
| row->data = entry; |
| entry->alarmIndex = alarmIndex; |
| entry->alarmInterval = 1; |
| entry->alarmSampleType = SAMPLE_TYPE_ABSOLUTE; |
| entry->alarmStartupAlarm = ALARM_BOTH; |
| entry->alarmRisingThreshold = 10; |
| entry->alarmFallingThreshold = 5; |
| entry->alarmRisingEventIndex = alarmIndex; |
| entry->alarmFallingEventIndex = alarmIndex; |
| entry->prev_alarm = ALARM_NOTHING; |
| netsnmp_tdata_row_add_index(row, ASN_INTEGER, |
| &(entry->alarmIndex), |
| sizeof(entry->alarmIndex)); |
| netsnmp_tdata_add_row(table_data, row); |
| return row; |
| } |
| |
| /* |
| * remove a row from the table |
| */ |
| void |
| alarmTable_removeEntry(netsnmp_tdata * table_data, netsnmp_tdata_row * row) |
| { |
| struct alarmTable_entry *entry; |
| |
| DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_removeEntry called.\n")); |
| if (!row) |
| return; /* Nothing to remove */ |
| entry = (struct alarmTable_entry *) |
| netsnmp_tdata_remove_and_delete_row(table_data, row); |
| if (entry) { |
| alarmTable_disable(entry); |
| SNMP_FREE(entry); /* XXX - release any other internal resources */ |
| } |
| } |
| |
| |
| /** handles requests for the alarmTable table */ |
| int |
| alarmTable_handler(netsnmp_mib_handler *handler, |
| netsnmp_handler_registration *reginfo, |
| netsnmp_agent_request_info *reqinfo, |
| netsnmp_request_info *requests) |
| { |
| netsnmp_request_info *request; |
| netsnmp_table_request_info *table_info; |
| netsnmp_tdata *table_data; |
| netsnmp_tdata_row *table_row; |
| struct alarmTable_entry *table_entry; |
| int ret; |
| netsnmp_session *sess = NULL; |
| char *secName; |
| |
| DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_handler called.\n")); |
| switch (reqinfo->mode) { |
| /* |
| * Read-support (also covers GetNext requests) |
| */ |
| case MODE_GET: |
| for (request = requests; request; request = request->next) { |
| table_entry = (struct alarmTable_entry *) |
| netsnmp_tdata_extract_entry(request); |
| table_info = netsnmp_extract_table_info(request); |
| |
| switch (table_info->colnum) { |
| case COLUMN_ALARMINDEX: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry->alarmIndex); |
| break; |
| case COLUMN_ALARMINTERVAL: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry->alarmInterval); |
| break; |
| case COLUMN_ALARMVARIABLE: |
| snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, |
| (u_char *) table_entry-> |
| alarmVariable, |
| table_entry->alarmVariable_len * |
| sizeof(oid)); |
| break; |
| case COLUMN_ALARMSAMPLETYPE: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry->alarmSampleType); |
| break; |
| case COLUMN_ALARMVALUE: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry->alarmValue); |
| break; |
| case COLUMN_ALARMSTARTUPALARM: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry->alarmStartupAlarm); |
| break; |
| case COLUMN_ALARMRISINGTHRESHOLD: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry-> |
| alarmRisingThreshold); |
| break; |
| case COLUMN_ALARMFALLINGTHRESHOLD: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry-> |
| alarmFallingThreshold); |
| break; |
| case COLUMN_ALARMRISINGEVENTINDEX: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry-> |
| alarmRisingEventIndex); |
| break; |
| case COLUMN_ALARMFALLINGEVENTINDEX: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry-> |
| alarmFallingEventIndex); |
| break; |
| case COLUMN_ALARMOWNER: |
| snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, |
| (u_char *) table_entry-> |
| alarmOwner, |
| table_entry->alarmOwner_len); |
| break; |
| case COLUMN_ALARMSTATUS: |
| snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, |
| table_entry->alarmStatus); |
| break; |
| } |
| } |
| break; |
| |
| /* |
| * Write-support |
| */ |
| case MODE_SET_RESERVE1: |
| for (request = requests; request; request = request->next) { |
| table_entry = (struct alarmTable_entry *) |
| netsnmp_tdata_extract_entry(request); |
| table_info = netsnmp_extract_table_info(request); |
| |
| switch (table_info->colnum) { |
| case COLUMN_ALARMINTERVAL: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| case COLUMN_ALARMVARIABLE: |
| /* |
| * or possibly 'netsnmp_check_vb_type_and_max_size' |
| */ |
| break; |
| case COLUMN_ALARMSAMPLETYPE: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| case COLUMN_ALARMSTARTUPALARM: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| case COLUMN_ALARMRISINGTHRESHOLD: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| case COLUMN_ALARMFALLINGTHRESHOLD: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| case COLUMN_ALARMRISINGEVENTINDEX: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| case COLUMN_ALARMFALLINGEVENTINDEX: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| case COLUMN_ALARMOWNER: |
| /* |
| * or possibly 'netsnmp_check_vb_type_and_max_size' |
| */ |
| break; |
| case COLUMN_ALARMSTATUS: |
| /* |
| * or possibly 'netsnmp_check_vb_int_range' |
| */ |
| ret = netsnmp_check_vb_int(request->requestvb); |
| if (ret != SNMP_ERR_NOERROR) { |
| netsnmp_set_request_error(reqinfo, request, ret); |
| return SNMP_ERR_NOERROR; |
| } |
| break; |
| default: |
| netsnmp_set_request_error(reqinfo, request, |
| SNMP_ERR_NOTWRITABLE); |
| return SNMP_ERR_NOERROR; |
| } |
| } |
| break; |
| |
| case MODE_SET_RESERVE2: |
| for (request = requests; request; request = request->next) { |
| table_row = netsnmp_tdata_extract_row(request); |
| table_data = netsnmp_tdata_extract_table(request); |
| table_info = netsnmp_extract_table_info(request); |
| |
| switch (table_info->colnum) { |
| case COLUMN_ALARMINTERVAL: |
| case COLUMN_ALARMVARIABLE: |
| case COLUMN_ALARMSAMPLETYPE: |
| case COLUMN_ALARMSTARTUPALARM: |
| case COLUMN_ALARMRISINGTHRESHOLD: |
| case COLUMN_ALARMFALLINGTHRESHOLD: |
| case COLUMN_ALARMRISINGEVENTINDEX: |
| case COLUMN_ALARMFALLINGEVENTINDEX: |
| case COLUMN_ALARMOWNER: |
| case COLUMN_ALARMSTATUS: |
| if (!table_row) { |
| table_row = |
| alarmTable_createEntry(table_data, |
| *table_info->indexes->val. |
| integer); |
| if (table_row) { |
| netsnmp_insert_tdata_row(request, table_row); |
| } else { |
| netsnmp_set_request_error(reqinfo, request, |
| SNMP_ERR_RESOURCEUNAVAILABLE); |
| return SNMP_ERR_NOERROR; |
| } |
| } |
| break; |
| } |
| } |
| break; |
| |
| case MODE_SET_FREE: |
| for (request = requests; request; request = request->next) { |
| table_entry = (struct alarmTable_entry *) |
| netsnmp_tdata_extract_entry(request); |
| table_row = netsnmp_tdata_extract_row(request); |
| table_data = netsnmp_tdata_extract_table(request); |
| table_info = netsnmp_extract_table_info(request); |
| |
| switch (table_info->colnum) { |
| case COLUMN_ALARMINTERVAL: |
| case COLUMN_ALARMVARIABLE: |
| case COLUMN_ALARMSAMPLETYPE: |
| case COLUMN_ALARMSTARTUPALARM: |
| case COLUMN_ALARMRISINGTHRESHOLD: |
| case COLUMN_ALARMFALLINGTHRESHOLD: |
| case COLUMN_ALARMRISINGEVENTINDEX: |
| case COLUMN_ALARMFALLINGEVENTINDEX: |
| case COLUMN_ALARMOWNER: |
| case COLUMN_ALARMSTATUS: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } |
| break; |
| } |
| } |
| break; |
| |
| case MODE_SET_ACTION: |
| for (request = requests; request; request = request->next) { |
| table_entry = (struct alarmTable_entry *) |
| netsnmp_tdata_extract_entry(request); |
| table_info = netsnmp_extract_table_info(request); |
| |
| switch (table_info->colnum) { |
| case COLUMN_ALARMINTERVAL: |
| table_entry->old_alarmInterval = |
| table_entry->alarmInterval; |
| table_entry->alarmInterval = |
| *request->requestvb->val.integer; |
| break; |
| case COLUMN_ALARMVARIABLE: |
| table_entry->alarmVariable_len = |
| request->requestvb->val_len / sizeof(oid); |
| memset(table_entry->alarmVariable, 0, |
| sizeof(table_entry->alarmVariable)); |
| memcpy(table_entry->alarmVariable, |
| request->requestvb->val.objid, |
| request->requestvb->val_len); |
| break; |
| case COLUMN_ALARMSAMPLETYPE: |
| table_entry->old_alarmSampleType = |
| table_entry->alarmSampleType; |
| table_entry->alarmSampleType = |
| *request->requestvb->val.integer; |
| break; |
| case COLUMN_ALARMSTARTUPALARM: |
| table_entry->old_alarmStartupAlarm = |
| table_entry->alarmStartupAlarm; |
| table_entry->alarmStartupAlarm = |
| *request->requestvb->val.integer; |
| break; |
| case COLUMN_ALARMRISINGTHRESHOLD: |
| table_entry->old_alarmRisingThreshold = |
| table_entry->alarmRisingThreshold; |
| table_entry->alarmRisingThreshold = |
| *request->requestvb->val.integer; |
| break; |
| case COLUMN_ALARMFALLINGTHRESHOLD: |
| table_entry->old_alarmFallingThreshold = |
| table_entry->alarmFallingThreshold; |
| table_entry->alarmFallingThreshold = |
| *request->requestvb->val.integer; |
| break; |
| case COLUMN_ALARMRISINGEVENTINDEX: |
| table_entry->old_alarmRisingEventIndex = |
| table_entry->alarmRisingEventIndex; |
| table_entry->alarmRisingEventIndex = |
| *request->requestvb->val.integer; |
| break; |
| case COLUMN_ALARMFALLINGEVENTINDEX: |
| table_entry->old_alarmFallingEventIndex = |
| table_entry->alarmFallingEventIndex; |
| table_entry->alarmFallingEventIndex = |
| *request->requestvb->val.integer; |
| break; |
| case COLUMN_ALARMOWNER: |
| memcpy(table_entry->old_alarmOwner, |
| table_entry->alarmOwner, |
| sizeof(table_entry->alarmOwner)); |
| table_entry->old_alarmOwner_len = |
| table_entry->alarmOwner_len; |
| memset(table_entry->alarmOwner, 0, |
| sizeof(table_entry->alarmOwner)); |
| memcpy(table_entry->alarmOwner, |
| request->requestvb->val.string, |
| request->requestvb->val_len); |
| table_entry->alarmOwner_len = request->requestvb->val_len; |
| break; |
| case COLUMN_ALARMSTATUS: |
| table_entry->old_alarmStatus = table_entry->alarmStatus; |
| table_entry->alarmStatus = |
| *request->requestvb->val.integer; |
| break; |
| } |
| } |
| break; |
| |
| case MODE_SET_UNDO: |
| for (request = requests; request; request = request->next) { |
| table_entry = (struct alarmTable_entry *) |
| netsnmp_tdata_extract_entry(request); |
| table_row = netsnmp_tdata_extract_row(request); |
| table_data = netsnmp_tdata_extract_table(request); |
| table_info = netsnmp_extract_table_info(request); |
| |
| switch (table_info->colnum) { |
| case COLUMN_ALARMINTERVAL: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmInterval = |
| table_entry->old_alarmInterval; |
| table_entry->old_alarmInterval = 0; |
| } |
| break; |
| case COLUMN_ALARMVARIABLE: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| memcpy(table_entry->alarmVariable, |
| table_entry->old_alarmVariable, |
| sizeof(table_entry->alarmVariable)); |
| memset(table_entry->old_alarmVariable, 0, |
| sizeof(table_entry->alarmVariable)); |
| table_entry->alarmVariable_len = |
| table_entry->old_alarmVariable_len; |
| } |
| break; |
| case COLUMN_ALARMSAMPLETYPE: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmSampleType = |
| table_entry->old_alarmSampleType; |
| table_entry->old_alarmSampleType = 0; |
| } |
| break; |
| case COLUMN_ALARMSTARTUPALARM: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmStartupAlarm = |
| table_entry->old_alarmStartupAlarm; |
| table_entry->old_alarmStartupAlarm = 0; |
| } |
| break; |
| case COLUMN_ALARMRISINGTHRESHOLD: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmRisingThreshold = |
| table_entry->old_alarmRisingThreshold; |
| table_entry->old_alarmRisingThreshold = 0; |
| } |
| break; |
| case COLUMN_ALARMFALLINGTHRESHOLD: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmFallingThreshold = |
| table_entry->old_alarmFallingThreshold; |
| table_entry->old_alarmFallingThreshold = 0; |
| } |
| break; |
| case COLUMN_ALARMRISINGEVENTINDEX: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmRisingEventIndex = |
| table_entry->old_alarmRisingEventIndex; |
| table_entry->old_alarmRisingEventIndex = 0; |
| } |
| break; |
| case COLUMN_ALARMFALLINGEVENTINDEX: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmFallingEventIndex = |
| table_entry->old_alarmFallingEventIndex; |
| table_entry->old_alarmFallingEventIndex = 0; |
| } |
| break; |
| case COLUMN_ALARMOWNER: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| memcpy(table_entry->alarmOwner, |
| table_entry->old_alarmOwner, |
| sizeof(table_entry->alarmOwner)); |
| memset(table_entry->old_alarmOwner, 0, |
| sizeof(table_entry->alarmOwner)); |
| table_entry->alarmOwner_len = |
| table_entry->old_alarmOwner_len; |
| } |
| break; |
| case COLUMN_ALARMSTATUS: |
| if (table_entry && !table_entry->valid) { |
| alarmTable_removeEntry(table_data, table_row); |
| } else { |
| table_entry->alarmStatus = |
| table_entry->old_alarmStatus; |
| table_entry->old_alarmStatus = 0; |
| } |
| break; |
| } |
| } |
| break; |
| |
| case MODE_SET_COMMIT: |
| for (request = requests; request; request = request->next) { |
| table_entry = (struct alarmTable_entry *) |
| netsnmp_tdata_extract_entry(request); |
| table_info = netsnmp_extract_table_info(request); |
| |
| switch (table_info->colnum) { |
| case COLUMN_ALARMINTERVAL: |
| case COLUMN_ALARMVARIABLE: |
| case COLUMN_ALARMSAMPLETYPE: |
| case COLUMN_ALARMSTARTUPALARM: |
| case COLUMN_ALARMRISINGTHRESHOLD: |
| case COLUMN_ALARMFALLINGTHRESHOLD: |
| case COLUMN_ALARMRISINGEVENTINDEX: |
| case COLUMN_ALARMFALLINGEVENTINDEX: |
| case COLUMN_ALARMOWNER: |
| if (table_entry && !table_entry->valid) { |
| table_entry->valid = 1; |
| } |
| break; |
| case COLUMN_ALARMSTATUS: |
| switch (*request->requestvb->val.integer) { |
| case RMON1_ENTRY_VALID: |
| alarmTable_enable( table_entry ); |
| break; |
| case RMON1_ENTRY_UNDER_CREATION: |
| alarmTable_disable( table_entry ); |
| #if 0 |
| table_entry->session = (netsnmp_session *) |
| netsnmp_iquery_pdu_session(reqinfo->asp->pdu); |
| #else |
| secName = netsnmp_ds_get_string(NETSNMP_DS_APPLICATION_ID, |
| NETSNMP_DS_AGENT_INTERNAL_SECNAME); |
| if (secName) { |
| sess = netsnmp_iquery_user_session(secName); |
| netsnmp_query_set_default_session(sess); |
| DEBUGMSGTL(("rmon:alarmTable", "user name %s\n", secName)); |
| } else { |
| snmp_log(LOG_ERR, "user name %s not found\n", secName); |
| config_perror("Unknown user name\n"); |
| } |
| |
| if (NULL == sess) { |
| sess = netsnmp_query_get_default_session(); |
| if (NULL == sess) { |
| config_perror |
| ("You must specify a default user name using the agentSecName token\n"); |
| return SNMP_ERR_NOERROR; |
| } |
| } |
| #endif |
| break; |
| case RMON1_ENTRY_INVALID: |
| table_row = netsnmp_tdata_extract_row(request); |
| table_data = netsnmp_tdata_extract_table(request); |
| alarmTable_removeEntry(table_data, table_row); |
| } |
| break; |
| } |
| } |
| break; |
| } |
| return SNMP_ERR_NOERROR; |
| } |
