deventm.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 <agent.h>
#include <config.h>
#include <snmp.h>
#include <message.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysmib.h>
#include <trap.h>
#include <dlog.h>

#include "deventd.h"
#include "devente.h"
#include "deventc.h"
#include "deventu.h"
#include "devent.h"


IMPORT BOOLEAN BeholderStrictRMON;


static CHAR MODULE[] = "DnpapEventM";


static MIB_LOCAL*	RmonEventInstance = NULL;


static SHORT LogMaxNrLogs = 100;


static BOOLEAN  EventMibNext(SNMP_OBJECT* obj, MIB_LOCAL** local, WORD idlen, WORD indexsize);
static BOOLEAN  EventFirstLastLog(DnpapRmonEvent *event, LONG *firstlog, LONG *lastlog);
static BOOLEAN  EventLogInRange(LONG firstlog, LONG lastlog, LONG logindex);
static DnpapRmonLog* EventLogEntry(SNMP_OBJECT *obj, WORD idlen, MIB_LOCAL *local);



BOOLEAN DnpapEventMInit(VOID)
{
    MessageConfig(DNPAP_EVENT_ERROR, "DnpapEvent");
	ConfigGetShort("beholder.event.maxnrlogs", &LogMaxNrLogs);
	if (LogMaxNrLogs < 2)
    {
        DnpapMessage(DMC_WARNING, DEVENT_MAX, "event: beholder.event.maxnrlogs < 2, setting it to 2");
        LogMaxNrLogs = 2;
    }
	
	return TRUE;
}


BOOLEAN EventMibNext(SNMP_OBJECT* obj, MIB_LOCAL** local, WORD idlen, WORD indexsize)
{
LONG firstlog, lastlog;

    if (*local == NULL || indexsize < 1)
        return FALSE;

    if (obj->IdLen < idlen + indexsize)
    {
        if (indexsize == 2)
        {                          
            while (*local != NULL && EventFirstLastLog((DnpapRmonEvent*)(*local)->Data, &firstlog, &lastlog) == FALSE)
                *local = (*local)->Next;
            if (*local == NULL)
                return FALSE;
            obj->Id[idlen] = (*local)->Index;
            obj->Id[idlen+1] = firstlog;
            obj->IdLen = idlen + 2;
        }
        else
        if (obj->IdLen == idlen)
        {
            obj->Id[idlen] = (*local)->Index;
            obj->IdLen = idlen + 1;
        }
        return TRUE;
    }
    else
    {
        switch (indexsize)
        {            
        case 2:
            if (EventFirstLastLog((DnpapRmonEvent*)(*local)->Data, &firstlog, &lastlog) == TRUE &&
                EventLogInRange(firstlog, lastlog, obj->Id[idlen+1]) == TRUE &&
                obj->Id[idlen+1] != lastlog)
            {
                obj->Id[idlen+1]++;
                if (obj->Id[idlen+1] == 0)
                    obj->Id[idlen+1] = 1;
                return TRUE;
            }
        case 1:
			/* only go to next collector if requested index was higher or equal */
			if (obj->Id[idlen] >= (*local)->Index)
	            *local = (*local)->Next;
            if (*local != NULL)
            {
                if (indexsize == 2)
                {                          
                    while (*local != NULL && EventFirstLastLog((DnpapRmonEvent*)(*local)->Data, &firstlog, &lastlog) == FALSE)
                        *local = (*local)->Next;
                    if (*local == NULL)
                        return FALSE;
                    obj->Id[idlen] = (*local)->Index;
                    obj->Id[idlen+1] = firstlog;
                    obj->IdLen = idlen + 2;
                }
                else
                {
                    obj->Id[idlen] = (*local)->Index;
                    obj->IdLen = idlen + 1;
                }
                return TRUE;
            }
            return FALSE;
        }
        return FALSE;
    }
    return FALSE;
}


