alarm_c.c

嵌入式RMON,RMON为Remote monitor的缩写,基于SNMP为网络提供主动监控及错误告警,智能交换路由必备协议

/* Beholder RMON ethernet network monitor,Copyright (C) 1993 DNPAP group */
/* See file COPYING 'GNU General Public Licence' for copyright details   */
#include <dnpap.h>
#include <event.h>
#include <memory.h>
#include <message.h>
#include <mibsup.h>
#include <mibrqs.h>
#include <stdlib.h>
#include <string.h>
#include <trap.h>

#include "alarm_e.h"
#include "alarm_d.h"
#include "alarm_c.h"


IMPORT BOOLEAN BeholderStrictRMON;


static CHAR MODULE[] = "AlarmC";

static SNMP_OBJECT varobj = { SNMP_PDU_GET, { 0, 0 }, 2, SNMP_INTEGER };
static SNMP_OBJECT invobj = { SNMP_PDU_SET, { MIB_ALARM,MIB_INDEX_ALARMSTATUS }, MIB_LEN_ALARM+2, SNMP_INTEGER, SNMP_INVALID };
static SNMP_OBJECT trapobj[] = 
{
	{ SNMP_PDU_TRAP, { MIB_ALARM,MIB_INDEX_ALARMINDEX }, MIB_LEN_ALARM+2, SNMP_INTEGER, 0 },
	{ SNMP_PDU_TRAP, { MIB_ALARM,MIB_INDEX_ALARMVARIABLE }, MIB_LEN_ALARM+2, SNMP_OBJECTID, 0, 0 },
	{ SNMP_PDU_TRAP, { MIB_ALARM,MIB_INDEX_ALARMSAMPLETYPE }, MIB_LEN_ALARM+2, SNMP_INTEGER, 0 },
	{ SNMP_PDU_TRAP, { MIB_ALARM,MIB_INDEX_ALARMVALUE }, MIB_LEN_ALARM+2, SNMP_INTEGER, 0 },
	{ SNMP_PDU_TRAP, { MIB_ALARM,MIB_INDEX_ALARMRISINGTHRESHOLD }, MIB_LEN_ALARM+2, SNMP_INTEGER, 0 }
};
static INT traplen = sizeof(trapobj)/sizeof(trapobj[0]);

static VOID AlarmFillTrap(RmonAlarm *alarm, BOOLEAN rising);

static VOID AlarmCallback(TIMER_DESCR *timer, ULONG now, VOID *param);



BOOLEAN AlarmCInit(RmonAlarm* alarm)
{
    alarm->Index = 0;
    alarm->Interval = 1;
    alarm->Variable[0] = 0;
    alarm->Variable[1] = 0;
    alarm->VarLen = 2;
    alarm->SampleType = ALARM_ABSOLUTE;
    alarm->Value = 0;
    alarm->PrevValue = 0;
    alarm->PrevDeltaValue = 0;
    alarm->StartupAlarm = 0;
    alarm->RisingThreshold = 0;
    alarm->RisingEvent = FALSE;
    alarm->FallingThreshold = 0;
    alarm->FallingEvent = FALSE;
    alarm->RisingEventIndex = 0;
    alarm->FallingEventIndex = 0;
    alarm->Owner[0] = '\0';
    alarm->OwnerLen = 0;
    alarm->Status = SNMP_INVALID;
    alarm->Timer = NULL;
	alarm->JustStarted = TRUE;

	BooleanSetAllTrue(alarm->ObjectSet);
	BooleanSetFalse(alarm->ObjectSet, ALARM_BOOLEAN_VARIABLE);
	BooleanSetFalse(alarm->ObjectSet, ALARM_BOOLEAN_OWNER);

    return TRUE;
}


