www.pudn.com > SNMP·¶ÀýÔ´´úÂë.zip > Snmp.c

#include 

/* defines */
#define SNMP_IPA    0			/* Ipaddress, APPLICATION (0) */
#define SNMP_CNT    1			/* Counter,   APPLICATION (1) */
#define SNMP_GGE    2			/* Gauge,     APPLICATION (2) */
#define SNMP_TIT    3			/* TimeTicks  APPLICATION (3) */
#define SNMP_OPQ    4			/* Opaque,    APPLICATION (4) */

/* typedefs */

typedef struct snmp_cnv_s snmp_cnv_t;

struct snmp_cnv_s
{
	u32 Class;
	u32 Tag;
	i32 Syntax;
};

/* globals */

i32 snmpErrStatus = SNMP_NOERROR;
i32 snmpErrIndex = 0;

asn1_sck_t snmpErrAsn1Status;
asn1_sck_t snmpErrAsn1Index;
asn1_sck_t snmpErrAsn1Resp;

snmp_stat_t SnmpStat;

const i8 *SnmpTrap[] =
{
	"cold start",
	"warm start",
	"link down",
	"link up",
	"authentication failure",
	"neighbor loss",
	"enterprise specific"
};

/* locals */

static snmp_cnv_t SnmpCnv[] =
{
	{ASN1_UNI, ASN1_NUL, SNMP_NULL},
	{ASN1_UNI, ASN1_INT, SNMP_INTEGER},
	{ASN1_UNI, ASN1_OTS, SNMP_OCTETSTR},
	{ASN1_UNI, ASN1_OTS, SNMP_DISPLAYSTR},
	{ASN1_UNI, ASN1_OJI, SNMP_OBJECTID},
	{ASN1_APL, SNMP_IPA, SNMP_IPADDR},
	{ASN1_APL, SNMP_CNT, SNMP_COUNTER},
	{ASN1_APL, SNMP_GGE, SNMP_GAUGE},
	{ASN1_APL, SNMP_TIT, SNMP_TIMETICKS},
	{ASN1_APL, SNMP_OPQ, SNMP_OPAQUE},
	{0, 0, -1}
};

/* forward declarations */

static int SnmpSyn2TagCls(u32 * Tag, u32 * Cls, i32 Syn);
static int SnmpTagCls2Syn(u32 Tag, u32 Cls, u16 * Syn);
static int SnmpObjEnc(asn1_sck_t * Asn1, snmp_object_t * Obj);
static int SnmpObjDec(asn1_sck_t * Asn1, snmp_object_t * Obj);
static int SnmpLstEnc(asn1_sck_t * Asn1, snmp_object_t * Lst, u32 LstLen);
static int SnmpLstDec(asn1_sck_t * Asn1, snmp_object_t * Lst, u32 LstSze, u32 * LstLen);
static int SnmpRqsEnc(asn1_sck_t * Asn1, snmp_pdu_t * Rqs);
static int SnmpRqsDec(asn1_sck_t * Asn1, snmp_pdu_t * Rqs);
static int SnmpPduEnc(asn1_sck_t * Asn1, snmp_pdu_t * Pdu, snmp_object_t * Lst, u32 LstLen);
static int SnmpPduDec(asn1_sck_t * Asn1, snmp_pdu_t * Pdu, snmp_object_t * Lst, u32 LstSze, u32 * LstLen);

