rvsnmpif.c

h.248协议源码

#if (0)
******************************************************************************
Filename   :	rvsnmpif.c
Description:	rv snmp interface module 
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD..

RADVision LTD. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:$
$Date:$
$Author:$
******************************************************************************
#endif

#include <stddef.h>
#include "rvlog.h"
#include "rvsnmpif.h"
#include "rvvector.h"
#include "rvtypes.h"
#include "rvdefalloc.h"

#include "rvsubagentif.h"
#include "rvtrapif.h"
#include "rvmib.h"

/* Trap handler */
RvSnmpIfTrap rvSnmpIfTrap = {0, 0};
RvSnmpIfStack rvSnmpIfGetActiveStack = {0, 0};
RvSnmpIfStack rvSnmpIfSetActiveStack = {0, 0};
RvSnmpIfStack rvSnmpIfGetStackSize = {0, 0};
RvSnmpIfStack rvSnmpIfGetStackType = {0, 0};
RvSnmpIfStack rvSnmpIfGetStackName = {0, 0};

#define RvRegMibConstructCopy(d, s, a)	rvDefaultConstructCopy(d, s, a)
#define RvRegMibDestruct(x)				rvDefaultDestruct(x)
#define RvRegMibEqual(a, b)				(memcmp((a), (b), sizeof(*(a))) == 0)
rvDeclareVector(RvRegMib)
rvDefineVector(RvRegMib)
static	RvVector(RvRegMib) regMibs;

/* private */

/* 
 *		rvSnmpOidCompare()
 */
static int	rvSnmpOidCompare(RvUint *rvOid1, size_t rvOidLen1, RvUint *rvOid2, size_t rvOidLen2)
{
    RvUint rvOidLen;

	rvLogEnter(&rvLog, "rvSnmpOidCompare");
    if (rvOidLen1 < rvOidLen2)  /* rvOidLen = minimum of rvOidLen1 and rvOidLen2 */	
		rvOidLen = rvOidLen1;
    else
		rvOidLen = rvOidLen2;

    
    while(rvOidLen-- > 0){		/* find first non-matching byte */
		if (*rvOid1 < *rvOid2) {
			rvLogLeave(&rvLog, "rvSnmpOidCompare");
			return -1;
		}
		if (*rvOid2++ < *rvOid1++) {
			rvLogLeave(&rvLog, "rvSnmpOidCompare");
			return 1;
		}
    }

    
    if (rvOidLen1 < rvOidLen2) {/* bytes match up to rvOidLength of shorter string */
		rvLogLeave(&rvLog, "rvSnmpOidCompare");
		return -1;				/* rvOid1 shorter, so it is "less" */
	}
    if (rvOidLen2 < rvOidLen1) {
		rvLogLeave(&rvLog, "rvSnmpOidCompare");
		return 1;
	}

	rvLogLeave(&rvLog, "rvSnmpOidCompare");
    return 0;					/* both strings are equal */
}


/*
 *		rvSnmpOidCopy()
 */
static	int	rvSnmpOidCopy(RvUint *rvOid1, RvUint *rvOid2, size_t rvOidLen2)
{
	rvLogEnter(&rvLog, "rvSnmpOidCopy");
	memcpy(rvOid1, rvOid2, rvOidLen2 * sizeof(RvUint));
	rvLogLeave(&rvLog, "rvSnmpOidCopy");
	return rvOidLen2;

}

/*
 *		rvSnmpGetOidPtr()
 */