BOOLEAN AlarmCStart(RmonAlarm* alarm)
{
LONG value;

	if (BeholderStrictRMON && !BooleanCheckAllTrue(alarm->ObjectSet))
		return FALSE;

    alarm->RisingEvent = FALSE;
    alarm->FallingEvent = FALSE;
	
    if (AlarmSample(alarm->Variable, alarm->VarLen, &value, &varobj) != SNMP_NOERROR)
    {
    	DnpapMessage(DMC_ERROR, ALARM_SAMPLE, "alarm %ld: can not sample MIB variable", alarm->Index);
        invobj.Id[MIB_LEN_ALARM+1] = alarm->Index;
        if (MibRequest(&invobj) != SNMP_NOERROR)
    	    DnpapMessage(DMC_ERROR, ALARM_INVALID, "can not destroy alarm entry %ld", alarm->Index);
        return FALSE;
    }

    if (alarm->SampleType == ALARM_ABSOLUTE)
    {
        if ((alarm->Timer = TimerRegister(AlarmCallback, (VOID*)alarm, alarm->Interval*1000, TIMER_FOREVER, TIMER_TYPE_SKIP)) == NULL)
            return FALSE;
		alarm->Value = value;
    }
    else
    if (alarm->SampleType == ALARM_DELTA)       /*  sample twice as much for the precise algorithm  */
    {
        if ((alarm->Timer = TimerRegister(AlarmCallback, (VOID*)alarm, alarm->Interval*500, TIMER_FOREVER, TIMER_TYPE_SKIP)) == NULL)
            return FALSE;
		alarm->Value = 0;
        alarm->PrevValue = value;
        alarm->PrevDeltaValue = 0;
    }

    if (alarm->SampleType == ALARM_ABSOLUTE)
    {
        switch (alarm->StartupAlarm)
        {
        case ALARM_RISINGFALLING:
            if (value < alarm->FallingThreshold)
			{
				AlarmFillTrap(alarm, FALSE);
                alarm->FallingEvent = GenerateEvent(MODULE, alarm->FallingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_FALLINGALARM, trapobj, traplen);
			}
            if (value > alarm->RisingThreshold)
			{
				AlarmFillTrap(alarm, TRUE);
                alarm->RisingEvent = GenerateEvent(MODULE, alarm->RisingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_RISINGALARM, trapobj, traplen);
			}
            break;
        case ALARM_RISING:
            if (value > alarm->RisingThreshold)
			{
				AlarmFillTrap(alarm, TRUE);
                alarm->RisingEvent = GenerateEvent(MODULE, alarm->RisingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_RISINGALARM, trapobj, traplen);
			}
            break;
        case ALARM_FALLING:
            if (value < alarm->FallingThreshold)
			{
				AlarmFillTrap(alarm, FALSE);
                alarm->FallingEvent = GenerateEvent(MODULE, alarm->FallingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_FALLINGALARM, trapobj, traplen);
			}
            break;
        default:
            break;
        }
    }    
    
	alarm->JustStarted = TRUE;
	
    return TRUE;
}


BOOLEAN AlarmCStop(RmonAlarm* alarm)
{
    TimerRemove(alarm->Timer);
    
    return TRUE;
}


WORD AlarmSample(LONG *id, WORD idlen, LONG *value, SNMP_OBJECT *obj)
{
    obj->Request = SNMP_PDU_GET;
	memcpy(obj->Id, id, (obj->IdLen = idlen)*sizeof(id[0]));
	if (MibRequest(obj) != SNMP_NOERROR)
        return SNMP_NOSUCHNAME;
	
	switch (obj->Type)
	{
	case SNMP_INTEGER:
	case SNMP_COUNTER:
	case SNMP_GAUGE:
	case SNMP_TIMETICKS:
		*value = obj->Syntax.LngInt;
		return SNMP_NOERROR;
	default:
		return SNMP_BADVALUE;
	}
}


VOID AlarmFillTrap(RmonAlarm *alarm, BOOLEAN rising)
{
INT i;

	/* set alarm instance in trap varbinds */		  				   
	for (i = 0; i < traplen; i++)
		trapobj[i].Id[MIB_LEN_ALARM+1] = alarm->Index;

	/* set values in varbinds */	
	trapobj[0].Syntax.LngInt = alarm->Index;
	memcpy(trapobj[1].Syntax.BufInt, alarm->Variable, alarm->VarLen*sizeof(alarm->Variable[0]));
	trapobj[2].Syntax.LngInt = alarm->SampleType;
	trapobj[3].Syntax.LngInt = alarm->Value;
	if (rising == TRUE)
	{
		trapobj[4].Id[MIB_LEN_ALARM] = MIB_INDEX_ALARMRISINGTHRESHOLD;
		trapobj[4].Syntax.LngInt = alarm->RisingThreshold;
	}
	else
	{
		trapobj[4].Id[MIB_LEN_ALARM] = MIB_INDEX_ALARMFALLINGTHRESHOLD;
		trapobj[4].Syntax.LngInt = alarm->FallingThreshold;
	}
}