/*******************************************************************************
*
* SnmpSyn2TagCls - Converts SNMP type (syntax) to Class and Tag
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpSyn2TagCls
    (
    u32 * Tag, 
    u32 * Cls, 
    i32   Syn
    )
{
	snmp_cnv_t *Cnv;

	Cnv = SnmpCnv;
	while (Cnv->Syntax != -1)
	{
		if (Cnv->Syntax == Syn)
		{
			*Tag = Cnv->Tag;
			*Cls = Cnv->Class;
			return TRUE;
		}
		Cnv++;
	}
	snmpErrStatus = SNMP_BADVALUE;
	SnmpStat.OutBadValues++;
	return FALSE;
}

/*******************************************************************************
*
* SnmpTagCls2Syn - Converts Tag and Class to SNMP type (syntax)
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpTagCls2Syn
    (
    u32   Tag, 
    u32   Cls, 
    u16 * Syn
    )
{
	snmp_cnv_t *Cnv;

	Cnv = SnmpCnv;
	while (Cnv->Syntax != -1)
	{
		if (Cnv->Tag == Tag && Cnv->Class == Cls)
		{
			*Syn = (u16) Cnv->Syntax;
			return TRUE;
		}
		Cnv++;
	}
	snmpErrStatus = SNMP_BADVALUE;
	SnmpStat.OutBadValues++;
	return FALSE;
}

/*******************************************************************************
*
* SnmpObjEnc - Encodes an snmp_object_t structure into asn1_sck_t
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpObjEnc
    (
    asn1_sck_t *    Asn1, 
    snmp_object_t * Obj
    )
{
	u32 Cls, Tag;
	u8 *Eoc, *End;

	if (!Asn1EocEnc(Asn1, &Eoc))
	{
		return FALSE;
	}
	switch (Obj->Type)
	{
	case SNMP_INTEGER:
		if (!Asn1IntEncLng(Asn1, &End, Obj->Syntax.LngInt))
		{
			return FALSE;
		}
		break;
	case SNMP_OCTETSTR:
	case SNMP_OPAQUE:
		if (!Asn1OtsEnc(Asn1, &End, Obj->Syntax.BufChr, Obj->SyntaxLen))
		{
			return FALSE;
		}
		break;
	case SNMP_NULL:
		if (!Asn1NulEnc(Asn1, &End))
		{
			return FALSE;
		}
		break;
	case SNMP_OBJECTID:
		if (!Asn1OjiEnc(Asn1, &End, (u32 *) Obj->Syntax.BufInt, Obj->SyntaxLen))
		{
			return FALSE;
		}
		break;
	case SNMP_IPADDR:
		if (!Asn1OtsEnc(Asn1, &End, (u8 *) & Obj->Syntax.LngUns, 4))
		{
			return FALSE;
		}
		break;
	case SNMP_COUNTER:
	case SNMP_GAUGE:
	case SNMP_TIMETICKS:
		if (!Asn1IntEncLngUns(Asn1, &End, Obj->Syntax.LngUns))
		{
			return FALSE;
		}
		break;
	default:
		snmpErrStatus = SNMP_BADVALUE;
		SnmpStat.OutBadValues++;
		return FALSE;
	}
	if (!SnmpSyn2TagCls(&Tag, &Cls, Obj->Type))
	{
		return FALSE;
	}
	if (!Asn1HdrEnc(Asn1, End, Cls, ASN1_PRI, Tag))
	{
		return FALSE;
	}
	if (!Asn1OjiEnc(Asn1, &End, (u32 *) Obj->Id, Obj->IdLen))
	{
		return FALSE;
	}
	if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_OJI))
	{
		return FALSE;
	}
	if (!Asn1HdrEnc(Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
	{
		return FALSE;
	}
	return TRUE;
}

/*******************************************************************************
*
* SnmpObjDec - Decodes an asn1_sck_t structure into an snmp_object_t structure
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpObjDec
    (
    asn1_sck_t *    Asn1, 
    snmp_object_t * Obj
    )
{
	u32 Cls, Con, Tag;
	u8 *Eoc, *End;

	if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Tag))
		return FALSE;
	if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
		return FALSE;
	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
		return FALSE;
	if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_OJI)
		return FALSE;
	if (!Asn1OjiDec(Asn1, End, (u32 *) Obj->Id, SNMP_SIZE_OBJECTID, &Obj->IdLen))
		return FALSE;
	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
		return FALSE;
	if (Con != ASN1_PRI)
	{
		snmpErrStatus = SNMP_BADVALUE;
		SnmpStat.OutBadValues++;
		return FALSE;
	}
	if (!SnmpTagCls2Syn(Tag, Cls, &Obj->Type))
		return FALSE;
	switch (Obj->Type)
	{
	case SNMP_INTEGER:
		if (!Asn1IntDecLng(Asn1, End, (i32 *) & Obj->Syntax.LngInt))
			return FALSE;
		break;
	case SNMP_OCTETSTR:
	case SNMP_OPAQUE:
		if (!Asn1OtsDec(Asn1, End, Obj->Syntax.BufChr, SNMP_SIZE_BUFCHR,
						&Obj->SyntaxLen))
			return FALSE;
		break;
	case SNMP_NULL:
		if (!Asn1NulDec(Asn1, End))
			return FALSE;
		break;
	case SNMP_OBJECTID:
		if (!Asn1OjiDec(Asn1, End, (u32 *) Obj->Syntax.BufInt, SNMP_SIZE_BUFINT,
						&Obj->SyntaxLen))
			return FALSE;
		break;
	case SNMP_IPADDR:
		if (!Asn1OtsDec(Asn1, End, (u8 *) & Obj->Syntax.LngUns, 4,
						&Obj->SyntaxLen))
			return FALSE;
		if (Obj->SyntaxLen != 4)
			return FALSE;
		break;
	case SNMP_COUNTER:
	case SNMP_GAUGE:
	case SNMP_TIMETICKS:
		if (!Asn1IntDecLngUns(Asn1, End, (u32 *) & Obj->Syntax.LngUns))
			return FALSE;
		break;
	default:
		snmpErrStatus = SNMP_BADVALUE;
		SnmpStat.OutBadValues++;
		return FALSE;
	}
	if (!Asn1EocDec(Asn1, Eoc))
		return FALSE;
	return TRUE;
}

/*******************************************************************************
*
* SnmpLstEnc - Encodes a list of snmp_object_t structures into an asn1_sck_t structure
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpLstEnc
    (
    asn1_sck_t *    Asn1, 
    snmp_object_t * Lst, 
    u32             LstLen
    )
{
	u8 *Eoc;

	if (!Asn1EocEnc(Asn1, &Eoc))
	{
		return FALSE;
	}
	Lst += LstLen;
	while (LstLen-- > 0)
	{
		if (!SnmpObjEnc(Asn1, --Lst))
		{
			return FALSE;
		}
	}
	if (!Asn1HdrEnc(Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
	{
		return FALSE;
	}
	return TRUE;
}

/*******************************************************************************
*
* SnmpLstDec - Decodes an asn1_sck_t structure into a list of snmp_object_t's
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpLstDec
    (
    asn1_sck_t *    Asn1, 
    snmp_object_t * Lst, 
    u32             LstSze, 
    u32 *           LstLen
    )
{
	u32 Cls, Con, Tag;
	u8 *Eoc;

	if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Tag))
		return FALSE;
	if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
		return FALSE;
	*LstLen = 0;
	while (!Asn1Eoc(Asn1, Eoc))
	{
		if (++(*LstLen) > LstSze)
		{
			snmpErrStatus = SNMP_TOOBIG;
			SnmpStat.OutTooBigs++;
			return FALSE;
		}
		if (!SnmpObjDec(Asn1, Lst++))
		{
			snmpErrIndex = (i32) * LstLen;
			return FALSE;
		}
	}
	if (!Asn1EocDec(Asn1, Eoc))
		return FALSE;
	return TRUE;
}

/*******************************************************************************
*
* SnmpRqsEnc - Encodes snmp_pdu_t into asn1_sck_t
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpRqsEnc
    (
    asn1_sck_t *     Asn1, 
    snmp_pdu_t * Rqs
    )
{
	u8 *End;

	if (!Asn1IntEncUns(Asn1, &End, Rqs->ErrorIndex))
		return FALSE;
	if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
		return FALSE;
	if (!Asn1IntEncUns(Asn1, &End, Rqs->ErrorStatus))
		return FALSE;
	if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
		return FALSE;
	if (!Asn1IntEncLngUns(Asn1, &End, Rqs->Id))
		return FALSE;
	if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
		return FALSE;
	return TRUE;
}

/*******************************************************************************
*
* SnmpRqsDec - Decodes asn1_sck_t to snmp_request_t
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpRqsDec
    (
    asn1_sck_t *     Asn1, 
    snmp_pdu_t * Rqs
    )
{
	u32 Cls, Con, Tag;
	u8 *End;

	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
		return FALSE;
	if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
		return FALSE;
	if (!Asn1IntDecLngUns(Asn1, End, (u32 *) & Rqs->Id))
		return FALSE;
	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
		return FALSE;
	if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
		return FALSE;
	if (!Asn1IntDecUns(Asn1, End, &Rqs->ErrorStatus))
		return FALSE;
	memcpy(&snmpErrAsn1Status, Asn1, sizeof(asn1_sck_t));
	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
		return FALSE;
	if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
		return FALSE;
	if (!Asn1IntDecUns(Asn1, End, &Rqs->ErrorIndex))
		return FALSE;
	/*
	 * Should not receive any error status
	 */
	if (Rqs->ErrorStatus != SNMP_NOERROR)
	{
		switch (Rqs->ErrorStatus)
		{
		case SNMP_TOOBIG:
			SnmpStat.InTooBigs++;
			break;
		case SNMP_NOSUCHNAME:
			SnmpStat.InNoSuchNames++;
			break;
		case SNMP_BADVALUE:
			SnmpStat.InBadValues++;
			break;
		case SNMP_READONLY:
			SnmpStat.InReadOnlys++;
			break;
		default:
			SnmpStat.InGenErrs++;
			break;
		}
		return FALSE;
	}
