| /************************************************************** |
| * 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> |
| |
| #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 <net-snmp/net-snmp-includes.h> |
| #include <net-snmp/agent/net-snmp-agent-includes.h> |
| |
| #include "history.h" |
| |
| /* |
| * Implementation headers |
| */ |
| #include "agutil_api.h" |
| #include "row_api.h" |
| |
| /* |
| * File scope definitions section |
| */ |
| |
| #define historyControlEntryFirstIndexBegin 11 |
| |
| #define CTRL_INDEX 3 |
| #define CTRL_DATASOURCE 4 |
| #define CTRL_BUCKETSREQUESTED 5 |
| #define CTRL_BUCKETSGRANTED 6 |
| #define CTRL_INTERVAL 7 |
| #define CTRL_OWNER 8 |
| #define CTRL_STATUS 9 |
| |
| #define DATA_INDEX 3 |
| #define DATA_SAMPLEINDEX 4 |
| #define DATA_INTERVALSTART 5 |
| #define DATA_DROPEVENTS 6 |
| #define DATA_OCTETS 7 |
| #define DATA_PKTS 8 |
| #define DATA_BROADCASTPKTS 9 |
| #define DATA_MULTICASTPKTS 10 |
| #define DATA_CRCALIGNERRORS 11 |
| #define DATA_UNDERSIZEPKTS 12 |
| #define DATA_OVERSIZEPKTS 13 |
| #define DATA_FRAGMENTS 14 |
| #define DATA_JABBERS 15 |
| #define DATA_COLLISIONS 16 |
| #define DATA_UTILIZATION 17 |
| |
| /* |
| * defaults & limitations |
| */ |
| |
| #define MAX_BUCKETS_IN_CRTL_ENTRY 50 |
| #define HIST_DEF_BUCK_REQ 50 |
| #define HIST_DEF_INTERVAL 1800 |
| static VAR_OID_T DEFAULT_DATA_SOURCE = { 11, /* ifIndex.1 */ |
| {1, 3, 6, 1, 2, 1, 2, 2, 1, 1, 1} |
| }; |
| |
| typedef struct data_struct_t { |
| struct data_struct_t *next; |
| u_long data_index; |
| u_long start_interval; |
| u_long utilization; |
| ETH_STATS_T EthData; |
| } DATA_ENTRY_T; |
| |
| typedef struct { |
| u_long interval; |
| u_long timer_id; |
| VAR_OID_T data_source; |
| |
| u_long coeff; |
| DATA_ENTRY_T previous_bucket; |
| SCROLLER_T scrlr; |
| |
| } CRTL_ENTRY_T; |
| |
| static TABLE_DEFINTION_T HistoryCtrlTable; |
| static TABLE_DEFINTION_T *table_ptr = &HistoryCtrlTable; |
| |
| /* |
| * Main section |
| */ |
| |
| # define Leaf_historyControlDataSource 2 |
| # define Leaf_historyControlBucketsRequested 3 |
| # define Leaf_historyControlInterval 5 |
| # define Leaf_historyControlOwner 6 |
| # define Leaf_historyControlStatus 7 |
| # define MIN_historyControlBucketsRequested 1 |
| # define MAX_historyControlBucketsRequested 65535 |
| # define MIN_historyControlInterval 1 |
| # define MAX_historyControlInterval 3600 |
| |
| static int |
| write_historyControl(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; |
| int leaf_id, snmp_status; |
| static int prev_action = COMMIT; |
| RMON_ENTRY_T *hdr; |
| CRTL_ENTRY_T *cloned_body; |
| CRTL_ENTRY_T *body; |
| |
| switch (action) { |
| case RESERVE1: |
| case FREE: |
| case UNDO: |
| case ACTION: |
| case COMMIT: |
| default: |
| return ROWAPI_do_another_action(name, |
| historyControlEntryFirstIndexBegin, |
| 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[historyControlEntryFirstIndexBegin]; |
| leaf_id = (int) name[historyControlEntryFirstIndexBegin - 1]; |
| hdr = ROWAPI_find(table_ptr, long_temp); /* it MUST be OK */ |
| cloned_body = (CRTL_ENTRY_T *) hdr->tmp; |
| body = (CRTL_ENTRY_T *) hdr->body; |
| switch (leaf_id) { |
| case Leaf_historyControlDataSource: |
| snmp_status = AGUTIL_get_oid_value(var_val, var_val_type, |
| var_val_len, |
| &cloned_body->data_source); |
| if (SNMP_ERR_NOERROR != snmp_status) { |
| ag_trace("can't browse historyControlDataSource"); |
| return snmp_status; |
| } |
| if (RMON1_ENTRY_UNDER_CREATION != hdr->status && |
| snmp_oid_compare(cloned_body->data_source.objid, |
| cloned_body->data_source.length, |
| body->data_source.objid, |
| body->data_source.length)) { |
| ag_trace |
| ("can't change historyControlDataSource - not Creation"); |
| return SNMP_ERR_BADVALUE; |
| } |
| break; |
| case Leaf_historyControlBucketsRequested: |
| snmp_status = AGUTIL_get_int_value(var_val, var_val_type, |
| var_val_len, |
| MIN_historyControlBucketsRequested, |
| MAX_historyControlBucketsRequested, |
| (long *) &cloned_body->scrlr. |
| data_requested); |
| if (SNMP_ERR_NOERROR != snmp_status) { |
| return snmp_status; |
| } |
| #if 0 |
| if (RMON1_ENTRY_UNDER_CREATION != hdr->status && |
| cloned_body->scrlr.data_requested != |
| body->scrlr.data_requested) |
| return SNMP_ERR_BADVALUE; |
| #endif |
| break; |
| case Leaf_historyControlInterval: |
| snmp_status = AGUTIL_get_int_value(var_val, var_val_type, |
| var_val_len, |
| MIN_historyControlInterval, |
| MAX_historyControlInterval, |
| (long *) &cloned_body->interval); |
| if (SNMP_ERR_NOERROR != snmp_status) { |
| return snmp_status; |
| } |
| #if 0 |
| if (RMON1_ENTRY_UNDER_CREATION != hdr->status && |
| cloned_body->interval != body->interval) |
| return SNMP_ERR_BADVALUE; |
| #endif |
| break; |
| case Leaf_historyControlOwner: |
| 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_historyControlStatus: |
| 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; |
| } |
| |
| /* |
| * var_historyControlTable(): |
| */ |
| unsigned char * |
| var_historyControlTable(struct variable *vp, |
| oid * name, |
| size_t * length, |
| int exact, |
| size_t * var_len, WriteMethod ** write_method) |
| { |
| static unsigned char zero_octet_string[1]; |
| static long long_ret; |
| static CRTL_ENTRY_T theEntry; |
| RMON_ENTRY_T *hdr; |
| |
| *write_method = write_historyControl; |
| 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 CTRL_INDEX: |
| long_ret = hdr->ctrl_index; |
| return (unsigned char *) &long_ret; |
| |
| case CTRL_DATASOURCE: |
| *var_len = sizeof(oid) * theEntry.data_source.length; |
| return (unsigned char *) theEntry.data_source.objid; |
| |
| case CTRL_BUCKETSREQUESTED: |
| long_ret = theEntry.scrlr.data_requested; |
| return (unsigned char *) &long_ret; |
| |
| case CTRL_BUCKETSGRANTED: |
| |
| long_ret = theEntry.scrlr.data_granted; |
| return (unsigned char *) &long_ret; |
| |
| case CTRL_INTERVAL: |
| long_ret = theEntry.interval; |
| return (unsigned char *) &long_ret; |
| |
| case CTRL_OWNER: |
| if (hdr->owner) { |
| *var_len = strlen(hdr->owner); |
| return (unsigned char *) hdr->owner; |
| } else { |
| *var_len = 0; |
| return zero_octet_string; |
| } |
| |
| case CTRL_STATUS: |
| long_ret = hdr->status; |
| return (unsigned char *) &long_ret; |
| |
| default: |
| ag_trace("HistoryControlTable: unknown vp->magic=%d", |
| (int) vp->magic); |
| ERROR_MSG(""); |
| } |
| return NULL; |
| } |
| |
| /* |
| * history row management control callbacks |
| */ |
| |
| static void |
| compute_delta(ETH_STATS_T * delta, |
| ETH_STATS_T * newval, ETH_STATS_T * prevval) |
| { |
| #define CNT_DIF(X) delta->X = newval->X - prevval->X |
| |
| CNT_DIF(octets); |
| CNT_DIF(packets); |
| CNT_DIF(bcast_pkts); |
| CNT_DIF(mcast_pkts); |
| CNT_DIF(crc_align); |
| CNT_DIF(undersize); |
| CNT_DIF(oversize); |
| CNT_DIF(fragments); |
| CNT_DIF(jabbers); |
| CNT_DIF(collisions); |
| } |
| |
| static void |
| history_get_backet(unsigned int clientreg, void *clientarg) |
| { |
| RMON_ENTRY_T *hdr_ptr; |
| CRTL_ENTRY_T *body; |
| DATA_ENTRY_T *bptr; |
| ETH_STATS_T newSample; |
| |
| /* |
| * ag_trace ("history_get_backet: timer_id=%d", (int) clientreg); |
| */ |
| hdr_ptr = (RMON_ENTRY_T *) clientarg; |
| if (!hdr_ptr) { |
| ag_trace |
| ("Err: history_get_backet: hdr_ptr=NULL ? (Inserted in shock)"); |
| return; |
| } |
| |
| body = (CRTL_ENTRY_T *) hdr_ptr->body; |
| if (!body) { |
| ag_trace |
| ("Err: history_get_backet: body=NULL ? (Inserted in shock)"); |
| return; |
| } |
| |
| if (RMON1_ENTRY_VALID != hdr_ptr->status) { |
| ag_trace("Err: history_get_backet when entry %d is not valid ?!!", |
| (int) hdr_ptr->ctrl_index); |
| /* |
| * snmp_alarm_print_list (); |
| */ |
| snmp_alarm_unregister(body->timer_id); |
| ag_trace("Err: unregistered %ld", (long) body->timer_id); |
| return; |
| } |
| |
| SYSTEM_get_eth_statistics(&body->data_source, &newSample); |
| |
| bptr = ROWDATAAPI_locate_new_data(&body->scrlr); |
| if (!bptr) { |
| ag_trace |
| ("Err: history_get_backet for %d: empty bucket's list !??\n", |
| (int) hdr_ptr->ctrl_index); |
| return; |
| } |
| |
| bptr->data_index = ROWDATAAPI_get_total_number(&body->scrlr); |
| |
| bptr->start_interval = body->previous_bucket.start_interval; |
| |
| compute_delta(&bptr->EthData, &newSample, |
| &body->previous_bucket.EthData); |
| |
| bptr->utilization = |
| bptr->EthData.octets * 8 + bptr->EthData.packets * (96 + 64); |
| bptr->utilization /= body->coeff; |
| |
| /* |
| * update previous_bucket |
| */ |
| body->previous_bucket.start_interval = AGUTIL_sys_up_time(); |
| memcpy(&body->previous_bucket.EthData, &newSample, |
| sizeof(ETH_STATS_T)); |
| } |
| |
| /* |
| * Control Table RowApi Callbacks |
| */ |
| |
| int |
| history_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->interval = HIST_DEF_INTERVAL; |
| body->timer_id = 0; |
| memcpy(&body->data_source, &DEFAULT_DATA_SOURCE, sizeof(VAR_OID_T)); |
| |
| ROWDATAAPI_init(&body->scrlr, HIST_DEF_BUCK_REQ, |
| MAX_BUCKETS_IN_CRTL_ENTRY, sizeof(DATA_ENTRY_T), NULL); |
| |
| return 0; |
| } |
| |
| int |
| history_Validate(RMON_ENTRY_T * eptr) |
| { |
| /* |
| * T.B.D. (system dependent) check valid inteface in body->data_source; |
| */ |
| return 0; |
| } |
| |
| int |
| history_Activate(RMON_ENTRY_T * eptr) |
| { |
| CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body; |
| |
| body->coeff = 100000L * (long) body->interval; |
| |
| ROWDATAAPI_set_size(&body->scrlr, |
| body->scrlr.data_requested, |
| (u_char)(RMON1_ENTRY_VALID == eptr->status) ); |
| |
| SYSTEM_get_eth_statistics(&body->data_source, |
| &body->previous_bucket.EthData); |
| body->previous_bucket.start_interval = AGUTIL_sys_up_time(); |
| |
| body->scrlr.current_data_ptr = body->scrlr.first_data_ptr; |
| /* |
| * ag_trace ("Dbg: registered in history_Activate"); |
| */ |
| body->timer_id = snmp_alarm_register(body->interval, SA_REPEAT, |
| history_get_backet, eptr); |
| return 0; |
| } |
| |
| int |
| history_Deactivate(RMON_ENTRY_T * eptr) |
| { |
| CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body; |
| |
| snmp_alarm_unregister(body->timer_id); |
| /* |
| * ag_trace ("Dbg: unregistered in history_Deactivate timer_id=%d", |
| * (int) body->timer_id); |
| */ |
| |
| /* |
| * free data list |
| */ |
| ROWDATAAPI_descructor(&body->scrlr); |
| |
| return 0; |
| } |
| |
| int |
| history_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->scrlr.data_requested != clone->scrlr.data_requested) { |
| ROWDATAAPI_set_size(&body->scrlr, clone->scrlr.data_requested, |
| (u_char)(RMON1_ENTRY_VALID == eptr->status) ); |
| } |
| |
| if (body->interval != clone->interval) { |
| if (RMON1_ENTRY_VALID == eptr->status) { |
| snmp_alarm_unregister(body->timer_id); |
| body->timer_id = |
| snmp_alarm_register(clone->interval, SA_REPEAT, |
| history_get_backet, eptr); |
| } |
| |
| body->interval = clone->interval; |
| } |
| |
| if (snmp_oid_compare |
| (clone->data_source.objid, clone->data_source.length, |
| body->data_source.objid, body->data_source.length)) { |
| memcpy(&body->data_source, &clone->data_source, sizeof(VAR_OID_T)); |
| } |
| |
| return 0; |
| } |
| |
| static SCROLLER_T * |
| history_extract_scroller(void *v_body) |
| { |
| CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) v_body; |
| return &body->scrlr; |
| } |
| |
| /* |
| * var_etherHistoryTable(): |
| */ |
| unsigned char * |
| var_etherHistoryTable(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 theBucket; |
| RMON_ENTRY_T *hdr; |
| |
| *write_method = NULL; |
| hdr = ROWDATAAPI_header_DataEntry(vp, name, length, exact, var_len, |
| table_ptr, |
| &history_extract_scroller, |
| sizeof(DATA_ENTRY_T), &theBucket); |
| if (!hdr) |
| return NULL; |
| |
| *var_len = sizeof(long); /* default */ |
| |
| switch (vp->magic) { |
| case DATA_INDEX: |
| long_ret = hdr->ctrl_index; |
| return (unsigned char *) &long_ret; |
| case DATA_SAMPLEINDEX: |
| long_ret = theBucket.data_index; |
| return (unsigned char *) &long_ret; |
| case DATA_INTERVALSTART: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.start_interval; |
| case DATA_DROPEVENTS: |
| long_ret = 0; |
| return (unsigned char *) &long_ret; |
| case DATA_OCTETS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.octets; |
| case DATA_PKTS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.packets; |
| case DATA_BROADCASTPKTS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.bcast_pkts; |
| case DATA_MULTICASTPKTS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.mcast_pkts; |
| case DATA_CRCALIGNERRORS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.crc_align; |
| case DATA_UNDERSIZEPKTS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.undersize; |
| case DATA_OVERSIZEPKTS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.oversize; |
| case DATA_FRAGMENTS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.fragments; |
| case DATA_JABBERS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.jabbers; |
| case DATA_COLLISIONS: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.EthData.collisions; |
| case DATA_UTILIZATION: |
| long_ret = 0; |
| return (unsigned char *) &theBucket.utilization; |
| default: |
| ag_trace("etherHistoryTable: unknown vp->magic=%d", |
| (int) vp->magic); |
| ERROR_MSG(""); |
| } |
| return NULL; |
| } |
| |
| #if 1 /* debug, but may be used for init. TBD: may be token snmpd.conf ? */ |
| int |
| add_hist_entry(int ctrl_index, int ifIndex, |
| u_long interval, u_long requested) |
| { |
| 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 |
| */ |
| |
| body->data_source.objid[body->data_source.length - 1] = ifIndex; |
| body->interval = interval; |
| body->scrlr.data_requested = requested; |
| |
| 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 historyControlTable_variables_oid[] = |
| { 1, 3, 6, 1, 2, 1, 16, 2, 1 }; |
| |
| struct variable2 historyControlTable_variables[] = { |
| /* |
| * magic number , variable type, ro/rw , callback fn , L, oidsuffix |
| */ |
| {CTRL_INDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, |
| var_historyControlTable, 2, {1, 1}}, |
| {CTRL_DATASOURCE, ASN_OBJECT_ID, NETSNMP_OLDAPI_RWRITE, |
| var_historyControlTable, 2, {1, 2}}, |
| {CTRL_BUCKETSREQUESTED, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE, |
| var_historyControlTable, 2, {1, 3}}, |
| {CTRL_BUCKETSGRANTED, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, |
| var_historyControlTable, 2, {1, 4}}, |
| {CTRL_INTERVAL, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE, |
| var_historyControlTable, 2, {1, 5}}, |
| {CTRL_OWNER, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE, |
| var_historyControlTable, 2, {1, 6}}, |
| {CTRL_STATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE, |
| var_historyControlTable, 2, {1, 7}}, |
| |
| }; |
| |
| oid etherHistoryTable_variables_oid[] = |
| { 1, 3, 6, 1, 2, 1, 16, 2, 2 }; |
| |
| struct variable2 etherHistoryTable_variables[] = { |
| /* |
| * magic number , variable type , ro/rw , callback fn , L, oidsuffix |
| */ |
| {DATA_INDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 1}}, |
| {DATA_SAMPLEINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 2}}, |
| {DATA_INTERVALSTART, ASN_TIMETICKS, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 3}}, |
| {DATA_DROPEVENTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 4}}, |
| {DATA_OCTETS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 5}}, |
| {DATA_PKTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 6}}, |
| {DATA_BROADCASTPKTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 7}}, |
| {DATA_MULTICASTPKTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 8}}, |
| {DATA_CRCALIGNERRORS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 9}}, |
| {DATA_UNDERSIZEPKTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 10}}, |
| {DATA_OVERSIZEPKTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 11}}, |
| {DATA_FRAGMENTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 12}}, |
| {DATA_JABBERS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 13}}, |
| {DATA_COLLISIONS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 14}}, |
| {DATA_UTILIZATION, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, |
| var_etherHistoryTable, 2, {1, 15}}, |
| |
| }; |
| |
| void |
| init_history(void) |
| { |
| REGISTER_MIB("historyControlTable", historyControlTable_variables, |
| variable2, historyControlTable_variables_oid); |
| REGISTER_MIB("etherHistoryTable", etherHistoryTable_variables, |
| variable2, etherHistoryTable_variables_oid); |
| |
| ROWAPI_init_table(&HistoryCtrlTable, "History", 0, &history_Create, NULL, /* &history_Clone, */ |
| NULL, /* &history_Delete, */ |
| &history_Validate, |
| &history_Activate, |
| &history_Deactivate, &history_Copy); |
| |
| /* |
| * add_hist_entry (2, 3, 4, 2); |
| */ |
| } |
