开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
SNMP.C
资源名称：ertos.rar　[点击查看]
上传用户：sunrenlu
上传日期：2022-06-13
资源大小：1419k
文件大小：25k
源码类别：

操作系统开发

开发平台：

DOS

SNMP.C：源码内容
  1. /* Beholder RMON ethernet network monitor,Copyright (C) 1993 DNPAP group */
  2. /* See file COPYING 'GNU General Public Licence' for copyright details   */
  3. /************************************************************************
  4. ** MODULE INFORMATION*
  5. **********************
  6. **     FILE     NAME:       snmp.c
  7. **     SYSTEM   NAME:       SNMP Packet Module
  8. **     ORIGINAL AUTHOR(S):  Dirk Wisse
  9. **     VERSION  NUMBER:     1
  10. **     CREATION DATE:       1990/11/28
  11. **
  12. ** DESCRIPTION: SNMP Packet Module
  13. **
  14. *************************************************************************
  15. ** CHANGES INFORMATION **
  16. *************************
  17. ** REVISION:    $Revision$
  18. ** WORKFILE:    $Workfile$
  19. ** LOGINFO:     $Log$
  20. *************************************************************************/
  21. #include "dnpap.h"
  22. #include <asn1.h>
  23. #include <snmp.h>
  24.  
  25. /*prototypes*/
  26. STATIC BOOLEAN SnmpSyn2TagCls(unsigned *Tag, unsigned *Cls, int Syn);
  27. STATIC BOOLEAN SnmpTagCls2Syn(unsigned Tag, unsigned Cls, WORD *Syn);
  28. STATIC BOOLEAN SnmpObjEnc(ASN1_SCK *Asn1, SNMP_OBJECT *Obj);
  29. STATIC BOOLEAN SnmpObjDec(ASN1_SCK *Asn1, SNMP_OBJECT *Obj);
  30. STATIC BOOLEAN SnmpLstEnc(ASN1_SCK *Asn1, SNMP_OBJECT *Lst, unsigned LstLen);
  31. STATIC BOOLEAN SnmpLstDec(ASN1_SCK *Asn1, SNMP_OBJECT *Lst, unsigned LstSze, unsigned *LstLen);
  32. STATIC BOOLEAN SnmpRqsEnc(ASN1_SCK *Asn1, SNMP_REQUEST *Rqs);
  33. STATIC BOOLEAN SnmpRqsDec(ASN1_SCK *Asn1, SNMP_REQUEST *Rqs);
  34. STATIC BOOLEAN SnmpTrpEnc(ASN1_SCK *Asn1, SNMP_TRAP *Trp);
  35. STATIC BOOLEAN SnmpTrpDec(ASN1_SCK *Asn1, SNMP_TRAP *Trp);
  36. STATIC BOOLEAN SnmpPduEnc(ASN1_SCK *Asn1, SNMP_PDU *Pdu, SNMP_OBJECT *Lst, unsigned LstLen);
  37. STATIC BOOLEAN SnmpPduDec(ASN1_SCK *Asn1, SNMP_PDU *Pdu, SNMP_OBJECT *Lst, unsigned LstSze, unsigned *LstLen);
  39. #define SNMP_IPA    0
  40. #define SNMP_CNT    1
  41. #define SNMP_GGE    2
  42. #define SNMP_TIT    3
  43. #define SNMP_OPQ    4
  46. INT snmpErrStatus = SNMP_NOERROR;
  49. typedef struct _SNMP_CNV SNMP_CNV;
  52. struct _SNMP_CNV
  53. {
  54.     unsigned Class;
  55.     unsigned Tag;
  56.     int      Syntax;
  57. };
  61. SNMP_STAT SnmpStat;
  63. CONST CHAR *SnmpTrap[] =
  64. {
  65. "cold start",
  66. "warm start",
  67. "link down",
  68. "link up",
  69. "authentication failure",
  70.     "neighbor loss",
  71. "enterprise specific"
  72. };
  77. static SNMP_CNV SnmpCnv [] =
  78. {
  79.     {ASN1_UNI, ASN1_NUL, SNMP_NULL},
  80.     {ASN1_UNI, ASN1_INT, SNMP_INTEGER},
  81.     {ASN1_UNI, ASN1_OTS, SNMP_OCTETSTR},
  82.     {ASN1_UNI, ASN1_OTS, SNMP_DISPLAYSTR},
  83.     {ASN1_UNI, ASN1_OJI, SNMP_OBJECTID},
  84.     {ASN1_APL, SNMP_IPA, SNMP_IPADDR},
  85.     {ASN1_APL, SNMP_CNT, SNMP_COUNTER},
  86.     {ASN1_APL, SNMP_GGE, SNMP_GAUGE},
  87.     {ASN1_APL, SNMP_TIT, SNMP_TIMETICKS},
  88.     {ASN1_APL, SNMP_OPQ, SNMP_OPAQUE},
  89.     {0,       0,       -1}
  90. };
  92. /**************************************************************
  93. ** NAME:        SnmpSyn2TagCls
  94. ** SYNOPSIS:    BOOLEAN SnmpSyn2TagCls
  95. **                  (
  96. **                      unsigned    *Tag,
  97. **                      unsigned    *Cls,
  98. **                      int         Syn
  99. **                  )
  100. ** DESCRIPTION: Converts Syntax tag to ASN1 tag and class.
  101. **              See SnmpCnv for conversion.
  102. ** RETURNS:     BOOLEAN success.
  103. **************************************************************/
  104. BOOLEAN SnmpSyn2TagCls
  105.     (
  106.         unsigned    *Tag,
  107.         unsigned    *Cls,
  108.         int         Syn
  109.     )
  110. {
  111.     SNMP_CNV
  112.         *Cnv;
  114.     Cnv = SnmpCnv;
  115.     while (Cnv->Syntax != -1)
  116.     {
  117.         if (Cnv->Syntax == Syn)
  118.         {
  119.             *Tag = Cnv->Tag;
  120.             *Cls = Cnv->Class;
  121.             return TRUE;
  122.         }
  123.         Cnv++;
  124.     }
  125.     return FALSE;
  126. }
  128. /**************************************************************
  129. ** NAME:        SnmpTagCls2Syn
  130. ** SYNOPSIS:    BOOLEAN SnmpTagCls2Syn
  131. **                  (
  132. **                      unsigned    Tag,
  133. **                      unsigned    Cls,
  134. **                      WORD        *Syn
  135. **                  )
  136. ** DESCRIPTION: Converts ASN1 tag and class to Syntax tag.
  137. **              See SnmpCnv for conversion.
  138. ** RETURNS:     BOOLEAN success.
  139. **************************************************************/
  140. BOOLEAN SnmpTagCls2Syn
  141.     (
  142.         unsigned    Tag,
  143.         unsigned    Cls,
  144.         WORD        *Syn
  145.     )
  146. {
  147.     SNMP_CNV
  148.         *Cnv;
  150.     Cnv = SnmpCnv;
  151.     while (Cnv->Syntax != -1)
  152.     {
  153.         if (Cnv->Tag == Tag && Cnv->Class == Cls)
  154.         {
  155.             *Syn = Cnv->Syntax;
  156.             return TRUE;
  157.         }
  158.         Cnv++;
  159.     }
  160.     return FALSE;
  161. }
  163. /**************************************************************
  164. ** NAME:        SnmpObjEnc
  165. ** SYNOPSIS:    BOOLEAN SnmpObjEnc
  166. **                  (
  167. **                      ASN1_SCK     *Asn1,
  168. **                      SNMP_OBJECT   *Obj,
  169. **                  )
  170. ** DESCRIPTION: Encodes an object in ASN1.
  171. ** RETURNS:     BOOLEAN success.
  172. **************************************************************/
  173. BOOLEAN SnmpObjEnc
  174.     (
  175.         ASN1_SCK     *Asn1,
  176.         SNMP_OBJECT   *Obj
  177.     )
  178. {
  179.     unsigned
  180.         Cls,
  181.         Tag;
  182.     BYTE
  183.         *Eoc,
  184.         *End;
  186.     if (!Asn1EocEnc (Asn1, &Eoc))
  187.         return FALSE;
  188.     switch (Obj->Type)
  189.     {
  190.         case SNMP_INTEGER:
  191.             if (!Asn1IntEncLng (Asn1, &End, Obj->Syntax.LngInt))
  192.                 return FALSE;
  193.             break;
  194.         case SNMP_OCTETSTR:
  195.         case SNMP_OPAQUE:
  196.             if (!Asn1OtsEnc (Asn1, &End, Obj->Syntax.BufChr, Obj->SyntaxLen))
  197.                 return FALSE;
  198.             break;
  199.         case SNMP_NULL:
  200.             if (!Asn1NulEnc (Asn1, &End))
  201.                 return FALSE;
  202.             break;
  203.         case SNMP_OBJECTID:
  204.             if (!Asn1OjiEnc (Asn1, &End, Obj->Syntax.BufInt, Obj->SyntaxLen))
  205.                 return FALSE;
  206.             break;
  207.         case SNMP_IPADDR:
  208.             if (!Asn1OtsEnc (Asn1, &End, (BYTE *)&Obj->Syntax.LngUns, 4))
  209.                 return FALSE;
  210.             break;
  211.         case SNMP_COUNTER:
  212.         case SNMP_GAUGE:
  213.         case SNMP_TIMETICKS:
  214.             if (!Asn1IntEncLngUns (Asn1, &End, Obj->Syntax.LngUns))
  215.                 return FALSE;
  216.             break;
  217.         default:
  218.             return FALSE;
  219.     }
  220.     if (!SnmpSyn2TagCls (&Tag, &Cls, Obj->Type))
  221.         return FALSE;
  222.     if (!Asn1HdrEnc (Asn1, End, Cls, ASN1_PRI, Tag))
  223.         return FALSE;
  224.     if (!Asn1OjiEnc (Asn1, &End, Obj->Id, Obj->IdLen))
  225.         return FALSE;
  226.     if (!Asn1HdrEnc (Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_OJI))
  227.         return FALSE;
  228.     if (!Asn1HdrEnc (Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
  229.         return FALSE;
  230.     return TRUE;
  231. }
  233. /**************************************************************
  234. ** NAME:        SnmpObjDec
  235. ** SYNOPSIS:    BOOLEAN SnmpObjDec
  236. **                  (
  237. **                      ASN1_SCK     *Asn1,
  238. **                      SNMP_OBJECT   *Obj,
  239. **                  )
  240. ** DESCRIPTION: Decodes an object from ASN1.
  241. ** RETURNS:     BOOLEAN success.
  242. **************************************************************/
  243. BOOLEAN SnmpObjDec
  244.     (
  245.         ASN1_SCK     *Asn1,
  246.         SNMP_OBJECT   *Obj
  247.     )
  248. {
  249.     unsigned
  250.         Cls,
  251.         Con,
  252.         Tag;
  253.     BYTE
  254.         *Eoc,
  255.         *End;
  257.     if (!Asn1HdrDec (Asn1, &Eoc, &Cls, &Con, &Tag))
  258.         return FALSE;
  259.     if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
  260.         return FALSE;
  261.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  262.         return FALSE;
  263.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_OJI)
  264.         return FALSE;
  265.     if (!Asn1OjiDec (Asn1, End, Obj->Id, SNMP_SIZE_OBJECTID, &Obj->IdLen))
  266.         return FALSE;
  267.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  268.         return FALSE;
  269.     if (Con != ASN1_PRI)
  270.         return FALSE;
  271.     if (!SnmpTagCls2Syn (Tag, Cls, &Obj->Type))
  272.         return FALSE;
  273.     switch (Obj->Type)
  274.     {
  275.         case SNMP_INTEGER:
  276.             if (!Asn1IntDecLng (Asn1, End, &Obj->Syntax.LngInt))
  277.                 return FALSE;
  278.             break;
  279.         case SNMP_OCTETSTR:
  280.         case SNMP_OPAQUE:
  281.             if (!Asn1OtsDec (Asn1, End, Obj->Syntax.BufChr, SNMP_SIZE_BUFCHR,
  282.                 &Obj->SyntaxLen))
  283.                 return FALSE;
  284.             break;
  285.         case SNMP_NULL:
  286.             if (!Asn1NulDec (Asn1, End))
  287.                 return FALSE;
  288.             break;
  289.         case SNMP_OBJECTID:
  290.             if (!Asn1OjiDec (Asn1, End, Obj->Syntax.BufInt, SNMP_SIZE_BUFINT,
  291.                 &Obj->SyntaxLen))
  292.                 return FALSE;
  293.             break;
  294.         case SNMP_IPADDR:
  295.             if (!Asn1OtsDec (Asn1, End, (BYTE *)&Obj->Syntax.LngUns, 4,
  296.                 &Obj->SyntaxLen))
  297.                 return FALSE;
  298.             if (Obj->SyntaxLen != 4)
  299.                 return FALSE;
  300.             break;
  301.         case SNMP_COUNTER:
  302.         case SNMP_GAUGE:
  303.         case SNMP_TIMETICKS:
  304.             if (!Asn1IntDecLngUns (Asn1, End, &Obj->Syntax.LngUns))
  305.                 return FALSE;
  306.             break;
  307.         default:
  308.             return FALSE;
  309.     }
  310.     if (!Asn1EocDec (Asn1, Eoc))
  311.         return FALSE;
  312.     return TRUE;
  313. }
  315. /**************************************************************
  316. ** NAME:        SnmpLstEnc
  317. ** SYNOPSIS:    BOOLEAN
  318. **                  SnmpLstEnc
  319. **                  (
  320. **                      ASN1_SCK     *Asn1,
  321. **                      SNMP_OBJECT   *Lst,
  322. **                      unsigned     LstLen
  323. **                  )
  324. ** DESCRIPTION: Encodes a list of objects in ASN1.
  325. ** RETURNS:     BOOLEAN success.
  326. **************************************************************/
  327. BOOLEAN
  328.     SnmpLstEnc
  329.     (
  330.         ASN1_SCK     *Asn1,
  331.         SNMP_OBJECT  *Lst,
  332.         unsigned     LstLen
  333.     )
  334. {
  335.     BYTE
  336.         *Eoc;
  338.     if (!Asn1EocEnc (Asn1, &Eoc))
  339.         return FALSE;
  340.     Lst += LstLen;
  341.     while (LstLen-- > 0)
  342.     {
  343.         if (!SnmpObjEnc (Asn1, --Lst))
  344.             return FALSE;
  345.     }
  346.     if (!Asn1HdrEnc (Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
  347.         return FALSE;
  348.     return TRUE;
  349. }
  351. /**************************************************************
  352. ** NAME:        SnmpLstDec
  353. ** SYNOPSIS:    BOOLEAN
  354. **                  SnmpLstDec
  355. **                  (
  356. **                      ASN1_SCK     *Asn1,
  357. **                      SNMP_OBJECT   *Lst,
  358. **                      unsigned     LstSze,
  359. **                      unsigned     *LstLen
  360. **                  )
  361. ** DESCRIPTION: Decodes a list of objects from ASN1.
  362. ** RETURNS:     BOOLEAN success.
  363. **************************************************************/
  364. BOOLEAN
  365.     SnmpLstDec
  366.     (
  367.         ASN1_SCK     *Asn1,
  368.         SNMP_OBJECT   *Lst,
  369.         unsigned     LstSze,
  370.         unsigned     *LstLen
  371.     )
  372. {
  373.     unsigned
  374.         Cls,
  375.         Con,
  376.         Tag;
  377.     BYTE
  378.         *Eoc;
  380.     if (!Asn1HdrDec (Asn1, &Eoc, &Cls, &Con, &Tag))
  381.         return FALSE;
  382.     if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
  383.         return FALSE;
  384.     *LstLen = 0;
  385.     while (!Asn1Eoc (Asn1, Eoc))
  386.     {
  387.         if (++(*LstLen) > LstSze)
  388.         {
  389.             snmpErrStatus = SNMP_TOOBIG;
  390.             return FALSE;
  391.         }
  392.         if (!SnmpObjDec (Asn1, Lst++))
  393.             return FALSE;
  394.     }
  395.     if (!Asn1EocDec (Asn1, Eoc))
  396.         return FALSE;
  397.     return TRUE;
  398. }
  400. /**************************************************************
  401. ** NAME:        SnmpRqsEnc
  402. ** SYNOPSIS:    BOOLEAN
  403. **                  SnmpRqsEnc
  404. **                  (
  405. **                      ASN1_SCK     *Asn1,
  406. **                      SNMP_REQUEST *Rqs
  407. **                  )
  408. ** DESCRIPTION: Encodes a request or response PDU in ASN1.
  409. ** RETURNS:     BOOLEAN success.
  410. **************************************************************/
  411. BOOLEAN
  412.     SnmpRqsEnc
  413.     (
  414.         ASN1_SCK     *Asn1,
  415.         SNMP_REQUEST *Rqs
  416.     )
  417. {
  418.     BYTE
  419.         *End;
  421.     if (!Asn1IntEncUns (Asn1, &End, Rqs->ErrorIndex))
  422.         return FALSE;
  423.     if (!Asn1HdrEnc (Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  424.         return FALSE;
  425.     if (!Asn1IntEncUns (Asn1, &End, Rqs->ErrorStatus))
  426.         return FALSE;
  427.     if (!Asn1HdrEnc (Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  428.         return FALSE;
  429.     if (!Asn1IntEncLngUns (Asn1, &End, Rqs->Id))
  430.         return FALSE;
  431.     if (!Asn1HdrEnc (Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  432.         return FALSE;
  433.     return TRUE;
  434. }
  436. /**************************************************************
  437. ** NAME:        SnmpRqsDec
  438. ** SYNOPSIS:    BOOLEAN
  439. **                  SnmpRqsDec
  440. **                  (
  441. **                      ASN1_SCK     *Asn1,
  442. **                      SNMP_REQUEST *Rqs
  443. **                  )
  444. ** DESCRIPTION: Decodes a request or response PDU from ASN1.
  445. ** RETURNS:     BOOLEAN success.
  446. **************************************************************/
  447. BOOLEAN
  448.     SnmpRqsDec
  449.     (
  450.         ASN1_SCK     *Asn1,
  451.         SNMP_REQUEST *Rqs
  452.     )
  453. {
  454.     unsigned
  455.         Cls,
  456.         Con,
  457.         Tag;
  458.     BYTE
  459.         *End;
  461.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  462.         return FALSE;
  463.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  464.         return FALSE;
  465.     if (!Asn1IntDecLngUns (Asn1, End, &Rqs->Id))
  466.         return FALSE;
  467.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  468.         return FALSE;
  469.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  470.         return FALSE;
  471.     if (!Asn1IntDecUns (Asn1, End, &Rqs->ErrorStatus))
  472.         return FALSE;
  473.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  474.         return FALSE;
  475.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  476.         return FALSE;
  477.     if (!Asn1IntDecUns (Asn1, End, &Rqs->ErrorIndex))
  478.         return FALSE;
  479.     return TRUE;
  480. }
  482. /**************************************************************
  483. ** NAME:        SnmpTrpEnc
  484. ** SYNOPSIS:    BOOLEAN
  485. **                  SnmpTrpEnc
  486. **                  (
  487. **                      ASN1_SCK     *Asn1,
  488. **                      SNMP_TRAP    *Trp
  489. **                  )
  490. ** DESCRIPTION: Encodes a trap PDU in ASN1.
  491. ** RETURNS:     BOOLEAN success.
  492. **************************************************************/
  493. BOOLEAN
  494.     SnmpTrpEnc
  495.     (
  496.         ASN1_SCK     *Asn1,
  497.         SNMP_TRAP    *Trp
  498.     )
  499. {
  500.     BYTE
  501.         *End;
  503.     if (!Asn1IntEncLngUns (Asn1, &End, Trp->Time))
  504.         return FALSE;
  505.     if (!Asn1HdrEnc (Asn1, End, ASN1_APL, ASN1_PRI, SNMP_TIT))
  506.         return FALSE;
  507.     if (!Asn1IntEncUns (Asn1, &End, Trp->Specific))
  508.         return FALSE;
  509.     if (!Asn1HdrEnc (Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  510.         return FALSE;
  511.     if (!Asn1IntEncUns (Asn1, &End, Trp->General))
  512.         return FALSE;
  513.     if (!Asn1HdrEnc (Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  514.         return FALSE;
  515.     if (!Asn1OtsEnc (Asn1, &End, (BYTE *)&(Trp->IpAddress), 4))
  516.         return FALSE;
  517.     if (!Asn1HdrEnc (Asn1, End, ASN1_APL, ASN1_PRI, SNMP_IPA))
  518.         return FALSE;
  519.     if (!Asn1OjiEnc (Asn1, &End, Trp->Id, Trp->IdLen))
  520.         return FALSE;
  521.     if (!Asn1HdrEnc (Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_OJI))
  522.         return FALSE;
  523.     return TRUE;
  524. }
  526. /**************************************************************
  527. ** NAME:        SnmpTrpDec
  528. ** SYNOPSIS:    BOOLEAN
  529. **                  SnmpTrpDec
  530. **                  (
  531. **                      ASN1_SCK     *Asn1,
  532. **                      SNMP_TRAP    *Trp
  533. **                  )
  534. ** DESCRIPTION: Decodes a trap PDU from ASN1.
  535. ** RETURNS:     BOOLEAN success.
  536. **************************************************************/
  537. BOOLEAN
  538.     SnmpTrpDec
  539.     (
  540.         ASN1_SCK     *Asn1,
  541.         SNMP_TRAP    *Trp
  542.     )
  543. {
  544.     unsigned
  545.         Cls,
  546.         Con,
  547.         Tag;
  548.     BYTE
  549.         *End;
  551.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  552.         return FALSE;
  553.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_OJI)
  554.         return FALSE;
  555.     if (!Asn1OjiDec (Asn1, End, Trp->Id, sizeof(Trp->Id)/sizeof(Trp->Id[0]), &Trp->IdLen))
  556.         return FALSE;
  557.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  558.         return FALSE;
  559.     if (Cls != ASN1_APL || Con != ASN1_PRI || Tag != SNMP_IPA)
  560.         return FALSE;
  561.     if (!Asn1OtsDec (Asn1, End, (BYTE *)&(Trp->IpAddress), 4, &Tag))
  562.         return FALSE;
  563.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  564.         return FALSE;
  565.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  566.         return FALSE;
  567.     if (!Asn1IntDecUns (Asn1, End, &Trp->General))
  568.         return FALSE;
  569.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  570.         return FALSE;
  571.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  572.         return FALSE;
  573.     if (!Asn1IntDecUns (Asn1, End, &Trp->Specific))
  574.         return FALSE;
  575.     if (!Asn1HdrDec (Asn1, &End, &Cls, &Con, &Tag))
  576.         return FALSE;
  577.     if (Cls != ASN1_APL || Con != ASN1_PRI || Tag != SNMP_TIT)
  578.         return FALSE;
  579.     if (!Asn1IntDecLngUns (Asn1, End, &Trp->Time))
  580.         return FALSE;
  581.     return TRUE;
  582. }
  584. /**************************************************************
  585. ** NAME:        SnmpPduEnc
  586. ** SYNOPSIS:    BOOLEAN
  587. **                  SnmpPduEnc
  588. **                  (
  589. **                      ASN1_SCK     *Asn1,
  590. **                      SNMP_PDU     *Pdu,
  591. **                      SNMP_OBJECT   *Lst,
  592. **                      unsigned     LstLen
  593. **                  )
  594. ** DESCRIPTION: Encodes a PDU in ASN1.
  595. **              Pdu is a union of snmp_ror and snmp_trp.
  596. ** RETURNS:     BOOLEAN success.
  597. **************************************************************/
  598. BOOLEAN
  599.     SnmpPduEnc
  600.     (
  601.         ASN1_SCK     *Asn1,
  602.         SNMP_PDU     *Pdu,
  603.         SNMP_OBJECT   *Lst,
  604.         unsigned     LstLen
  605.     )
  606. {
  607.     BYTE
  608.         *Eoc;
  610.     if (!Asn1EocEnc (Asn1, &Eoc))
  611.         return FALSE;
  612.     if (!SnmpLstEnc (Asn1, Lst, LstLen))
  613.         return FALSE;
  614.     switch (Pdu->Type)
  615.     {
  616.         case SNMP_PDU_GET:
  617.         case SNMP_PDU_NEXT:
  618.         case SNMP_PDU_RESPONSE:
  619.         case SNMP_PDU_SET:
  620.             if (!SnmpRqsEnc (Asn1, &Pdu->Request))
  621.                 return FALSE;
  622.             break;
  623.         case SNMP_PDU_TRAP:
  624.            if (!SnmpTrpEnc (Asn1, &Pdu->Trap))
  625.                 return FALSE;
  626.             break;
  627.         default:
  628.             return FALSE;
  629.     }
  630.     if (!Asn1HdrEnc (Asn1, Eoc, ASN1_CTX, ASN1_CON, Pdu->Type))
  631.         return FALSE;
  632.     return TRUE;
  633. }
  635. /**************************************************************
  636. ** NAME:        SnmpPduDec
  637. ** SYNOPSIS:    BOOLEAN
  638. **                  SnmpPduDec
  639. **                  (
  640. **                      ASN1_SCK     *Asn1,
  641. **                      SNMP_PDU     *Pdu
  642. **                      SNMP_OBJECT   *Lst,
  643. **                      unsigned     LstSze,
  644. **                      unsigned     *LstLen
  645. **                  )
  646. ** DESCRIPTION: Decodes a PDU from ASN1.
  647. **              Pdu is a union of snmp_ror and snmp_trp.
  648. ** RETURNS:     BOOLEAN success.
  649. **************************************************************/
  650. BOOLEAN
  651.     SnmpPduDec
  652.     (
  653.         ASN1_SCK     *Asn1,
  654.         SNMP_PDU     *Pdu,
  655.         SNMP_OBJECT   *Lst,
  656.         unsigned     LstSze,
  657.         unsigned     *LstLen
  658.     )
  659. {
  660.     unsigned
  661.         Cls,
  662.         Con;
  663.     BYTE
  664.         *Eoc;
  666.     if (!Asn1HdrDec (Asn1, &Eoc, &Cls, &Con, &Pdu->Type))
  667.         return FALSE;
  668.     if (Cls != ASN1_CTX || Con != ASN1_CON)
  669.         return FALSE;
  670.     switch (Pdu->Type)
  671.     {
  672.         case SNMP_PDU_GET:
  673.         case SNMP_PDU_NEXT:
  674.         case SNMP_PDU_RESPONSE:
  675.         case SNMP_PDU_SET:
  676.             if (!SnmpRqsDec (Asn1, &Pdu->Request))
  677.                 return FALSE;
  678.             break;
  679.         case SNMP_PDU_TRAP:
  680.             if (!SnmpTrpDec (Asn1, &Pdu->Trap))
  681.                 return FALSE;
  682.             break;
  683.         default:
  684.             SnmpStat.InBadTypes++;
  685.             return FALSE;
  686.     }
  687.     if (!SnmpLstDec (Asn1, Lst, LstSze, LstLen))
  688.         return FALSE;
  689.     if (!Asn1EocDec (Asn1, Eoc))
  690.         return FALSE;
  691.     return TRUE;
  692. }
  694. /**************************************************************
  695. ** NAME:        SnmpEnc                                   [API]
  696. ** SYNOPSIS:    BOOLEAN SnmpEnc
  697. **                  (
  698. **                      BYTE        **Snmp, 
  699. **                      unsigned    *SnmpLen,
  700. **                      SNMP_PDU    *Pdu, 
  701. **                      BYTE        *Com, 
  702. **                      unsigned    ComLen, 
  703. **                      SNMP_OBJECT  *Lst, 
  704. **                      unsigned    LstLen
  705. **                  )
  706. ** DESCRIPTION: Encodes a request, response or trap in ASN1.
  707. ** RETURNS:     BOOLEAN success.
  708. **************************************************************/
  709. BOOLEAN SnmpEnc(BYTE        **Snmp, 
  710.                 unsigned    *SnmpLen,
  711.                 SNMP_PDU    *Pdu, 
  712.                 BYTE        *Com, 
  713.                 unsigned    ComLen, 
  714.                 SNMP_OBJECT  *Lst, 
  715.                 unsigned    LstLen)
  716. {
  717.     BYTE
  718.         *Eoc,
  719.         *End;
  720.     ASN1_SCK
  721.         Asn1;
  723.     snmpErrStatus = SNMP_GENERROR;
  725.     Asn1Opn (&Asn1, *Snmp, *SnmpLen, ASN1_ENC);
  726.     if (!Asn1EocEnc (&Asn1, &Eoc))
  727.         return FALSE;
  728.     if (!SnmpPduEnc (&Asn1, Pdu, Lst, LstLen))
  729.         return FALSE;
  730.     if (!Asn1OtsEnc (&Asn1, &End, Com, ComLen))
  731.         return FALSE;
  732.     if (!Asn1HdrEnc (&Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_OTS))
  733.         return FALSE;
  734.     if (!Asn1IntEncUns (&Asn1, &End, SNMP_VERSION))
  735.         return FALSE;
  736.     if (!Asn1HdrEnc (&Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  737.         return FALSE;
  738.     if (!Asn1HdrEnc (&Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
  739.         return FALSE;
  740.     Asn1Cls (&Asn1, Snmp, SnmpLen);
  741.     
  742.     SnmpStat.OutPkts++;
  743.     switch (Pdu->Type)
  744.     {
  745.         case SNMP_PDU_GET:
  746.             SnmpStat.OutGetRequests++;
  747.             break;
  748.         case SNMP_PDU_NEXT:
  749.             SnmpStat.OutGetNexts++;
  750.             break;
  751.         case SNMP_PDU_RESPONSE:
  752.             SnmpStat.OutGetResponses++;
  753.             break;
  754.         case SNMP_PDU_SET:
  755.             SnmpStat.OutSetRequests++;
  756.             break;
  757.         case SNMP_PDU_TRAP:
  758.             SnmpStat.OutTraps++;
  759.             break;
  760.     }
  761.     
  762.     return TRUE;
  763. }
  765. /**************************************************************
  766. ** NAME:        SnmpDec                                   [API]
  767. ** SYNOPSIS:    BOOLEAN SnmpDec
  768. **                  (
  769. **                      BYTE        *Snmp, 
  770. **                      unsigned    SnmpLen,
  771. **                      SNMP_PDU    *Pdu,
  772. **                      BYTE        *Com, 
  773. **                      unsigned    ComSze,
  774. **                      unsigned    *ComLen, 
  775. **                      SNMP_OBJECT  *Lst, 
  776. **                      unsigned    LstSze,
  777. **                      unsigned    *LstLen
  778. **                  )
  779. ** DESCRIPTION: Decodes a request, response or trap from ASN1.
  780. ** RETURNS:     BOOLEAN success.
  781. **************************************************************/
  782. BOOLEAN SnmpDec(BYTE        *Snmp, 
  783.                 unsigned    SnmpLen,
  784.                 SNMP_PDU    *Pdu,
  785.                 BYTE        *Com, 
  786.                 unsigned    ComSze,
  787.                 unsigned    *ComLen, 
  788.                 SNMP_OBJECT  *Lst, 
  789.                 unsigned    LstSze,
  790.                 unsigned    *LstLen)
  791. {
  792.     unsigned
  793.         Cls,
  794.         Con,
  795.         Tag;
  796.     BYTE
  797.         *Eoc,
  798.         *End;
  799.     ASN1_SCK
  800.         Asn1;
  801.     unsigned
  802.         Ver;
  804.     snmpErrStatus = SNMP_GENERROR;
  806.     Asn1Opn (&Asn1, Snmp, SnmpLen, ASN1_DEC);
  807.     if (!Asn1HdrDec (&Asn1, &Eoc, &Cls, &Con, &Tag))
  808.     {
  809.         SnmpStat.InASNParseErrs++;
  810.         return FALSE;
  811.     }
  812.     if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
  813.     {
  814.         SnmpStat.InASNParseErrs++;
  815.         return FALSE;
  816.     }
  817.     if (!Asn1HdrDec (&Asn1, &End, &Cls, &Con, &Tag))
  818.     {
  819.         SnmpStat.InASNParseErrs++;
  820.         return FALSE;
  821.     }
  822.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  823.     {
  824.         SnmpStat.InASNParseErrs++;
  825.         return FALSE;
  826.     }
  827.     if (!Asn1IntDecUns (&Asn1, End, &Ver))
  828.     {
  829.         SnmpStat.InASNParseErrs++;
  830.         return FALSE;
  831.     }
  832.     if (!Asn1HdrDec (&Asn1, &End, &Cls, &Con, &Tag))
  833.     {
  834.         SnmpStat.InASNParseErrs++;
  835.         return FALSE;
  836.     }
  837.     if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_OTS)
  838.     {
  839.         SnmpStat.InASNParseErrs++;
  840.         return FALSE;
  841.     }
  842.     if (!Asn1OtsDec (&Asn1, End, Com, ComSze, ComLen))
  843.     {
  844.         SnmpStat.InASNParseErrs++;
  845.         return FALSE;
  846.     }
  847.     if (Ver != SNMP_VERSION)
  848.     {
  849.         SnmpStat.InBadVersions++;
  850.         return FALSE;
  851.     }
  852.     if (!SnmpPduDec (&Asn1, Pdu, Lst, LstSze, LstLen))
  853.     {
  854.         SnmpStat.InASNParseErrs++;
  855.         return FALSE;
  856.     }
  857.     if (!Asn1EocDec (&Asn1, Eoc))
  858.     {
  859.         SnmpStat.InASNParseErrs++;
  860.         return FALSE;
  861.     }
  862.     Asn1Cls (&Asn1, &Snmp, &SnmpLen);
  863.     
  864.     SnmpStat.InPkts++;
  865.     switch (Pdu->Type)
  866.     {
  867.         case SNMP_PDU_GET:
  868.             SnmpStat.InGetRequests++;
  869.             break;
  870.         case SNMP_PDU_NEXT:
  871.             SnmpStat.InGetNexts++;
  872.             break;
  873.         case SNMP_PDU_RESPONSE:
  874.             SnmpStat.InGetResponses++;
  875.             break;
  876.         case SNMP_PDU_SET:
  877.             SnmpStat.InSetRequests++;
  878.             break;
  879.         case SNMP_PDU_TRAP:
  880.             SnmpStat.InTraps++;
  881.             break;
  882.     }
  883.     
  884.     return TRUE;
  885. }