static	RvOidVars*	rvSnmpGetOidPtr(RvUint *rvOid, size_t rvOidLen)
{
	int			rvCompResult;
	RvUint		i, j;
	RvRegMib	*mib;

	rvLogEnter(&rvLog, "rvSnmpGetOidPtr");
	for (i = 0; i < rvVectorSize(&regMibs); ++i) {
		mib = rvVectorAt(&regMibs, i);

		for (j = 0; j < mib->rvOidNums; ++j) {
			rvCompResult = rvSnmpOidCompare(rvOid, rvOidLen,
											mib->rvOidPtr[j].rvOid,
											mib->rvOidPtr[j].rvOidLen );
			/* has passed the oid location, check for array */
			if (rvCompResult < 0) {	
				if ((rvOidLen - 1)== mib->rvOidPtr[j - 1].rvOidLen) { /* check length */
					if (rvSnmpOidCompare(rvOid, rvOidLen - 1,		 /* compare      */
										 mib->rvOidPtr[j - 1].rvOid,
										 mib->rvOidPtr[j - 1].rvOidLen ) == 0) {
						rvLogLeave(&rvLog, "rvSnmpGetOidPtr");
						return (&mib->rvOidPtr[j - 1]);
					}
					else {
						rvLogLeave(&rvLog, "rvSnmpGetOidPtr");
						return NULL;
					}
				}
				else {
					rvLogLeave(&rvLog, "rvSnmpGetOidPtr");
					return NULL;		/* no, error */
				}	
			}
			
			/* found an exact oid match */
			else if (rvCompResult == 0)	{
				rvLogLeave(&rvLog, "rvSnmpGetOidPtr");
				return (&mib->rvOidPtr[j]);
			}
		}
	}

	/* has not passed the oid, but end of the mib table */
	if (rvCompResult) {		
		if ( (rvOidLen - 1) == mib->rvOidPtr[j - 1].rvOidLen ) {
			if (mib->rvOidPtr[j - 1].getTableFunc != NULL) {	/* table?, yes */
				if ( rvSnmpOidCompare(rvOid, rvOidLen - 1, 
									  mib->rvOidPtr[j - 1].rvOid,
									  mib->rvOidPtr[j - 1].rvOidLen ) == 0)
					rvLogLeave(&rvLog, "rvSnmpGetOidPtr");
					return (&mib->rvOidPtr[j - 1]);
			}
		}
	}

	rvLogLeave(&rvLog, "rvSnmpGetOidPtr");
	return NULL;
}


/*
 *		rvSnmpGetNextOidPtr()
 */
static	RvOidVars*	rvSnmpGetNextOidPtr(RvUint *rvOid, size_t *rvOidLen)
{
	int			rvCompResult;
	RvUint		i, j, k;
	RvRegMib	*mib;
	size_t		rvOidLentmp;
	RvUint		*rvOidtmp;

	rvLogEnter(&rvLog, "rvSnmpGetNextOidPtr");
	rvOidtmp = rvOid;
	rvOidLentmp = *rvOidLen;
	for (i = 0; i < rvVectorSize(&regMibs); ++i) {
		mib = rvVectorAt(&regMibs, i);

		for (j = 0; j < mib->rvOidNums; ++j) {
			rvCompResult = rvSnmpOidCompare(rvOid, rvOidLentmp,
											mib->rvOidPtr[j].rvOid,
											mib->rvOidPtr[j].rvOidLen );
		
			
			if (rvCompResult < 0) {			/* search has passed */
				if (*rvOidLen > mib->rvOidPtr[j].rvOidLen)
					k = j - 1;
				else
					k = j;
				
				if ( *rvOidLen > mib->rvOidPtr[k].rvOidLen) {
					if (mib->rvOidPtr[k].getTableFunc != NULL) {	/* table?, yes */
						while(rvOidLentmp-- > 1) {
							rvOidtmp++;
						}

						if (*rvOidtmp < (RvUint)(mib->rvOidPtr[k].getTableFunc)()) {
							*rvOidtmp = *rvOidtmp + 1;				/* increament Instance */
							/* rvOidLentmp is same size */
							rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
							return (&mib->rvOidPtr[k]);
						}
						else {
							*rvOidLen = rvSnmpOidCopy( rvOid, mib->rvOidPtr[j].rvOid,
													   mib->rvOidPtr[j].rvOidLen );
							*rvOidLen = *rvOidLen + 1;	/* increae length  */
							*rvOidtmp = 1;				/* set 1 for 1st Instacne */	
							rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
							return (&mib->rvOidPtr[j]);
						}	
					}
				}
				else {									/* no table */
					*rvOidLen = rvSnmpOidCopy(	rvOid, mib->rvOidPtr[j].rvOid, 	
												mib->rvOidPtr[j].rvOidLen );
					rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
					return (&mib->rvOidPtr[j]);
				}
			}

			else if (rvCompResult == 0) {				/* found exact match oid */
				if (mib->rvOidPtr[j].getTableFunc) {	/* table?, yes */
					*rvOidLen = rvOidLentmp + 1;				/* oid length increase 1 */
					while(rvOidLentmp-- > 0)	{
						rvOidtmp++;
					}
					*rvOidtmp = 1;						/* attach 1 for first array */
					rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
					return (&mib->rvOidPtr[j]);		
				}
				else {									/* table?, no */
					if ( (j + 1) < mib->rvOidNums ) {	/* copy next oib */
						*rvOidLen = rvSnmpOidCopy( rvOid, mib->rvOidPtr[j + 1].rvOid,
												   mib->rvOidPtr[j + 1].rvOidLen );
						rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
						return (&mib->rvOidPtr[j + 1]);
					}
				}
			}
		}
	}

	if (rvCompResult) {		/* has not passed the oid, but end of the mib table */
		if ( *rvOidLen > mib->rvOidPtr[j - 1].rvOidLen) {
			if (mib->rvOidPtr[j - 1].getTableFunc != NULL) {	/* table?, yes */
				while(rvOidLentmp-- > 1) {
					rvOidtmp++;					/* to get last value, instance */
				}
				if (*rvOidtmp < (RvUint)(mib->rvOidPtr[j - 1].getTableFunc)()) {
					*rvOidtmp = *rvOidtmp + 1;				/* increament Instance */
					rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
					return (&mib->rvOidPtr[j - 1]);
				}
				/* over the array size and end of the mib table */
				rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
				return NULL;
			}
		}
	}
	
	rvLogLeave(&rvLog, "rvSnmpGetNextOidPtr");
	return NULL;
}


