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

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

SNMP编程

开发平台：

Unix_Linux

alarm.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 HAVE_UNISTD_H
  27. #include <unistd.h>
  28. #endif
  29. #if TIME_WITH_SYS_TIME
  30. # ifdef WIN32
  31. #  include <sys/timeb.h>
  32. # else
  33. #  include <sys/time.h>
  34. # endif
  35. # include <time.h>
  36. #else
  37. # if HAVE_SYS_TIME_H
  38. #  include <sys/time.h>
  39. # else
  40. #  include <time.h>
  41. # endif
  42. #endif
  44. #include <net-snmp/net-snmp-includes.h>
  45. #include <net-snmp/agent/net-snmp-agent-includes.h>
  46. #include "util_funcs.h"
  47. #include "alarm.h"
  48.     /*
  49.      * Implementation headers 
  50.      */
  51. #include "agutil_api.h"
  52. #include "row_api.h"
  53.     /*
  54.      * File scope definitions section 
  55.      */
  56.     /*
  57.      * from MIB compilation 
  58.      */
  59. #define alarmEntryFirstIndexBegin       11
  60. #define MMM_MAX 0xFFFFFFFFl
  61. #define IDalarmIndex                    1
  62. #define IDalarmInterval                 2
  63. #define IDalarmVariable                 3
  64. #define IDalarmSampleType               4
  65. #define IDalarmValue                    5
  66. #define IDalarmStartupAlarm             6
  67. #define IDalarmRisingThreshold          7
  68. #define IDalarmFallingThreshold         8
  69. #define IDalarmRisingEventIndex         9
  70. #define IDalarmFallingEventIndex        10
  71. #define IDalarmOwner                    11
  72. #define IDalarmStatus                   12
  73. #define MIN_alarmEventIndex             0
  74. #define MAX_alarmEventIndex             65535
  75.      typedef enum {
  76.          SAMPLE_TYPE_ABSOLUTE =
  77.              1,
  78.          SAMPLE_TYPE_DELTE
  79.      } SAMPLE_TYPE_T;
  81.      typedef enum {
  82.          ALARM_NOTHING =
  83.              0,
  84.          ALARM_RISING,
  85.          ALARM_FALLING,
  86.          ALARM_BOTH
  87.      } ALARM_TYPE_T;
  89.      typedef struct {
  90.          u_long
  91.              interval;
  92.          u_long
  93.              timer_id;
  94.          VAR_OID_T
  95.              var_name;
  96.          SAMPLE_TYPE_T
  97.              sample_type;
  98.          ALARM_TYPE_T
  99.              startup_type;      /* RISING | FALLING | BOTH */
  101.          u_long
  102.              rising_threshold;
  103.          u_long
  104.              falling_threshold;
  105.          u_long
  106.              rising_event_index;
  107.          u_long
  108.              falling_event_index;
  110.          u_long
  111.              last_abs_value;
  112.          u_long
  113.              value;
  114.          ALARM_TYPE_T
  115.              prev_alarm;        /* NOTHING | RISING | FALLING */
  116.      } CRTL_ENTRY_T;
  118. /*
  119.  * Main section 
  120.  */
  122.      static TABLE_DEFINTION_T
  123.          AlarmCtrlTable;
  124.      static TABLE_DEFINTION_T *
  125.          table_ptr = &
  126.          AlarmCtrlTable;
  128. #if 0                           /* KUKU */
  129.      static u_long
  130.          kuku_sum =
  131.          0,
  132.          kuku_cnt =
  133.          0;
  134. #endif
  136. /*
  137.  * find & enjoy it in event.c 
  138.  */
  139.      extern int
  140.      event_api_send_alarm(u_char is_rising,
  141.                           u_long alarm_index,
  142.                           u_long event_index,
  143.                           oid * alarmed_var,
  144.                           size_t alarmed_var_length,
  145.                           u_long sample_type,
  146.                           u_long value,
  147.                           u_long the_threshold, char *alarm_descr);
  149. static int
  150. fetch_var_val(oid * name, size_t namelen, u_long * new_value)
  151. {
  152.     netsnmp_subtree *tree_ptr;
  153.     size_t          var_len;
  154.     WriteMethod    *write_method;
  155.     struct variable called_var;
  156.     register struct variable *s_var_ptr = NULL;
  157.     register u_char *access;
  160.     tree_ptr = netsnmp_subtree_find(name, namelen, NULL, "");
  161.     if (!tree_ptr) {
  162.         ag_trace("tree_ptr is NULL");
  163.         return SNMP_ERR_NOSUCHNAME;
  164.     }
  166.     
  167.     memcpy(called_var.name, tree_ptr->name_a,
  168.            tree_ptr->namelen * sizeof(oid));
  169.  
  170.     if (tree_ptr->reginfo && 
  171.         tree_ptr->reginfo->handler && 
  172.         tree_ptr->reginfo->handler->next && 
  173.         tree_ptr->reginfo->handler->next->myvoid) {
  174.         s_var_ptr = (struct variable *)tree_ptr->reginfo->handler->next->myvoid;
  175.     }
  177.     if (s_var_ptr) {
  178.         if (s_var_ptr->namelen) {
  179.                 called_var.namelen = 
  180.                                    tree_ptr->namelen;
  181.                 called_var.type = s_var_ptr->type;
  182.                 called_var.magic = s_var_ptr->magic;
  183.                 called_var.acl = s_var_ptr->acl;
  184.                 called_var.findVar = s_var_ptr->findVar;
  185.                 access =    
  186.                     (*(s_var_ptr->findVar)) (&called_var, name, &namelen,
  187.                                              1, &var_len, &write_method);
  189.                 if (access
  190.                     && snmp_oid_compare(name, namelen, tree_ptr->end_a,
  191.                                         tree_ptr->end_len) > 0) {
  192.                     memcpy(name, tree_ptr->end_a, tree_ptr->end_len);
  193.                     access = 0;
  194.                     ag_trace("access := 0");
  195.                 }
  197.                 if (access) {
  199.                     /*
  200.                      * check 'var_len' ? 
  201.                      */
  203.                     /*
  204.                      * check type 
  205.                      */
  206.                     switch (called_var.type) {
  207.                     case ASN_INTEGER:
  208.                     case ASN_COUNTER:
  209.                     case ASN_TIMETICKS:
  210.                     case ASN_GAUGE:
  211.                     case ASN_COUNTER64:
  212.                         break;
  213.                     default:
  214.                         ag_trace("invalid type: %d",
  215.                                  (int) called_var.type);
  216.                         return SNMP_ERR_GENERR;
  217.                     }
  218.                     *new_value = *(u_long *) access;
  219.                     return SNMP_ERR_NOERROR;
  220.                 }
  221.             }
  222.         }
  224.     return SNMP_ERR_NOSUCHNAME;
  225. }
  227. static void
  228. alarm_check_var(unsigned int clientreg, void *clientarg)
  229. {
  230.     RMON_ENTRY_T   *hdr_ptr;
  231.     CRTL_ENTRY_T   *body;
  232.     u_long          new_value;
  233.     int             ierr;
  235.     hdr_ptr = (RMON_ENTRY_T *) clientarg;
  236.     if (!hdr_ptr) {
  237.         ag_trace
  238.             ("Err: history_get_backet: hdr_ptr=NULL ? (Inserted in shock)");
  239.         return;
  240.     }
  242.     body = (CRTL_ENTRY_T *) hdr_ptr->body;
  243.     if (!body) {
  244.         ag_trace
  245.             ("Err: history_get_backet: body=NULL ? (Inserted in shock)");
  246.         return;
  247.     }
  249.     if (RMON1_ENTRY_VALID != hdr_ptr->status) {
  250.         ag_trace("Err: history_get_backet when entry %d is not valid ?!!",
  251.                  (int) hdr_ptr->ctrl_index);
  252.         snmp_alarm_unregister(body->timer_id);
  253.         return;
  254.     }
  256.     ierr = fetch_var_val(body->var_name.objid,
  257.                          body->var_name.length, &new_value);
  258.     if (SNMP_ERR_NOERROR != ierr) {
  259.         ag_trace("Err: Can't fetch var_name");
  260.         return;
  261.     }
  263.     body->value = (SAMPLE_TYPE_ABSOLUTE == body->sample_type) ?
  264.         new_value : new_value - body->last_abs_value;
  265.     body->last_abs_value = new_value;
  266.     /*
  267.      * ag_trace ("fetched value=%ld check %ld", (long) new_value, (long) body->value); 
  268.      */
  269. #if 0                           /* KUKU */
  270.     kuku_sum += body->value;
  271.     kuku_cnt++;
  272. #endif
  274.     if (ALARM_RISING != body->prev_alarm &&
  275.         body->value >= body->rising_threshold &&
  276.         SNMP_ERR_NOERROR == event_api_send_alarm(1, hdr_ptr->ctrl_index,
  277.                                                  body->rising_event_index,
  278.                                                  body->var_name.objid,
  279.                                                  body->var_name.length,
  280.                                                  ALARM_RISING, body->value,
  281.                                                  body->rising_threshold,
  282.                                                  "Rising"))
  283.         body->prev_alarm = ALARM_RISING;
  284.     else if (ALARM_FALLING != body->prev_alarm &&
  285.              body->value <= body->falling_threshold &&
  286.              SNMP_ERR_NOERROR == event_api_send_alarm(0,
  287.                                                       hdr_ptr->ctrl_index,
  288.                                                       body->
  289.                                                       falling_event_index,
  290.                                                       body->var_name.objid,
  291.                                                       body->var_name.
  292.                                                       length, ALARM_RISING,
  293.                                                       body->value,
  294.                                                       body->
  295.                                                       falling_threshold,
  296.                                                       "Falling"))
  297.         body->prev_alarm = ALARM_FALLING;
  298. }
  300. /*
  301.  * Control Table RowApi Callbacks 
  302.  */
  304. int
  305. alarm_Create(RMON_ENTRY_T * eptr)
  306. {                               /* create the body: alloc it and set defaults */
  307.     CRTL_ENTRY_T   *body;
  308.     static VAR_OID_T DEFAULT_VAR = { 12,        /* etherStatsPkts.1 */
  309.         {1, 3, 6, 1, 2, 1, 16, 1, 1, 1, 5, 1}
  310.     };
  313.     eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T));
  314.     if (!eptr->body)
  315.         return -3;
  316.     body = (CRTL_ENTRY_T *) eptr->body;
  318.     /*
  319.      * set defaults 
  320.      */
  321.     body->interval = 1;
  322.     memcpy(&body->var_name, &DEFAULT_VAR, sizeof(VAR_OID_T));
  323.     body->sample_type = SAMPLE_TYPE_ABSOLUTE;
  324.     body->startup_type = ALARM_BOTH;
  325.     body->rising_threshold = MMM_MAX;
  326.     body->falling_threshold = 0;
  327.     body->rising_event_index = body->falling_event_index = 0;
  329.     body->prev_alarm = ALARM_NOTHING;
  331.     return 0;
  332. }
  334. int
  335. alarm_Validate(RMON_ENTRY_T * eptr)
  336. {
  337.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  339.     if (body->rising_threshold <= body->falling_threshold) {
  340.         ag_trace("alarm_Validate failed: %lu must be > %lu",
  341.                  body->rising_threshold, body->falling_threshold);
  342.         return SNMP_ERR_BADVALUE;
  343.     }
  345.     return 0;
  346. }
  348. int
  349. alarm_Activate(RMON_ENTRY_T * eptr)
  350. {
  351.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  352.     int             ierr;
  354. #if 0                           /* KUKU */
  355.     kuku_sum = 0;
  356.     kuku_cnt = 0;
  357. #endif
  358.     ierr = fetch_var_val(body->var_name.objid,
  359.                          body->var_name.length, &body->last_abs_value);
  360.     if (SNMP_ERR_NOERROR != ierr) {
  361.         ag_trace("Can't fetch var_name");
  362.         return ierr;
  363.     }
  365.     if (SAMPLE_TYPE_ABSOLUTE != body->sample_type) {
  366.         /*
  367.          * check startup alarm 
  368.          */
  369.         if (ALARM_RISING == body->startup_type ||
  370.             ALARM_BOTH == body->startup_type) {
  371.             if (body->last_abs_value >= body->rising_threshold) {
  372.                 event_api_send_alarm(1, eptr->ctrl_index,
  373.                                      body->rising_event_index,
  374.                                      body->var_name.objid,
  375.                                      body->var_name.length,
  376.                                      ALARM_RISING, body->value,
  377.                                      body->rising_threshold,
  378.                                      "Startup Rising");
  379.             }
  380.         }
  382.         if (ALARM_FALLING == body->startup_type ||
  383.             ALARM_BOTH == body->startup_type) {
  384.             if (body->last_abs_value <= body->falling_threshold) {
  385.                 event_api_send_alarm(0, eptr->ctrl_index,
  386.                                      body->falling_event_index,
  387.                                      body->var_name.objid,
  388.                                      body->var_name.length,
  389.                                      ALARM_RISING, body->value,
  390.                                      body->falling_threshold,
  391.                                      "Startup Falling");
  392.             }
  393.         }
  395.     }
  397.     body->timer_id = snmp_alarm_register(body->interval, SA_REPEAT,
  398.                                          alarm_check_var, eptr);
  399.     return 0;
  400. }
  402. int
  403. alarm_Deactivate(RMON_ENTRY_T * eptr)
  404. {
  405.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  407.     snmp_alarm_unregister(body->timer_id);
  408. #if 0                           /* KUKU */
  409.     ag_trace("kuku_sum=%ld kuku_cnt=%ld sp=%ld",
  410.              (long) kuku_sum, (long) kuku_cnt,
  411.              (long) (kuku_sum / kuku_cnt));
  412. #endif
  413.     return 0;
  414. }
  416. int
  417. alarm_Copy(RMON_ENTRY_T * eptr)
  418. {
  419.     CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
  420.     CRTL_ENTRY_T   *clone = (CRTL_ENTRY_T *) eptr->tmp;
  422.     if (RMON1_ENTRY_VALID == eptr->status &&
  423.         clone->rising_threshold <= clone->falling_threshold) {
  424.         ag_trace("alarm_Copy failed: invalid thresholds");
  425.         return SNMP_ERR_BADVALUE;
  426.     }
  428.     if (clone->interval != body->interval) {
  429.         if (RMON1_ENTRY_VALID == eptr->status) {
  430.             snmp_alarm_unregister(body->timer_id);
  431.             body->timer_id =
  432.                 snmp_alarm_register(clone->interval, SA_REPEAT,
  433.                                     alarm_check_var, eptr);
  434.         }
  435.         body->interval = clone->interval;
  436.     }
  438.     if (snmp_oid_compare(clone->var_name.objid, clone->var_name.length,
  439.                          body->var_name.objid, body->var_name.length)) {
  440.         memcpy(&body->var_name, &clone->var_name, sizeof(VAR_OID_T));
  441.     }
  443.     body->sample_type = clone->sample_type;
  444.     body->startup_type = clone->startup_type;
  445.     body->sample_type = clone->sample_type;
  446.     body->rising_threshold = clone->rising_threshold;
  447.     body->falling_threshold = clone->falling_threshold;
  448.     body->rising_event_index = clone->rising_event_index;
  449.     body->falling_event_index = clone->falling_event_index;
  450.     /*
  451.      * ag_trace ("alarm_Copy: rising_threshold=%lu falling_threshold=%lu",
  452.      * body->rising_threshold, body->falling_threshold); 
  453.      */
  454.     return 0;
  455. }
  457. static int
  458. write_alarmEntry(int action, u_char * var_val, u_char var_val_type,
  459.                  size_t var_val_len, u_char * statP,
  460.                  oid * name, size_t name_len)
  461. {
  462.     long            long_tmp;
  463.     int             leaf_id, snmp_status;
  464.     static int      prev_action = COMMIT;
  465.     RMON_ENTRY_T   *hdr;
  466.     CRTL_ENTRY_T   *cloned_body;
  467.     CRTL_ENTRY_T   *body;
  469.     switch (action) {
  470.     case RESERVE1:
  471.     case FREE:
  472.     case UNDO:
  473.     case ACTION:
  474.     case COMMIT:
  475.     default:
  476.         return ROWAPI_do_another_action(name, alarmEntryFirstIndexBegin,
  477.                                         action, &prev_action,
  478.                                         table_ptr, sizeof(CRTL_ENTRY_T));
  479.     case RESERVE2:
  480.         /*
  481.          * get values from PDU, check them and save them in the cloned entry 
  482.          */
  483.         long_tmp = name[alarmEntryFirstIndexBegin];
  484.         leaf_id = (int) name[alarmEntryFirstIndexBegin - 1];
  485.         hdr = ROWAPI_find(table_ptr, long_tmp); /* it MUST be OK */
  486.         cloned_body = (CRTL_ENTRY_T *) hdr->tmp;
  487.         body = (CRTL_ENTRY_T *) hdr->body;
  488.         switch (leaf_id) {
  489.         case IDalarmInterval:
  490.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  491.                                                var_val_len,
  492.                                                0, MMM_MAX, &long_tmp);
  493.             if (SNMP_ERR_NOERROR != snmp_status) {
  494.                 return snmp_status;
  495.             }
  496.             cloned_body->interval = long_tmp;
  497.             break;
  498.         case IDalarmVariable:
  499.             snmp_status = AGUTIL_get_oid_value(var_val, var_val_type,
  500.                                                var_val_len,
  501.                                                &cloned_body->var_name);
  502.             if (SNMP_ERR_NOERROR != snmp_status) {
  503.                 return snmp_status;
  504.             }
  505.             if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&
  506.                 snmp_oid_compare(cloned_body->var_name.objid,
  507.                                  cloned_body->var_name.length,
  508.                                  body->var_name.objid,
  509.                                  body->var_name.length))
  510.                 return SNMP_ERR_BADVALUE;
  511.             break;
  513.             break;
  514.         case IDalarmSampleType:
  515.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  516.                                                var_val_len,
  517.                                                SAMPLE_TYPE_ABSOLUTE,
  518.                                                SAMPLE_TYPE_DELTE,
  519.                                                &long_tmp);
  520.             if (SNMP_ERR_NOERROR != snmp_status) {
  521.                 return snmp_status;
  522.             }
  523.             cloned_body->sample_type = long_tmp;
  524.             break;
  525.         case IDalarmStartupAlarm:
  526.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  527.                                                var_val_len,
  528.                                                ALARM_RISING,
  529.                                                ALARM_BOTH, &long_tmp);
  530.             if (SNMP_ERR_NOERROR != snmp_status) {
  531.                 return snmp_status;
  532.             }
  533.             cloned_body->startup_type = long_tmp;
  534.             break;
  535.         case IDalarmRisingThreshold:
  536.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  537.                                                var_val_len,
  538.                                                0, MMM_MAX, &long_tmp);
  539.             if (SNMP_ERR_NOERROR != snmp_status) {
  540.                 return snmp_status;
  541.             }
  542.             cloned_body->rising_threshold = long_tmp;
  543.             break;
  544.         case IDalarmFallingThreshold:
  545.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  546.                                                var_val_len,
  547.                                                0, 0xFFFFFFFFl, &long_tmp);
  548.             if (SNMP_ERR_NOERROR != snmp_status) {
  549.                 return snmp_status;
  550.             }
  551.             cloned_body->falling_threshold = long_tmp;
  552.             break;
  553.         case IDalarmRisingEventIndex:
  554.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type, var_val_len, 0,   /* min. value */
  555.                                                0,       /* max. value */
  556.                                                &long_tmp);
  557.             if (SNMP_ERR_NOERROR != snmp_status) {
  558.                 return snmp_status;
  559.             }
  560.             cloned_body->rising_event_index = long_tmp;
  561.             break;
  562.         case IDalarmFallingEventIndex:
  563.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type, var_val_len, 0,   /* min. value */
  564.                                                0,       /* max. value */
  565.                                                &long_tmp);
  566.             if (SNMP_ERR_NOERROR != snmp_status) {
  567.                 return snmp_status;
  568.             }
  569.             cloned_body->falling_event_index = long_tmp;
  570.             break;
  571.         case IDalarmOwner:
  572.             if (hdr->new_owner)
  573.                 AGFREE(hdr->new_owner);
  574.             hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);;
  575.             if (!hdr->new_owner)
  576.                 return SNMP_ERR_TOOBIG;
  577.             snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
  578.                                                   var_val_len,
  579.                                                   MAX_OWNERSTRING,
  580.                                                   1, NULL, hdr->new_owner);
  581.             if (SNMP_ERR_NOERROR != snmp_status) {
  582.                 return snmp_status;
  583.             }
  585.             break;
  586.         case IDalarmStatus:
  587.             snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
  588.                                                var_val_len,
  589.                                                RMON1_ENTRY_VALID,
  590.                                                RMON1_ENTRY_INVALID,
  591.                                                &long_tmp);
  592.             if (SNMP_ERR_NOERROR != snmp_status) {
  593.                 return snmp_status;
  594.             }
  595.             hdr->new_status = long_tmp;
  596.             break;
  597.         default:
  598.             ag_trace("%s:unknown leaf_id=%dn", table_ptr->name,
  599.                      (int) leaf_id);
  600.             return SNMP_ERR_NOSUCHNAME;
  601.         }                       /* of switch by 'leaf_id' */
  603.         break;
  604.     }                           /* of switch by actions */
  606.     prev_action = action;
  607.     return SNMP_ERR_NOERROR;
  608. }
  610. u_char         *
  611. var_alarmEntry(struct variable * vp, oid * name, size_t * length,
  612.                int exact, size_t * var_len, WriteMethod ** write_method)
  613. {
  614.     static long     long_return;
  615.     static CRTL_ENTRY_T theEntry;
  616.     RMON_ENTRY_T   *hdr;
  618.     *write_method = write_alarmEntry;
  619.     hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len,
  620.                                      table_ptr,
  621.                                      &theEntry, sizeof(CRTL_ENTRY_T));
  622.     if (!hdr)
  623.         return NULL;
  625.     *var_len = sizeof(long);    /* default */
  627.     switch (vp->magic) {
  628.     case IDalarmIndex:
  629.         long_return = hdr->ctrl_index;
  630.         return (u_char *) & long_return;
  631.     case IDalarmInterval:
  632.         long_return = theEntry.interval;
  633.         return (u_char *) & long_return;
  634.     case IDalarmVariable:
  635.         *var_len = sizeof(oid) * theEntry.var_name.length;
  636.         return (unsigned char *) theEntry.var_name.objid;
  637.         return (u_char *) & long_return;
  638.     case IDalarmSampleType:
  639.         long_return = theEntry.sample_type;
  640.         return (u_char *) & long_return;
  641.     case IDalarmValue:
  642.         long_return = theEntry.value;
  643.         return (u_char *) & long_return;
  644.     case IDalarmStartupAlarm:
  645.         long_return = theEntry.startup_type;
  646.         return (u_char *) & long_return;
  647.     case IDalarmRisingThreshold:
  648.         long_return = theEntry.rising_threshold;
  649.         return (u_char *) & long_return;
  650.     case IDalarmFallingThreshold:
  651.         long_return = theEntry.falling_threshold;
  652.         return (u_char *) & long_return;
  653.     case IDalarmRisingEventIndex:
  654.         long_return = theEntry.rising_event_index;
  655.         return (u_char *) & long_return;
  656.     case IDalarmFallingEventIndex:
  657.         long_return = theEntry.falling_event_index;
  658.         return (u_char *) & long_return;
  659.     case IDalarmOwner:
  660.         if (hdr->owner) {
  661.             *var_len = strlen(hdr->owner);
  662.             return (unsigned char *) hdr->owner;
  663.         } else {
  664.             *var_len = 0;
  665.             return (unsigned char *) "";
  666.         }
  668.     case IDalarmStatus:
  669.         long_return = hdr->status;
  670.         return (u_char *) & long_return;
  671.     default:
  672.         ag_trace("%s: unknown vp->magic=%d", table_ptr->name,
  673.                  (int) vp->magic);
  674.         ERROR_MSG("");
  675.     };                          /* of switch by 'vp->magic' */
  677.     return NULL;
  678. }
  680. /*
  681.  * Registration & Initializatio section 
  682.  */
  684. oid             oidalarmVariablesOid[] = { 1, 3, 6, 1, 2, 1, 16, 3 };
  686. struct variable7 oidalarmVariables[] = {
  687.     {IDalarmIndex, ASN_INTEGER, RONLY, var_alarmEntry, 3, {1, 1, 1}},
  688.     {IDalarmInterval, ASN_INTEGER, RWRITE, var_alarmEntry, 3, {1, 1, 2}},
  689.     {IDalarmVariable, ASN_OBJECT_ID, RWRITE, var_alarmEntry, 3, {1, 1, 3}},
  690.     {IDalarmSampleType, ASN_INTEGER, RWRITE, var_alarmEntry, 3, {1, 1, 4}},
  691.     {IDalarmValue, ASN_INTEGER, RONLY, var_alarmEntry, 3, {1, 1, 5}},
  692.     {IDalarmStartupAlarm, ASN_INTEGER, RWRITE, var_alarmEntry, 3,
  693.      {1, 1, 6}},
  694.     {IDalarmRisingThreshold, ASN_INTEGER, RWRITE, var_alarmEntry, 3,
  695.      {1, 1, 7}},
  696.     {IDalarmFallingThreshold, ASN_INTEGER, RWRITE, var_alarmEntry, 3,
  697.      {1, 1, 8}},
  698.     {IDalarmRisingEventIndex, ASN_INTEGER, RWRITE, var_alarmEntry, 3,
  699.      {1, 1, 9}},
  700.     {IDalarmFallingEventIndex, ASN_INTEGER, RWRITE, var_alarmEntry, 3,
  701.      {1, 1, 10}},
  702.     {IDalarmOwner, ASN_OCTET_STR, RWRITE, var_alarmEntry, 3, {1, 1, 11}},
  703.     {IDalarmStatus, ASN_INTEGER, RWRITE, var_alarmEntry, 3, {1, 1, 12}}
  704. };
  706. void
  707. init_alarm(void)
  708. {
  709.     REGISTER_MIB("alarmTable", oidalarmVariables, variable7,
  710.                  oidalarmVariablesOid);
  712.     ROWAPI_init_table(&AlarmCtrlTable, "Alarm", 0, &alarm_Create, NULL, /* &alarm_Clone, */
  713.                       NULL,     /* &alarm_Delete, */
  714.                       &alarm_Validate,
  715.                       &alarm_Activate, &alarm_Deactivate, &alarm_Copy);
  716. }
  718. /*
  719.  * end of file alarm.c 
  720.  */