ptypem.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 <memory.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <config.h>
#include <snmp.h>
#include <mibrqs.h>
#include <mibsup.h>
#include <message.h>
#include <mac.h>

#include "ptypee.h"
#include "ptypec.h"
#include "ptype.h"

IMPORT BOOLEAN BeholderStrictRMON;


#define INDEXSIZE   1

static MIB_LOCAL *packetType = NULL;

static BOOLEAN RmonNext(SNMP_OBJECT * Obj, MIB_LOCAL ** Local, WORD IdLen, WORD IdSze, PACKET_TYPE ** Elm);

BOOLEAN PacketTypeMInit(VOID)
{
	LONG i, collnr = 1, k, nriface, nrcoll;

	/* collnr is the index of the next available collector, nrcoll is the number of collectors per iface defined in the
	 * configuration file. */
	CHAR s[81];
	BOOLEAN v;
	BYTE *m;
	USHORT n;

	MAC_IFACE *iface;

	LONG typesource[] =
	{1, 3, 6, 1, 2, 1, 2, 2, 1, 1, 1};	/* object descriptor of iface[1] */
	CHAR typeowner[] = "monitorPacketType";

#define TYPEINDEX     (BTNG_MIBLEN + 4)
	/* the index of the collector variable is element (BTNG_MIBLEN + 4) of the object descriptor: BTNG_MIB . 17 . 1 . 1 . 1 .
	 * (index) (this is an object descriptor of PacketTypeIndex[(index)]. Its 'length' (number of elements in the object
	 * descriptor) is BTNG_MIBLEN + 5. The index is element #(BTNG_MIBLEN + 4) of the object descriptor. */

	SNMP_OBJECT typeobj[] =
	{
		{SNMP_PDU_SET,
		 {BTNG_MIB, 17, 1, 1, 7}, BTNG_MIBLEN + 5, SNMP_INTEGER},
	/* PacketTypeStatus */
		{SNMP_PDU_SET,
		 {BTNG_MIB, 17, 1, 1, 6}, BTNG_MIBLEN + 5, SNMP_DISPLAYSTR},
	/* PacketTypeOwner */
		{SNMP_PDU_SET,
		 {BTNG_MIB, 17, 1, 1, 2}, BTNG_MIBLEN + 5, SNMP_OBJECTID},
	/* PacketTypeDataSource */
		{SNMP_PDU_SET,
		 {BTNG_MIB, 17, 1, 1, 5}, BTNG_MIBLEN + 5, SNMP_OCTETSTR}
	/* PacketTypeMatch */
	};

	/* these SNMP_OBJECTs are used to start the collectors specified in the initialisation (.ini) file */

	MessageConfig(TYPE_ERROR, "PacketType");
	/* TYPE_ERROR has to be registered in dnpap/dnpap.h */

	nriface = (LONG) MacIfaceCount();
	for (i = 1; i <= nriface; i++)
	{
		sprintf(s, "beholder.type.iface.%ld", i);
		if (ConfigGetBoolean(s, &v) == TRUE)
		{
			iface = MacIfaceGet((WORD) i);
			if (iface != NULL && v == TRUE &&
				(iface->type == MAC_TYPE_ETHERNET_CSMACD ||
				 iface->type == MAC_TYPE_88023_CSMACD))
			{
				nrcoll = 0;
				sprintf(s, "beholder.type.collectors.%ld", i);
				ConfigGetLong(s, &nrcoll);
				for (k = 1; k <= nrcoll; k++)
				{
					typeobj[0].Id[TYPEINDEX] = collnr;
					typeobj[1].Id[TYPEINDEX] = collnr;
					typeobj[2].Id[TYPEINDEX] = collnr;
					typeobj[3].Id[TYPEINDEX] = collnr;

					typeobj[0].Syntax.LngInt = SNMP_INVALID;
					MibRequest(&typeobj[0]);
					typeobj[0].Syntax.LngInt = SNMP_CREATEREQUEST;
					if (MibRequest(&typeobj[0]) != SNMP_NOERROR)
					{
						DnpapMessage(DMC_WARNING, TYPE_TYPEINIT, "packetType: couldn't create packetType collector %ld", i);
						continue;
					}
					strncpy(typeobj[1].Syntax.BufChr, typeowner, typeobj[1].SyntaxLen = strlen(typeowner));
					if (MibRequest(&typeobj[1]) != SNMP_NOERROR)
					{
						DnpapMessage(DMC_WARNING, TYPE_TYPEINIT, "packetType: couldn't set owner of packetType collector %ld", i);
						typeobj[0].Syntax.LngInt = SNMP_INVALID;
						MibRequest(&typeobj[0]);
						continue;
					}
					memcpy(typeobj[2].Syntax.BufInt, typesource, sizeof(typesource));
					typeobj[2].Syntax.BufInt[sizeof(typesource) / sizeof(typesource[0]) - 1] = i;
					typeobj[2].SyntaxLen = sizeof(typesource) / sizeof(typesource[0]);
					if (MibRequest(&typeobj[2]) != SNMP_NOERROR)
					{
						DnpapMessage(DMC_WARNING, TYPE_TYPEINIT, "packetType: couldn't set datasource of packetType collector %ld", i);
						typeobj[0].Syntax.LngInt = SNMP_INVALID;
						MibRequest(&typeobj[0]);
						continue;
					}
					sprintf(s, "beholder.type.match.%ld.%ld", i, k);
					if ((ConfigGetBytes(s, &m, &n) == TRUE) && (n == 2))
					{
						memcpy(typeobj[3].Syntax.BufChr, m, 2);
						typeobj[3].SyntaxLen = 2;
					}
					else
					{
						DnpapMessage(DMC_WARNING, TYPE_TYPEINIT, "packetType: illegal Match value for packetType collector %ld", i);
						typeobj[0].Syntax.LngInt = SNMP_INVALID;
						MibRequest(&typeobj[0]);
						continue;
					}

					if (MibRequest(&typeobj[3]) != SNMP_NOERROR)
					{
						DnpapMessage(DMC_WARNING, TYPE_TYPEINIT, "packetType: couldn't set Match value of packetType collector %ld", i);
						typeobj[0].Syntax.LngInt = SNMP_INVALID;
						MibRequest(&typeobj[0]);
						continue;
					}
					typeobj[0].Syntax.LngInt = SNMP_VALID;
					if (MibRequest(&typeobj[0]) != SNMP_NOERROR)
					{
						DnpapMessage(DMC_WARNING, TYPE_TYPEINIT, "packetType: couldn't set packetType collector %ld to valid", i);
						typeobj[0].Syntax.LngInt = SNMP_INVALID;
						MibRequest(&typeobj[0]);
						continue;
					}
					collnr++;
				}
			}
		}
	}

	return TRUE;
}

