开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
history.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：22k
源码类别：

SNMP编程

开发平台：

Unix_Linux

history.c：源码内容
  1. /**************************************************************
  2.  * Copyright (C) 2001 Alex Rozin, Optical Access 
  3.  *
  4.  *                     All Rights Reserved
  5.  *
  6.  * Permission to use, copy, modify and distribute this software and its
  7.  * documentation for any purpose and without fee is hereby granted,
  8.  * provided that the above copyright notice appear in all copies and that
  9.  * both that copyright notice and this permission notice appear in
  10.  * supporting documentation.
  11.  * 
  12.  * ALEX ROZIN DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  13.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  14.  * ALEX ROZIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  15.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  16.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  17.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  18.  * SOFTWARE.
  19.  ******************************************************************/
  21. #include <net-snmp/net-snmp-config.h>
  23. #if HAVE_STDLIB_H
  24. #include <stdlib.h>
  25. #endif
  26. #if TIME_WITH_SYS_TIME
  27. # ifdef WIN32
  28. #  include <sys/timeb.h>
  29. # else
  30. #  include <sys/time.h>
  31. # endif
  32. # include <time.h>
  33. #else
  34. # if HAVE_SYS_TIME_H
  35. #  include <sys/time.h>
  36. # else
  37. #  include <time.h>
  38. # endif
  39. #endif
  40. #if HAVE_UNISTD_H
  41. #include <unistd.h>
  42. #endif
  44. #include <net-snmp/net-snmp-includes.h>
  45. #include <net-snmp/agent/net-snmp-agent-includes.h>
  47. #include "util_funcs.h"
  49. #include "history.h"
  51. /*
  52.  * Implementation headers 
  53.  */
  54. #include "agutil_api.h"
  55. #include "row_api.h"
  57. /*
  58.  * File scope definitions section 
  59.  */
  61. #define historyControlEntryFirstIndexBegin      11
  63. #define CTRL_INDEX 3
  64. #define CTRL_DATASOURCE 4
  65. #define CTRL_BUCKETSREQUESTED 5
  66. #define CTRL_BUCKETSGRANTED 6
  67. #define CTRL_INTERVAL 7
  68. #define CTRL_OWNER 8
  69. #define CTRL_STATUS 9
  71. #define DATA_INDEX 3
  72. #define DATA_SAMPLEINDEX 4
  73. #define DATA_INTERVALSTART 5
  74. #define DATA_DROPEVENTS 6
  75. #define DATA_OCTETS 7
  76. #define DATA_PKTS 8
  77. #define DATA_BROADCASTPKTS 9
  78. #define DATA_MULTICASTPKTS 10
  79. #define DATA_CRCALIGNERRORS 11
  80. #define DATA_UNDERSIZEPKTS 12
  81. #define DATA_OVERSIZEPKTS 13
  82. #define DATA_FRAGMENTS 14
  83. #define DATA_JABBERS 15
  84. #define DATA_COLLISIONS 16
  85. #define DATA_UTILIZATION 17
  87. /*
  88.  * defaults & limitations 
  89.  */
  91. #define MAX_BUCKETS_IN_CRTL_ENTRY 50
  92. #define HIST_DEF_BUCK_REQ 50
  93. #define HIST_DEF_INTERVAL 1800
  94. static VAR_OID_T DEFAULT_DATA_SOURCE = { 11,    /* ifIndex.1 */
  95.     {1, 3, 6, 1, 2, 1, 2, 2, 1, 1, 1}
  96. };
  98. typedef struct data_struct_t {
  99.     struct data_struct_t *next;
  100.     u_long          data_index;
  101.     u_long          start_interval;
  102.     u_long          utilization;
  103.     ETH_STATS_T     EthData;
  104. } DATA_ENTRY_T;
  106. typedef struct {
  107.     u_long          interval;
  108.     u_long          timer_id;
  109.     VAR_OID_T       data_source;
  111.     u_long          coeff;
  112.     DATA_ENTRY_T    previous_bucket;
  113.     SCROLLER_T      scrlr;
  115. } CRTL_ENTRY_T;
  117. static TABLE_DEFINTION_T HistoryCtrlTable;
  118. static TABLE_DEFINTION_T *table_ptr = &HistoryCtrlTable;
  120. /*
  121.  * Main section 
  122.  */
  124. #  define Leaf_historyControlDataSource                    2
  125. #  define Leaf_historyControlBucketsRequested              3
  126. #  define Leaf_historyControlInterval                      5
  127. #  define Leaf_historyControlOwner                         6
  128. #  define Leaf_historyControlStatus                        7
  129. #  define MIN_historyControlBucketsRequested               1
  130. #  define MAX_historyControlBucketsRequested               65535
  131. #  define MIN_historyControlInterval                       1
  132. #  define MAX_historyControlInterval                       3600
  134. static int
  135. write_historyControl(int action, u_char * var_val, u_char var_val_type,
  136.                      size_t var_val_len, u_char * statP,
  137.                      oid * name, size_t name_len)
  138. {
  139.     long            long_temp;
  140.     int             leaf_id, snmp_status;
  141.     static int      prev_action = COMMIT;
  142.     RMON_ENTRY_T   *hdr;
  143.     CRTL_ENTRY_T   *cloned_body;
  144.     CRTL_ENTRY_T   *body;
  146.     switch (action) {
  147.     case RESERVE1:
  148.     case FREE:
  149.     case UNDO:
  150.     case ACTION:
  151.     case COMMIT:
  152.     default:
  153.         return ROWAPI_do_another_action(name,
  154.                                         historyControlEntryFirstIndexBegin,
  155.                                         action, &prev_action, table_ptr,
  156.                                         sizeof(CRTL_ENTRY_T));
  157.     case RESERVE2:
  158.         /*
  159.          * get values from PDU, check them and save them in the cloned entry 
  160.          */
  161.         long_temp = name[historyControlEntryFirstIndexBegin];
  162.         leaf_id = (int) name[historyControlEntryFirstIndexBegin - 1];
  163.         hdr = ROWAPI_find(table_ptr, long_temp);        /* it MUST be OK */
  164.         cloned_body = (CRTL_ENTRY_T *) hdr->tmp;
  165.         body = (CRTL_ENTRY_T *) hdr->body;
  166.         switch (leaf_id) {
  167.         case Leaf_historyControlDataSource:
  168.             snmp_status = AGUTIL_get_oid_value(var_val, var_val_type,
  169.                                                var_val_len,
  170.                                                &cloned_body->data_source);
  171.             if (SNMP_ERR_NOERROR != snmp_status) {
  172.                 ag_trace("can't browse historyControlDataSource");
  173.                 return snmp_status;
  174.             }
  175.             if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&
  176.                 snmp_oid_compare(cloned_body->data_source.objid,
  177.                                  cloned_body->data_source.length,
  178.                                  body->data_source.objid,
  179.                                  body->data_source.length)) {
  180.                 ag_trace
  181.                     ("can't change historyControlDataSource - not Creation");
  182.                 return SNMP_ERR_BADVALUE;
  183.             }
  184.             break;
  185.         case Leaf_historyControlBucketsRequested:
  186.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  187.                                                var_val_len,
  188.                                                MIN_historyControlBucketsRequested,
  189.                                                MAX_historyControlBucketsRequested,
  190.                                                &cloned_body->scrlr.
  191.                                                data_requested);
  192.             if (SNMP_ERR_NOERROR != snmp_status) {
  193.                 return snmp_status;
  194.             }
  195. #if 0
  196.             if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&
  197.                 cloned_body->scrlr.data_requested !=
  198.                 body->scrlr.data_requested)
  199.                 return SNMP_ERR_BADVALUE;
  200. #endif
  201.             break;
  202.         case Leaf_historyControlInterval:
  203.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  204.                                                var_val_len,
  205.                                                MIN_historyControlInterval,
  206.                                                MAX_historyControlInterval,
  207.                                                &cloned_body->interval);
  208.             if (SNMP_ERR_NOERROR != snmp_status) {
  209.                 return snmp_status;
  210.             }
  211. #if 0
  212.             if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&
  213.                 cloned_body->interval != body->interval)
  214.                 return SNMP_ERR_BADVALUE;
  215. #endif
  216.             break;
  217.         case Leaf_historyControlOwner:
  218.             if (hdr->new_owner)
  219.                 AGFREE(hdr->new_owner);
  220.             hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);;
  221.             if (!hdr->new_owner)
  222.                 return SNMP_ERR_TOOBIG;
  223.             snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
  224.                                                   var_val_len,
  225.                                                   MAX_OWNERSTRING,
  226.                                                   1, NULL, hdr->new_owner);
  227.             if (SNMP_ERR_NOERROR != snmp_status) {
  228.                 return snmp_status;
  229.             }
  231.             break;
  232.         case Leaf_historyControlStatus:
  233.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  234.                                                var_val_len,
  235.                                                RMON1_ENTRY_VALID,
  236.                                                RMON1_ENTRY_INVALID,
  237.                                                &long_temp);
  238.             if (SNMP_ERR_NOERROR != snmp_status) {
  239.                 return snmp_status;
  240.             }
  241.             hdr->new_status = long_temp;
  242.             break;
  243.         default:
  244.             ag_trace("%s:unknown leaf_id=%dn", table_ptr->name,
  245.                      (int) leaf_id);
  246.             return SNMP_ERR_NOSUCHNAME;
  247.         }                       /* of switch by 'leaf_id' */
  248.         break;
  250.     }                           /* of switch by actions */
  252.     prev_action = action;
  253.     return SNMP_ERR_NOERROR;
  254. }
  256. /*
  257.  * var_historyControlTable():
  258.  */
  259. unsigned char  *
  260. var_historyControlTable(struct variable *vp,
  261.                         oid * name,
  262.                         size_t * length,
  263.                         int exact,
  264.                         size_t * var_len, WriteMethod ** write_method)
  265. {
  266.     static long     long_ret;
  267.     static CRTL_ENTRY_T theEntry;
  268.     RMON_ENTRY_T   *hdr;
  270.     *write_method = write_historyControl;
  271.     hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len,
  272.                                      table_ptr,
  273.                                      &theEntry, sizeof(CRTL_ENTRY_T));
  274.     if (!hdr)
  275.         return NULL;
  277.     *var_len = sizeof(long);    /* default */
  279.     switch (vp->magic) {
  280.     case CTRL_INDEX:
  281.         long_ret = hdr->ctrl_index;
  282.         return (unsigned char *) &long_ret;
  284.     case CTRL_DATASOURCE:
  285.         *var_len = sizeof(oid) * theEntry.data_source.length;
  286.         return (unsigned char *) theEntry.data_source.objid;
  288.     case CTRL_BUCKETSREQUESTED:
  289.         long_ret = theEntry.scrlr.data_requested;
  290.         return (unsigned char *) &long_ret;
  292.     case CTRL_BUCKETSGRANTED:
  294.         long_ret = theEntry.scrlr.data_granted;
  295.         return (unsigned char *) &long_ret;
  297.     case CTRL_INTERVAL:
  298.         long_ret = theEntry.interval;
  299.         return (unsigned char *) &long_ret;
  301.     case CTRL_OWNER:
  302.         if (hdr->owner) {
  303.             *var_len = strlen(hdr->owner);
  304.             return (unsigned char *) hdr->owner;
  305.         } else {
  306.             *var_len = 0;
  307.             return (unsigned char *) "";
  308.         }
  310.     case CTRL_STATUS:
  311.         long_ret = hdr->status;
  312.         return (unsigned char *) &long_ret;
  314.     default:
  315.         ag_trace("HistoryControlTable: unknown vp->magic=%d",
  316.                  (int) vp->magic);
  317.         ERROR_MSG("");
  318.     }
  319.     return NULL;
  320. }
  322. /*
  323.  * history row management control callbacks 
  324.  */
  326. static void
  327. compute_delta(ETH_STATS_T * delta,
  328.               ETH_STATS_T * newval, ETH_STATS_T * prevval)
  329. {
  330. #define CNT_DIF(X) delta->X = newval->X - prevval->X
  332.     CNT_DIF(octets);
  333.     CNT_DIF(packets);
  334.     CNT_DIF(bcast_pkts);
  335.     CNT_DIF(mcast_pkts);
  336.     CNT_DIF(crc_align);
  337.     CNT_DIF(undersize);
  338.     CNT_DIF(oversize);
  339.     CNT_DIF(fragments);
  340.     CNT_DIF(jabbers);
  341.     CNT_DIF(collisions);
  342. }
  344. static void
  345. history_get_backet(unsigned int clientreg, void *clientarg)
  346. {
  347.     RMON_ENTRY_T   *hdr_ptr;
  348.     CRTL_ENTRY_T   *body;
  349.     DATA_ENTRY_T   *bptr;
  350.     ETH_STATS_T     newSample;
  352.     /*
  353.      * ag_trace ("history_get_backet: timer_id=%d", (int) clientreg); 
  354.      */
  355.     hdr_ptr = (RMON_ENTRY_T *) clientarg;
  356.     if (!hdr_ptr) {
  357.         ag_trace
  358.             ("Err: history_get_backet: hdr_ptr=NULL ? (Inserted in shock)");
  359.         return;
  360.     }
  362.     body = (CRTL_ENTRY_T *) hdr_ptr->body;
  363.     if (!body) {
  364.         ag_trace
  365.             ("Err: history_get_backet: body=NULL ? (Inserted in shock)");
  366.         return;
  367.     }
  369.     if (RMON1_ENTRY_VALID != hdr_ptr->status) {
  370.         ag_trace("Err: history_get_backet when entry %d is not valid ?!!",
  371.                  (int) hdr_ptr->ctrl_index);
  372.         /*
  373.          * snmp_alarm_print_list (); 
  374.          */
  375.         snmp_alarm_unregister(body->timer_id);
  376.         ag_trace("Err: unregistered %ld", (long) body->timer_id);
  377.         return;
  378.     }
  380.     SYSTEM_get_eth_statistics(&body->data_source, &newSample);
  382.     bptr = ROWDATAAPI_locate_new_data(&body->scrlr);
  383.     if (!bptr) {
  384.         ag_trace
  385.             ("Err: history_get_backet for %d: empty bucket's list !??n",
  386.              (int) hdr_ptr->ctrl_index);
  387.         return;
  388.     }
  390.     bptr->data_index = ROWDATAAPI_get_total_number(&body->scrlr);
  392.     bptr->start_interval = body->previous_bucket.start_interval;
  394.     compute_delta(&bptr->EthData, &newSample,
  395.                   &body->previous_bucket.EthData);
  397.     bptr->utilization =
  398.         bptr->EthData.octets * 8 + bptr->EthData.packets * (96 + 64);
  399.     bptr->utilization /= body->coeff;
  401.     /*
  402.      * update previous_bucket 
  403.      */
  404.     body->previous_bucket.start_interval = AGUTIL_sys_up_time();
  405.     memcpy(&body->previous_bucket.EthData, &newSample,
  406.            sizeof(ETH_STATS_T));
  407. }
  409. /*
  410.  * Control Table RowApi Callbacks 
  411.  */
  413. int
  414. history_Create(RMON_ENTRY_T * eptr)
  415. {                               /* create the body: alloc it and set defaults */
  416.     CRTL_ENTRY_T   *body;
  418.     eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T));
  419.     if (!eptr->body)
  420.         return -3;
  421.     body = (CRTL_ENTRY_T *) eptr->body;
  423.     /*
  424.      * set defaults 
  425.      */
  426.     body->interval = HIST_DEF_INTERVAL;
  427.     body->timer_id = 0;
  428.     memcpy(&body->data_source, &DEFAULT_DATA_SOURCE, sizeof(VAR_OID_T));
  430.     ROWDATAAPI_init(&body->scrlr, HIST_DEF_BUCK_REQ,
  431.                     MAX_BUCKETS_IN_CRTL_ENTRY, sizeof(DATA_ENTRY_T), NULL);
  433.     return 0;
  434. }
  436. int
  437. history_Validate(RMON_ENTRY_T * eptr)
  438. {
  439.     /*
  440.      * T.B.D. (system dependent) check valid inteface in body->data_source; 
  441.      */
  442.     return 0;
  443. }
  445. int
  446. history_Activate(RMON_ENTRY_T * eptr)
  447. {
  448.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  450.     body->coeff = 100000L * (long) body->interval;
  452.     ROWDATAAPI_set_size(&body->scrlr,
  453.                         body->scrlr.data_requested,
  454.                         (u_char)(RMON1_ENTRY_VALID == eptr->status) );
  456.     SYSTEM_get_eth_statistics(&body->data_source,
  457.                               &body->previous_bucket.EthData);
  458.     body->previous_bucket.start_interval = AGUTIL_sys_up_time();
  460.     body->scrlr.current_data_ptr = body->scrlr.first_data_ptr;
  461.     /*
  462.      * ag_trace ("Dbg:   registered in history_Activate"); 
  463.      */
  464.     body->timer_id = snmp_alarm_register(body->interval, SA_REPEAT,
  465.                                          history_get_backet, eptr);
  466.     return 0;
  467. }
  469. int
  470. history_Deactivate(RMON_ENTRY_T * eptr)
  471. {
  472.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  474.     snmp_alarm_unregister(body->timer_id);
  475.     /*
  476.      * ag_trace ("Dbg: unregistered in history_Deactivate timer_id=%d",
  477.      * (int) body->timer_id); 
  478.      */
  480.     /*
  481.      * free data list 
  482.      */
  483.     ROWDATAAPI_descructor(&body->scrlr);
  485.     return 0;
  486. }
  488. int
  489. history_Copy(RMON_ENTRY_T * eptr)
  490. {
  491.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  492.     CRTL_ENTRY_T   *clone = (CRTL_ENTRY_T *) eptr->tmp;
  494.     if (body->scrlr.data_requested != clone->scrlr.data_requested) {
  495.         ROWDATAAPI_set_size(&body->scrlr, clone->scrlr.data_requested,
  496.                             (u_char)(RMON1_ENTRY_VALID == eptr->status) );
  497.     }
  499.     if (body->interval != clone->interval) {
  500.         if (RMON1_ENTRY_VALID == eptr->status) {
  501.             snmp_alarm_unregister(body->timer_id);
  502.             body->timer_id =
  503.                 snmp_alarm_register(clone->interval, SA_REPEAT,
  504.                                     history_get_backet, eptr);
  505.         }
  507.         body->interval = clone->interval;
  508.     }
  510.     if (snmp_oid_compare
  511.         (clone->data_source.objid, clone->data_source.length,
  512.          body->data_source.objid, body->data_source.length)) {
  513.         memcpy(&body->data_source, &clone->data_source, sizeof(VAR_OID_T));
  514.     }
  516.     return 0;
  517. }
  519. static SCROLLER_T *
  520. history_extract_scroller(void *v_body)
  521. {
  522.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) v_body;
  523.     return &body->scrlr;
  524. }
  526. /*
  527.  * var_etherHistoryTable():
  528.  */
  529. unsigned char  *
  530. var_etherHistoryTable(struct variable *vp,
  531.                       oid * name,
  532.                       size_t * length,
  533.                       int exact,
  534.                       size_t * var_len, WriteMethod ** write_method)
  535. {
  536.     static long     long_ret;
  537.     static DATA_ENTRY_T theBucket;
  538.     RMON_ENTRY_T   *hdr;
  539.     CRTL_ENTRY_T   *ctrl;
  541.     *write_method = NULL;
  542.     hdr = ROWDATAAPI_header_DataEntry(vp, name, length, exact, var_len,
  543.                                       table_ptr,
  544.                                       &history_extract_scroller,
  545.                                       sizeof(DATA_ENTRY_T), &theBucket);
  546.     if (!hdr)
  547.         return NULL;
  549.     *var_len = sizeof(long);    /* default */
  551.     ctrl = (CRTL_ENTRY_T *) hdr->body;
  553.     switch (vp->magic) {
  554.     case DATA_INDEX:
  555.         long_ret = hdr->ctrl_index;
  556.         return (unsigned char *) &long_ret;
  557.     case DATA_SAMPLEINDEX:
  558.         long_ret = theBucket.data_index;
  559.         return (unsigned char *) &long_ret;
  560.     case DATA_INTERVALSTART:
  561.         long_ret = 0;
  562.         return (unsigned char *) &theBucket.start_interval;
  563.     case DATA_DROPEVENTS:
  564.         long_ret = 0;
  565.         return (unsigned char *) &long_ret;
  566.     case DATA_OCTETS:
  567.         long_ret = 0;
  568.         return (unsigned char *) &theBucket.EthData.octets;
  569.     case DATA_PKTS:
  570.         long_ret = 0;
  571.         return (unsigned char *) &theBucket.EthData.packets;
  572.     case DATA_BROADCASTPKTS:
  573.         long_ret = 0;
  574.         return (unsigned char *) &theBucket.EthData.bcast_pkts;
  575.     case DATA_MULTICASTPKTS:
  576.         long_ret = 0;
  577.         return (unsigned char *) &theBucket.EthData.mcast_pkts;
  578.     case DATA_CRCALIGNERRORS:
  579.         long_ret = 0;
  580.         return (unsigned char *) &theBucket.EthData.crc_align;
  581.     case DATA_UNDERSIZEPKTS:
  582.         long_ret = 0;
  583.         return (unsigned char *) &theBucket.EthData.undersize;
  584.     case DATA_OVERSIZEPKTS:
  585.         long_ret = 0;
  586.         return (unsigned char *) &theBucket.EthData.oversize;
  587.     case DATA_FRAGMENTS:
  588.         long_ret = 0;
  589.         return (unsigned char *) &theBucket.EthData.fragments;
  590.     case DATA_JABBERS:
  591.         long_ret = 0;
  592.         return (unsigned char *) &theBucket.EthData.jabbers;
  593.     case DATA_COLLISIONS:
  594.         long_ret = 0;
  595.         return (unsigned char *) &theBucket.EthData.collisions;
  596.     case DATA_UTILIZATION:
  597.         long_ret = 0;
  598.         return (unsigned char *) &theBucket.utilization;
  599.     default:
  600.         ag_trace("etherHistoryTable: unknown vp->magic=%d",
  601.                  (int) vp->magic);
  602.         ERROR_MSG("");
  603.     }
  604.     return NULL;
  605. }
  607. #if 1                           /* debug, but may be used for init. TBD: may be token snmpd.conf ? */
  608. int
  609. add_hist_entry(int ctrl_index, int ifIndex,
  610.                u_long interval, u_long requested)
  611. {
  612.     register RMON_ENTRY_T *eptr;
  613.     register CRTL_ENTRY_T *body;
  614.     int             ierr;
  616.     ierr = ROWAPI_new(table_ptr, ctrl_index);
  617.     if (ierr) {
  618.         ag_trace("ROWAPI_new failed with %d", ierr);
  619.         return ierr;
  620.     }
  622.     eptr = ROWAPI_find(table_ptr, ctrl_index);
  623.     if (!eptr) {
  624.         ag_trace("ROWAPI_find failed");
  625.         return -4;
  626.     }
  628.     body = (CRTL_ENTRY_T *) eptr->body;
  630.     /*
  631.      * set parameters 
  632.      */
  634.     body->data_source.objid[body->data_source.length - 1] = ifIndex;
  635.     body->interval = interval;
  636.     body->scrlr.data_requested = requested;
  638.     eptr->new_status = RMON1_ENTRY_VALID;
  639.     ierr = ROWAPI_commit(table_ptr, ctrl_index);
  640.     if (ierr) {
  641.         ag_trace("ROWAPI_commit failed with %d", ierr);
  642.     }
  644.     return ierr;
  646. }
  648. #endif
  650. /*
  651.  * Registration & Initializatio section 
  652.  */
  654. oid             historyControlTable_variables_oid[] =
  655.     { 1, 3, 6, 1, 2, 1, 16, 2, 1 };
  657. struct variable2 historyControlTable_variables[] = {
  658.     /*
  659.      * magic number        , variable type, ro/rw , callback fn  ,           L, oidsuffix 
  660.      */
  661.     {CTRL_INDEX, ASN_INTEGER, RONLY, var_historyControlTable, 2, {1, 1}},
  662.     {CTRL_DATASOURCE, ASN_OBJECT_ID, RWRITE, var_historyControlTable, 2,
  663.      {1, 2}},
  664.     {CTRL_BUCKETSREQUESTED, ASN_INTEGER, RWRITE, var_historyControlTable,
  665.      2, {1, 3}},
  666.     {CTRL_BUCKETSGRANTED, ASN_INTEGER, RONLY, var_historyControlTable, 2,
  667.      {1, 4}},
  668.     {CTRL_INTERVAL, ASN_INTEGER, RWRITE, var_historyControlTable, 2,
  669.      {1, 5}},
  670.     {CTRL_OWNER, ASN_OCTET_STR, RWRITE, var_historyControlTable, 2,
  671.      {1, 6}},
  672.     {CTRL_STATUS, ASN_INTEGER, RWRITE, var_historyControlTable, 2, {1, 7}},
  674. };
  676. oid             etherHistoryTable_variables_oid[] =
  677.     { 1, 3, 6, 1, 2, 1, 16, 2, 2 };
  679. struct variable2 etherHistoryTable_variables[] = {
  680.     /*
  681.      * magic number     , variable type , ro/rw , callback fn  ,        L, oidsuffix 
  682.      */
  683.     {DATA_INDEX, ASN_INTEGER, RONLY, var_etherHistoryTable, 2, {1, 1}},
  684.     {DATA_SAMPLEINDEX, ASN_INTEGER, RONLY, var_etherHistoryTable, 2,
  685.      {1, 2}},
  686.     {DATA_INTERVALSTART, ASN_TIMETICKS, RONLY, var_etherHistoryTable, 2,
  687.      {1, 3}},
  688.     {DATA_DROPEVENTS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  689.      {1, 4}},
  690.     {DATA_OCTETS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2, {1, 5}},
  691.     {DATA_PKTS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2, {1, 6}},
  692.     {DATA_BROADCASTPKTS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  693.      {1, 7}},
  694.     {DATA_MULTICASTPKTS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  695.      {1, 8}},
  696.     {DATA_CRCALIGNERRORS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  697.      {1, 9}},
  698.     {DATA_UNDERSIZEPKTS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  699.      {1, 10}},
  700.     {DATA_OVERSIZEPKTS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  701.      {1, 11}},
  702.     {DATA_FRAGMENTS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  703.      {1, 12}},
  704.     {DATA_JABBERS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2, {1, 13}},
  705.     {DATA_COLLISIONS, ASN_COUNTER, RONLY, var_etherHistoryTable, 2,
  706.      {1, 14}},
  707.     {DATA_UTILIZATION, ASN_INTEGER, RONLY, var_etherHistoryTable, 2,
  708.      {1, 15}},
  710. };
  712. void
  713. init_history(void)
  714. {
  715.     REGISTER_MIB("historyControlTable", historyControlTable_variables,
  716.                  variable2, historyControlTable_variables_oid);
  717.     REGISTER_MIB("etherHistoryTable", etherHistoryTable_variables,
  718.                  variable2, etherHistoryTable_variables_oid);
  720.     ROWAPI_init_table(&HistoryCtrlTable, "History", 0, &history_Create, NULL,   /* &history_Clone, */
  721.                       NULL,     /* &history_Delete, */
  722.                       &history_Validate,
  723.                       &history_Activate,
  724.                       &history_Deactivate, &history_Copy);
  726.     /*
  727.      * add_hist_entry (2, 3, 4, 2); 
  728.      */
  729. }