alarm.c

snmp的源代码,已经在我的ubuntu下编译通过

/**************************************************************
 * 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 HAVE_UNISTD_H
#include <unistd.h>
#endif
#if TIME_WITH_SYS_TIME
# ifdef WIN32
#  include <sys/timeb.h>
# else
#  include <sys/time.h>
# endif
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif

#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include "util_funcs.h"
#include "alarm.h"
    /*
     * Implementation headers 
     */
#include "agutil_api.h"
#include "row_api.h"
    /*
     * File scope definitions section 
     */
    /*
     * from MIB compilation 
     */
#define alarmEntryFirstIndexBegin       11
#define MMM_MAX				0xFFFFFFFFl
#define IDalarmIndex                    1
#define IDalarmInterval                 2
#define IDalarmVariable                 3
#define IDalarmSampleType               4
#define IDalarmValue                    5
#define IDalarmStartupAlarm             6
#define IDalarmRisingThreshold          7
#define IDalarmFallingThreshold         8
#define IDalarmRisingEventIndex         9
#define IDalarmFallingEventIndex        10
#define IDalarmOwner                    11
#define IDalarmStatus                   12
#define MIN_alarmEventIndex             0
#define MAX_alarmEventIndex             65535
     typedef enum {
         SAMPLE_TYPE_ABSOLUTE =
             1,
         SAMPLE_TYPE_DELTE
     } SAMPLE_TYPE_T;

     typedef enum {
         ALARM_NOTHING =
             0,
         ALARM_RISING,
         ALARM_FALLING,
         ALARM_BOTH
     } ALARM_TYPE_T;

     typedef struct {
         u_long
             interval;
         u_long
             timer_id;
         VAR_OID_T
             var_name;
         SAMPLE_TYPE_T
             sample_type;
         ALARM_TYPE_T
             startup_type;      /* RISING | FALLING | BOTH */

         u_long
             rising_threshold;
         u_long
             falling_threshold;
         u_long
             rising_event_index;
         u_long
             falling_event_index;

         u_long
             last_abs_value;
         u_long
             value;
         ALARM_TYPE_T
             prev_alarm;        /* NOTHING | RISING | FALLING */
     } CRTL_ENTRY_T;

/*
 * Main section 
 */

     static TABLE_DEFINTION_T
         AlarmCtrlTable;
     static TABLE_DEFINTION_T *
         table_ptr = &
         AlarmCtrlTable;

#if 0                           /* KUKU */
     static u_long
         kuku_sum =
         0,
         kuku_cnt =
         0;
#endif

/*
 * find & enjoy it in event.c 
 */
     extern int
     event_api_send_alarm(u_char is_rising,
                          u_long alarm_index,
                          u_long event_index,
                          oid * alarmed_var,
                          size_t alarmed_var_length,
                          u_long sample_type,
                          u_long value,
                          u_long the_threshold, char *alarm_descr);

static int
fetch_var_val(oid * name, size_t namelen, u_long * new_value)
{
    netsnmp_subtree *tree_ptr;
    size_t          var_len;
    WriteMethod    *write_method;
    struct variable called_var;
    register struct variable *s_var_ptr = NULL;
    register u_char *access;


    tree_ptr = netsnmp_subtree_find(name, namelen, NULL, "");
    if (!tree_ptr) {
        ag_trace("tree_ptr is NULL");
        return SNMP_ERR_NOSUCHNAME;
    }

    
    memcpy(called_var.name, tree_ptr->name_a,
           tree_ptr->namelen * sizeof(oid));
 
    if (tree_ptr->reginfo && 
        tree_ptr->reginfo->handler && 
        tree_ptr->reginfo->handler->next && 
        tree_ptr->reginfo->handler->next->myvoid) {
        s_var_ptr = (struct variable *)tree_ptr->reginfo->handler->next->myvoid;
    }

    if (s_var_ptr) {
        if (s_var_ptr->namelen) {
                called_var.namelen = 
                                   tree_ptr->namelen;
                called_var.type = s_var_ptr->type;
                called_var.magic = s_var_ptr->magic;
                called_var.acl = s_var_ptr->acl;
                called_var.findVar = s_var_ptr->findVar;
                access =    
                    (*(s_var_ptr->findVar)) (&called_var, name, &namelen,
                                             1, &var_len, &write_method);

                if (access
                    && snmp_oid_compare(name, namelen, tree_ptr->end_a,
                                        tree_ptr->end_len) > 0) {
                    memcpy(name, tree_ptr->end_a, tree_ptr->end_len);
                    access = 0;
                    ag_trace("access := 0");
                }

                if (access) {

                    /*
                     * check 'var_len' ? 
                     */

                    /*
                     * check type 
                     */
                    switch (called_var.type) {
                    case ASN_INTEGER:
                    case ASN_COUNTER:
                    case ASN_TIMETICKS:
                    case ASN_GAUGE:
                    case ASN_COUNTER64:
                        break;
                    default:
                        ag_trace("invalid type: %d",
                                 (int) called_var.type);
                        return SNMP_ERR_GENERR;
                    }
                    *new_value = *(u_long *) access;
                    return SNMP_ERR_NOERROR;
                }
            }
        }

    return SNMP_ERR_NOSUCHNAME;
}