/*****************************************************************
** NAME:        RmonNext
** SYNOPSIS:    BOOLEAN RmonNext (SNMP_OBJECT *Obj,
**                                  MIB_LOCAL **Local, WORD IdLen,
**                                  WORD IdSze, VOID **Elm)
** PARAMETERS:  Obj: requested object
**              Local: local datastructure: a collector
**              IdLen: identifier length known to the MIB
**              IdSze: number of indices after the MIB
**              Elm: pointer to object if tables are used
** DESCRIPTION: application specific RMON NEXT function.
**              only called after MibRmon() for next requests 
**              searches the next object in the collector
** REMARKS:     ONLY FOR INTERNAL USE
** RETURNS:     TRUE: object found
**                    OPTIONAL: Elm -> pointer to object in table
*******************************************************************/

BOOLEAN RmonNext(SNMP_OBJECT * Obj, MIB_LOCAL ** Local, WORD IdLen, WORD IdSze, PACKET_TYPE ** Elm)
{
	MIB_LOCAL *local = *Local;

	if (local == NULL)
		return FALSE;
	if (Obj->IdLen == IdLen || local->Index > Obj->Id[IdLen])
	{
		/********************************************************************
        **  OPTIONAL: search function to find first obj in a table !! 
        **  if (not found)
        **      search next collector
        **  adjust object identifier to identifier first object
        **  Elm -> found table obj
        ********************************************************************/
		Obj->IdLen = IdLen + IdSze;
		Obj->Id[IdLen] = local->Index;
		return TRUE;
	}
	/********************************************************************
    **  OPTIONAL: search function to find next obj in a table !! 
    **  if (found)
    **      adjust object identifier to identifier next object
    **      Elm -> found table obj
    **      return TRUE
    ********************************************************************/
	*Local = local->Next;
	return RmonNext(Obj, Local, IdLen, IdSze, Elm);
}

