rvsnmpif.c

h.248协议源码

 */
void rvSnmpIfRegisterGetActiveStack(RvSnmpStackCB func, void* data)
{
	rvLogEnter(&rvLog, "rvSnmpIfRegisterGetActiveStack");
	rvSnmpIfGetActiveStack.func = func;
	rvSnmpIfGetActiveStack.data = data;
	rvLogLeave(&rvLog, "rvSnmpIfGetRegisterActiveStack");
}

void rvSnmpIfRegisterSetActiveStack(RvSnmpStackCB func, void* data)
{
	rvLogEnter(&rvLog, "rvSnmpIfRegisterSetActiveStack");
	rvSnmpIfSetActiveStack.func = func;
	rvSnmpIfSetActiveStack.data = data;
	rvLogLeave(&rvLog, "rvSnmpIfRegisterSetActiveStack");
}

void rvSnmpIfRegisterGetStackSize(RvSnmpStackCB func, void* data)
{
	rvLogEnter(&rvLog, "rvSnmpIfRegisterGetStackSize");
	rvSnmpIfGetStackSize.func = func;
	rvSnmpIfGetStackSize.data = data;
	rvLogLeave(&rvLog, "rvSnmpIfRegisterGetStackSize");
}

void rvSnmpIfRegisterGetStackType(RvSnmpStackCB func, void* data)
{
	rvLogEnter(&rvLog, "rvSnmpIfRegisterGetStackType");
	rvSnmpIfGetStackType.func = func;
	rvSnmpIfGetStackType.data = data;
	rvLogLeave(&rvLog, "rvSnmpIfRegisterGetStackType");
}

void rvSnmpIfRegisterGetStackName(RvSnmpStackCB func, void* data)
{
	rvLogEnter(&rvLog, "rvSnmpIfRegisterGetStackName");
	rvSnmpIfGetStackName.func = func;
	rvSnmpIfGetStackName.data = data;
	rvLogLeave(&rvLog, "rvSnmpIfRegisterGetStackName");
}


/*		
 *		Stack Get & Set Functions
 */
RvSnmpStatus   rvSnmpGetActiveStack(RvUint rvIndex, void *rvValue)
{
	RvSnmpStatus rt;

	rvLogEnter(&rvLog, "rvSnmpGetActiveStack");

	if (rvSnmpIfGetActiveStack.func) {
		rt = rvSnmpIfGetActiveStack.func(rvIndex, rvValue);
		rvLogLeave(&rvLog, "rvSnmpGetActiveStack");
		return rt;
	}

	*(int *)rvValue = 0;
	rvLogLeave(&rvLog, "rvSnmpGetActiveStack");
	return RV_SNMPSTATUS_GENERR;
}

RvSnmpStatus   rvSnmpSetActiveStack(RvUint rvIndex, void *rvValue)
{
	RvSnmpStatus rt;

	rvLogEnter(&rvLog, "rvSnmpSetActiveStack");

	if (rvSnmpIfSetActiveStack.func) {
		rt = rvSnmpIfSetActiveStack.func(rvIndex, rvValue);
		rvLogLeave(&rvLog, "rvSnmpSetActiveStack");
		return rt;
	}

	*(int *)rvValue = 0;
	rvLogLeave(&rvLog, "rvSnmpSetActiveStack");
	return RV_SNMPSTATUS_GENERR;
}

RvSnmpStatus   rvSnmpGetStackSize(RvUint rvIndex, void *rvValue)
{
	RvSnmpStatus rt;

	rvLogEnter(&rvLog, "rvSnmpGetStackSize");
	
	if (rvSnmpIfGetStackSize.func) {
		rt = rvSnmpIfGetStackSize.func(rvIndex, rvValue);
		rvLogLeave(&rvLog, "rvSnmpGetStackSize");
		return rt;
	}
	
	*(int *)rvValue = 0;
	rvLogLeave(&rvLog, "rvSnmpGetStackSize");
	return RV_SNMPSTATUS_GENERR;
}

RvSnmpStatus   rvSnmpGetStackType(RvUint rvIndex, void *rvValue)
{
	RvSnmpStatus rt;

	rvLogEnter(&rvLog, "rvSnmpGetStackType");
	
	if (rvSnmpIfGetStackType.func) {
		rt = rvSnmpIfGetStackType.func(rvIndex, rvValue);
		rvLogLeave(&rvLog, "rvSnmpGetStackType");
		return rt;
	}
	
	*(int *)rvValue = 0;
	rvLogLeave(&rvLog, "rvSnmpGetStackType");
	return RV_SNMPSTATUS_GENERR;
}

RvSnmpStatus   rvSnmpGetStackName(RvUint rvIndex, void *rvValue)
{
	RvSnmpStatus rt;

	rvLogEnter(&rvLog, "rvSnmpGetStackName");
	
	if (rvSnmpIfGetStackName.func) {
		rt = rvSnmpIfGetStackName.func(rvIndex, rvValue);
		rvLogLeave(&rvLog, "rvSnmpGetStackName");
		return rt;
	}
	
	*(int *)rvValue = 0;
	rvLogLeave(&rvLog, "rvSnmpGetStackName");
	return RV_SNMPSTATUS_GENERR;
}


