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

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

SNMP编程

开发平台：

Unix_Linux

event.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
  43. #include <ctype.h>
  45. #include <net-snmp/net-snmp-includes.h>
  46. #include <net-snmp/agent/net-snmp-agent-includes.h>
  48. #include "util_funcs.h"
  50. #include "event.h"
  52. /*
  53.  * Implementation headers 
  54.  */
  55. #include "agutil_api.h"
  56. #include "row_api.h"
  58. /*
  59.  * File scope definitions section 
  60.  */
  62. /*
  63.  * from MIB compilation 
  64.  */
  65. #define eventEntryFirstIndexBegin       11
  67. #define EVENTINDEX            3
  68. #define EVENTDESCRIPTION      4
  69. #define EVENTTYPE             5
  70. #define EVENTCOMMUNITY        6
  71. #define EVENTLASTTIMESENT     7
  72. #define EVENTOWNER            8
  73. #define EVENTSTATUS           9
  75. #define Leaf_event_description  2
  76. #define MIN_event_description   0
  77. #define MAX_event_description   127
  78. #define Leaf_event_type         3
  79. #define Leaf_event_community    4
  80. #define MIN_event_community     0
  81. #define MAX_event_community     127
  82. #define Leaf_event_last_time_sent 5
  83. #define Leaf_eventOwner        6
  84. #define Leaf_eventStatus       7
  87. #define LOGEVENTINDEX         3
  88. #define LOGINDEX              4
  89. #define LOGTIME               5
  90. #define LOGDESCRIPTION        6
  93. /*
  94.  * defaults & limitations 
  95.  */
  97. #define MAX_LOG_ENTRIES_PER_CTRL 200
  99. typedef struct data_struct_t {
  100.     struct data_struct_t *next;
  101.     u_long          data_index;
  102.     u_long          log_time;
  103.     char           *log_description;
  104. } DATA_ENTRY_T;
  106. typedef enum {
  107.     EVENT_NONE = 1,
  108.     EVENT_LOG,
  109.     EVENT_TRAP,
  110.     EVENT_LOG_AND_TRAP
  111. } EVENT_TYPE_T;
  113. typedef struct {
  114.     char           *event_description;
  115.     char           *event_community;
  116.     EVENT_TYPE_T    event_type;
  117.     u_long          event_last_time_sent;
  119.     SCROLLER_T      scrlr;
  120. #if 0
  121.     u_long          event_last_logged_index;
  122.     u_long          event_number_of_log_entries;
  123.     DATA_ENTRY_T   *log_list;
  124.     DATA_ENTRY_T   *last_log_ptr;
  125. #endif
  126. } CRTL_ENTRY_T;
  128. /*
  129.  * Main section 
  130.  */
  132. static TABLE_DEFINTION_T EventCtrlTable;
  133. static TABLE_DEFINTION_T *table_ptr = &EventCtrlTable;
  135. /*
  136.  * Control Table RowApi Callbacks 
  137.  */
  139. static int
  140. data_destructor(SCROLLER_T * scrlr, void *free_me)
  141. {
  142.     DATA_ENTRY_T   *lptr = free_me;
  144.     if (lptr->log_description)
  145.         AGFREE(lptr->log_description);
  147.     return 0;
  148. }
  150. int
  151. event_Create(RMON_ENTRY_T * eptr)
  152. {                               /* create the body: alloc it and set defaults */
  153.     CRTL_ENTRY_T   *body;
  155.     eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T));
  156.     if (!eptr->body)
  157.         return -3;
  158.     body = (CRTL_ENTRY_T *) eptr->body;
  160.     /*
  161.      * set defaults 
  162.      */
  164.     body->event_description = NULL;
  165.     body->event_community = AGSTRDUP("public");
  166.     /*
  167.      * ag_trace ("Dbg: created event_community=<%s>", body->event_community); 
  168.      */
  169.     body->event_type = EVENT_NONE;
  170.     ROWDATAAPI_init(&body->scrlr,
  171.                     MAX_LOG_ENTRIES_PER_CTRL,
  172.                     MAX_LOG_ENTRIES_PER_CTRL,
  173.                     sizeof(DATA_ENTRY_T), &data_destructor);
  176.     return 0;
  177. }
  179. int
  180. event_Clone(RMON_ENTRY_T * eptr)
  181. {                               /* copy entry_bod -> clone */
  182.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  183.     CRTL_ENTRY_T   *clone = (CRTL_ENTRY_T *) eptr->tmp;
  185.     if (body->event_description)
  186.         clone->event_description = AGSTRDUP(body->event_description);
  188.     if (body->event_community)
  189.         clone->event_community = AGSTRDUP(body->event_community);
  190.     return 0;
  191. }
  193. int
  194. event_Copy(RMON_ENTRY_T * eptr)
  195. {
  196.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  197.     CRTL_ENTRY_T   *clone = (CRTL_ENTRY_T *) eptr->tmp;
  199.     if (body->event_type != clone->event_type) {
  200.         body->event_type = clone->event_type;
  201.     }
  203.     if (clone->event_description) {
  204.         if (body->event_description)
  205.             AGFREE(body->event_description);
  206.         body->event_description = AGSTRDUP(clone->event_description);
  207.     }
  209.     if (clone->event_community) {
  210.         if (body->event_community)
  211.             AGFREE(body->event_community);
  212.         body->event_community = AGSTRDUP(clone->event_community);
  213.     }
  215.     return 0;
  216. }
  218. int
  219. event_Delete(RMON_ENTRY_T * eptr)
  220. {
  221.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr;
  223.     if (body->event_description)
  224.         AGFREE(body->event_description);
  226.     if (body->event_community)
  227.         AGFREE(body->event_community);
  229.     return 0;
  230. }
  232. int
  233. event_Activate(RMON_ENTRY_T * eptr)
  234. {                               /* init logTable */
  235.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  237.     ROWDATAAPI_set_size(&body->scrlr,
  238.                         body->scrlr.data_requested,
  239.                         (u_char)(RMON1_ENTRY_VALID == eptr->status) );
  241.     return 0;
  242. }
  244. int
  245. event_Deactivate(RMON_ENTRY_T * eptr)
  246. {                               /* free logTable */
  247.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  249.     /*
  250.      * free data list 
  251.      */
  252.     ROWDATAAPI_descructor(&body->scrlr);
  254.     return 0;
  255. }
  257. static int
  258. write_eventControl(int action, u_char * var_val, u_char var_val_type,
  259.                    size_t var_val_len, u_char * statP,
  260.                    oid * name, size_t name_len)
  261. {
  262.     long            long_temp;
  263.     char           *char_temp;
  264.     int             leaf_id, snmp_status;
  265.     static int      prev_action = COMMIT;
  266.     RMON_ENTRY_T   *hdr;
  267.     CRTL_ENTRY_T   *cloned_body;
  268.     CRTL_ENTRY_T   *body;
  270.     switch (action) {
  271.     case RESERVE1:
  272.     case FREE:
  273.     case UNDO:
  274.     case ACTION:
  275.     case COMMIT:
  276.     default:
  277.         return ROWAPI_do_another_action(name, eventEntryFirstIndexBegin,
  278.                                         action, &prev_action,
  279.                                         table_ptr, sizeof(CRTL_ENTRY_T));
  281.     case RESERVE2:
  282.         /*
  283.          * get values from PDU, check them and save them in the cloned entry 
  284.          */
  285.         long_temp = name[eventEntryFirstIndexBegin];
  286.         leaf_id = (int) name[eventEntryFirstIndexBegin - 1];
  287.         hdr = ROWAPI_find(table_ptr, long_temp);        /* it MUST be OK */
  288.         cloned_body = (CRTL_ENTRY_T *) hdr->tmp;
  289.         body = (CRTL_ENTRY_T *) hdr->body;
  290.         switch (leaf_id) {
  291.         case Leaf_event_description:
  292.             char_temp = AGMALLOC(1 + MAX_event_description);
  293.             if (!char_temp)
  294.                 return SNMP_ERR_TOOBIG;
  295.             snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
  296.                                                   var_val_len,
  297.                                                   MAX_event_description,
  298.                                                   1, NULL, char_temp);
  299.             if (SNMP_ERR_NOERROR != snmp_status) {
  300.                 AGFREE(char_temp);
  301.                 return snmp_status;
  302.             }
  304.             if (cloned_body->event_description)
  305.                 AGFREE(cloned_body->event_description);
  307.             cloned_body->event_description = AGSTRDUP(char_temp);
  308.             /*
  309.              * ag_trace ("rx: event_description=<%s>", cloned_body->event_description); 
  310.              */
  311.             AGFREE(char_temp);
  313.             break;
  314.         case Leaf_event_type:
  315.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  316.                                                var_val_len,
  317.                                                EVENT_NONE,
  318.                                                EVENT_LOG_AND_TRAP,
  319.                                                &long_temp);
  320.             if (SNMP_ERR_NOERROR != snmp_status) {
  321.                 return snmp_status;
  322.             }
  323.             cloned_body->event_type = long_temp;
  324.             break;
  325.         case Leaf_event_community:
  326.             char_temp = AGMALLOC(1 + MAX_event_community);
  327.             if (!char_temp)
  328.                 return SNMP_ERR_TOOBIG;
  329.             snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
  330.                                                   var_val_len,
  331.                                                   MAX_event_community,
  332.                                                   1, NULL, char_temp);
  333.             if (SNMP_ERR_NOERROR != snmp_status) {
  334.                 AGFREE(char_temp);
  335.                 return snmp_status;
  336.             }
  338.             if (cloned_body->event_community)
  339.                 AGFREE(cloned_body->event_community);
  341.             cloned_body->event_community = AGSTRDUP(char_temp);
  342.             AGFREE(char_temp);
  344.             break;
  345.         case Leaf_eventOwner:
  346.             if (hdr->new_owner)
  347.                 AGFREE(hdr->new_owner);
  348.             hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);;
  349.             if (!hdr->new_owner)
  350.                 return SNMP_ERR_TOOBIG;
  351.             snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
  352.                                                   var_val_len,
  353.                                                   MAX_OWNERSTRING,
  354.                                                   1, NULL, hdr->new_owner);
  355.             if (SNMP_ERR_NOERROR != snmp_status) {
  356.                 return snmp_status;
  357.             }
  359.             break;
  360.         case Leaf_eventStatus:
  361.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  362.                                                var_val_len,
  363.                                                RMON1_ENTRY_VALID,
  364.                                                RMON1_ENTRY_INVALID,
  365.                                                &long_temp);
  366.             if (SNMP_ERR_NOERROR != snmp_status) {
  367.                 return snmp_status;
  368.             }
  369.             hdr->new_status = long_temp;
  370.             break;
  371.         default:
  372.             ag_trace("%s:unknown leaf_id=%dn", table_ptr->name,
  373.                      (int) leaf_id);
  374.             return SNMP_ERR_NOSUCHNAME;
  375.         }                       /* of switch by 'leaf_id' */
  376.         break;
  377.     }                           /* of switch by actions */
  379.     prev_action = action;
  380.     return SNMP_ERR_NOERROR;
  381. }
  383. unsigned char  *
  384. var_eventTable(struct variable *vp,
  385.                oid * name,
  386.                size_t * length,
  387.                int exact, size_t * var_len, WriteMethod ** write_method)
  388. {
  389.     static long     long_ret;
  390.     static CRTL_ENTRY_T theEntry;
  391.     RMON_ENTRY_T   *hdr;
  393.     *write_method = write_eventControl;
  394.     hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len,
  395.                                      table_ptr,
  396.                                      &theEntry, sizeof(CRTL_ENTRY_T));
  397.     if (!hdr)
  398.         return NULL;
  400.     *var_len = sizeof(long);    /* default */
  402.     switch (vp->magic) {
  403.     case EVENTINDEX:
  404.         long_ret = hdr->ctrl_index;
  405.         return (unsigned char *) &long_ret;
  406.     case EVENTDESCRIPTION:
  407.         if (theEntry.event_description) {
  408.             *var_len = strlen(theEntry.event_description);
  409.             return (unsigned char *) theEntry.event_description;
  410.         } else {
  411.             *var_len = 0;
  412.             return (unsigned char *) "";
  413.         }
  414.     case EVENTTYPE:
  415.         long_ret = theEntry.event_type;
  416.         return (unsigned char *) &long_ret;
  417.     case EVENTCOMMUNITY:
  418.         if (theEntry.event_community) {
  419.             *var_len = strlen(theEntry.event_community);
  420.             return (unsigned char *) theEntry.event_community;
  421.         } else {
  422.             *var_len = 0;
  423.             return (unsigned char *) "";
  424.         }
  425.     case EVENTLASTTIMESENT:
  426.         long_ret = theEntry.event_last_time_sent;
  427.         return (unsigned char *) &long_ret;
  428.     case EVENTOWNER:
  429.         if (hdr->owner) {
  430.             *var_len = strlen(hdr->owner);
  431.             return (unsigned char *) hdr->owner;
  432.         } else {
  433.             *var_len = 0;
  434.             return (unsigned char *) "";
  435.         }
  436.     case EVENTSTATUS:
  437.         long_ret = hdr->status;
  438.         return (unsigned char *) &long_ret;
  439.     default:
  440.         ag_trace("EventControlTable: unknown vp->magic=%d",
  441.                  (int) vp->magic);
  442.         ERROR_MSG("");
  443.     }
  444.     return NULL;
  445. }
  447. static SCROLLER_T *
  448. event_extract_scroller(void *v_body)
  449. {
  450.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) v_body;
  451.     return &body->scrlr;
  452. }
  454. unsigned char  *
  455. var_logTable(struct variable *vp,
  456.              oid * name,
  457.              size_t * length,
  458.              int exact, size_t * var_len, WriteMethod ** write_method)
  459. {
  460.     static long     long_ret;
  461.     static DATA_ENTRY_T theEntry;
  462.     RMON_ENTRY_T   *hdr;
  463.     CRTL_ENTRY_T   *ctrl;
  465.     *write_method = NULL;
  466.     hdr = ROWDATAAPI_header_DataEntry(vp, name, length, exact, var_len,
  467.                                       table_ptr,
  468.                                       &event_extract_scroller,
  469.                                       sizeof(DATA_ENTRY_T), &theEntry);
  470.     if (!hdr)
  471.         return NULL;
  473.     ctrl = (CRTL_ENTRY_T *) hdr->body;
  475.     *var_len = sizeof(long);    /* default */
  477.     switch (vp->magic) {
  478.     case LOGEVENTINDEX:
  479.         long_ret = hdr->ctrl_index;
  480.         return (unsigned char *) &long_ret;
  481.     case LOGINDEX:
  482.         long_ret = theEntry.data_index;
  483.         return (unsigned char *) &long_ret;
  484.     case LOGTIME:
  485.         long_ret = theEntry.log_time;
  486.         return (unsigned char *) &long_ret;
  487.     case LOGDESCRIPTION:
  488.         if (theEntry.log_description) {
  489.             *var_len = strlen(theEntry.log_description);
  490.             return (unsigned char *) theEntry.log_description;
  491.         } else {
  492.             *var_len = 0;
  493.             return (unsigned char *) "";
  494.         }
  495.     default:
  496.         ERROR_MSG("");
  497.     }
  499.     return NULL;
  500. }
  502. /*
  503.  * External API section 
  504.  */
  506. static char    *
  507. create_explanaition(CRTL_ENTRY_T * evptr, u_char is_rising,
  508.                     u_long alarm_index, u_long event_index,
  509.                     oid * alarmed_var,
  510.                     size_t alarmed_var_length,
  511.                     u_long value, u_long the_threshold,
  512.                     u_long sample_type, char *alarm_descr)
  513. {
  514. #define UNEQ_LENGTH (1 + 11 + 4 + 11 + 1 + 20)
  515.     char            expl[UNEQ_LENGTH];
  516.     static char     c_oid[SPRINT_MAX_LEN];
  517.     size_t          sz;
  518.     char           *descr;
  519.     register char  *pch;
  520.     register char  *tmp;
  523.     snprint_objid(c_oid, sizeof(c_oid)-1, alarmed_var, alarmed_var_length);
  524.     c_oid[sizeof(c_oid)-1] = '';
  525.     for (pch = c_oid;;) {
  526.         tmp = strchr(pch, '.');
  527.         if (!tmp)
  528.             break;
  529.         if (isdigit(tmp[1]) || '"' == tmp[1])
  530.             break;
  531.         pch = tmp + 1;
  532.     }
  534.     snprintf(expl, UNEQ_LENGTH, "=%ld %s= %ld :%ld, %ld",
  535.              (unsigned long) value,
  536.              is_rising ? ">" : "<",
  537.              (unsigned long) the_threshold,
  538.              (long) alarm_index, (long) event_index);
  539.     sz = 3 + strlen(expl) + strlen(pch);
  540.     if (alarm_descr)
  541.         sz += strlen(alarm_descr);
  543.     descr = AGMALLOC(sz);
  544.     if (!descr) {
  545.         ag_trace("Can't allocate event description");
  546.         return NULL;
  547.     }
  549.     if (alarm_descr) {
  550.         strcpy(descr, alarm_descr);
  551.         strcat(descr, ":");
  552.     } else
  553.         *descr = '';
  555.     strcat(descr, pch);
  556.     strcat(descr, expl);
  557.     return descr;
  558. }
  560. extern void     send_enterprise_trap_vars(int, int, oid *, int,
  561.                                           netsnmp_variable_list *);
  563. static netsnmp_variable_list *
  564. oa_bind_var(netsnmp_variable_list * prev,
  565.             void *value, int type, size_t sz_val, oid * oid, size_t sz_oid)
  566. {
  567.     netsnmp_variable_list *var;
  569.     var = (netsnmp_variable_list *) malloc(sizeof(netsnmp_variable_list));
  570.     if (!var) {
  571.         ag_trace("FATAL: cannot malloc in oa_bind_varn");
  572.         exit(-1);               /* Sorry :( */
  573.     }
  574.     memset(var, 0, sizeof(netsnmp_variable_list));
  575.     var->next_variable = prev;
  576.     snmp_set_var_objid(var, oid, sz_oid);
  577.     snmp_set_var_value(var, (u_char *) value, sz_val);
  578.     var->type = type;
  580.     return var;
  581. }
  583. static void
  584. event_send_trap(CRTL_ENTRY_T * evptr, u_char is_rising,
  585.                 u_int alarm_index,
  586.                 u_int value, u_int the_threshold,
  587.                 oid * alarmed_var, size_t alarmed_var_length,
  588.                 u_int sample_type)
  589. {
  590.     static oid      rmon1_trap_oid[] = { 1, 3, 6, 1, 2, 1, 16, 0, 0 };
  591.     static oid      alarm_index_oid[] =
  592.         { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 1 };
  593.     static oid      alarmed_var_oid[] =
  594.         { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 3 };
  595.     static oid      sample_type_oid[] =
  596.         { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 4 };
  597.     static oid      value_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 5 };
  598.     static oid      threshold_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 7 };     /* rising case */
  599.     netsnmp_variable_list *top = NULL;
  600.     register int    iii;
  602.     /*
  603.      * set the last 'oid' : risingAlarm or fallingAlarm 
  604.      */
  605.     if (is_rising) {
  606.         iii = OID_LENGTH(rmon1_trap_oid);
  607.         rmon1_trap_oid[iii - 1] = 1;
  608.         iii = OID_LENGTH(threshold_oid);
  609.         threshold_oid[iii - 1] = 7;
  610.     } else {
  611.         iii = OID_LENGTH(rmon1_trap_oid);
  612.         rmon1_trap_oid[iii - 1] = 0;
  613.         iii = OID_LENGTH(threshold_oid);
  614.         threshold_oid[iii - 1] = 8;
  615.     }
  617.     /*
  618.      * build the var list 
  619.      */
  620.     top = oa_bind_var(top, &alarm_index, ASN_INTEGER, sizeof(u_int),
  621.                       alarm_index_oid, OID_LENGTH(alarm_index_oid));
  623.     top =
  624.         oa_bind_var(top, alarmed_var, ASN_OBJECT_ID,
  625.                     sizeof(oid) * alarmed_var_length, alarmed_var_oid,
  626.                     OID_LENGTH(alarmed_var_oid));
  628.     top = oa_bind_var(top, &sample_type, ASN_INTEGER, sizeof(u_int),
  629.                       sample_type_oid, OID_LENGTH(sample_type_oid));
  631.     top = oa_bind_var(top, &value, ASN_INTEGER, sizeof(u_int),
  632.                       value_oid, OID_LENGTH(value_oid));
  634.     top = oa_bind_var(top, &the_threshold, ASN_INTEGER, sizeof(u_int),
  635.                       threshold_oid, OID_LENGTH(threshold_oid));
  638.     send_enterprise_trap_vars(SNMP_TRAP_ENTERPRISESPECIFIC, 0,
  639.                               rmon1_trap_oid,
  640.                               OID_LENGTH(rmon1_trap_oid), top);
  641.     ag_trace("rmon trap has been sent");
  642.     snmp_free_varbind(top);
  644. }
  647. static void
  648. event_save_log(CRTL_ENTRY_T * body, char *event_descr)
  649. {
  650.     register DATA_ENTRY_T *lptr;
  652.     lptr = ROWDATAAPI_locate_new_data(&body->scrlr);
  653.     if (!lptr) {
  654.         ag_trace("Err: event_save_log:cannot locate ?");
  655.         return;
  656.     }
  658.     lptr->log_time = body->event_last_time_sent;
  659.     if (lptr->log_description)
  660.         AGFREE(lptr->log_description);
  661.     lptr->log_description = AGSTRDUP(event_descr);
  662.     lptr->data_index = ROWDATAAPI_get_total_number(&body->scrlr);
  664.     /*
  665.      * ag_trace ("log has been saved, data_index=%d", (int) lptr->data_index); 
  666.      */
  667. }
  669. int
  670. event_api_send_alarm(u_char is_rising,
  671.                      u_long alarm_index,
  672.                      u_long event_index,
  673.                      oid * alarmed_var,
  674.                      size_t alarmed_var_length,
  675.                      u_long sample_type,
  676.                      u_long value, u_long the_threshold, char *alarm_descr)
  677. {
  678.     RMON_ENTRY_T   *eptr;
  679.     CRTL_ENTRY_T   *evptr;
  681.     if (!event_index)
  682.         return SNMP_ERR_NOSUCHNAME;
  684. #if 0
  685.     ag_trace("event_api_send_alarm(%d,%d,%d,'%s')",
  686.              (int) is_rising, (int) alarm_index, (int) event_index,
  687.              alarm_descr);
  688. #endif
  689.     eptr = ROWAPI_find(table_ptr, event_index);
  690.     if (!eptr) {
  691.         /*
  692.          * ag_trace ("event cannot find entry %ld", event_index); 
  693.          */
  694.         return SNMP_ERR_NOSUCHNAME;
  695.     }
  697.     evptr = (CRTL_ENTRY_T *) eptr->body;
  698.     evptr->event_last_time_sent = AGUTIL_sys_up_time();
  701.     if (EVENT_TRAP == evptr->event_type
  702.         || EVENT_LOG_AND_TRAP == evptr->event_type) {
  703.         event_send_trap(evptr, is_rising, alarm_index, value,
  704.                         the_threshold, alarmed_var, alarmed_var_length,
  705.                         sample_type);
  706.     }
  708.     if (EVENT_LOG == evptr->event_type
  709.         || EVENT_LOG_AND_TRAP == evptr->event_type) {
  710.         register char  *explain;
  712.         explain = create_explanaition(evptr, is_rising,
  713.                                       alarm_index, event_index,
  714.                                       alarmed_var, alarmed_var_length,
  715.                                       value, the_threshold,
  716.                                       sample_type, alarm_descr);
  717.         /*
  718.          * if (explain) ag_trace ("Dbg:'%s'", explain); 
  719.          */
  720.         event_save_log(evptr, explain);
  721.         if (explain)
  722.             AGFREE(explain);
  723.     }
  725.     return SNMP_ERR_NOERROR;
  726. }
  728. #if 1                           /* debug, but may be used for init. TBD: may be token snmpd.conf ? */
  729. int
  730. add_event_entry(int ctrl_index,
  731.                 char *event_description,
  732.                 EVENT_TYPE_T event_type, char *event_community)
  733. {
  734.     register RMON_ENTRY_T *eptr;
  735.     register CRTL_ENTRY_T *body;
  736.     int             ierr;
  738.     ierr = ROWAPI_new(table_ptr, ctrl_index);
  739.     if (ierr) {
  740.         ag_trace("ROWAPI_new failed with %d", ierr);
  741.         return ierr;
  742.     }
  744.     eptr = ROWAPI_find(table_ptr, ctrl_index);
  745.     if (!eptr) {
  746.         ag_trace("ROWAPI_find failed");
  747.         return -4;
  748.     }
  750.     body = (CRTL_ENTRY_T *) eptr->body;
  752.     /*
  753.      * set parameters 
  754.      */
  756.     if (event_description) {
  757.         if (body->event_description)
  758.             AGFREE(body->event_description);
  759.         body->event_description = AGSTRDUP(event_description);
  760.     }
  762.     if (event_community) {
  763.         if (body->event_community)
  764.             AGFREE(body->event_community);
  765.         body->event_community = AGSTRDUP(event_community);
  766.     }
  768.     body->event_type = event_type;
  770.     eptr->new_status = RMON1_ENTRY_VALID;
  771.     ierr = ROWAPI_commit(table_ptr, ctrl_index);
  772.     if (ierr) {
  773.         ag_trace("ROWAPI_commit failed with %d", ierr);
  774.     }
  776.     return ierr;
  777. }
  778. #endif
  780. /*
  781.  * Registration & Initializatio section 
  782.  */
  784. oid             eventTable_variables_oid[] =
  785.     { 1, 3, 6, 1, 2, 1, 16, 9, 1 };
  786. oid             logTable_variables_oid[] = { 1, 3, 6, 1, 2, 1, 16, 9, 2 };
  788. struct variable2 eventTable_variables[] = {
  789.     /*
  790.      * magic number        , variable type, ro/rw , callback fn  ,           L, oidsuffix 
  791.      */
  792.     {EVENTINDEX, ASN_INTEGER, RONLY, var_eventTable, 2, {1, 1}},
  793.     {EVENTDESCRIPTION, ASN_OCTET_STR, RWRITE, var_eventTable, 2, {1, 2}},
  794.     {EVENTTYPE, ASN_INTEGER, RWRITE, var_eventTable, 2, {1, 3}},
  795.     {EVENTCOMMUNITY, ASN_OCTET_STR, RWRITE, var_eventTable, 2, {1, 4}},
  796.     {EVENTLASTTIMESENT, ASN_TIMETICKS, RONLY, var_eventTable, 2, {1, 5}},
  797.     {EVENTOWNER, ASN_OCTET_STR, RWRITE, var_eventTable, 2, {1, 6}},
  798.     {EVENTSTATUS, ASN_INTEGER, RWRITE, var_eventTable, 2, {1, 7}}
  799. };
  801. struct variable2 logTable_variables[] = {
  802.     /*
  803.      * magic number        , variable type, ro/rw , callback fn  ,           L, oidsuffix 
  804.      */
  805.     {LOGEVENTINDEX, ASN_INTEGER, RONLY, var_logTable, 2, {1, 1}},
  806.     {LOGINDEX, ASN_INTEGER, RONLY, var_logTable, 2, {1, 2}},
  807.     {LOGTIME, ASN_TIMETICKS, RONLY, var_logTable, 2, {1, 3}},
  808.     {LOGDESCRIPTION, ASN_OCTET_STR, RONLY, var_logTable, 2, {1, 4}}
  810. };
  812. void
  813. init_event(void)
  814. {
  815.     REGISTER_MIB("eventTable", eventTable_variables, variable2,
  816.                  eventTable_variables_oid);
  817.     REGISTER_MIB("logTable", logTable_variables, variable2,
  818.                  logTable_variables_oid);
  820.     ROWAPI_init_table(&EventCtrlTable, "Event", 0, &event_Create, &event_Clone, &event_Delete, NULL,    /* &event_Validate, */
  821.                       &event_Activate, &event_Deactivate, &event_Copy);
  822. #if 0
  823.     add_event_entry(3, "Alarm", EVENT_LOG_AND_TRAP, NULL);
  824.     /*
  825.      * add_event_entry (5, ">=", EVENT_LOG_AND_TRAP, NULL); 
  826.      */
  827. #endif
  828. }