WORD PacketTypeIndex(SNMP_OBJECT * Obj, WORD IdLen)
{
	MIB_LOCAL *local = NULL;

	if ((local = MibRmon(Obj, packetType, IdLen, INDEXSIZE)) == NULL)
		return SNMP_NOSUCHNAME;
	switch (Obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (RmonNext(Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		Obj->Syntax.LngInt = local->Index;
		return SNMP_NOERROR;
	}
	return SNMP_GENERROR;
}

WORD PacketTypeDataSource(SNMP_OBJECT * Obj, WORD IdLen)
{
	MIB_LOCAL *local = NULL;
	PACKET_TYPE *data;
	MAC_IFACE *iface;

	if ((local = MibRmon(Obj, packetType, IdLen, INDEXSIZE)) == NULL)
		return SNMP_NOSUCHNAME;

	switch (Obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (RmonNext(Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (PACKET_TYPE *) local->Data;
		if (BeholderStrictRMON && !BooleanCheck(data->ObjectSet, TYPE_BOOLEAN_DATASOURCE))
			return SNMP_NOSUCHNAME;
		memcpy(Obj->Syntax.BufInt, data->Source, data->SourceLen * sizeof(LONG));
		Obj->SyntaxLen = data->SourceLen;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		data = (PACKET_TYPE *) local->Data;
		if (data->Status != SNMP_UNDERCREATION)
			return SNMP_READONLY;
		if (data->SourceLen != Obj->SyntaxLen ||
			memcmp(data->Source, Obj->Syntax.BufInt, (data->SourceLen - 1) * sizeof(LONG)))
			return SNMP_BADVALUE;
		if ((iface = MacIfaceGet((WORD) Obj->Syntax.BufInt[Obj->SyntaxLen - 1])) == NULL)
			return SNMP_BADVALUE;
		if (iface->type != MAC_TYPE_ETHERNET_CSMACD && iface->type != MAC_TYPE_88023_CSMACD)
			return SNMP_BADVALUE;
		memcpy(data->Source, Obj->Syntax.BufInt, Obj->SyntaxLen * sizeof(LONG));
		data->SourceLen = Obj->SyntaxLen;
		BooleanSetTrue(data->ObjectSet, TYPE_BOOLEAN_DATASOURCE);
		return SNMP_NOERROR;
	}
	return SNMP_GENERROR;
}

WORD PacketTypeOctets(SNMP_OBJECT * Obj, WORD IdLen)
{
	MIB_LOCAL *local = NULL;
	PACKET_TYPE *data;

	if ((local = MibRmon(Obj, packetType, IdLen, INDEXSIZE)) == NULL)
		return SNMP_NOSUCHNAME;

	switch (Obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (RmonNext(Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (PACKET_TYPE *) local->Data;
		Obj->Syntax.LngUns = data->Octets;
		return SNMP_NOERROR;
	}
	return SNMP_GENERROR;
}

WORD PacketTypePkts(SNMP_OBJECT * Obj, WORD IdLen)
{
	MIB_LOCAL *local = NULL;
	PACKET_TYPE *data;

	if ((local = MibRmon(Obj, packetType, IdLen, INDEXSIZE)) == NULL)
		return SNMP_NOSUCHNAME;

	switch (Obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (RmonNext(Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (PACKET_TYPE *) local->Data;
		Obj->Syntax.LngUns = data->Pkts;
		return SNMP_NOERROR;
	}
	return SNMP_GENERROR;
}

WORD PacketTypeMatch(SNMP_OBJECT * Obj, WORD IdLen)
{
	MIB_LOCAL *local = NULL;
	PACKET_TYPE *data;

	if ((local = MibRmon(Obj, packetType, IdLen, INDEXSIZE)) == NULL)
		return SNMP_NOSUCHNAME;

	switch (Obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (RmonNext(Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (PACKET_TYPE *) local->Data;
		Obj->Syntax.BufChr[0] = data->Match >> 8;
		Obj->Syntax.BufChr[1] = data->Match & 0xff;
		Obj->SyntaxLen = 2;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		if (Obj->SyntaxLen != 2)
			return SNMP_BADVALUE;
		data = (PACKET_TYPE *) local->Data;
		data->Match = (Obj->Syntax.BufChr[0] << 8) | Obj->Syntax.BufChr[1];
		return SNMP_NOERROR;
	}
	return SNMP_GENERROR;
}

WORD PacketTypeOwner(SNMP_OBJECT * Obj, WORD IdLen)
{
	MIB_LOCAL *local = NULL;
	PACKET_TYPE *data;

	if ((local = MibRmon(Obj, packetType, IdLen, INDEXSIZE)) == NULL)
		return SNMP_NOSUCHNAME;

	switch (Obj->Request)
	{
	case SNMP_PDU_NEXT:
		if (RmonNext(Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
			return SNMP_NOSUCHNAME;
	case SNMP_PDU_GET:
		data = (PACKET_TYPE *) local->Data;
		if (BeholderStrictRMON && !BooleanCheck(data->ObjectSet, TYPE_BOOLEAN_OWNER))
			return SNMP_NOSUCHNAME;
		memcpy(Obj->Syntax.BufChr, data->Owner, data->OwnerLen);
		Obj->SyntaxLen = data->OwnerLen;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		data = (PACKET_TYPE *) local->Data;
		if (data->Status != SNMP_UNDERCREATION)
			return SNMP_READONLY;
		memcpy(data->Owner, Obj->Syntax.BufChr, Obj->SyntaxLen);
		data->OwnerLen = Obj->SyntaxLen;
		BooleanSetTrue(data->ObjectSet, TYPE_BOOLEAN_OWNER);
		return SNMP_NOERROR;
	}
	return SNMP_GENERROR;
}

WORD PacketTypeStatus(SNMP_OBJECT * Obj, WORD IdLen)
{
	MIB_LOCAL *local = NULL;
	PACKET_TYPE *data;

	local = MibRmon(Obj, packetType, IdLen, INDEXSIZE);

	switch (Obj->Request)
	{
	case SNMP_PDU_GET:
		if (local == NULL)
		{
			Obj->Syntax.LngInt = SNMP_INVALID;
			return SNMP_NOSUCHNAME;
		}
		data = (PACKET_TYPE *) local->Data;
		Obj->Syntax.LngInt = data->Status;
		return SNMP_NOERROR;
	case SNMP_PDU_NEXT:
		if (RmonNext(Obj, &local, IdLen, INDEXSIZE, NULL) == FALSE)
		{
			Obj->Syntax.LngInt = SNMP_INVALID;
			return SNMP_NOSUCHNAME;
		}
		data = (PACKET_TYPE *) local->Data;
		Obj->Syntax.LngInt = data->Status;
		return SNMP_NOERROR;
	case SNMP_PDU_SET:
		if (local == NULL)
		{
			switch (Obj->Syntax.LngInt)
			{
			case SNMP_CREATEREQUEST:
				if ((local = MibInsert(Obj, &packetType, IdLen, INDEXSIZE)) == NULL)
					return SNMP_GENERROR;
				if ((local->Data = DnpapMalloc(sizeof(PACKET_TYPE))) == NULL)
					return SNMP_GENERROR;
				data = (PACKET_TYPE *) local->Data;
				memset(data, 0, sizeof(PACKET_TYPE));
				if (PacketTypeCInit(data) == TRUE)
				{
					data->Status = SNMP_UNDERCREATION;
					DnpapMessage(DMC_MESSAGE, TYPE_CREATE, "packetType: collector %ld created", local->Index);
					return SNMP_NOERROR;
				}
				DnpapFree(local->Data);
				MibRemove(Obj, &packetType, IdLen, INDEXSIZE);
				return SNMP_GENERROR;
			default:
				return SNMP_NOSUCHNAME;
			}
		}
		data = (PACKET_TYPE *) local->Data;
		switch (data->Status)
		{
		case SNMP_UNDERCREATION:
			switch (Obj->Syntax.LngInt)
			{
			case SNMP_VALID:
				if (PacketTypeCStart(data) == TRUE)
				{
					data->Status = SNMP_VALID;
					DnpapMessage(DMC_MESSAGE, TYPE_ACTIVE, "packetType: collector %ld active", local->Index);
					return SNMP_NOERROR;
				}
				else
                    return SNMP_BADVALUE;
			case SNMP_INVALID:
				if (PacketTypeCStop(data) == TRUE)
				{
					DnpapFree(local->Data);
					DnpapMessage(DMC_MESSAGE, TYPE_DESTROY, "packetType: collector %ld destroyed", local->Index);
					if (MibRemove(Obj, &packetType, IdLen, INDEXSIZE) == TRUE)
						return SNMP_NOERROR;
				}
				return SNMP_GENERROR;
			default:
				return SNMP_BADVALUE;
			}
		case SNMP_VALID:
			switch (Obj->Syntax.LngInt)
			{
			case SNMP_INVALID:
				if (PacketTypeCStop(data) == TRUE)
				{
					DnpapFree(local->Data);
					DnpapMessage(DMC_MESSAGE, TYPE_DESTROY, "packetType: collector %ld destroyed", local->Index);
					if (MibRemove(Obj, &packetType, IdLen, INDEXSIZE) == TRUE)
						return SNMP_NOERROR;
				}
				return SNMP_GENERROR;
			case SNMP_VALID:
				return SNMP_NOERROR;
			default:
				return SNMP_BADVALUE;
			}
		}
	}
	return SNMP_GENERROR;
}