/**************************************
 *		SNMP Get and Set
 **************************************/
/*
 *		rvSnmpIfGet() 
 *		Retrieve the value of the Mib entry specified by Oid.
 */
/*$
{function:
	{name: rvSnmpIfGet}	
    {superpackage: Snmpif}
	{include: rvsnmpif.h}
	{description: 
		{p:Retrieves the value of the MIB entry specified by the parameter oid.}
	}
	{proto: RvSnmpStatus rvSnmpIfGet(RvUint* oid, size_t oidLen, RvSnmpType* type, void* value, size_t* len);}
	{params:
		{param: {n:oid} {d:The Object Identifier of the MIB entry as an array of unsigned integers.}}
		{param: {n:oidLen} {d:The number of elements in the OID array.}}
		{param: {n:type} {d:The return data type.}}
		{param: {n:value} {d:Returns the value of the MIB entry specified by oid.}}
		{param: {n:len} {d:Returns the length of the value in bytes.}}
	}
	{returns: 
		RV_SNMPSTATUS_NOERROR on success, RV_SNMPSTATUS_NOSUCHNAME if OID not found, or 
		RV_SNMPSTATUS_GENERR if a general error occurred.
	}
}
$*/
RvSnmpStatus	rvSnmpIfGet(RvUint	*rvOid,				/* IN, mib oid */
							size_t	rvOidLen,			/* IN, oid length */
							OUT RvSnmpType	*dataType,	/* OUT, data Type */
							OUT void	*rvValue,		/* OUT, data value */
							OUT size_t	*dataLen)		/* OUT, data length */
		
{
	RvOidVars *rvOidPtr = NULL;
	int	rtValue = RV_SNMPSTATUS_NOERROR;

	rvLogEnter(&rvLog, "rvSnmpIfGet");
	if ((rvOidPtr = rvSnmpGetOidPtr(rvOid, rvOidLen)) == NULL) {
		rvLogLeave(&rvLog, "rvSnmpIfGet");
		return RV_SNMPSTATUS_NOSUCHNAME;	
  	}
	
	if (rvOidPtr->getFunc != NULL) {
		rtValue = (*rvOidPtr->getFunc)( rvOid[rvOidLen - 1], rvValue); 
		*dataType = rvOidPtr->bType;

		switch ( rvOidPtr->bType ) {
			case	RV_SNMPTYPE_INTEGER:
					*dataLen = sizeof(RvUint);
					break;
			case	RV_SNMPTYPE_OCTETSTRING:
			case	RV_SNMPTYPE_IPADDRESS:
					*dataLen = strlen(rvValue);
					break;
			default:
					*dataLen = 0;
					break;
		}

		rvLogLeave(&rvLog, "rvSnmpIfGet");
		return rtValue;
	}

	rvLogLeave(&rvLog, "rvSnmpIfGet");
	return RV_SNMPSTATUS_NOACCESS;
}    


/*
 *		rvSnmpIfGetNext()
 *		Get the value of the Next Mib entry 
 */
/*$
{function:
	{name: rvSnmpIfGetNext}
    {superpackage: Snmpif}
	{include: rvsnmpif.h}
	{description: 
		{p:Gets the OID of the next MIB entry after oid.}
	}
	{proto: RvSnmpStatus rvSnmpIfGetNext(RvUint* oid, size_t* oidLen, RvSnmpType* type, void* value, size_t* len);}
	{params:
		{param: {n:oid} {d:The OID of the MIB entry as an array of unsigned integers.}}
		{param: {n:oidLen} {d:The number of elements in the OID array.}}
		{param: {n:type} {d:The return data type.}}
		{param: {n:value} {d:Returns the value of the Next MIB entry specified by oid.}}
		{param: {n:len} {d:Returns the length of the value in bytes.}}
	}
	{returns: 
		RV_SNMPSTATUS_NOERROR on success, RV_SNMPSTATUS_NOSUCHNAME if OID not found, or 
		RV_SNMPSTATUS_GENERR if a general error occurred.
	}
}
$*/
RvSnmpStatus	rvSnmpIfGetNext(INOUT RvUint	*rvOid,		/* INOUT, mib oid */
								INOUT size_t	*rvOidLen,	/* INOUT, oid length */
								OUT RvSnmpType	*dataType,	/* OUT, data type */
								OUT void	*dataValue,		/* OUT, data value */		
								OUT size_t	*dataLen )		/* OUT, data length */
{
	size_t	oidNewLen =0;
	RvOidVars *rvOidPtr = NULL;
	int	rtValue = RV_SNMPSTATUS_NOERROR;

	rvLogEnter(&rvLog, "rvSnmpIfGetNext");
	if ( (rvOidPtr = rvSnmpGetNextOidPtr( rvOid, rvOidLen ) ) == 0 ) {
		rvLogLeave(&rvLog, "rvSnmpIfGetNext");
		return RV_SNMPSTATUS_NOSUCHNAME;
	}
	  
	oidNewLen = *rvOidLen;

	if (rvOidPtr->getFunc != NULL) {
		rtValue = (*rvOidPtr->getFunc)( rvOid[oidNewLen - 1], dataValue); 
		*dataType = rvOidPtr->bType;

		switch ( rvOidPtr->bType ) {
			case	RV_SNMPTYPE_INTEGER:
					*dataLen = sizeof(RvUint);
					break;
			case	RV_SNMPTYPE_OCTETSTRING:
			case    RV_SNMPTYPE_IPADDRESS:
					*dataLen = strlen(dataValue);
					break;
			default:
					*dataLen = 0;
					break;
		}

		rvLogLeave(&rvLog, "rvSnmpIfGetNext");
		return rtValue;
	}
	else if (oidNewLen == 0) {
		rvLogLeave(&rvLog, "rvSnmpIfGetNext");
		return RV_SNMPSTATUS_NOSUCHNAME;
	}
	else {
		rvLogLeave(&rvLog, "rvSnmpIfGetNext");
		return (rvSnmpIfGetNext( rvOid, rvOidLen, dataType, dataValue, dataLen));
	}
}


