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

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

操作系统开发

开发平台：

DOS

ASN1.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:       asn1.c
  7. **     SYSTEM   NAME:       ASN1 Basic Encoding
  8. **     ORIGINAL AUTHOR(S):  Dirk Wisse
  9. **     VERSION  NUMBER:     1
  10. **     CREATION DATE:       1990/11/22
  11. **
  12. ** DESCRIPTION: ASN1 Basic Encoding Rules.
  13. **              Encoding takes place from end to begin. A normal
  14. **              procedure for definite encoding is:
  15. **
  16. **              Asn1Opn (Asn1, Buf, sizeof (Buf), ASN_ENC);
  17. **              Asn1EocEnc (Asn1, &EndOfSeq);
  18. **              Asn1IntEnc (Asn1, &EndOfInt, 3);
  19. **              Asn1HdrEnc (Asn1, EndOfInt, ASN_UNI, ASN_PRI, ASN_INT);
  20. **              Asn1OtsEnc (Asn1, &EndOfOts, "String", 6);
  21. **              Asn1HdrEnc (Asn1, EndOfOts, ASN_UNI, ASN_PRI, ASN_OTS);
  22. **              Asn1HdrEnc (Asn1, EndOfSeq, ASN_UNI, ASN_CON, ASN_SEQ);
  23. **              Asn1Cls (Asn1, &BufBeg, &BufLen);
  24. **
  25. **              To decode this we must do:
  26. **
  27. **              Asn1Opn (Asn1, BufBeg, BufLen, ASN_DEC);
  28. **              Asn1HdrDec (Asn1, &EndOfSeq, Cls, Con, Tag);
  29. **              Asn1HdrDec (Asn1, &EndOfOts, Cls, Con, Tag);
  30. **              Asn1OtsDec (Asn1, EndOfOts, String, sizeof (String), Length);
  31. **              Asn1HdrDec (Asn1, &EndOfInt, Cls, Con, Tag);
  32. **              Asn1IntDec (Asn1, EndOfInt, &Integer);
  33. **              Asn1EocDec (Asn1, EndOfSeq);
  34. **              Asn1Cls (Asn1, &BufBeg, &BufLen);
  35. **              
  36. **              For indefinite encoding EndOfSeq and &EndOfSeq in the
  37. **              example above should be replaced by NULL.
  38. **              For indefinite decoding nothing has to be changed.
  39. **              This can be very useful if you want to decode both
  40. **              definite and indefinite encodings.
  41. **
  42. *************************************************************************
  43. ** CHANGES INFORMATION **
  44. *************************
  45. ** REVISION:    $Revision$
  46. ** WORKFILE:    $Workfile$
  47. ** LOGINFO:     $Log$
  48. *************************************************************************/
  49. #include "dnpap.h"
  50. #include "asn1.h"
  52. /**************************************************************
  53. ** NAME:        Asn1Opn                                   [API]
  54. ** SYNOPSIS:    void Asn1Opn
  55. **                  (
  56. **                      ASN1_SCK    *Asn1,
  57. **                      BYTE        *Buf,
  58. **                      unsigned    Len,
  59. **                      unsigned    Mde
  60. **                  )
  61. ** DESCRIPTION: Opens an ASN1 socket.
  62. **              Parameters:
  63. **              Asn1: Pointer to ASN1 socket.
  64. **              Buf: Character buffer for encoding.
  65. **              Len: Length of character buffer.
  66. **              Mde: Encoding, Decoding (ASN_ENC, ASN_DEC).
  67. **              Encoding starts at the end of the buffer, and
  68. **              proceeds to the beginning.
  69. ** RETURNS:     void
  70. **************************************************************/
  71. void Asn1Opn(ASN1_SCK *Asn1, BYTE *Buf, unsigned Len, unsigned Mde)
  72. {
  73.     Asn1->Begin = Buf;
  74.     Asn1->End = Buf + Len;
  75.     Asn1->Pointer = (Mde == ASN1_ENC) ? Buf + Len : Buf;
  76. }
  78. /**************************************************************
  79. ** NAME:        Asn1Cls                                   [API]
  80. ** SYNOPSIS:    void Asn1Cls
  81. **                  (
  82. **                      ASN1_SCK    *Asn1,
  83. **                      BYTE        **Buf,
  84. **                      unsigned    *Len
  85. **                  )
  86. ** DESCRIPTION: Closes an ASN1 socket.
  87. **              Parameters:
  88. **              Asn1: Pointer to ASN1 socket.
  89. **              Buf: Pointer to beginning of encoding.
  90. **              Len: Length of encoding.
  91. ** RETURNS:     void
  92. **************************************************************/
  93. void Asn1Cls(ASN1_SCK *Asn1, BYTE **Buf, unsigned *Len)
  94. {
  95.     *Buf = Asn1->Pointer;
  96.     *Len = Asn1->End - Asn1->Pointer;
  97. }
  101. /**************************************************************
  102. ** NAME:        Asn1OctEnc
  103. ** SYNOPSIS:    BOOLEAN Asn1OctEnc
  104. **                  (
  105. **                      ASN1_SCK        *Asn1,
  106. **                      BYTE            Chr
  107. **                  )
  108. ** DESCRIPTION: Encodes an octet.
  109. ** RETURNS:     BOOLEAN success.
  110. **************************************************************/
  111. BOOLEAN Asn1OctEnc(ASN1_SCK *Asn1, BYTE Chr)
  112. {
  113.     if (Asn1->Pointer <= Asn1->Begin)
  114.         return FALSE;
  115.     *--(Asn1->Pointer) = Chr;
  116.     return TRUE;
  117. }
  119. /**************************************************************
  120. ** NAME:        Asn1OctDec
  121. ** SYNOPSIS:    BOOLEAN Asn1OctDec
  122. **                  (
  123. **                      ASN1_SCK        *Asn1,
  124. **                      BYTE            *Chr
  125. **                  )
  126. ** DESCRIPTION: Decodes an octet.
  127. ** RETURNS:     BOOLEAN success.
  128. **************************************************************/
  129. BOOLEAN Asn1OctDec(ASN1_SCK *Asn1, BYTE *Chr)
  130. {
  131.     if (Asn1->Pointer >= Asn1->End)
  132.         return FALSE;
  133.     *Chr = *(Asn1->Pointer)++;
  134.     return TRUE;
  135. }
  137. /**************************************************************
  138. ** NAME:        Asn1TagEnc
  139. ** SYNOPSIS:    BOOLEAN Asn1TagEnc
  140. **                  (
  141. **                      ASN1_SCK         *Asn1,
  142. **                      unsigned        Tag
  143. **                  )
  144. ** DESCRIPTION: Encodes a tag.
  145. ** RETURNS:     BOOLEAN success.
  146. **************************************************************/
  147. BOOLEAN Asn1TagEnc(ASN1_SCK *Asn1, unsigned Tag)
  148. {
  149.     BYTE        Chr;
  151.     Chr = (BYTE) (Tag & 0x7F);
  152.     Tag >>= 7;
  153.     if (!Asn1OctEnc (Asn1, Chr))
  154.         return FALSE;
  155.     while (Tag > 0)
  156.     {
  157.         Chr = (BYTE) (Tag | 0x80);
  158.         Tag >>= 7;
  159.         if (!Asn1OctEnc (Asn1, Chr))
  160.             return FALSE;
  161.     }
  162.     return TRUE;
  163. }
  165. /**************************************************************
  166. ** NAME:        Asn1TagDec
  167. ** SYNOPSIS:    BOOLEAN Asn1TagDec
  168. **                  (
  169. **                      ASN1_SCK         *Asn1,
  170. **                      unsigned        *Tag
  171. **                  )
  172. ** DESCRIPTION: Decodes a tag.
  173. ** RETURNS:     BOOLEAN success.
  174. **************************************************************/
  175. BOOLEAN Asn1TagDec(ASN1_SCK *Asn1, unsigned *Tag)
  176. {
  177.     BYTE        Chr;
  179.     *Tag = 0;
  180.     do
  181.     {
  182.         if (!Asn1OctDec (Asn1, &Chr))
  183.             return FALSE;
  184.         *Tag <<= 7;
  185.         *Tag |= Chr & 0x7F;
  186.     }
  187.     while ((Chr & 0x80) == 0x80);
  188.     return TRUE;
  189. }
  191. /**************************************************************
  192. ** NAME:        Asn1IdrEnc
  193. ** SYNOPSIS:    BOOLEAN Asn1IdrEnc
  194. **                  (
  195. **                      ASN1_SCK     *Asn1,
  196. **                      unsigned    Cls,
  197. **                      unsigned    Con,
  198. **                      unsigned    Tag
  199. **                  )
  200. ** DESCRIPTION: Encodes an identifier.
  201. ** RETURNS:     BOOLEAN success.
  202. **************************************************************/
  203. BOOLEAN Asn1IdrEnc(ASN1_SCK *Asn1, unsigned Cls, unsigned Con,
  204.         unsigned Tag)
  205. {
  206.     BYTE        Chr;
  208.     if (Tag >= 0x1F)
  209.     {
  210.         if (!Asn1TagEnc (Asn1, Tag))
  211.             return FALSE;
  212.         Tag = 0x1F;
  213.     }
  214.     Chr = (BYTE) ((Cls << 6) | (Con << 5) | (Tag));
  215.     if (!Asn1OctEnc (Asn1, Chr))
  216.         return FALSE;
  217.     return TRUE;
  218. }
  220. /**************************************************************
  221. ** NAME:        Asn1IdrDec
  222. ** SYNOPSIS:    BOOLEAN Asn1IdrDec
  223. **                  (
  224. **                      ASN1_SCK     *Asn1,
  225. **                      unsigned    *Cls,
  226. **                      unsigned    *Con,
  227. **                      unsigned    *Tag
  228. **                  )
  229. ** DESCRIPTION: Decodes an identifier.
  230. ** RETURNS:     BOOLEAN success.
  231. **************************************************************/
  232. BOOLEAN Asn1IdrDec(ASN1_SCK *Asn1, unsigned *Cls, unsigned *Con,
  233.         unsigned *Tag)
  234. {
  235.     BYTE        Chr;
  237.     if (!Asn1OctDec (Asn1, &Chr))
  238.         return FALSE;
  239.     *Cls = (Chr & 0xC0) >> 6;
  240.     *Con = (Chr & 0x20) >> 5;
  241.     *Tag = (Chr & 0x1F);
  242.     if (*Tag == 0x1F)
  243.     {
  244.         if (!Asn1TagDec (Asn1, Tag))
  245.             return FALSE;
  246.     }
  247.     return TRUE;
  248. }
  250. /**************************************************************
  251. ** NAME:        Asn1LenEnc
  252. ** SYNOPSIS:    BOOLEAN Asn1LenEnc
  253. **                  (
  254. **                      ASN1_SCK     *Asn1,
  255. **                      unsigned    Def,
  256. **                      unsigned    Len
  257. **                  )
  258. ** DESCRIPTION: Encodes a definite or indefinite length.
  259. ** RETURNS:     BOOLEAN success.
  260. **************************************************************/
  261. BOOLEAN Asn1LenEnc(ASN1_SCK *Asn1, unsigned Def, unsigned Len)
  262. {
  263.     BYTE        Chr,Cnt;
  265.     if (!Def)
  266.         Chr = 0x80;
  267.     else
  268.     {
  269.         if (Len < 0x80)
  270.             Chr = (BYTE) Len;
  271.         else
  272.         {
  273.             Cnt = 0;
  274.             while (Len > 0)
  275.             {
  276.                 Chr = (BYTE) Len;
  277.                 Len >>= 8;
  278.                 if (!Asn1OctEnc (Asn1, Chr))
  279.                     return FALSE;
  280.                 Cnt++;
  281.             }
  282.             Chr = (BYTE) (Cnt | 0x80);
  283.         }
  284.     }
  285.     if (!Asn1OctEnc (Asn1, Chr))
  286.         return FALSE;
  287.     return TRUE;
  288. }
  290. /**************************************************************
  291. ** NAME:        Asn1LenDec
  292. ** SYNOPSIS:    BOOLEAN Asn1LenDec
  293. **                  (
  294. **                      ASN1_SCK     *Asn1,
  295. **                      unsigned    Def,
  296. **                      unsigned    Len
  297. **                  )
  298. ** DESCRIPTION: Decodes a definite or indefinite length.
  299. ** RETURNS:     BOOLEAN success.
  300. **************************************************************/
  301. BOOLEAN Asn1LenDec(ASN1_SCK *Asn1, unsigned *Def, unsigned *Len)
  302. {
  303.     BYTE        Chr,Cnt;
  305.     if (!Asn1OctDec (Asn1, &Chr))
  306.         return FALSE;
  307.     if (Chr == 0x80)
  308.         *Def = 0;
  309.     else
  310.     {
  311.         *Def = 1;
  312.         if (Chr < 0x80)
  313.             *Len = Chr;
  314.         else
  315.         {
  316.             Cnt = (BYTE) (Chr & 0x7F);
  317.             *Len = 0;
  318.             while (Cnt > 0)
  319.             {
  320.                 if (!Asn1OctDec (Asn1, &Chr))
  321.                     return FALSE;
  322.                 *Len <<= 8;
  323.                 *Len |= Chr;
  324.                 Cnt--;
  325.             }
  326.         }
  327.     }
  328.     return TRUE;
  329. }
  331. /**************************************************************
  332. ** NAME:        Asn1HdrEnc                                [API]
  333. ** SYNOPSIS:    BOOLEAN Asn1HdrEnc
  334. **                  (
  335. **                      ASN1_SCK    *Asn1,
  336. **                      BYTE        *Eoc,
  337. **                      unsigned    Cls,
  338. **                      unsigned    Con,
  339. **                      unsigned    Tag
  340. **                  )
  341. ** DESCRIPTION: Encodes an ASN1 header.
  342. **              Parameters:
  343. **              Asn1: Pointer to ASN1 socket.
  344. **              Eoc: Pointer to end of encoding or NULL if
  345. **                   indefinite.
  346. **              Cls: Class (see asn1.h)
  347. **              Con: Primitive, Constructed (ASN_PRI, ASN_CON)
  348. **              Tag: Tag (see asn1.h)
  349. ** RETURNS:     BOOLEAN success.
  350. **************************************************************/
  351. BOOLEAN Asn1HdrEnc(ASN1_SCK *Asn1, BYTE *Eoc, unsigned Cls,
  352.         unsigned Con, unsigned Tag)
  353. {
  354.     unsigned
  355.         Def,
  356.         Len;
  358.     if (Eoc == 0)
  359.     {
  360.         Def = 0;
  361.         Len = 0;
  362.     }
  363.     else
  364.     {
  365.         Def = 1;
  366.         Len = Eoc - Asn1->Pointer;
  367.     }
  368.     if (!Asn1LenEnc (Asn1, Def, Len))
  369.         return FALSE;
  370.     if (!Asn1IdrEnc (Asn1, Cls, Con, Tag))
  371.         return FALSE;
  372.     return TRUE;
  373. }
  375. /**************************************************************
  376. ** NAME:        Asn1HdrDec                                [API]
  377. ** SYNOPSIS:    BOOLEAN Asn1HdrDec
  378. **                  (
  379. **                      ASN1_SCK    *Asn1,
  380. **                      BYTE        **Eoc,
  381. **                      unsigned    *Cls,
  382. **                      unsigned    *Con,
  383. **                      unsigned    *Tag
  384. **                  )
  385. ** DESCRIPTION: Decodes an ASN1 header.
  386. **              Parameters:
  387. **              Asn1: Pointer to ASN1 socket.
  388. **              Eoc: Pointer to end of encoding or 0 if
  389. **                   indefinite.
  390. **              Cls: Class (see asn1.h)
  391. **              Con: Primitive, Constructed (ASN_PRI, ASN_CON)
  392. **              Tag: Tag (see asn1.h)
  393. ** RETURNS:     BOOLEAN success.
  394. **************************************************************/
  395. BOOLEAN Asn1HdrDec(ASN1_SCK *Asn1, BYTE **Eoc, unsigned *Cls,
  396.         unsigned *Con, unsigned *Tag)
  397. {
  398.     unsigned
  399.         Def,
  400.         Len;
  402.     if (!Asn1IdrDec (Asn1, Cls, Con, Tag))
  403.         return FALSE;
  404.     if (!Asn1LenDec (Asn1, &Def, &Len))
  405.         return FALSE;
  406.     if (Def)
  407.         *Eoc = Asn1->Pointer + Len;
  408.     else
  409.         *Eoc = 0;
  410.     return TRUE;
  411. }
  414. /**************************************************************
  415. ** NAME:        Asn1Eoc                                   [API]
  416. ** SYNOPSIS:    BOOLEAN Asn1Eoc
  417. **                  (
  418. **                      ASN1_SCK    *Asn1,
  419. **                      BYTE        *Eoc
  420. **                  )
  421. ** DESCRIPTION: Checks if decoding is at End Of Contents.
  422. **              Parameters:
  423. **              Asn1: Pointer to ASN1 socket.
  424. **              Eoc: Pointer to end of encoding or 0 if
  425. **                   indefinite.
  426. ** RETURNS:     BOOLEAN success.
  427. **************************************************************/
  428. BOOLEAN Asn1Eoc
  429.     (
  430.         ASN1_SCK *Asn1,
  431.         BYTE     *Eoc
  432.     )
  433. {
  434.     if (Eoc == 0)
  435.         return (Asn1->Pointer [0] == 0x00 && Asn1->Pointer [1] == 0x00);
  436.     else
  437.         return (Asn1->Pointer >= Eoc);
  438. }
  440. /**************************************************************
  441. ** NAME:        Asn1EocEnc                                [API]
  442. ** SYNOPSIS:    BOOLEAN Asn1EocEnc
  443. **                  (
  444. **                      ASN1_SCK    *Asn1,
  445. **                      BYTE        **Eoc
  446. **                  )
  447. ** DESCRIPTION: Encodes End Of Contents.
  448. **              Parameters:
  449. **              Asn1: Pointer to ASN1 socket.
  450. **              Eoc: Pointer to end of encoding or 0 if
  451. **                   indefinite.
  452. **              If Eoc is 0 it encodes an ASN1 End Of
  453. **              Contents (0x00 0x00), so it produces an
  454. **              indefinite length encoding. If Eoc points to
  455. **              a character pointer, Eoc is filled with the
  456. **              pointer to the last encoded octet. This pointer
  457. **              can be used in the next Asn1HdrEnc to determine
  458. **              the length of the encoding. This produces a
  459. **              definite length encoding.
  460. ** RETURNS:     BOOLEAN success.
  461. **************************************************************/
  462. BOOLEAN Asn1EocEnc
  463.     (
  464.         ASN1_SCK *Asn1,
  465.         BYTE     **Eoc
  466.     )        
  467. {
  468.     if (Eoc == 0)
  469.     {
  470.         if (!Asn1OctEnc (Asn1, 0x00))
  471.             return FALSE;
  472.         if (!Asn1OctEnc (Asn1, 0x00))
  473.             return FALSE;
  474.         return TRUE;
  475.     }
  476.     else
  477.     {
  478.         *Eoc = Asn1->Pointer;
  479.         return TRUE;
  480.     }
  481. }
  483. /**************************************************************
  484. ** NAME:        Asn1EocDec                                [API]
  485. ** SYNOPSIS:    BOOLEAN Asn1EocDec
  486. **                  (
  487. **                      ASN1_SCK    *Asn1,
  488. **                      BYTE        *Eoc
  489. **                  )
  490. ** DESCRIPTION: Decodes End Of Contents.
  491. **              Parameters:
  492. **              Asn1: Pointer to ASN1 socket.
  493. **              Eoc: Pointer to end of encoding or 0 if
  494. **                   indefinite.
  495. **              If Eoc is 0 it decodes an ASN1 End Of
  496. **              Contents (0x00 0x00), so it has to be an
  497. **              indefinite length encoding. If Eoc is a
  498. **              character pointer, it probably was filled by
  499. **              Asn1HdrDec, and should point to the octet
  500. **              after the last of the encoding. It is checked
  501. **              if this pointer points to the octet to be
  502. **              decoded. This only takes place in decoding a
  503. **              definite length encoding.
  504. ** RETURNS:     BOOLEAN success.
  505. **************************************************************/
  506. BOOLEAN Asn1EocDec
  507.     (
  508.         ASN1_SCK *Asn1,
  509.         BYTE     *Eoc
  510.     )
  511. {
  512.     BYTE        Chr;
  514.     if (Eoc == 0)
  515.     {
  516.         if (!Asn1OctDec (Asn1, &Chr))
  517.             return FALSE;
  518.         if (Chr != 0x00)
  519.             return FALSE;
  520.         if (!Asn1OctDec (Asn1, &Chr))
  521.             return FALSE;
  522.         if (Chr != 0x00)
  523.             return FALSE;
  524.         return TRUE;
  525.     }
  526.     else
  527.     {
  528.         if (Asn1->Pointer != Eoc)
  529.             return FALSE;
  530.         return TRUE;
  531.     }
  532. }
  534. /**************************************************************
  535. ** NAME:        Asn1NulEnc                                [API]
  536. ** SYNOPSIS:    BOOLEAN Asn1NulEnc
  537. **                  (
  538. **                      ASN1_SCK    *Asn1,
  539. **                      BYTE        **Eoc
  540. **                  )
  541. ** DESCRIPTION: Encodes Null.
  542. **              Parameters:
  543. **              Asn1: Pointer to ASN1 socket.
  544. **              Eoc: Pointer to end of encoding.
  545. **              Encodes nothing but can be used to fill Eoc.
  546. ** RETURNS:     BOOLEAN success.
  547. **************************************************************/
  548. BOOLEAN Asn1NulEnc
  549.     (
  550.         ASN1_SCK *Asn1,
  551.         BYTE     **Eoc
  552.     )
  553. {
  554.     *Eoc = Asn1->Pointer;
  555.     return TRUE;
  556. }
  558. /**************************************************************
  559. ** NAME:        Asn1NulDec                                [API]
  560. ** SYNOPSIS:    BOOLEAN Asn1NulDec
  561. **                  (
  562. **                      ASN1_SCK    *Asn1,
  563. **                      BYTE        *Eoc
  564. **                  )
  565. ** DESCRIPTION: Decodes Null.
  566. **              Parameters:
  567. **              Asn1: Pointer to ASN1 socket.
  568. **              Eoc: Pointer to end of encoding or 0 if
  569. **                   indefinite.
  570. **              Decodes anything up to Eoc.
  571. ** RETURNS:     BOOLEAN success.
  572. **************************************************************/
  573. BOOLEAN Asn1NulDec
  574.     (
  575.         ASN1_SCK *Asn1,
  576.         BYTE    *Eoc
  577.     )
  578. {
  579.     Asn1->Pointer = Eoc;
  580.     return TRUE;
  581. }
  583. /**************************************************************
  584. ** NAME:        Asn1BolEnc                                [API]
  585. ** SYNOPSIS:    BOOLEAN Asn1BolEnc
  586. **                  (
  587. **                      ASN1_SCK    *Asn1,
  588. **                      BYTE        **Eoc,
  589. **                      BOOLEAN     Bol
  590. **                  )
  591. ** DESCRIPTION: Encodes Boolean.
  592. **              Parameters:
  593. **              Asn1: Pointer to ASN1 socket.
  594. **              Eoc: Pointer to end of encoding.
  595. **              Bol: FALSE, TRUE (0, !0).
  596. ** RETURNS:     BOOLEAN success.
  597. **************************************************************/
  598. BOOLEAN Asn1BolEnc
  599.     (
  600.         ASN1_SCK *Asn1,
  601.         BYTE    **Eoc,
  602.         BOOLEAN     Bol
  603.     )
  604. {
  605.     BYTE        Chr;
  607.     *Eoc = Asn1->Pointer;
  608.     Chr = (BYTE) (Bol ? 0xFF : 0x00);
  609.     if (!Asn1OctEnc (Asn1, Chr))
  610.         return FALSE;
  611.     return TRUE;
  612. }
  614. /**************************************************************
  615. ** NAME:        Asn1BolDec                                [API]
  616. ** SYNOPSIS:    BOOLEAN Asn1BolDec
  617. **                  (
  618. **                      ASN1_SCK    *Asn1,
  619. **                      BYTE        *Eoc
  620. **                      BOOLEAN     *Bol
  621. **                  )
  622. ** DESCRIPTION: Decodes Boolean.
  623. **              Parameters:
  624. **              Asn1: Pointer to ASN1 socket.
  625. **              Eoc: Pointer to end of encoding or 0 if
  626. **                   indefinite.
  627. **              Bol: False, True (0, !0).
  628. ** RETURNS:     BOOLEAN success.
  629. **************************************************************/
  630. BOOLEAN Asn1BolDec
  631.     (
  632.         ASN1_SCK *Asn1,
  633.         BYTE    *Eoc,
  634.         BOOLEAN     *Bol
  635.     )
  636. {
  637.     BYTE        Chr;
  639.     if (!Asn1OctDec (Asn1, &Chr))
  640.         return FALSE;
  641.     *Bol = Chr ? 1 : 0;
  642.     if (Asn1->Pointer != Eoc)
  643.         return FALSE;
  644.     return TRUE;
  645. }
  647. /**************************************************************
  648. ** NAME:        Asn1IntEnc                                [API]
  649. ** SYNOPSIS:    BOOLEAN Asn1IntEnc
  650. **                  (
  651. **                      ASN1_SCK    *Asn1,
  652. **                      BYTE        **Eoc,
  653. **                      int         Int
  654. **                  )
  655. ** DESCRIPTION: Encodes Integer.
  656. **              Parameters:
  657. **              Asn1: Pointer to ASN1 socket.
  658. **              Eoc: Pointer to end of encoding.
  659. **              Int: Integer.
  660. ** RETURNS:     BOOLEAN success.
  661. **************************************************************/
  662. BOOLEAN Asn1IntEnc
  663.     (
  664.         ASN1_SCK *Asn1,
  665.         BYTE    **Eoc,
  666.         int     Int
  667.     )
  668. {
  669.     BYTE        Chr,Sgn;
  670.     int
  671.         Lim;
  673.     *Eoc = Asn1->Pointer;
  674.     if (Int < 0)
  675.     {
  676.         Lim = -1;
  677.         Sgn = 0x80;
  678.     }
  679.     else
  680.     {
  681.         Lim = 0;
  682.         Sgn = 0x00;
  683.     }
  684.     do
  685.     {
  686.         Chr = (BYTE) Int;
  687.         Int >>= 8;
  688.         if (!Asn1OctEnc (Asn1, Chr))
  689.             return FALSE;
  690.     }
  691.     while ((Int != Lim) || (BYTE) (Chr & 0x80) != Sgn);
  692.     return TRUE;
  693. }
  695. /**************************************************************
  696. ** NAME:        Asn1IntDec                                [API]
  697. ** SYNOPSIS:    BOOLEAN Asn1IntDec
  698. **                  (
  699. **                      ASN1_SCK    *Asn1,
  700. **                      BYTE        *Eoc
  701. **                      int         *Int
  702. **                  )
  703. ** DESCRIPTION: Decodes Integer.
  704. **              Parameters:
  705. **              Asn1: Pointer to ASN1 socket.
  706. **              Eoc: Pointer to end of encoding or 0 if
  707. **                   indefinite.
  708. **              Int: Integer.
  709. ** RETURNS:     BOOLEAN success.
  710. **************************************************************/
  711. BOOLEAN Asn1IntDec
  712.     (
  713.         ASN1_SCK *Asn1,
  714.         BYTE     *Eoc,
  715.         int     *Int
  716.     )
  717. {
  718.     BYTE
  719.         Chr;
  720.     unsigned
  721.         Len;
  723.     if (!Asn1OctDec (Asn1, &Chr))
  724.         return FALSE;
  725.     *Int = (int) Chr;
  726.     Len = 1;
  727.     while (Asn1->Pointer < Eoc)
  728.     {
  729.         if (++Len > sizeof (int))
  730.             return FALSE;
  731.         if (!Asn1OctDec (Asn1, &Chr))
  732.             return FALSE;
  733.         *Int <<= 8;
  734.         *Int |= Chr;
  735.     }
  736.     return TRUE;
  737. }
  739. /**************************************************************
  740. ** NAME:        Asn1IntEncLng                             [API]
  741. ** SYNOPSIS:    BOOLEAN Asn1IntEncLng
  742. **                  (
  743. **                      ASN1_SCK    *Asn1,
  744. **                      BYTE        **Eoc,
  745. **                      long        Int
  746. **                  )
  747. ** DESCRIPTION: Encodes Long Integer.
  748. **              Parameters:
  749. **              Asn1: Pointer to ASN1 socket.
  750. **              Eoc: Pointer to end of encoding.
  751. **              Int: Integer.
  752. ** RETURNS:     BOOLEAN success.
  753. **************************************************************/
  754. BOOLEAN Asn1IntEncLng
  755.     (
  756.         ASN1_SCK *Asn1,
  757.         BYTE     **Eoc,
  758.         long    Int
  759.     )
  760. {
  761.     BYTE
  762.         Chr,
  763.         Sgn;
  764.     long
  765.         Lim;
  767.     *Eoc = Asn1->Pointer;
  768.     if (Int < 0)
  769.     {
  770.         Lim = -1;
  771.         Sgn = 0x80;
  772.     }
  773.     else
  774.     {
  775.         Lim = 0;
  776.         Sgn = 0x00;
  777.     }
  778.     do
  779.     {
  780.         Chr = (BYTE) Int;
  781.         Int >>= 8;
  782.         if (!Asn1OctEnc (Asn1, Chr))
  783.             return FALSE;
  784.     }
  785.     while ((Int != Lim) || (BYTE) (Chr & 0x80) != Sgn);
  786.     return TRUE;
  787. }
  789. /**************************************************************
  790. ** NAME:        Asn1IntDecLng                             [API]
  791. ** SYNOPSIS:    BOOLEAN Asn1IntDecLng
  792. **                  (
  793. **                      ASN1_SCK    *Asn1,
  794. **                      BYTE        *Eoc,
  795. **                      long        *Int
  796. **                  )
  797. ** DESCRIPTION: Decodes Long Integer.
  798. **              Parameters:
  799. **              Asn1: Pointer to ASN1 socket.
  800. **              Eoc: Pointer to end of encoding or 0 if
  801. **                   indefinite.
  802. **              Int: Integer.
  803. ** RETURNS:     BOOLEAN success.
  804. **************************************************************/
  805. BOOLEAN Asn1IntDecLng
  806.     (
  807.         ASN1_SCK *Asn1,
  808.         BYTE    *Eoc,
  809.         long    *Int
  810.     )
  811. {
  812.     BYTE
  813.         Chr;
  814.     unsigned
  815.         Len;
  817.     if (!Asn1OctDec (Asn1, &Chr))
  818.         return FALSE;
  819.     *Int = (signed char) Chr;
  820.     Len = 1;
  821.     while (Asn1->Pointer < Eoc)
  822.     {
  823.         if (++Len > sizeof (long))
  824.             return FALSE;
  825.         if (!Asn1OctDec (Asn1, &Chr))
  826.             return FALSE;
  827.         *Int <<= 8;
  828.         *Int |= Chr;
  829.     }
  830.     return TRUE;
  831. }
  833. /**************************************************************
  834. ** NAME:        Asn1IntEncUns                             [API]
  835. ** SYNOPSIS:    BOOLEAN Asn1IntEncUns
  836. **                  (
  837. **                      ASN1_SCK    *Asn1,
  838. **                      BYTE        **Eoc,
  839. **                      unsigned    Int
  840. **                  )
  841. ** DESCRIPTION: Encodes Unsigned Integer.
  842. **              Parameters:
  843. **              Asn1: Pointer to ASN1 socket.
  844. **              Eoc: Pointer to end of encoding.
  845. **              Int: Integer.
  846. ** RETURNS:     BOOLEAN success.
  847. **************************************************************/
  848. BOOLEAN Asn1IntEncUns
  849.     (
  850.         ASN1_SCK     *Asn1,
  851.         BYTE        **Eoc,
  852.         unsigned    Int
  853.     )
  854. {
  855.     BYTE
  856.         Chr;
  858.     *Eoc = Asn1->Pointer;
  859.     do
  860.     {
  861.         Chr = (BYTE) Int;
  862.         Int >>= 8;
  863.         if (!Asn1OctEnc (Asn1, Chr))
  864.             return FALSE;
  865.     }
  866.     while ((Int != 0) || (Chr & 0x80) != 0x00);
  867.     return TRUE;
  868. }
  870. /**************************************************************
  871. ** NAME:        Asn1IntDecUns                             [API]
  872. ** SYNOPSIS:    BOOLEAN An1IntDecUns
  873. **                  (
  874. **                      ASN1_SCK    *Asn1,
  875. **                      BYTE        *Eoc,
  876. **                      unsigned    *Int
  877. **                  )
  878. ** DESCRIPTION: Decodes Unsigned Integer.
  879. **              Parameters:
  880. **              Asn1: Pointer to ASN1 socket.
  881. **              Eoc: Pointer to end of encoding or 0 if
  882. **                   indefinite.
  883. **              Int: Integer.
  884. ** RETURNS:     BOOLEAN success.
  885. **************************************************************/
  886. BOOLEAN Asn1IntDecUns
  887.     (
  888.         ASN1_SCK     *Asn1,
  889.         BYTE        *Eoc,
  890.         unsigned    *Int
  891.     )
  892. {
  893.     BYTE
  894.         Chr;
  895.     unsigned
  896.         Len;
  898.     if (!Asn1OctDec (Asn1, &Chr))
  899.         return FALSE;
  900.     *Int = Chr;
  901.     if (Chr == 0)
  902.         Len = 0;
  903.     else
  904.         Len = 1;
  905.     while (Asn1->Pointer < Eoc)
  906.     {
  907.         if (++Len > sizeof (int))
  908.             return FALSE;
  909.         if (!Asn1OctDec (Asn1, &Chr))
  910.             return FALSE;
  911.         *Int <<= 8;
  912.         *Int |= Chr;
  913.     }
  914.     return TRUE;
  915. }
  917. /**************************************************************
  918. ** NAME:        Asn1IntEncLngUns                          [API]
  919. ** SYNOPSIS:    BOOLEAN Asn1IntEncLngUns
  920. **                  (
  921. **                      ASN1_SCK        *Asn1,
  922. **                      BYTE            **Eoc,
  923. **                      long unsigned   Int
  924. **                  )
  925. ** DESCRIPTION: Encodes Long Unsigned Integer.
  926. **              Parameters:
  927. **              Asn1: Pointer to ASN1 socket.
  928. **              Eoc: Pointer to end of encoding.
  929. **              Int: Integer.
  930. ** RETURNS:     BOOLEAN success.
  931. **************************************************************/
  932. BOOLEAN Asn1IntEncLngUns
  933.     (
  934.         ASN1_SCK         *Asn1,
  935.         BYTE            **Eoc,
  936.         unsigned long   Int
  937.     )
  938. {
  939.     BYTE
  940.         Chr;
  942.     *Eoc = Asn1->Pointer;
  943.     do
  944.     {
  945.         Chr = (BYTE) Int;
  946.         Int >>= 8;
  947.         if (!Asn1OctEnc (Asn1, Chr))
  948.             return FALSE;
  949.     }
  950.     while ((Int != 0) || (Chr & 0x80) != 0x00);
  951.     return TRUE;
  952. }
  954. /**************************************************************
  955. ** NAME:        Asn1IntDecLngUns                          [API]
  956. ** SYNOPSIS:    BOOLEAN Asn1IntDecLngUns
  957. **                  (
  958. **                      ASN1_SCK        *Asn1,
  959. **                      BYTE            *Eoc,
  960. **                      long unsigned   *Int
  961. **                  )
  962. ** DESCRIPTION: Decodes Long Unsigned Integer.
  963. **              Parameters:
  964. **              Asn1: Pointer to ASN1 socket.
  965. **              Eoc: Pointer to end of encoding or 0 if
  966. **                   indefinite.
  967. **              Int: Integer.
  968. ** RETURNS:     BOOLEAN success.
  969. **************************************************************/
  970. BOOLEAN Asn1IntDecLngUns
  971.     (
  972.         ASN1_SCK         *Asn1,
  973.         BYTE            *Eoc,
  974.         unsigned long   *Int
  975.     )
  976. {
  977.     BYTE
  978.         Chr;
  979.     unsigned
  980.         Len;
  982.     if (!Asn1OctDec (Asn1, &Chr))
  983.         return FALSE;
  984.     *Int = Chr;
  985.     if (Chr == 0)
  986.         Len = 0;
  987.     else
  988.         Len = 1;
  989.     while (Asn1->Pointer < Eoc)
  990.     {
  991.         if (++Len > sizeof (long))
  992.             return FALSE;
  993.         if (!Asn1OctDec (Asn1, &Chr))
  994.             return FALSE;
  995.         *Int <<= 8;
  996.         *Int |= Chr;
  997.     }
  998.     return TRUE;
  999. }
  1001. /**************************************************************
  1002. ** NAME:        Asn1BtsEnc                                [API]
  1003. ** SYNOPSIS:    BOOLEAN Asn1BtsEnc
  1004. **                  (
  1005. **                      ASN1_SCK    *Asn1,
  1006. **                      BYTE        **Eoc,
  1007. **                      BYTE        *Bts,
  1008. **                      unsigned    BtsLen,
  1009. **                      BYTE        BtsUnu
  1010. **                  )
  1011. ** DESCRIPTION: Encodes Bit String.
  1012. **              Parameters:
  1013. **              Asn1: Pointer to ASN1 socket.
  1014. **              Eoc: Pointer to end of encoding.
  1015. **              Bts: Pointer to begin of Bit String.
  1016. **              BtsLen: Length of Bit String in characters.
  1017. **              BtsUnu: Number of unused bits in last character.
  1018. ** RETURNS:     BOOLEAN success.
  1019. **************************************************************/
  1020. BOOLEAN Asn1BtsEnc
  1021.     (
  1022.         ASN1_SCK      *Asn1,
  1023.         BYTE         **Eoc,
  1024.         BYTE         *Bts,
  1025.         unsigned     BtsLen,
  1026.         BYTE   BtsUnu
  1027.     )
  1028. {
  1029.     *Eoc = Asn1->Pointer;
  1030.     Bts += BtsLen;
  1031.     while (BtsLen-- > 0)
  1032.     {
  1033.         if (!Asn1OctEnc (Asn1, *--Bts))
  1034.             return FALSE;
  1035.     }
  1036.     if (!Asn1OctEnc (Asn1, BtsUnu))
  1037.         return FALSE;
  1038.     return TRUE;
  1039. }
  1041. /**************************************************************
  1042. ** NAME:        Asn1BtsDec                                [API]
  1043. ** SYNOPSIS:    BOOLEAN Asn1BtsDec
  1044. **                  (
  1045. **                      ASN1_SCK      *Asn1,
  1046. **                      BYTE         *Eoc,
  1047. **                      BYTE         *Bts,
  1048. **                      unsigned     BtsSze,
  1049. **                      unsigned     *BtsLen,
  1050. **                      BYTE   *BtsUnu
  1051. **                  )
  1052. ** DESCRIPTION: Decodes Bit String.
  1053. **              Parameters:
  1054. **              Asn1: Pointer to ASN1 socket.
  1055. **              Eoc: Pointer to end of encoding or 0 if
  1056. **                   indefinite.
  1057. **              Bts: Pointer to begin of Bit String.
  1058. **              BtsSze: Size of Bit String in characters.
  1059. **              BtsLen: Length of Bit String in characters.
  1060. **              BtsUnu: Number of unused bits in last character.
  1061. ** RETURNS:     BOOLEAN success.
  1062. **************************************************************/
  1063. BOOLEAN Asn1BtsDec
  1064.     (
  1065.         ASN1_SCK      *Asn1,
  1066.         BYTE         *Eoc,
  1067.         BYTE     *Bts,
  1068.         unsigned     BtsSze,
  1069.         unsigned     *BtsLen,
  1070.         BYTE   *BtsUnu
  1071.     )
  1072. {
  1073.     if (!Asn1OctDec (Asn1, BtsUnu))
  1074.         return FALSE;
  1075.     *BtsLen = 0;
  1076.     while (Asn1->Pointer < Eoc)
  1077.     {
  1078.         if (++(*BtsLen) > BtsSze)
  1079.             return FALSE;
  1080.         if (!Asn1OctDec (Asn1, (BYTE *)Bts++))
  1081.             return FALSE;
  1082.     }
  1083.     return TRUE;
  1084. }
  1086. /**************************************************************
  1087. ** NAME:        Asn1OtsEnc                                [API]
  1088. ** SYNOPSIS:    BOOLEAN Asn1OtsEnc
  1089. **                  (
  1090. **                      ASN1_SCK    *Asn1,
  1091. **                      BYTE        **Eoc,
  1092. **                      BYTE        *Ots,
  1093. **                      unsigned    OtsLen
  1094. **                  )
  1095. ** DESCRIPTION: Encodes Octet String.
  1096. **              Parameters:
  1097. **              Asn1: Pointer to ASN1 socket.
  1098. **              Eoc: Pointer to end of encoding.
  1099. **              Ots: Pointer to begin of Octet String.
  1100. **              OtsLen: Length of Octet String in characters.
  1101. ** RETURNS:     BOOLEAN success.
  1102. **************************************************************/
  1103. BOOLEAN Asn1OtsEnc
  1104.     (
  1105.         ASN1_SCK     *Asn1,
  1106.         BYTE        **Eoc,
  1107.         BYTE        *Ots,
  1108.         unsigned    OtsLen
  1109.     )
  1110. {
  1111.     *Eoc = Asn1->Pointer;
  1112.     Ots += OtsLen;
  1113.     while (OtsLen-- > 0)
  1114.     {
  1115.         if (!Asn1OctEnc (Asn1, *--Ots))
  1116.             return FALSE;
  1117.     }
  1118.     return TRUE;
  1119. }
  1121. /**************************************************************
  1122. ** NAME:        Asn1OtsDec                                [API]
  1123. ** SYNOPSIS:    BOOLEAN Asn1OtsDec
  1124. **                  (
  1125. **                      ASN1_SCK    *Asn1,
  1126. **                      BYTE        *Eoc,
  1127. **                      BYTE        *Ots,
  1128. **                      unsigned    OtsSze,
  1129. **                      unsigned    *OtsLen
  1130. **                  )
  1131. ** DESCRIPTION: Decodes Octet String.
  1132. **              Parameters:
  1133. **              Asn1: Pointer to ASN1 socket.
  1134. **              Eoc: Pointer to end of encoding or 0 if
  1135. **                   indefinite.
  1136. **              Ots: Pointer to begin of Octet String.
  1137. **              OtsSze: Size of Octet String in characters.
  1138. **              OtsLen: Length of Octet String in characters.
  1139. ** RETURNS:     BOOLEAN success.
  1140. **************************************************************/
  1141. BOOLEAN Asn1OtsDec
  1142.     (
  1143.         ASN1_SCK     *Asn1,
  1144.         BYTE        *Eoc,
  1145.         BYTE        *Ots,
  1146.         unsigned    OtsSze,
  1147.         unsigned    *OtsLen
  1148.     )
  1149. {
  1150.     *OtsLen = 0;
  1151.     while (Asn1->Pointer < Eoc)
  1152.     {
  1153.         if (++(*OtsLen) > OtsSze)
  1154.             return FALSE;
  1155.         if (!Asn1OctDec (Asn1, (BYTE *)Ots++))
  1156.             return FALSE;
  1157.     }
  1158.     return TRUE;
  1159. }
  1161. /**************************************************************
  1162. ** NAME:        Asn1SbiEnc
  1163. ** SYNOPSIS:    BOOLEAN Asn1SbiEnc
  1164. **                  (
  1165. **                      ASN1_SCK        *Asn1,
  1166. **                      unsigned long   Sbi
  1167. **                  )
  1168. ** DESCRIPTION: Encodes Sub Identifier.
  1169. **              Parameters:
  1170. **              Asn1: Pointer to ASN1 socket.
  1171. **              Sbi: Sub Identifier.
  1172. ** RETURNS:     BOOLEAN success.
  1173. **************************************************************/
  1174. BOOLEAN Asn1SbiEnc
  1175.     (
  1176.         ASN1_SCK      *Asn1,
  1177.         unsigned long Sbi
  1178.     )
  1179. {
  1180.     BYTE
  1181.         Chr;
  1183.     Chr = (BYTE) (Sbi & 0x7F);
  1184.     Sbi >>= 7;
  1185.     if (!Asn1OctEnc (Asn1, Chr))
  1186.         return FALSE;
  1187.     while (Sbi > 0)
  1188.     {
  1189.         Chr = (BYTE) (Sbi | 0x80);
  1190.         Sbi >>= 7;
  1191.         if (!Asn1OctEnc (Asn1, Chr))
  1192.             return FALSE;
  1193.     }
  1194.     return TRUE;
  1195. }
  1197. /**************************************************************
  1198. ** NAME:        Asn1SbiDec
  1199. ** SYNOPSIS:    BOOLEAN Asn1SbiDec
  1200. **                  (
  1201. **                      ASN1_SCK        *Asn1,
  1202. **                      unsigned long   *Sbi
  1203. **                  )
  1204. ** DESCRIPTION: Encodes Sub Identifier.
  1205. **              Parameters:
  1206. **              Asn1: Pointer to ASN1 socket.
  1207. **              Sbi: Sub Identifier.
  1208. ** RETURNS:     BOOLEAN success.
  1209. **************************************************************/
  1210. BOOLEAN Asn1SbiDec
  1211.     (
  1212.         ASN1_SCK      *Asn1,
  1213.         unsigned long *Sbi
  1214.     )
  1215. {
  1216.     BYTE
  1217.         Chr;
  1219.     *Sbi = 0;
  1220.     do
  1221.     {
  1222.         if (!Asn1OctDec (Asn1, &Chr))
  1223.             return FALSE;
  1224.         *Sbi <<= 7;
  1225.         *Sbi |= Chr & 0x7F;
  1226.     }
  1227.     while ((Chr & 0x80) == 0x80);
  1228.     return TRUE;
  1229. }
  1231. /**************************************************************
  1232. ** NAME:        Asn1OjiEnc                                [API]
  1233. ** SYNOPSIS:    BOOLEAN Asn1OjiEnc
  1234. **                  (
  1235. **                      ASN1_SCK        *Asn1,
  1236. **                      char            **Eoc,
  1237. **                      unsigned long   *Oji,
  1238. **                      unsigned        OjiLen
  1239. **                  )
  1240. ** DESCRIPTION: Encodes Obect Identifier.
  1241. **              Parameters:
  1242. **              Asn1: Pointer to ASN1 socket.
  1243. **              Eoc: Pointer to end of encoding.
  1244. **              Oji: Pointer to begin of Object Identifier.
  1245. **              OjiLen: Length of Object Identifier in unsigneds.
  1246. ** RETURNS:     BOOLEAN success.
  1247. **************************************************************/
  1248. BOOLEAN Asn1OjiEnc
  1249.     (
  1250.         ASN1_SCK        *Asn1,
  1251.         BYTE            **Eoc,
  1252.         unsigned long   *Oji,
  1253.         unsigned        OjiLen
  1254.     )
  1255. {
  1256.     unsigned long
  1257.         Sbi;
  1259.     *Eoc = Asn1->Pointer;
  1260.     if (OjiLen < 2)
  1261.         return FALSE;
  1262.     Sbi = Oji [1] + Oji [0] * 40;
  1263.     Oji += OjiLen;
  1264.     while (OjiLen-- > 2)
  1265.     {
  1266.         if (!Asn1SbiEnc (Asn1, *--Oji))
  1267.             return FALSE;
  1268.     }
  1269.     if (!Asn1SbiEnc (Asn1, Sbi))
  1270.         return FALSE;
  1271.     return TRUE;
  1272. }
  1274. /**************************************************************
  1275. ** NAME:        Asn1OjiDec                                [API]
  1276. ** SYNOPSIS:    BOOLEAN Asn1OjiDec
  1277. **                  (
  1278. **                      ASN1_SCK        *Asn1,
  1279. **                      char            *Eoc,
  1280. **                      unsigned long   *Oji,
  1281. **                      unsigned        OjiSze,
  1282. **                      unsigned        *OjiLen
  1283. **                  )
  1284. ** DESCRIPTION: Decodes Obect Identifier.
  1285. **              Parameters:
  1286. **              Asn1: Pointer to ASN1 socket.
  1287. **              Eoc: Pointer to end of encoding or 0 if
  1288. **                   indefinite.
  1289. **              Oji: Pointer to begin of Object Identifier.
  1290. **              OjiSze: Size of Obect Identifier in unsigneds
  1291. **              OjiLen: Length of Object Identifier in unsigneds.
  1292. ** RETURNS:     BOOLEAN success.
  1293. **************************************************************/
  1294. BOOLEAN Asn1OjiDec
  1295.     (
  1296.         ASN1_SCK      *Asn1,
  1297.         BYTE          *Eoc,
  1298.         unsigned long *Oji,
  1299.         unsigned      OjiSze,
  1300.         unsigned      *OjiLen
  1301.     )
  1302. {
  1303.     unsigned long
  1304.         Sbi;
  1306.     if (OjiSze < 2)
  1307.         return FALSE;
  1308.     if (!Asn1SbiDec (Asn1, &Sbi))
  1309.         return FALSE;
  1310.     if (Sbi < 40)
  1311.     {
  1312.         Oji [0] = 0;
  1313.         Oji [1] = Sbi;
  1314.     }
  1315.     else if (Sbi < 80)
  1316.     {
  1317.         Oji [0] = 1;
  1318.         Oji [1] = Sbi - 40;
  1319.     }
  1320.     else
  1321.     {
  1322.         Oji [0] = 2;
  1323.         Oji [1] = Sbi - 80;
  1324.     }
  1325.     *OjiLen = 2;
  1326.     Oji += 2;
  1327.     while (Asn1->Pointer < Eoc)
  1328.     {
  1329.         if (++(*OjiLen) > OjiSze)
  1330.             return FALSE;
  1331.         if (!Asn1SbiDec (Asn1, Oji++))
  1332.             return FALSE;
  1333.     }
  1334.     return TRUE;
  1335. }