#if 0
	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
		return FALSE;
	if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
		return FALSE;
	if (!Asn1IntDecUns(Asn1, End, &Rqs->ErrorIndex))
		return FALSE;
#endif
	memcpy(&snmpErrAsn1Index, Asn1, sizeof(asn1_sck_t));
	return TRUE;
}



/*******************************************************************************
*
* SnmpPduEnc - Encodes a list of snmp_object_t and a snmp_pdu_t into asn1_sck_t 
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpPduEnc
    (
    asn1_sck_t *    Asn1, 
    snmp_pdu_t *    Pdu, 
    snmp_object_t * Lst, 
    u32             LstLen
    )
{
	u8 *Eoc;

	if (!Asn1EocEnc(Asn1, &Eoc))
	{
		return FALSE;
	}
	if (!SnmpLstEnc(Asn1, Lst, LstLen))
	{
		return FALSE;
	}
	switch (Pdu->Type)
	{
	case SNMP_PDU_GET:
	case SNMP_PDU_NEXT:
	case SNMP_PDU_RESPONSE:
	case SNMP_PDU_SET:
	case SNMP_PDU_TRAP:
		if (!SnmpRqsEnc(Asn1, Pdu))
		{
			return FALSE;
		}
		break;
	
	default:
		return FALSE;
	}
	if (!Asn1HdrEnc(Asn1, Eoc, ASN1_CTX, ASN1_CON, Pdu->Type))
	{
		return FALSE;
	}
	return TRUE;
}

/*******************************************************************************
*
* SnmpPduDec - Decodes a asn1_sck_t into a list of snmp_object_t and a snmp_pdu_t
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpPduDec
    (
    asn1_sck_t *    Asn1, 
    snmp_pdu_t *    Pdu, 
    snmp_object_t * Lst, 
    u32             LstSze, 
    u32 *           LstLen
    )
{
	u32 Cls, Con;
	u8 *Eoc;

	if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Pdu->Type))
		return FALSE;

	memcpy(&snmpErrAsn1Resp, Asn1, sizeof(asn1_sck_t));

	if (Cls != ASN1_CTX || Con != ASN1_CON)
		return FALSE;
	switch (Pdu->Type)
	{
	case SNMP_PDU_GET:
	case SNMP_PDU_NEXT:
	case SNMP_PDU_RESPONSE:
	case SNMP_PDU_SET:
	case SNMP_PDU_TRAP:
		if (!SnmpRqsDec(Asn1, Pdu))
			return FALSE;
		break;
	default:
		SnmpStat.InBadTypes++;
		return FALSE;
	}
	if (!SnmpLstDec(Asn1, Lst, LstSze, LstLen))
		return FALSE;
	if (!Asn1EocDec(Asn1, Eoc))
		return FALSE;
	return TRUE;
}

/*******************************************************************************
*
* SnmpMsgEnc - Encodes snmp_object_t list, snmp_pdu_t and Com to asn1_sck_t
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpMsgEnc
    (
    asn1_sck_t *    Asn1, 
    snmp_pdu_t *    Pdu, 
    u8 *            Com, 
    u32             ComLen, 
    snmp_object_t * Lst, 
    u32             LstLen
    )
{
	u8 *Eoc, *End;

	if (!Asn1EocEnc(Asn1, &Eoc))
	{
		return FALSE;
	}
	if (!SnmpPduEnc(Asn1, Pdu, Lst, LstLen))
	{
		return FALSE;
	}
	if (!Asn1OtsEnc(Asn1, &End, Com, ComLen))
	{
		return FALSE;
	}
	if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_OTS))
	{
		return FALSE;
	}
	if (!Asn1IntEncUns(Asn1, &End, SNMP_VERSION))
	{
		return FALSE;
	}
	if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
	{
		return FALSE;
	}
	if (!Asn1HdrEnc(Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
	{
		return FALSE;
	}
	return TRUE;
}

/*******************************************************************************
*
* SnmpMsgDec - Decodes asn1_sck_t to snmp_object_t list, snmp_pdu_t and Com
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpMsgDec
    (
    asn1_sck_t *    Asn1, 
    snmp_pdu_t *    Pdu, 
    u8 *            Com, 
    u32             ComSze, 
    u32 *           ComLen, 
    snmp_object_t * Lst, 
    u32             LstSze, 
    u32 *           LstLen
    )
{
	u32 Cls, Con, Tag, Ver;
	u8 *Eoc, *End;

	if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Tag))
	{
		return FALSE;
	}
	if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
	{
#ifdef SNMP_DEBUG
		PrintStr("\r\nCls = ");
		PrintLong(Cls);
		PrintStr("\r\nCon = ");
		PrintLong(Con);
		PrintStr("\r\nTag = ");
		PrintLong(Tag);
#endif
		
		return FALSE;
	}
	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
	{
		return FALSE;
	}
	if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
	{
		return FALSE;
	}
	if (!Asn1IntDecUns(Asn1, End, &Ver))
	{
		return FALSE;
	}
	if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
	{
		return FALSE;
	}
	if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_OTS)
	{
		return FALSE;
	}
	if (!Asn1OtsDec(Asn1, End, Com, ComSze, ComLen))
	{
		return FALSE;
	}
	if (Ver != SNMP_VERSION)
	{
		SnmpStat.InBadVersions++;
		return FALSE;
	}
	if (!SnmpPduDec(Asn1, Pdu, Lst, LstSze, LstLen))
	{
		return FALSE;
	}
	if (!Asn1EocDec(Asn1, Eoc))
	{
		return FALSE;
	}
	return TRUE;
}

/*******************************************************************************
*
* SnmpEnc - Convert char buffer into asn1_sck_t and SnmpMsgEnc
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpEnc
    (
    u8 **           Snmp, 
    u32 *           SnmpLen, 
    snmp_pdu_t *    Pdu, 
    u8 *            Com, 
    u32             ComLen, 
    snmp_object_t * Lst, 
    u32             LstLen
    )
{
	static asn1_sck_t SnmpEncAsn1;

	snmpErrStatus = SNMP_NOERROR;
	snmpErrIndex = 0;

	Asn1Opn(&SnmpEncAsn1, *Snmp, *SnmpLen, ASN1_ENC);
	if (!SnmpMsgEnc(&SnmpEncAsn1, Pdu, Com, ComLen, Lst, LstLen))
	{

		if (snmpErrStatus == SNMP_NOERROR)
		{
			switch (asn1ErrStatus)
			{
			case ASN1_ERR_ENC_FULL:
			case ASN1_ERR_NOERROR:
			case ASN1_ERR_DEC_EMPTY:
			case ASN1_ERR_DEC_EOC_MISMATCH:
			case ASN1_ERR_DEC_LENGTH_MISMATCH:
			case ASN1_ERR_DEC_BADVALUE:
			case ASN1_ERR_ENC_BADVALUE:
			default:
				printf("\r\nSnmpEnc: GENERROR, asn1ErrStatus = %d", asn1ErrStatus);
				snmpErrStatus = SNMP_GENERROR;
				SnmpStat.OutGenErrs++;
				break;

			}
		}
		return FALSE;
	}

	Asn1Cls(&SnmpEncAsn1, Snmp, SnmpLen);

	SnmpStat.OutPkts++;

	switch (Pdu->Type)
	{
	case SNMP_PDU_GET:
		SnmpStat.OutGetRequests++;
		break;
	case SNMP_PDU_NEXT:
		SnmpStat.OutGetNexts++;
		break;
	case SNMP_PDU_RESPONSE:
		SnmpStat.OutGetResponses++;
		break;
	case SNMP_PDU_SET:
		SnmpStat.OutSetRequests++;
		break;
	case SNMP_PDU_TRAP:
		SnmpStat.OutTraps++;
		break;
	default:
		break;
	}

	return TRUE;
}

/*******************************************************************************
*
* SnmpDec - Convert char buffer into asn1_sck_t and SnmpMsgDec
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpDec
    (
    u8 *            Snmp, 
    u32             SnmpLen, 
    snmp_pdu_t *    Pdu, 
    u8 *            Com, 
    u32             ComSze, 
    u32 *           ComLen, 
    snmp_object_t * Lst, 
    u32             LstSze, 
    u32 *           LstLen
    )
{
	static asn1_sck_t SnmpDecAsn1;

	snmpErrStatus = SNMP_NOERROR;
	snmpErrIndex = 0;

	Asn1Opn(&SnmpDecAsn1, Snmp, SnmpLen, ASN1_DEC);
	if (!SnmpMsgDec(&SnmpDecAsn1, Pdu, Com, ComSze, ComLen, Lst, LstSze, LstLen))
	{
		if (snmpErrStatus == SNMP_NOERROR)
		{
			switch (asn1ErrStatus)
			{
			case ASN1_ERR_DEC_BADVALUE:
			case ASN1_ERR_DEC_EOC_MISMATCH:
			case ASN1_ERR_DEC_LENGTH_MISMATCH:
			case ASN1_ERR_DEC_EMPTY:
				snmpErrStatus = SNMP_BADVALUE;
				SnmpStat.OutBadValues++;
				SnmpStat.InASNParseErrs++;
				break;
			case ASN1_ERR_ENC_FULL:
			case ASN1_ERR_NOERROR:
			case ASN1_ERR_ENC_BADVALUE:
			default:
				snmpErrStatus = SNMP_GENERROR;
				SnmpStat.OutGenErrs++;
				break;
			}
		}
		return FALSE;
	}

	Asn1Cls(&SnmpDecAsn1, &Snmp, &SnmpLen);

	SnmpStat.InPkts++;
	switch (Pdu->Type)
	{
	case SNMP_PDU_GET:
		SnmpStat.InGetRequests++;
		break;
	case SNMP_PDU_NEXT:
		SnmpStat.InGetNexts++;
		break;
	case SNMP_PDU_RESPONSE:
		SnmpStat.InGetResponses++;
		break;
	case SNMP_PDU_SET:
		SnmpStat.InSetRequests++;
		break;
	case SNMP_PDU_TRAP:
		SnmpStat.InTraps++;
		break;
	default:
		break;
	}

	return TRUE;
}

/*******************************************************************************
*
* SnmpErrEnc - Encode snmp error response
*
* DESCRIPTION
*
* RETURNS
*   
* NOMANUAL
*/

int SnmpErrEnc
    (
    snmp_pdu_t * Rqs
    )
{
	u8 *End;
/* asn1_sck_t *Asn1 = &snmpErrAsn1; */

	if (!Asn1IntEncUns(&snmpErrAsn1Index, &End, Rqs->ErrorIndex))
		return FALSE;
	if (!Asn1HdrEnc(&snmpErrAsn1Index, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
		return FALSE;

	if (!Asn1IntEncUns(&snmpErrAsn1Status, &End, Rqs->ErrorStatus))
		return FALSE;
	if (!Asn1HdrEnc(&snmpErrAsn1Status, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
		return FALSE;

/*    if(!Asn1IntEncLngUns(&snmpErrAsn1Status, &End, Rqs->Id))
 * return FALSE;
 * if(!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
 * return FALSE; 
 */

	if (!Asn1HdrEnc(&snmpErrAsn1Resp, snmpErrAsn1Resp.End, ASN1_CTX, ASN1_CON, Rqs->Type))
		return FALSE;
	return TRUE;
}