BOOLEAN EventFirstLastLog(DnpapRmonEvent *event, LONG *firstlog, LONG *lastlog)
{
	if (event->NrLogs == 0)
	{
		*firstlog = *lastlog = 0;
		return FALSE;
	}
	if (event->LogBounced == TRUE && event->LogPos < event->NrLogs)
		*firstlog = event->Logs[event->LogPos].Index;
	else
		*firstlog = event->Logs[0].Index;
	*lastlog = event->Logs[(event->LogPos > 0) ? (event->LogPos-1) : (event->NrLogs-1)].Index;
	return TRUE;
}


BOOLEAN EventLogInRange(LONG firstlog, LONG lastlog, LONG logindex)
{
	if (firstlog <= lastlog)
		return (logindex >= firstlog && logindex <= lastlog);
	else
		return (logindex >= firstlog || logindex <= lastlog);
}


WORD DnpapEventIndex(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
			
	if ((local = MibRmon(obj, RmonEventInstance, idlen, 1)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
        if (EventMibNext(obj, &local, idlen, 1) == FALSE)
	    return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		obj->Syntax.LngInt = local->Index;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD DnpapEventDescription(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
DnpapRmonEvent* data = NULL;
			
    if ((local = MibRmon(obj, RmonEventInstance, idlen, 1)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (EventMibNext(obj, &local, idlen, 1) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (DnpapRmonEvent*)local->Data;
		memcpy(obj->Syntax.BufChr, data->Description, obj->SyntaxLen = data->DescrLen);
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		data = (DnpapRmonEvent*)local->Data;
        if (obj->SyntaxLen > RMONEVENT_SZEDESCR)
            return SNMP_BADVALUE;
        memcpy(data->Description, obj->Syntax.BufChr, data->DescrLen = obj->SyntaxLen);
		return SNMP_NOERROR;
	}
    return SNMP_GENERROR;
}


WORD DnpapEventType(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
DnpapRmonEvent* data = NULL;
			
    if ((local = MibRmon(obj, RmonEventInstance, idlen, 1)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (EventMibNext(obj, &local, idlen, 1) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (DnpapRmonEvent*)local->Data;
        obj->Syntax.LngInt = data->Type;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		data = (DnpapRmonEvent*)local->Data;
        if (obj->Syntax.LngInt < DEVENTTYPE_MIN || obj->Syntax.LngInt > DEVENTTYPE_MAX)
            return SNMP_BADVALUE;
        data->Type = obj->Syntax.LngInt;
        return SNMP_NOERROR;
	}
    return SNMP_GENERROR;
}


WORD DnpapEventCommunity(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
DnpapRmonEvent* data = NULL;
			
    if ((local = MibRmon(obj, RmonEventInstance, idlen, 1)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (EventMibNext(obj, &local, idlen, 1) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (DnpapRmonEvent*)local->Data;
		if (BeholderStrictRMON && !BooleanCheck(data->ObjectSet, EVENT_BOOLEAN_COMMUNITY))
			return SNMP_NOSUCHNAME;
        memcpy(obj->Syntax.BufChr, data->Community, obj->SyntaxLen = data->CommLen);
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		data = (DnpapRmonEvent*)local->Data;
        if (obj->SyntaxLen > RMONEVENT_SZECOMM)
            return SNMP_BADVALUE;
        memcpy(data->Community, obj->Syntax.BufChr, data->CommLen = obj->SyntaxLen);
		BooleanSetTrue(data->ObjectSet, EVENT_BOOLEAN_COMMUNITY);
		return SNMP_NOERROR;
	}
    return SNMP_GENERROR;
}


WORD DnpapEventLastTimeSent(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
DnpapRmonEvent* data = NULL;
			
    if ((local = MibRmon(obj, RmonEventInstance, idlen, 1)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (EventMibNext(obj, &local, idlen, 1) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (DnpapRmonEvent*)local->Data;
        obj->Syntax.LngUns = data->LastTimeSent;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
        return SNMP_READONLY;
	}
    return SNMP_GENERROR;
}


WORD DnpapEventOwner(SNMP_OBJECT* obj, WORD idlen)
{
MIB_LOCAL* local = NULL;
DnpapRmonEvent* data = NULL;
			
    if ((local = MibRmon(obj, RmonEventInstance, idlen, 1)) == NULL)
		return SNMP_NOSUCHNAME;
		
	switch (obj->Request)
	{