VOID AlarmCallback(TIMER_DESCR *timer, ULONG now, VOID *param)
{
RmonAlarm *alarm = param;
LONG value, delta;

	if (AlarmSample(alarm->Variable, alarm->VarLen, &value, &varobj) != SNMP_NOERROR)
    {
    	DnpapMessage(DMC_ERROR, ALARM_SAMPLE, "alarm %ld: can not sample MIB variable", alarm->Index);
        invobj.Id[MIB_LEN_ALARM+1] = alarm->Index;
        if (MibRequest(&invobj) != SNMP_NOERROR)
    	    DnpapMessage(DMC_ERROR, ALARM_INVALID, "can not destroy alarm entry %ld", alarm->Index);
        return;
    }

    if (alarm->SampleType == ALARM_DELTA)
    {
        /*  calculate the sum of the last 2 delta values  */
        alarm->Value = (delta = value - alarm->PrevValue) + alarm->PrevDeltaValue;
        alarm->PrevValue = value;
        alarm->PrevDeltaValue = delta;
		
		if (alarm->JustStarted == TRUE)
		{
			value = alarm->Value;
			
	        switch (alarm->StartupAlarm)
	        {
	        case ALARM_RISINGFALLING:
	            if (value < alarm->FallingThreshold)
				{
					AlarmFillTrap(alarm, FALSE);
	                alarm->FallingEvent = GenerateEvent(MODULE, alarm->FallingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_FALLINGALARM, trapobj, traplen);
				}
	            if (value > alarm->RisingThreshold)
				{
					AlarmFillTrap(alarm, TRUE);
	                alarm->RisingEvent = GenerateEvent(MODULE, alarm->RisingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_RISINGALARM, trapobj, traplen);
				}
	            break;
	        case ALARM_RISING:
	            if (value > alarm->RisingThreshold)
				{
					AlarmFillTrap(alarm, TRUE);
	                alarm->RisingEvent = GenerateEvent(MODULE, alarm->RisingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_RISINGALARM, trapobj, traplen);
				}
	            break;
	        case ALARM_FALLING:
	            if (value < alarm->FallingThreshold)
				{
					AlarmFillTrap(alarm, FALSE);
	                alarm->FallingEvent = GenerateEvent(MODULE, alarm->FallingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_FALLINGALARM, trapobj, traplen);
				}
	            break;
	        default:
	            break;
	        }
		}
		
		alarm->JustStarted = FALSE;
    }
    else
    if (alarm->SampleType == ALARM_ABSOLUTE)
    {
        alarm->Value = value;
    }

    if (alarm->Value < alarm->FallingThreshold && alarm->FallingEvent == FALSE)
    {
		AlarmFillTrap(alarm, FALSE);
        alarm->FallingEvent = GenerateEvent(MODULE, alarm->FallingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_FALLINGALARM, trapobj, traplen);
        alarm->RisingEvent = FALSE;
    }
    if (alarm->Value > alarm->RisingThreshold && alarm->RisingEvent == FALSE)
    {
		AlarmFillTrap(alarm, TRUE);
        alarm->RisingEvent = GenerateEvent(MODULE, alarm->RisingEventIndex, SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_RISINGALARM, trapobj, traplen);
        alarm->FallingEvent = FALSE;
    }
}


RmonAlarm* NewRmonAlarm(WORD nralarms)
{
    return DnpapMalloc(nralarms*sizeof(RmonAlarm));
}


RmonAlarm* ReNewRmonAlarm(RmonAlarm* ptr, WORD nralarms)
{
    return DnpapRealloc(ptr, nralarms*sizeof(RmonAlarm));
}


VOID DelRmonAlarm(RmonAlarm* ptr)
{
    DnpapFree(ptr);
}