/*
 *		rvSnmpIfSet() 
 *      Modify the value of the Mib entry specified by oid.
 */
/*$
{function:
	{name: rvSnmpIfSet}	
    {superpackage: Snmpif}
	{include: rvsnmpif.h}
	{description: 
		{p:Modifies the value of the MIB entry specified by oid.}
	}
	{proto: RvSnmpStatus rvSnmpIfSet(RvUint* oid, size_t oidLen, RvSnmpType type, void* value, size_t len);}
	{params:
		{param: {n:oid} {d:The OID of the MIB entry as an array of unsigned integers.}}
		{param: {n:oidLen} {d:The number of elements in the OID array.}}
		{param: {n:type} {d:The value data type.}}
		{param: {n:value} {d:The value to be set.}}
		{param: {n:len} {d:The length of the value in bytes.}}
	}
	{returns: 
		RV_SNMPSTATUS_NOERROR on success, RV_SNMPSTATUS_NOSUCHNAME if OID not found, or 
		RV_SNMPSTATUS_GENERR if a general error occurred.
	}
}
$*/
RvSnmpStatus	rvSnmpIfSet(RvUint	*rvOid,			/* in, oid */
							size_t	rvOidLen,		/* in, oid length */
							RvSnmpType	dataType,	/* in, data type */
							void	*rvValue,		/* in, set value */
							size_t	dataLen)		/* in, data length */
							
{
	RvOidVars *rvOidPtr = NULL;

	rvLogEnter(&rvLog, "rvSnmpIfSet");
	if ((rvOidPtr = rvSnmpGetOidPtr(rvOid, rvOidLen)) == NULL) {
		rvLogLeave(&rvLog, "rvSnmpIfSet");
		return RV_SNMPSTATUS_NOSUCHNAME;	
  	}

	if (rvOidPtr->setFunc != NULL) {
		rvLogLeave(&rvLog, "rvSnmpIfSet");
		return ((*rvOidPtr->setFunc)( rvOid[rvOidLen - 1], rvValue));
	}
	else {
		rvLogLeave(&rvLog, "rvSnmpIfSet");
		return RV_SNMPSTATUS_NOACCESS;
	}
}


RvSnmpStatus    rvSnmpIfGetFnc(int  offset1, int offset2, int index,
                            	RvSnmpType *dataType, void *rvValue, size_t *dataLen)
{
    RvRegMib    *mib;
    int         rtValue;

	if (rvVectorSize(&regMibs) > (size_t)offset1) {
		mib = rvVectorAt(&regMibs, offset1);

		if ((mib->rvOidPtr[offset2].getFunc) != NULL) {
			rtValue = (mib->rvOidPtr[offset2].getFunc)( index, rvValue);
			*dataType = mib->rvOidPtr[offset2].bType;

			switch ( mib->rvOidPtr[offset2].bType ) {
				case    RV_SNMPTYPE_INTEGER:
					    *dataLen = sizeof(RvUint);
						break;
				case    RV_SNMPTYPE_OCTETSTRING:
				case    RV_SNMPTYPE_IPADDRESS:
					    *dataLen = strlen(rvValue);
						break;
				default:
					    *dataLen = 0;
						break;
			}
			return rtValue;
		}
	}

	return RV_SNMPSTATUS_GENERR;
}


RvSnmpStatus	rvSnmpIfSetFnc(int	offset1, int offset2, int index,
								RvSnmpType dataType, void *rvValue, size_t dataLen)
{
    RvRegMib    *mib;
	int			rtValue;

	if (rvVectorSize(&regMibs) > (size_t)offset1) {
		mib = rvVectorAt(&regMibs, offset1);
		
		if ((mib->rvOidPtr[offset2].getFunc) != NULL) {    
 			rtValue = (mib->rvOidPtr[offset2].setFunc)( index, rvValue);
			return rtValue;
		}
	}
	
	return RV_SNMPSTATUS_GENERR;
}