/**************************************
 *		Snmp Interface Initialization 
 **************************************/							 
/*	
 *		rvSnmpIfEnd()
 *		Destroy the mib memory allocation	
 */
void	rvSnmpIfEnd()
{
#if defined (RV_SNMP)
	rvLogEnter(&rvLog, "rvSnmpIfEnd");

#if defined(RV_SNMP_SUBAGENT)
	rvSnmpSubagentEnd();
#endif

	rvVectorDestruct(RvRegMib)(&regMibs);

	rvLogLeave(&rvLog, "rvSnmpIfEnd");
#endif

}

															
/*	
 *		rvSnmpIfInit()	
 *		Initialize the all the snmp interface routines  
 *		Initialize the default registration mib memory allocation
 */
RvBool	rvSnmpIfInit(void) 
{
#if defined (RV_SNMP)
	rvLogEnter(&rvLog, "rvSnmpIfInit");

	rvVectorConstruct(RvRegMib)(&regMibs, &rvDefaultAlloc);
	rvSnmpRvInit();

#if defined(RV_SNMP_SUBAGENT)	
	/* Register trap handler */
	rvSnmpTrapSocketInit();
	rvSnmpIfRegisterTrap(rvSnmpTrapMsgSend, 0);

	/* Connect to SNMP rvsubagent, register the rx port to rvsubagent */
	rvSnmpSubagentInit();
#endif

	rvLogLeave(&rvLog, "rvSnmpIfInit");
#endif
	return rvTrue;
}

/*
 *		rvSnmpIfRegistraterMIb()
 *		Registrate the specific mib tables
 */
void	rvSnmpIfRegisterMib( RvUint	 *oidPrefix,		/* group oid prefix */	
							 size_t	 oidPrefixLen,		/* group oid length */
							 RvOidVars		*rvOidPtr,	/* group oid array pointer */	
							 RvUint	 rvOidNums)			/* group oid total size */
{
		RvRegMib mib;
		
		rvLogEnter(&rvLog, "rvSnmpIfRegisterMib");
		mib.oidPrefix = oidPrefix;
		mib.oidPrefixLen = oidPrefixLen;
		mib.rvOidPtr = rvOidPtr;	
		mib.rvOidNums = rvOidNums;
		
		rvVectorPushBack(RvRegMib)(&regMibs, &mib);
		rvLogLeave(&rvLog, "rvSnmpIfRegisterMib");
}


/**************************************
 *		Trap fuction registration
 **************************************/
/* 
 *		rvSnmpIfRegisterTrap()
 *		Register callback function to handle traps.
 */
/*$
{function:
	{name: rvSnmpIfRegisterTrap}
    {superpackage: Snmpif}
	{include: rvsnmpif.h}
	{description: 
		{p:Registers a callback function for handling traps.}
	}
	{proto: void rvSnmpIfRegisterTrap(RvSnmpTrapCB trapFn, void* data);}
	{params:
		{param: {n:trapFn} {d:The callback function.}}
		{param: {n:data} {d:A pointer to user-defined data}}
	}
	{returns: 
		A pointer to the previously registered trap function.
	}
    {see_also:
        {n:  void RvSnmpTrapCB(RvUint* oid, size_t oidLen, int type, char* value, size_t len);}
    }
}
$*/
void rvSnmpIfRegisterTrap(RvSnmpTrapCB func, void* data)
{
	rvLogEnter(&rvLog, "rvSnmpIfRegisterTrap");
	rvSnmpIfTrap.func = func;
	rvSnmpIfTrap.data = data;
	rvLogLeave(&rvLog, "rvSnmpIfRegisterTrap");
}



/*
 *		Stack Interface Functions