static void
alarm_check_var(unsigned int clientreg, void *clientarg)
{
    RMON_ENTRY_T   *hdr_ptr;
    CRTL_ENTRY_T   *body;
    u_long          new_value;
    int             ierr;

    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_unregister(body->timer_id);
        return;
    }

    ierr = fetch_var_val(body->var_name.objid,
                         body->var_name.length, &new_value);
    if (SNMP_ERR_NOERROR != ierr) {
        ag_trace("Err: Can't fetch var_name");
        return;
    }

    body->value = (SAMPLE_TYPE_ABSOLUTE == body->sample_type) ?
        new_value : new_value - body->last_abs_value;
    body->last_abs_value = new_value;
    /*
     * ag_trace ("fetched value=%ld check %ld", (long) new_value, (long) body->value); 
     */
#if 0                           /* KUKU */
    kuku_sum += body->value;
    kuku_cnt++;
#endif

    if (ALARM_RISING != body->prev_alarm &&
        body->value >= body->rising_threshold &&
        SNMP_ERR_NOERROR == event_api_send_alarm(1, hdr_ptr->ctrl_index,
                                                 body->rising_event_index,
                                                 body->var_name.objid,
                                                 body->var_name.length,
                                                 ALARM_RISING, body->value,
                                                 body->rising_threshold,
                                                 "Rising"))
        body->prev_alarm = ALARM_RISING;
    else if (ALARM_FALLING != body->prev_alarm &&
             body->value <= body->falling_threshold &&
             SNMP_ERR_NOERROR == event_api_send_alarm(0,
                                                      hdr_ptr->ctrl_index,
                                                      body->
                                                      falling_event_index,
                                                      body->var_name.objid,
                                                      body->var_name.
                                                      length, ALARM_RISING,
                                                      body->value,
                                                      body->
                                                      falling_threshold,
                                                      "Falling"))
        body->prev_alarm = ALARM_FALLING;
}

/*
 * Control Table RowApi Callbacks 
 */

int
alarm_Create(RMON_ENTRY_T * eptr)
{                               /* create the body: alloc it and set defaults */
    CRTL_ENTRY_T   *body;
    static VAR_OID_T DEFAULT_VAR = { 12,        /* etherStatsPkts.1 */
        {1, 3, 6, 1, 2, 1, 16, 1, 1, 1, 5, 1}
    };


    eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T));
    if (!eptr->body)
        return -3;
    body = (CRTL_ENTRY_T *) eptr->body;

    /*
     * set defaults 
     */
    body->interval = 1;
    memcpy(&body->var_name, &DEFAULT_VAR, sizeof(VAR_OID_T));
    body->sample_type = SAMPLE_TYPE_ABSOLUTE;
    body->startup_type = ALARM_BOTH;
    body->rising_threshold = MMM_MAX;
    body->falling_threshold = 0;
    body->rising_event_index = body->falling_event_index = 0;

    body->prev_alarm = ALARM_NOTHING;

    return 0;
}

int
alarm_Validate(RMON_ENTRY_T * eptr)
{
    CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;

    if (body->rising_threshold <= body->falling_threshold) {
        ag_trace("alarm_Validate failed: %lu must be > %lu",
                 body->rising_threshold, body->falling_threshold);
        return SNMP_ERR_BADVALUE;
    }

    return 0;
}

int
alarm_Activate(RMON_ENTRY_T * eptr)
{
    CRTL_ENTRY_T   *body = (CRTL_ENTRY_T *) eptr->body;
    int             ierr;

#if 0                           /* KUKU */
    kuku_sum = 0;
    kuku_cnt = 0;
#endif
    ierr = fetch_var_val(body->var_name.objid,
                         body->var_name.length, &body->last_abs_value);
    if (SNMP_ERR_NOERROR != ierr) {
        ag_trace("Can't fetch var_name");