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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
asner.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：96k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

asner.cxx：源码内容
  1. /*
  2.  * asner.cxx
  3.  *
  4.  * Abstract Syntax Notation 1 Encoding Rules
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: asner.cxx,v $
  30.  * Revision 1.30  2000/02/29 06:32:12  robertj
  31.  * Added ability to remove optional field in sequence, thanks Dave Harvey.
  32.  *
  33.  * Revision 1.29  2000/01/20 06:22:22  robertj
  34.  * Fixed boundary condition error for constrained integer encoding (values 1, 256 etc)
  35.  *
  36.  * Revision 1.28  1999/11/22 23:15:43  robertj
  37.  * Fixed bug in PASN_Choice::Compare(), should make sure choices are the same before comparing.
  38.  *
  39.  * Revision 1.27  1999/08/19 15:43:07  robertj
  40.  * Fixed incorrect size of OID if zero length encoded.
  41.  *
  42.  * Revision 1.26  1999/08/09 13:02:45  robertj
  43.  * dded ASN compiler #defines for backward support of pre GCC 2.9 compilers.
  44.  * Added ASN compiler #defines to reduce its memory footprint.
  45.  *
  46.  * Revision 1.25  1999/08/08 15:45:59  robertj
  47.  * Fixed incorrect encoding of unknown extensions.
  48.  *
  49.  * Revision 1.24  1999/08/05 00:44:28  robertj
  50.  * Fixed PER encoding problems for large integer values.
  51.  *
  52.  * Revision 1.23  1999/07/22 06:48:54  robertj
  53.  * Added comparison operation to base ASN classes and compiled ASN code.
  54.  * Added support for ANY type in ASN parser.
  55.  *
  56.  * Revision 1.22  1999/07/08 08:39:12  robertj
  57.  * Fixed bug when assigning negative number ot cosntrained PASN_Integer
  58.  *
  59.  * Revision 1.21  1999/06/30 08:58:12  robertj
  60.  * Fixed bug in encoding/decoding OID greater than 2.39
  61.  *
  62.  * Revision 1.20  1999/06/17 13:27:09  robertj
  63.  * Fixed bug causing crashes on pass through of unknown extensions.
  64.  *
  65.  * Revision 1.19  1999/06/07 00:31:25  robertj
  66.  * Fixed signed/unsigned problem with number of unknown extensions check.
  67.  *
  68.  * Revision 1.18  1999/04/26 05:58:48  craigs
  69.  * Fixed problems with encoding of extensions
  70.  *
  71.  * Revision 1.17  1999/03/09 08:12:38  robertj
  72.  * Fixed problem with closing a steam encoding twice.
  73.  *
  74.  * Revision 1.16  1999/01/16 01:28:25  robertj
  75.  * Fixed problems with reading stream multiple times.
  76.  *
  77.  * Revision 1.15  1998/11/30 04:50:44  robertj
  78.  * New directory structure
  79.  *
  80.  * Revision 1.14  1998/10/22 04:33:11  robertj
  81.  * Fixed bug in constrained strings and PER, incorrect order of character set.
  82.  *
  83.  * Revision 1.13  1998/09/23 06:21:49  robertj
  84.  * Added open source copyright license.
  85.  *
  86.  * Revision 1.12  1998/05/26 05:29:23  robertj
  87.  * Workaroung for g++ iostream bug.
  88.  *
  89.  * Revision 1.11  1998/05/21 04:58:54  robertj
  90.  * GCC comptaibility.
  91.  *
  92.  * Revision 1.10  1998/05/21 04:26:54  robertj
  93.  * Fixed numerous PER problems.
  94.  *
  95.  * Revision 1.9  1998/05/11 06:01:55  robertj
  96.  * Why did this compile under MSC?
  97.  *
  98.  * Revision 1.8  1998/05/07 05:19:29  robertj
  99.  * Fixed problems with using copy constructor/assignment oeprator on PASN_Objects.
  100.  *
  101.  * Revision 1.7  1998/03/05 12:49:50  robertj
  102.  * MemCheck fixes.
  103.  *
  104.  * Revision 1.6  1998/02/03 06:28:27  robertj
  105.  * Fixed length calculation of integers in BER.
  106.  * Added new function to read a block with minimum number of bytes.
  107.  *
  108.  * Revision 1.5  1998/01/26 01:51:20  robertj
  109.  * Removed uninitialised variable warnings.
  110.  *
  111.  * Revision 1.4  1997/12/18 05:07:56  robertj
  112.  * Fixed bug in choice name display.
  113.  * Added function to get choice discriminator name.
  114.  * Fixed bug in encoding extensions.
  115.  *
  116.  * Revision 1.3  1997/12/11 10:36:22  robertj
  117.  * Support for new ASN parser.
  118.  *
  119.  */
  121. #include <ptlib.h>
  123. #ifdef __GNUC__
  124. #pragma implementation "asner.h"
  125. #endif
  127. #include <ptclib/asner.h>
  129. #define new PNEW
  132. static PINDEX CountBits(unsigned range)
  133. {
  134.   if (range == 0)
  135.     return sizeof(unsigned)*8;
  137.   PINDEX nBits = 0;
  138.   while (nBits < (sizeof(unsigned)*8) && range > (unsigned)(1 << nBits))
  139.     nBits++;
  140.   return nBits;
  141. }
  144. ///////////////////////////////////////////////////////////////////////
  146. PASN_Object::PASN_Object(unsigned theTag, TagClass theTagClass, BOOL extend)
  147. {
  148.   extendable = extend;
  150.   tag = theTag;
  152.   if (theTagClass != DefaultTagClass)
  153.     tagClass = theTagClass;
  154.   else
  155.     tagClass = ContextSpecificTagClass;
  156. }
  159. void PASN_Object::SetTag(unsigned newTag, TagClass tagClass_)
  160. {
  161.   tag = newTag;
  162.   if (tagClass_ != DefaultTagClass)
  163.     tagClass = tagClass_;
  164. }
  167. PINDEX PASN_Object::GetObjectLength() const
  168. {
  169.   PINDEX len = 1;
  171.   if (tag >= 31)
  172.     len += (CountBits(tag)+6)/7;
  174.   PINDEX dataLen = GetDataLength();
  175.   if (dataLen < 128)
  176.     len++;
  177.   else
  178.     len += (CountBits(dataLen)+7)/8 + 1;
  180.   return len + dataLen;
  181. }
  184. void PASN_Object::SetConstraints(ConstraintType, MinimumValueTag lower, unsigned upper)
  185. {
  186.   SetConstraints(PartiallyConstrained, (int)lower, upper);
  187. }
  190. void PASN_Object::SetConstraints(ConstraintType, int lower, MaximumValueTag upper)
  191. {
  192.   SetConstraints(PartiallyConstrained, lower, (unsigned)upper);
  193. }
  196. void PASN_Object::SetConstraints(ConstraintType, MinimumValueTag lower, MaximumValueTag upper)
  197. {
  198.   SetConstraints(PartiallyConstrained, (int)lower, (unsigned)upper);
  199. }
  202. void PASN_Object::SetConstraints(ConstraintType, int, unsigned)
  203. {
  204. }
  207. void PASN_Object::SetCharacterSet(ConstraintType, const char *)
  208. {
  209. }
  212. void PASN_Object::SetCharacterSet(ConstraintType, unsigned, unsigned)
  213. {
  214. }
  217. ///////////////////////////////////////////////////////////////////////
  219. PASN_ConstrainedObject::PASN_ConstrainedObject(unsigned tag, TagClass tagClass)
  220.   : PASN_Object(tag, tagClass)
  221. {
  222.   constraint = Unconstrained;
  223.   lowerLimit = 0;
  224.   upperLimit =  UINT_MAX;
  225. }
  228. void PASN_ConstrainedObject::SetConstraints(ConstraintType ctype,
  229.                                             int lower, unsigned upper)
  230. {
  231.   constraint = ctype;
  232.   if (constraint == Unconstrained) {
  233.     lower = 0;
  234.     upper = UINT_MAX;
  235.   }
  237.   extendable = ctype == ExtendableConstraint;
  238.   PAssert((lower >= 0 || upper < 0x7fffffff) &&
  239.           (lower < 0 || (unsigned)lower <= upper), PInvalidParameter);
  240.   lowerLimit = lower;
  241.   upperLimit = upper;
  242. }
  245. int PASN_ConstrainedObject::ConstrainedLengthDecode(PPER_Stream & strm, unsigned & length)
  246. {
  247.   // The execution order is important in the following. The SingleBitDecode() function
  248.   // must be called if extendable is TRUE, no matter what.
  249.   if ((extendable && strm.SingleBitDecode()) || constraint == Unconstrained)
  250.     return strm.LengthDecode(0, INT_MAX, length);
  251.   else
  252.     return strm.LengthDecode(lowerLimit, upperLimit, length);
  253. }
  256. void PASN_ConstrainedObject::ConstrainedLengthEncode(PPER_Stream & strm, unsigned length) const
  257. {
  258.   if (ConstraintEncode(strm, length)) // 26.4
  259.     strm.LengthEncode(length, 0, INT_MAX);
  260.   else
  261.     strm.LengthEncode(length, lowerLimit, upperLimit);
  262. }
  265. BOOL PASN_ConstrainedObject::ConstraintEncode(PPER_Stream & strm, unsigned value) const
  266. {
  267.   if (!extendable)
  268.     return constraint != FixedConstraint;
  270.   BOOL needsExtending = value > upperLimit;
  272.   if (!needsExtending) {
  273.     if (lowerLimit < 0) {
  274.       if ((int)value < lowerLimit)
  275.         needsExtending = TRUE;
  276.     }
  277.     else {
  278.       if (value < (unsigned)lowerLimit)
  279.         needsExtending = TRUE;
  280.     }
  281.   }
  283.   strm.SingleBitEncode(needsExtending);
  285.   return needsExtending || constraint != FixedConstraint;
  286. }
  289. ///////////////////////////////////////////////////////////////////////
  291. PASN_Null::PASN_Null(unsigned tag, TagClass tagClass)
  292.   : PASN_Object(tag, tagClass)
  293. {
  294. }
  297. PObject::Comparison PASN_Null::Compare(const PObject & obj) const
  298. {
  299.   PAssert(obj.IsDescendant(PASN_Null::Class()), PInvalidCast);
  300.   return EqualTo;
  301. }
  304. PObject * PASN_Null::Clone() const
  305. {
  306.   PAssert(IsClass(PASN_Null::Class()), PInvalidCast);
  307.   return new PASN_Null(*this);
  308. }
  311. void PASN_Null::PrintOn(ostream & strm) const
  312. {
  313.   strm << "<<null>>";
  314. }
  317. PString PASN_Null::GetTypeAsString() const
  318. {
  319.   return "Null";
  320. }
  323. PINDEX PASN_Null::GetDataLength() const
  324. {
  325.   return 0;
  326. }
  329. BOOL PASN_Null::Decode(PASN_Stream & strm)
  330. {
  331.   return strm.NullDecode(*this);
  332. }
  335. void PASN_Null::Encode(PASN_Stream & strm) const
  336. {
  337.   strm.NullEncode(*this);
  338. }
  341. BOOL PBER_Stream::NullDecode(PASN_Null & value)
  342. {
  343.   unsigned len;
  344.   if (!HeaderDecode(value, len))
  345.     return FALSE;
  347.   byteOffset += len;
  348.   return TRUE;
  349. }
  352. void PBER_Stream::NullEncode(const PASN_Null & value)
  353. {
  354.   HeaderEncode(value);
  355. }
  358. BOOL PPER_Stream::NullDecode(PASN_Null &)
  359. {
  360.   return TRUE;
  361. }
  364. void PPER_Stream::NullEncode(const PASN_Null &)
  365. {
  366. }
  369. ///////////////////////////////////////////////////////////////////////
  371. PASN_Boolean::PASN_Boolean(BOOL val, unsigned tag, TagClass tagClass)
  372.   : PASN_Object(tag, tagClass)
  373. {
  374.   value = val;
  375. }
  378. PObject::Comparison PASN_Boolean::Compare(const PObject & obj) const
  379. {
  380.   PAssert(obj.IsDescendant(PASN_Boolean::Class()), PInvalidCast);
  381.   return value == ((const PASN_Boolean &)obj).value ? EqualTo : GreaterThan;
  382. }
  385. PObject * PASN_Boolean::Clone() const
  386. {
  387.   PAssert(IsClass(PASN_Boolean::Class()), PInvalidCast);
  388.   return new PASN_Boolean(*this);
  389. }
  392. void PASN_Boolean::PrintOn(ostream & strm) const
  393. {
  394.   if (value)
  395.     strm << "TRUE";
  396.   else
  397.     strm << "FALSE";
  398. }
  401. PString PASN_Boolean::GetTypeAsString() const
  402. {
  403.   return "Boolean";
  404. }
  407. PINDEX PASN_Boolean::GetDataLength() const
  408. {
  409.   return 1;
  410. }
  413. BOOL PASN_Boolean::Decode(PASN_Stream & strm)
  414. {
  415.   return strm.BooleanDecode(*this);
  416. }
  419. void PASN_Boolean::Encode(PASN_Stream & strm) const
  420. {
  421.   strm.BooleanEncode(*this);
  422. }
  425. BOOL PBER_Stream::BooleanDecode(PASN_Boolean & value)
  426. {
  427.   unsigned len;
  428.   if (!HeaderDecode(value, len))
  429.     return FALSE;
  431.   while (len-- > 0) {
  432.     if (IsAtEnd())
  433.       return FALSE;
  434.     value = (BOOL)ByteDecode();
  435.   }
  437.   return TRUE;
  438. }
  441. void PBER_Stream::BooleanEncode(const PASN_Boolean & value)
  442. {
  443.   HeaderEncode(value);
  444.   ByteEncode((BOOL)value);
  445. }
  448. BOOL PPER_Stream::BooleanDecode(PASN_Boolean & value)
  449. {
  450.   if (IsAtEnd())
  451.     return FALSE;
  453.   // X.931 Section 11
  454.   value = (BOOL)SingleBitDecode();
  455.   return TRUE;
  456. }
  459. void PPER_Stream::BooleanEncode(const PASN_Boolean & value)
  460. {
  461.   // X.931 Section 11
  462.   SingleBitEncode((BOOL)value);
  463. }
  466. ///////////////////////////////////////////////////////////////////////
  468. PASN_Integer::PASN_Integer(unsigned tag, TagClass tagClass, unsigned val)
  469.   : PASN_ConstrainedObject(tag, tagClass)
  470. {
  471.   value = val;
  472. }
  475. PASN_Integer & PASN_Integer::operator=(unsigned val)
  476. {
  477.   if (constraint == Unconstrained)
  478.     value = val;
  479.   else if (lowerLimit >= 0) { // Is unsigned integer
  480.     if (val < (unsigned)lowerLimit)
  481.       value = lowerLimit;
  482.     else if (val > upperLimit)
  483.       value = upperLimit;
  484.     else
  485.       value = val;
  486.   }
  487.   else {
  488.     int ival = (int)val;
  489.     if (ival < lowerLimit)
  490.       value = lowerLimit;
  491.     else if (upperLimit < INT_MAX && ival > (int)upperLimit)
  492.       value = upperLimit;
  493.     else
  494.       value = val;
  495.   }
  497.   return *this;
  498. }
  501. PObject::Comparison PASN_Integer::Compare(const PObject & obj) const
  502. {
  503.   PAssert(obj.IsDescendant(PASN_Integer::Class()), PInvalidCast);
  504.   const PASN_Integer & other = (const PASN_Integer &)obj;
  506.   if (value < other.value)
  507.     return LessThan;
  509.   if (value > other.value)
  510.     return GreaterThan;
  512.   return EqualTo;
  513. }
  516. PObject * PASN_Integer::Clone() const
  517. {
  518.   PAssert(IsClass(PASN_Integer::Class()), PInvalidCast);
  519.   return new PASN_Integer(*this);
  520. }
  523. void PASN_Integer::PrintOn(ostream & strm) const
  524. {
  525.   if (lowerLimit < 0)
  526.     strm << (int)value;
  527.   else
  528.     strm << value;
  529. }
  532. PString PASN_Integer::GetTypeAsString() const
  533. {
  534.   return "Integer";
  535. }
  538. static PINDEX GetIntegerDataLength(int value)
  539. {
  540.   // create a mask which is the top nine bits of a DWORD, or 0xFF800000
  541.   // on a big endian machine
  542.   int shift = (sizeof(value)-1)*8-1;
  544.   // remove all sequences of nine 0's or 1's at the start of the value
  545.   while (shift > 0 && ((value >> shift)&0x1ff) == (value < 0 ? 0x1ff : 0))
  546.     shift -= 8;
  548.   return (shift+9)/8;
  549. }
  552. PINDEX PASN_Integer::GetDataLength() const
  553. {
  554.   return GetIntegerDataLength(value);
  555. }
  558. BOOL PASN_Integer::Decode(PASN_Stream & strm)
  559. {
  560.   return strm.IntegerDecode(*this);
  561. }
  564. void PASN_Integer::Encode(PASN_Stream & strm) const
  565. {
  566.   strm.IntegerEncode(*this);
  567. }
  570. BOOL PBER_Stream::IntegerDecode(PASN_Integer & value)
  571. {
  572.   unsigned len;
  573.   if (!HeaderDecode(value, len) || len == 0 || IsAtEnd())
  574.     return FALSE;
  576.   int accumulator = (char)ByteDecode(); // sign extended first byte
  577.   while (--len > 0) {
  578.     if (IsAtEnd())
  579.       return FALSE;
  580.     accumulator = (accumulator << 8) | ByteDecode();
  581.   }
  583.   value = accumulator;
  584.   return TRUE;
  585. }
  588. void PBER_Stream::IntegerEncode(const PASN_Integer & value)
  589. {
  590.   HeaderEncode(value);
  591.   // output the integer bits
  592.   for (int count = GetIntegerDataLength(value)-1; count >= 0; count--)
  593.     ByteEncode(value >> (count*8));
  594. }
  597. BOOL PPER_Stream::IntegerDecode(PASN_Integer & value)
  598. {
  599.   return value.DecodePER(*this);
  600. }
  603. void PPER_Stream::IntegerEncode(const PASN_Integer & value)
  604. {
  605.   value.EncodePER(*this);
  606. }
  609. BOOL PASN_Integer::DecodePER(PPER_Stream & strm)
  610. {
  611.   // X.931 Sections 12
  613.   if ((extendable && strm.SingleBitDecode()) || constraint != FixedConstraint) { //  12.1
  614.     unsigned len;
  615.     if (strm.LengthDecode(0, INT_MAX, len) != 0)
  616.       return FALSE;
  617.     value = strm.MultiBitDecode(len*8);
  618.     return TRUE;
  619.   }
  621.   if ((unsigned)lowerLimit != upperLimit)  // 12.2.1
  622.     return strm.UnsignedDecode(lowerLimit, upperLimit, value) == 0; // 12.2.2 which devolves to 10.5
  624.   value = lowerLimit;
  625.   return TRUE;
  626. }
  629. void PASN_Integer::EncodePER(PPER_Stream & strm) const
  630. {
  631.   // X.931 Sections 12
  633.   if (ConstraintEncode(strm, (int)value)) { //  12.1
  634.     PINDEX nBytes;
  635.     unsigned adjusted_value = value - lowerLimit;
  636.     if (adjusted_value == 0)
  637.       nBytes = 1;
  638.     else {
  639.       PINDEX nBits = CountBits(adjusted_value+1);
  640.       nBytes = (nBits+7)/8;
  641.     }
  642.     strm.LengthEncode(nBytes, 0, INT_MAX);
  643.     strm.MultiBitEncode(adjusted_value, nBytes*8);
  644.     return;
  645.   }
  647.   if ((unsigned)lowerLimit == upperLimit) // 12.2.1
  648.     return;
  650.   // 12.2.2 which devolves to 10.5
  651.   strm.UnsignedEncode(value, lowerLimit, upperLimit);
  652. }
  655. ///////////////////////////////////////////////////////////////////////
  657. PASN_Enumeration::PASN_Enumeration(unsigned tag, TagClass tagClass,
  658.                                    unsigned maxEnum, BOOL extend,
  659.                                    unsigned val)
  660.   : PASN_Object(tag, tagClass, extend)
  661. {
  662.   value = val;
  663.   maxEnumValue = maxEnum;
  664. }
  667. static POrdinalToString BuildNamesDict(const PString & nameSpec)
  668. {
  669.   POrdinalToString names;
  671.   PStringArray nameList = nameSpec.Tokenise(' ', FALSE);
  673.   int num = 0;
  674.   for (PINDEX i = 0; i < nameList.GetSize(); i++) {
  675.     const PString & thisName = nameList[i];
  676.     if (!thisName) {
  677.       PINDEX equalPos = thisName.Find('=');
  678.       if (equalPos != P_MAX_INDEX)
  679.         num = (int)thisName.Mid(equalPos+1).AsInteger();
  680.       names.SetAt(POrdinalKey(num), thisName.Left(equalPos));
  681.       num++;
  682.     }
  683.   }
  685.   return names;
  686. }
  689. PASN_Enumeration::PASN_Enumeration(unsigned tag, TagClass tagClass,
  690.                                    unsigned maxEnum, BOOL extend,
  691.                                    const PString & nameSpec,
  692.                                    unsigned val)
  693.   : PASN_Object(tag, tagClass, extend),
  694.     names(BuildNamesDict(nameSpec))
  695. {
  696.   PAssert(maxEnum > 0, PInvalidParameter);
  697.   maxEnumValue = maxEnum;
  699.   PAssert(val < maxEnum, PInvalidParameter);
  700.   value = val;
  701. }
  704. PObject::Comparison PASN_Enumeration::Compare(const PObject & obj) const
  705. {
  706.   PAssert(obj.IsDescendant(PASN_Enumeration::Class()), PInvalidCast);
  707.   const PASN_Enumeration & other = (const PASN_Enumeration &)obj;
  709.   if (value < other.value)
  710.     return LessThan;
  712.   if (value > other.value)
  713.     return GreaterThan;
  715.   return EqualTo;
  716. }
  719. PObject * PASN_Enumeration::Clone() const
  720. {
  721.   PAssert(IsClass(PASN_Enumeration::Class()), PInvalidCast);
  722.   return new PASN_Enumeration(*this);
  723. }
  726. void PASN_Enumeration::PrintOn(ostream & strm) const
  727. {
  728.   if (names.Contains(value))
  729.     strm << names[value];
  730.   else
  731.     strm << '<' << value << '>';
  732. }
  735. PString PASN_Enumeration::GetTypeAsString() const
  736. {
  737.   return "Enumeration";
  738. }
  741. PINDEX PASN_Enumeration::GetDataLength() const
  742. {
  743.   return GetIntegerDataLength(value);
  744. }
  747. BOOL PASN_Enumeration::Decode(PASN_Stream & strm)
  748. {
  749.   return strm.EnumerationDecode(*this);
  750. }
  753. void PASN_Enumeration::Encode(PASN_Stream & strm) const
  754. {
  755.   strm.EnumerationEncode(*this);
  756. }
  759. BOOL PBER_Stream::EnumerationDecode(PASN_Enumeration & value)
  760. {
  761.   unsigned len;
  762.   if (!HeaderDecode(value, len) || len == 0 || IsAtEnd())
  763.     return FALSE;
  765.   unsigned val = 0;
  766.   while (len-- > 0) {
  767.     if (IsAtEnd())
  768.       return FALSE;
  769.     val = (val << 8) | ByteDecode();
  770.   }
  772.   value = val;
  773.   return TRUE;
  774. }
  777. void PBER_Stream::EnumerationEncode(const PASN_Enumeration & value)
  778. {
  779.   HeaderEncode(value);
  780.   // output the integer bits
  781.   for (int count = GetIntegerDataLength(value)-1; count >= 0; count--)
  782.     ByteEncode(value >> (count*8));
  783. }
  786. BOOL PPER_Stream::EnumerationDecode(PASN_Enumeration & value)
  787. {
  788.   return value.DecodePER(*this);
  789. }
  792. void PPER_Stream::EnumerationEncode(const PASN_Enumeration & value)
  793. {
  794.   value.EncodePER(*this);
  795. }
  798. BOOL PASN_Enumeration::DecodePER(PPER_Stream & strm)
  799. {
  800.   // X.691 Section 13
  802.   if (extendable) {  // 13.3
  803.     if (strm.SingleBitDecode())
  804.       return strm.UnsignedDecode(0, strm.SmallUnsignedDecode()-1, value) == 0;
  805.   }
  807.   return strm.UnsignedDecode(0, maxEnumValue, value) == 0;  // 13.2
  808. }
  811. void PASN_Enumeration::EncodePER(PPER_Stream & strm) const
  812. {
  813.   // X.691 Section 13
  815.   if (extendable) {  // 13.3
  816.     BOOL extended = value > maxEnumValue;
  817.     strm.SingleBitEncode(extended);
  818.     if (extended) {
  819.       strm.SmallUnsignedEncode(1+value);
  820.       strm.UnsignedEncode(value, 0, value);
  821.       return;
  822.     }
  823.   }
  825.   strm.UnsignedEncode(value, 0, maxEnumValue);  // 13.2
  826. }
  829. ///////////////////////////////////////////////////////////////////////
  831. PASN_Real::PASN_Real(unsigned tag, TagClass tagClass, double val)
  832.   : PASN_Object(tag, tagClass)
  833. {
  834.   value = val;
  835. }
  838. PObject::Comparison PASN_Real::Compare(const PObject & obj) const
  839. {
  840.   PAssert(obj.IsDescendant(PASN_Real::Class()), PInvalidCast);
  841.   const PASN_Real & other = (const PASN_Real &)obj;
  843.   if (value < other.value)
  844.     return LessThan;
  846.   if (value > other.value)
  847.     return GreaterThan;
  849.   return EqualTo;
  850. }
  853. PObject * PASN_Real::Clone() const
  854. {
  855.   PAssert(IsClass(PASN_Real::Class()), PInvalidCast);
  856.   return new PASN_Real(*this);
  857. }
  860. void PASN_Real::PrintOn(ostream & strm) const
  861. {
  862.   strm << value;
  863. }
  866. PString PASN_Real::GetTypeAsString() const
  867. {
  868.   return "Real";
  869. }
  872. PINDEX PASN_Real::GetDataLength() const
  873. {
  874.   PAssertAlways(PUnimplementedFunction);
  875.   return 0;
  876. }
  879. BOOL PASN_Real::Decode(PASN_Stream & strm)
  880. {
  881.   return strm.RealDecode(*this);
  882. }
  885. void PASN_Real::Encode(PASN_Stream & strm) const
  886. {
  887.   strm.RealEncode(*this);
  888. }
  891. BOOL PBER_Stream::RealDecode(PASN_Real & value)
  892. {
  893.   unsigned len;
  894.   if (!HeaderDecode(value, len) || len == 0 || IsAtEnd())
  895.     return FALSE;
  897.   PAssertAlways(PUnimplementedFunction);
  898.   byteOffset += len;
  900.   return TRUE;
  901. }
  904. void PBER_Stream::RealEncode(const PASN_Real &)
  905. {
  906.   PAssertAlways(PUnimplementedFunction);
  907. }
  910. BOOL PPER_Stream::RealDecode(PASN_Real &)
  911. {
  912.   // X.691 Section 14
  914.   if (IsAtEnd())
  915.     return FALSE;
  917.   PINDEX len = MultiBitDecode(8)+1;
  918.   PAssertAlways(PUnimplementedFunction);
  919.   byteOffset += len;
  920.   return TRUE;
  921. }
  924. void PPER_Stream::RealEncode(const PASN_Real &)
  925. {
  926.   // X.691 Section 14
  928.   MultiBitEncode(0, 8);
  929.   PAssertAlways(PUnimplementedFunction);
  930.   MultiBitEncode(0, 8);
  931. }
  934. ///////////////////////////////////////////////////////////////////////
  936. PASN_ObjectId::PASN_ObjectId(unsigned tag, TagClass tagClass)
  937.   : PASN_Object(tag, tagClass)
  938. {
  939. }
  942. PASN_ObjectId::PASN_ObjectId(const PASN_ObjectId & other)
  943.   : PASN_Object(other),
  944.     value(other.value, other.GetSize())
  945. {
  946. }
  949. PASN_ObjectId & PASN_ObjectId::operator=(const PASN_ObjectId & other)
  950. {
  951.   PASN_Object::operator=(other);
  952.   value = PUnsignedArray(other.value, other.GetSize());
  953.   return *this;
  954. }
  957. PASN_ObjectId & PASN_ObjectId::operator=(const char * dotstr)
  958. {
  959.   SetValue(dotstr);
  960.   return *this;
  961. }
  964. PASN_ObjectId & PASN_ObjectId::operator=(const PString & dotstr)
  965. {
  966.   SetValue(dotstr);
  967.   return *this;
  968. }
  971. void PASN_ObjectId::SetValue(const PString & dotstr)
  972. {
  973.   PStringArray parts = dotstr.Tokenise('.');
  974.   value.SetSize(parts.GetSize());
  975.   for (PINDEX i = 0; i < parts.GetSize(); i++)
  976.     value[i] = parts[i].AsUnsigned();
  977. }
  980. BOOL PASN_ObjectId::operator==(const char * dotstr) const
  981. {
  982.   PASN_ObjectId id;
  983.   id.SetValue(dotstr);
  984.   return *this == id;
  985. }
  988. PObject::Comparison PASN_ObjectId::Compare(const PObject & obj) const
  989. {
  990.   PAssert(obj.IsDescendant(PASN_ObjectId::Class()), PInvalidCast);
  991.   const PASN_ObjectId & other = (const PASN_ObjectId &)obj;
  992.   return value.Compare(other.value);
  993. }
  996. PObject * PASN_ObjectId::Clone() const
  997. {
  998.   PAssert(IsClass(PASN_ObjectId::Class()), PInvalidCast);
  999.   return new PASN_ObjectId(*this);
  1000. }
  1003. void PASN_ObjectId::PrintOn(ostream & strm) const
  1004. {
  1005.   for (PINDEX i = 0; i < value.GetSize(); i++) {
  1006.     strm << (unsigned)value[i];
  1007.     if (i < value.GetSize()-1)
  1008.       strm << '.';
  1009.   }
  1010. }
  1013. PString PASN_ObjectId::GetTypeAsString() const
  1014. {
  1015.   return "Object ID";
  1016. }
  1019. BOOL PASN_ObjectId::CommonDecode(PASN_Stream & strm, unsigned dataLen)
  1020. {
  1021.   value.SetSize(0);
  1023.   // handle zero length strings correctly
  1024.   if (dataLen == 0)
  1025.     return TRUE;
  1027.   unsigned subId;
  1029.   // start at the second identifier in the buffer, because we will later
  1030.   // expand the first number into the first two IDs
  1031.   PINDEX i = 1;
  1032.   while (dataLen > 0) {
  1033.     unsigned byte;
  1034.     subId = 0;
  1035.     do {    /* shift and add in low order 7 bits */
  1036.       if (strm.IsAtEnd())
  1037.         return FALSE;
  1038.       byte = strm.ByteDecode();
  1039.       subId = (subId << 7) + (byte & 0x7f);
  1040.       dataLen--;
  1041.     } while ((byte & 0x80) != 0);
  1042.     value.SetAt(i++, subId);
  1043.   }
  1045.   /*
  1046.    * The first two subidentifiers are encoded into the first component
  1047.    * with the value (X * 40) + Y, where:
  1048.    *  X is the value of the first subidentifier.
  1049.    *  Y is the value of the second subidentifier.
  1050.    */
  1051.   subId = value[1];
  1052.   if (subId < 40) {
  1053.     value[0] = 0;
  1054.     value[1] = subId;
  1055.   }
  1056.   else if (subId < 80) {
  1057.     value[0] = 1;
  1058.     value[1] = subId-40;
  1059.   }
  1060.   else {
  1061.     value[0] = 2;
  1062.     value[1] = subId-80;
  1063.   }
  1065.   return TRUE;
  1066. }
  1069. void PASN_ObjectId::CommonEncode(PBYTEArray & encodecObjectId) const
  1070. {
  1071.   PINDEX length = value.GetSize();
  1072.   const unsigned * objId = value;
  1074.   if (length < 2) {
  1075.     // Thise case is really illegal, but we have to do SOMETHING
  1076.     encodecObjectId.SetSize(0);
  1077.     return;
  1078.   }
  1080.   unsigned subId = (objId[0] * 40) + objId[1];
  1081.   objId += 2;
  1083.   PINDEX outputPosition = 0;
  1085.   while (--length > 0) {
  1086.     if (subId < 128)
  1087.       encodecObjectId[outputPosition++] = (BYTE)subId;
  1088.     else {
  1089.       unsigned mask = 0x7F; /* handle subid == 0 case */
  1090.       int bits = 0;
  1092.       /* testmask *MUST* !!!! be of an unsigned type */
  1093.       unsigned testmask = 0x7F;
  1094.       int      testbits = 0;
  1095.       while (testmask != 0) {
  1096.         if (subId & testmask) {  /* if any bits set */
  1097.           mask = testmask;
  1098.         bits = testbits;
  1099.       }
  1100.         testmask <<= 7;
  1101.         testbits += 7;
  1102.       }
  1104.       /* mask can't be zero here */
  1105.       while (mask != 0x7F) {
  1106.         /* fix a mask that got truncated above */
  1107.        if (mask == 0x1E00000)
  1108.         mask = 0xFE00000;
  1110.         encodecObjectId[outputPosition++] = (BYTE)(((subId & mask) >> bits) | 0x80);
  1112.         mask >>= 7;
  1113.         bits -= 7;
  1114.       }
  1116.       encodecObjectId[outputPosition++] = (BYTE)(subId & mask);
  1117.     }
  1119.     subId = *objId++;
  1120.   }
  1121. }
  1124. PINDEX PASN_ObjectId::GetDataLength() const
  1125. {
  1126.   PBYTEArray dummy;
  1127.   CommonEncode(dummy);
  1128.   return dummy.GetSize();
  1129. }
  1132. BOOL PASN_ObjectId::Decode(PASN_Stream & strm)
  1133. {
  1134.   return strm.ObjectIdDecode(*this);
  1135. }
  1138. void PASN_ObjectId::Encode(PASN_Stream & strm) const
  1139. {
  1140.   strm.ObjectIdEncode(*this);
  1141. }
  1144. BOOL PBER_Stream::ObjectIdDecode(PASN_ObjectId & value)
  1145. {
  1146.   unsigned len;
  1147.   if (!HeaderDecode(value, len))
  1148.     return FALSE;
  1150.   return value.CommonDecode(*this, len);
  1151. }
  1154. void PBER_Stream::ObjectIdEncode(const PASN_ObjectId & value)
  1155. {
  1156.   HeaderEncode(value);
  1157.   PBYTEArray data;
  1158.   value.CommonEncode(data);
  1159.   BlockEncode(data, data.GetSize());
  1160. }
  1163. BOOL PPER_Stream::ObjectIdDecode(PASN_ObjectId & value)
  1164. {
  1165.   // X.691 Section 23
  1167.   unsigned dataLen;
  1168.   if (LengthDecode(0, 255, dataLen) < 0)
  1169.     return FALSE;
  1171.   ByteAlign();
  1172.   return value.CommonDecode(*this, dataLen);
  1173. }
  1176. void PPER_Stream::ObjectIdEncode(const PASN_ObjectId & value)
  1177. {
  1178.   // X.691 Section 23
  1180.   PBYTEArray eObjId;
  1181.   value.CommonEncode(eObjId);
  1182.   LengthEncode(eObjId.GetSize(), 0, 255);
  1183.   BlockEncode(eObjId, eObjId.GetSize());
  1184. }
  1187. ///////////////////////////////////////////////////////////////////////
  1189. PASN_BitString::PASN_BitString(unsigned tag, TagClass tagClass, unsigned nBits)
  1190.   : PASN_ConstrainedObject(tag, tagClass),
  1191.     totalBits(nBits),
  1192.     bitData((totalBits+7)/8)
  1193. {
  1194. }
  1197. PASN_BitString::PASN_BitString(const PASN_BitString & other)
  1198.   : PASN_ConstrainedObject(other),
  1199.     bitData(other.bitData, other.bitData.GetSize())
  1200. {
  1201.   totalBits = other.totalBits;
  1202. }
  1205. PASN_BitString & PASN_BitString::operator=(const PASN_BitString & other)
  1206. {
  1207.   PASN_ConstrainedObject::operator=(other);
  1208.   totalBits = other.totalBits;
  1209.   bitData = PBYTEArray(other.bitData, other.bitData.GetSize());
  1210.   return *this;
  1211. }
  1214. void PASN_BitString::SetData(unsigned nBits, const PBYTEArray & bytes)
  1215. {
  1216.   bitData = bytes;
  1217.   totalBits = nBits;
  1218. }
  1221. void PASN_BitString::SetData(unsigned nBits, const BYTE * buf, PINDEX size)
  1222. {
  1223.   bitData = PBYTEArray(buf, size);
  1224.   totalBits = nBits;
  1225. }
  1228. BOOL PASN_BitString::SetSize(unsigned nBits)
  1229. {
  1230.   totalBits = nBits;
  1231.   return bitData.SetSize((nBits+7)/8);
  1232. }
  1235. BOOL PASN_BitString::operator[](PINDEX bit) const
  1236. {
  1237.   if ((unsigned)bit < totalBits)
  1238.     return (bitData[bit>>3] & (1 << (7 - (bit&7)))) != 0;
  1239.   return FALSE;
  1240. }
  1243. void PASN_BitString::Set(unsigned bit)
  1244. {
  1245.   if (bit < totalBits)
  1246.     bitData[(PINDEX)(bit>>3)] |= 1 << (7 - (bit&7));
  1247. }
  1250. void PASN_BitString::Clear(unsigned bit)
  1251. {
  1252.   if (bit < totalBits)
  1253.     bitData[(PINDEX)(bit>>3)] &= ~(1 << (7 - (bit&7)));
  1254. }
  1257. void PASN_BitString::Invert(unsigned bit)
  1258. {
  1259.   if (bit < totalBits)
  1260.     bitData[(PINDEX)(bit>>3)] ^= 1 << (7 - (bit&7));
  1261. }
  1264. void PASN_BitString::SetConstraints(ConstraintType type, int lower, unsigned upper)
  1265. {
  1266.   PAssert(lower >= 0, PInvalidParameter);
  1267.   PASN_ConstrainedObject::SetConstraints(type, lower, upper);
  1268.   if (constraint != Unconstrained) {
  1269.     if (totalBits < (unsigned)lowerLimit)
  1270.       SetSize(lowerLimit);
  1271.     else if ((unsigned)totalBits > upperLimit)
  1272.       SetSize(upperLimit);
  1273.   }
  1274. }
  1277. PObject::Comparison PASN_BitString::Compare(const PObject & obj) const
  1278. {
  1279.   PAssert(obj.IsDescendant(PASN_BitString::Class()), PInvalidCast);
  1280.   const PASN_BitString & other = (const PASN_BitString &)obj;
  1281.   if (totalBits < other.totalBits)
  1282.     return LessThan;
  1283.   if (totalBits > other.totalBits)
  1284.     return GreaterThan;
  1285.   return bitData.Compare(other.bitData);
  1286. }
  1289. PObject * PASN_BitString::Clone() const
  1290. {
  1291.   PAssert(IsClass(PASN_BitString::Class()), PInvalidCast);
  1292.   return new PASN_BitString(*this);
  1293. }
  1296. void PASN_BitString::PrintOn(ostream & strm) const
  1297. {
  1298.   BYTE mask = 0x80;
  1299.   PINDEX offset = 0;
  1300.   for (unsigned i = 0; i < totalBits; i++) {
  1301.     strm << ((bitData[offset]&mask) != 0 ? '1' : '0');
  1302.     mask >>= 1;
  1303.     if (mask == 0) {
  1304.       mask = 0x80;
  1305.       offset++;
  1306.     }
  1307.   }
  1308. }
  1311. PString PASN_BitString::GetTypeAsString() const
  1312. {
  1313.   return "Bit String";
  1314. }
  1317. PINDEX PASN_BitString::GetDataLength() const
  1318. {
  1319.   return (totalBits+7)/8 + 1;
  1320. }
  1323. BOOL PASN_BitString::Decode(PASN_Stream & strm)
  1324. {
  1325.   return strm.BitStringDecode(*this);
  1326. }
  1329. void PASN_BitString::Encode(PASN_Stream & strm) const
  1330. {
  1331.   strm.BitStringEncode(*this);
  1332. }
  1335. BOOL PASN_BitString::DecodeBER(PBER_Stream & strm, unsigned len)
  1336. {
  1337.   totalBits = len*8 - strm.ByteDecode();
  1338.   unsigned nBytes = (totalBits+7)/8;
  1339.   return strm.BlockDecode(bitData.GetPointer(nBytes), nBytes) == nBytes;
  1340. }
  1343. void PASN_BitString::EncodeBER(PBER_Stream & strm) const
  1344. {
  1345.   if (totalBits == 0)
  1346.     strm.ByteEncode(0);
  1347.   else {
  1348.     strm.ByteEncode(8-totalBits%8);
  1349.     strm.BlockEncode(bitData, (totalBits+7)/8);
  1350.   }
  1351. }
  1354. BOOL PASN_BitString::DecodePER(PPER_Stream & strm)
  1355. {
  1356.   // X.691 Section 15
  1358.   if (ConstrainedLengthDecode(strm, totalBits) < 0)
  1359.     return FALSE;
  1361.   SetSize(totalBits);
  1363.   if (totalBits == 0)
  1364.     return TRUE;   // 15.7
  1366.   if (totalBits > strm.GetBitsLeft())
  1367.     return FALSE;
  1369.   if (totalBits > 16) {
  1370.     unsigned nBytes = (totalBits+7)/8;
  1371.     return strm.BlockDecode(bitData.GetPointer(), nBytes) == nBytes;   // 15.9
  1372.   }
  1374.   if (totalBits <= 8)
  1375.     bitData[0] = (BYTE)(strm.MultiBitDecode(totalBits) << (8-totalBits));
  1376.   else {  // 15.8
  1377.     bitData[0] = (BYTE)strm.MultiBitDecode(8);
  1378.     bitData[1] = (BYTE)(strm.MultiBitDecode(totalBits-8) << (16-totalBits));
  1379.   }
  1381.   return TRUE;
  1382. }
  1385. void PASN_BitString::EncodePER(PPER_Stream & strm) const
  1386. {
  1387.   // X.691 Section 15
  1389.   ConstrainedLengthEncode(strm, totalBits);
  1391.   if (totalBits == 0)
  1392.     return;
  1394.   if (totalBits > 16)
  1395.     strm.BlockEncode(bitData, (totalBits+7)/8);   // 15.9
  1396.   else if (totalBits <= 8)  // 15.8
  1397.     strm.MultiBitEncode(bitData[0] >> (8 - totalBits), totalBits);
  1398.   else {
  1399.     strm.MultiBitEncode(bitData[0], 8);
  1400.     strm.MultiBitEncode(bitData[1] >> (16 - totalBits), totalBits-8);
  1401.   }
  1402. }
  1405. BOOL PBER_Stream::BitStringDecode(PASN_BitString & value)
  1406. {
  1407.   unsigned len;
  1408.   if (!HeaderDecode(value, len) || len == 0 || IsAtEnd())
  1409.     return FALSE;
  1411.   return value.DecodeBER(*this, len);
  1412. }
  1415. void PBER_Stream::BitStringEncode(const PASN_BitString & value)
  1416. {
  1417.   HeaderEncode(value);
  1418.   value.EncodeBER(*this);
  1419. }
  1422. BOOL PPER_Stream::BitStringDecode(PASN_BitString & value)
  1423. {
  1424.   return value.DecodePER(*this);
  1425. }
  1428. void PPER_Stream::BitStringEncode(const PASN_BitString & value)
  1429. {
  1430.   value.EncodePER(*this);
  1431. }
  1434. ///////////////////////////////////////////////////////////////////////
  1436. PASN_OctetString::PASN_OctetString(unsigned tag, TagClass tagClass)
  1437.   : PASN_ConstrainedObject(tag, tagClass)
  1438. {
  1439. }
  1442. PASN_OctetString::PASN_OctetString(const PASN_OctetString & other)
  1443.   : PASN_ConstrainedObject(other),
  1444.     value(other.value, other.GetSize())
  1445. {
  1446. }
  1449. PASN_OctetString & PASN_OctetString::operator=(const PASN_OctetString & other)
  1450. {
  1451.   PASN_ConstrainedObject::operator=(other);
  1452.   value = PBYTEArray(other.value, other.GetSize());
  1453.   return *this;
  1454. }
  1457. PASN_OctetString & PASN_OctetString::operator=(const char * str)
  1458. {
  1459.   SetValue((const BYTE *)str, strlen(str));
  1460.   return *this;
  1461. }
  1464. PASN_OctetString & PASN_OctetString::operator=(const PString & str)
  1465. {
  1466.   SetValue((const BYTE *)(const char *)str, str.GetSize()-1);
  1467.   return *this;
  1468. }
  1471. PASN_OctetString & PASN_OctetString::operator=(const PBYTEArray & arr)
  1472. {
  1473.   PINDEX len = arr.GetSize();
  1474.   if ((unsigned)len > upperLimit || (int)len < lowerLimit)
  1475.     SetValue(arr, len);
  1476.   else
  1477.     value = arr;
  1478.   return *this;
  1479. }
  1482. void PASN_OctetString::SetValue(const BYTE * data, PINDEX len)
  1483. {
  1484.   if ((unsigned)len > upperLimit)
  1485.     len = upperLimit;
  1486.   value.SetSize((int)len < lowerLimit ? lowerLimit : len);
  1487.   memcpy(value.GetPointer(), data, len);
  1488. }
  1491. PString PASN_OctetString::AsString() const
  1492. {
  1493.   if (value.IsEmpty())
  1494.     return PString();
  1495.   return PString((const char *)(const BYTE *)value, value.GetSize());
  1496. }
  1499. void PASN_OctetString::SetConstraints(ConstraintType type, int lower, unsigned upper)
  1500. {
  1501.   PAssert(lower >= 0, PInvalidParameter);
  1502.   PASN_ConstrainedObject::SetConstraints(type, lower, upper);
  1503.   if (constraint != Unconstrained) {
  1504.     if (value.GetSize() < (PINDEX)lowerLimit)
  1505.       value.SetSize(lowerLimit);
  1506.     else if ((unsigned)value.GetSize() > upperLimit)
  1507.       value.SetSize(upperLimit);
  1508.   }
  1509. }
  1512. PObject::Comparison PASN_OctetString::Compare(const PObject & obj) const
  1513. {
  1514.   PAssert(obj.IsDescendant(PASN_OctetString::Class()), PInvalidCast);
  1515.   const PASN_OctetString & other = (const PASN_OctetString &)obj;
  1516.   return value.Compare(other.value);
  1517. }
  1520. PObject * PASN_OctetString::Clone() const
  1521. {
  1522.   PAssert(IsClass(PASN_OctetString::Class()), PInvalidCast);
  1523.   return new PASN_OctetString(*this);
  1524. }
  1527. void PASN_OctetString::PrintOn(ostream & strm) const
  1528. {
  1529.   int indent = strm.precision() + 2;
  1530.   strm << ' ' << value.GetSize() << " octets {n";
  1531.   PINDEX i = 0;
  1532.   while (i < value.GetSize()) {
  1533.     strm << setw(indent) << " " << hex << setfill('0');
  1534.     PINDEX j;
  1535.     for (j = 0; j < 16; j++) {
  1536.       if (i+j < value.GetSize())
  1537.         strm << setw(2) << (unsigned)value[i+j] << ' ';
  1538.       else
  1539.         strm << "   ";
  1540.     }
  1541.     strm << "  ";
  1542.     for (j = 0; j < 16; j++) {
  1543.       if (i+j < value.GetSize()) {
  1544.         if (isprint(value[i+j]))
  1545.           strm << value[i+j];
  1546.         else
  1547.           strm << ' ';
  1548.       }
  1549.     }
  1550.     strm << dec << setfill(' ') << 'n';
  1551.     i += 16;
  1552.   }
  1553.   strm << setw(indent-1) << "}";
  1554. }
  1557. PString PASN_OctetString::GetTypeAsString() const
  1558. {
  1559.   return "Octet String";
  1560. }
  1563. PINDEX PASN_OctetString::GetDataLength() const
  1564. {
  1565.   return value.GetSize();
  1566. }
  1569. BOOL PASN_OctetString::Decode(PASN_Stream & strm)
  1570. {
  1571.   return strm.OctetStringDecode(*this);
  1572. }
  1575. void PASN_OctetString::Encode(PASN_Stream & strm) const
  1576. {
  1577.   strm.OctetStringEncode(*this);
  1578. }
  1581. BOOL PASN_OctetString::DecodePER(PPER_Stream & strm)
  1582. {
  1583.   // X.691 Section 16
  1585.   unsigned nBytes;
  1586.   if (ConstrainedLengthDecode(strm, nBytes) < 0)
  1587.     return FALSE;
  1589.   value.SetSize(nBytes);   // 16.5
  1591.   switch (nBytes) {
  1592.     case 0 :
  1593.       break;
  1595.     case 1 :  // 16.6
  1596.       if (strm.IsAtEnd())
  1597.         return FALSE;
  1598.       value[0] = (BYTE)strm.MultiBitDecode(8);
  1599.       break;
  1601.     case 2 :  // 16.6
  1602.       if (strm.IsAtEnd())
  1603.         return FALSE;
  1604.       value[0] = (BYTE)strm.MultiBitDecode(8);
  1605.       value[1] = (BYTE)strm.MultiBitDecode(8);
  1606.       break;
  1608.     default: // 16.7
  1609.       return strm.BlockDecode(value.GetPointer(), nBytes) == nBytes;
  1610.   }
  1612.   return TRUE;
  1613. }
  1616. void PASN_OctetString::EncodePER(PPER_Stream & strm) const
  1617. {
  1618.   // X.691 Section 16
  1620.   PINDEX nBytes = value.GetSize();
  1621.   ConstrainedLengthEncode(strm, nBytes);
  1623.   switch (nBytes) {
  1624.     case 0 :  // 16.5
  1625.       break;
  1627.     case 1 :  // 16.6
  1628.       strm.MultiBitEncode(value[0], 8);
  1629.       break;
  1631.     case 2 :  // 16.6
  1632.       strm.MultiBitEncode(value[0], 8);
  1633.       strm.MultiBitEncode(value[1], 8);
  1634.       break;
  1636.     default: // 16.7
  1637.       strm.BlockEncode(value, nBytes);
  1638.   }
  1639. }
  1642. BOOL PBER_Stream::OctetStringDecode(PASN_OctetString & value)
  1643. {
  1644.   unsigned len;
  1645.   if (!HeaderDecode(value, len))
  1646.     return FALSE;
  1648.   return BlockDecode(value.GetPointer(len), len) == len;
  1649. }
  1652. void PBER_Stream::OctetStringEncode(const PASN_OctetString & value)
  1653. {
  1654.   HeaderEncode(value);
  1655.   BlockEncode(value, value.GetSize());
  1656. }
  1659. BOOL PPER_Stream::OctetStringDecode(PASN_OctetString & value)
  1660. {
  1661.   return value.DecodePER(*this);
  1662. }
  1665. void PPER_Stream::OctetStringEncode(const PASN_OctetString & value)
  1666. {
  1667.   value.EncodePER(*this);
  1668. }
  1671. ///////////////////////////////////////////////////////////////////////
  1673. PASN_ConstrainedString::PASN_ConstrainedString(const char * canonical, PINDEX size,
  1674.                                                unsigned tag, TagClass tagClass)
  1675.   : PASN_ConstrainedObject(tag, tagClass)
  1676. {
  1677.   canonicalSet = canonical;
  1678.   canonicalSetSize = size;
  1679.   canonicalSetBits = CountBits(size);
  1680.   charSetUnalignedBits = 8;
  1681.   charSetAlignedBits = 8;
  1682. }
  1685. PASN_ConstrainedString & PASN_ConstrainedString::operator=(const char * str)
  1686. {
  1687.   value = PString();
  1688.   PINDEX len = strlen(str);
  1689.   for (PINDEX i = 0; i < len; i++) {
  1690.     PINDEX sz = characterSet.GetSize();
  1691.     if (sz == 0 || memchr(characterSet, str[i], sz) != NULL)
  1692.       value += str[i];
  1693.   }
  1694.   return *this;
  1695. }
  1698. void PASN_ConstrainedString::SetCharacterSet(ConstraintType ctype, const char * set)
  1699. {
  1700.   SetCharacterSet(set, strlen(set), ctype);
  1701. }
  1704. void PASN_ConstrainedString::SetCharacterSet(ConstraintType ctype, unsigned firstChar, unsigned lastChar)
  1705. {
  1706.   char buffer[256];
  1707.   for (unsigned i = firstChar; i < lastChar; i++)
  1708.     buffer[i] = (char)i;
  1709.   SetCharacterSet(buffer, lastChar - firstChar + 1, ctype);
  1710. }
  1713. void PASN_ConstrainedString::SetCharacterSet(const char * set, PINDEX setSize, ConstraintType ctype)
  1714. {
  1715.   if (ctype == Unconstrained)
  1716.     characterSet.SetSize(0);
  1717.   else {
  1718.     characterSet.SetSize(setSize);
  1719.     PINDEX count = 0;
  1720.     for (PINDEX i = 0; i < canonicalSetSize; i++) {
  1721.       if (memchr(set, canonicalSet[i], setSize) != NULL)
  1722.         characterSet[count++] = canonicalSet[i];
  1723.     }
  1724.     PAssert(count > 0, PInvalidParameter);
  1725.     characterSet.SetSize(count);
  1726.   }
  1728.   if (characterSet.IsEmpty())
  1729.     charSetUnalignedBits = 8;
  1730.   else
  1731.     charSetUnalignedBits = CountBits(characterSet.GetSize());
  1733.   charSetAlignedBits = 1;
  1734.   while (charSetUnalignedBits > charSetAlignedBits)
  1735.     charSetAlignedBits <<= 1;
  1736. }
  1739. PObject::Comparison PASN_ConstrainedString::Compare(const PObject & obj) const
  1740. {
  1741.   PAssert(obj.IsDescendant(PASN_ConstrainedString::Class()), PInvalidCast);
  1742.   const PASN_ConstrainedString & other = (const PASN_ConstrainedString &)obj;
  1743.   return value.Compare(other.value);
  1744. }
  1747. void PASN_ConstrainedString::PrintOn(ostream & strm) const
  1748. {
  1749.   strm << value.ToLiteral();
  1750. }
  1753. PINDEX PASN_ConstrainedString::GetDataLength() const
  1754. {
  1755.   return value.GetSize()-1;
  1756. }
  1759. BOOL PASN_ConstrainedString::Decode(PASN_Stream & strm)
  1760. {
  1761.   return strm.ConstrainedStringDecode(*this);
  1762. }
  1765. void PASN_ConstrainedString::Encode(PASN_Stream & strm) const
  1766. {
  1767.   strm.ConstrainedStringEncode(*this);
  1768. }
  1771. BOOL PASN_ConstrainedString::DecodeBER(PBER_Stream & strm, unsigned len)
  1772. {
  1773.   return strm.BlockDecode((BYTE *)value.GetPointer(len+1), len) == len;
  1774. }
  1777. void PASN_ConstrainedString::EncodeBER(PBER_Stream & strm) const
  1778. {
  1779.   strm.BlockEncode(value, value.GetSize()-1);
  1780. }
  1783. BOOL PASN_ConstrainedString::DecodePER(PPER_Stream & strm)
  1784. {
  1785.   // X.691 Section 26
  1787.   unsigned len;
  1788.   if (ConstrainedLengthDecode(strm, len) < 0)
  1789.     return FALSE;
  1791.   unsigned nBits = strm.IsAligned() ? charSetAlignedBits : charSetUnalignedBits;
  1793.   if (constraint == Unconstrained || upperLimit*nBits > 16) {
  1794.     if (nBits == 8)
  1795.       return strm.BlockDecode((BYTE *)value.GetPointer(len+1), len) == len;
  1796.     if (strm.IsAligned())
  1797.       strm.ByteAlign();
  1798.   }
  1800.   value.SetSize(len+1);
  1802.   PINDEX i;
  1803.   for (i = 0; i < (PINDEX)len; i++) {
  1804.     if (strm.IsAtEnd())
  1805.       return FALSE;
  1806.     if (nBits >= canonicalSetBits && canonicalSetBits > 4)
  1807.       value[i] = (char)strm.MultiBitDecode(nBits);
  1808.     else
  1809.       value[i] = characterSet[strm.MultiBitDecode(nBits)];
  1810.   }
  1811.   value[i] = '';
  1813.   return TRUE;
  1814. }
  1817. void PASN_ConstrainedString::EncodePER(PPER_Stream & strm) const
  1818. {
  1819.   // X.691 Section 26
  1821.   PINDEX len = value.GetSize()-1;
  1822.   ConstrainedLengthEncode(strm, len);
  1824.   unsigned nBits = strm.IsAligned() ? charSetAlignedBits : charSetUnalignedBits;
  1826.   if (constraint == Unconstrained || upperLimit*nBits > 16) {
  1827.     if (nBits == 8) {
  1828.       strm.BlockEncode((const BYTE *)(const char *)value, len);
  1829.       return;
  1830.     }
  1831.     if (strm.IsAligned())
  1832.       strm.ByteAlign();
  1833.   }
  1835.   for (PINDEX i = 0; i < len; i++) {
  1836.     if (nBits >= canonicalSetBits && canonicalSetBits > 4)
  1837.       strm.MultiBitEncode(value[i], nBits);
  1838.     else {
  1839.       const void * ptr = memchr(characterSet, value[i], characterSet.GetSize());
  1840.       PINDEX pos = 0;
  1841.       if (ptr != NULL)
  1842.         pos = ((const char *)ptr - (const char *)characterSet);
  1843.       strm.MultiBitEncode(pos, nBits);
  1844.     }
  1845.   }
  1846. }
  1849. BOOL PBER_Stream::ConstrainedStringDecode(PASN_ConstrainedString & value)
  1850. {
  1851.   unsigned len;
  1852.   if (!HeaderDecode(value, len))
  1853.     return FALSE;
  1855.   return value.DecodeBER(*this, len);
  1856. }
  1859. void PBER_Stream::ConstrainedStringEncode(const PASN_ConstrainedString & value)
  1860. {
  1861.   HeaderEncode(value);
  1862.   value.Encode(*this);
  1863. }
  1866. BOOL PPER_Stream::ConstrainedStringDecode(PASN_ConstrainedString & value)
  1867. {
  1868.   return value.DecodePER(*this);
  1869. }
  1872. void PPER_Stream::ConstrainedStringEncode(const PASN_ConstrainedString & value)
  1873. {
  1874.   value.EncodePER(*this);
  1875. }
  1878. #define DEFINE_STRING_CLASS(name, set) 
  1879.   static const char name##StringSet[] = set; 
  1880.   PASN_##name##String::PASN_##name##String(unsigned tag, TagClass tagClass) 
  1881.     : PASN_ConstrainedString(name##StringSet, sizeof(name##StringSet)-1, tag, tagClass) 
  1882.     { } 
  1883.     PASN_##name##String & PASN_##name##String::operator=(const char * str) 
  1884.     { PASN_ConstrainedString::SetValue(str); return *this; } 
  1885.   PASN_##name##String & PASN_##name##String::operator=(const PString & str) 
  1886.     { PASN_ConstrainedString::SetValue(str); return *this; } 
  1887.   PObject * PASN_##name##String::Clone() const 
  1888.     { PAssert(IsClass(PASN_##name##String::Class()), PInvalidCast); 
  1889.       return new PASN_##name##String(*this); } 
  1890.   PString PASN_##name##String::GetTypeAsString() const 
  1891.     { return #name " String"; }
  1893. DEFINE_STRING_CLASS(Numeric,   " 0123456789")
  1894. DEFINE_STRING_CLASS(Printable, " '()+,-./0123456789:=?"
  1895.                                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  1896.                                "abcdefghijklmnopqrstuvwxyz")
  1897. DEFINE_STRING_CLASS(Visible,   " !"#$%&'()*+,-./0123456789:;<=>?"
  1898.                                "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_"
  1899.                                "`abcdefghijklmnopqrstuvwxyz{|}~")
  1900. DEFINE_STRING_CLASS(IA5,       "0001020304050607"
  1901.                                "1011121314151617"
  1902.                                "2021222324252627"
  1903.                                "3031323334353637"
  1904.                                " !"#$%&'()*+,-./0123456789:;<=>?"
  1905.                                "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_"
  1906.                                "`abcdefghijklmnopqrstuvwxyz{|}~177")
  1907. DEFINE_STRING_CLASS(General,   "0001020304050607"
  1908.                                "1011121314151617"
  1909.                                "2021222324252627"
  1910.                                "3031323334353637"
  1911.                                " !"#$%&'()*+,-./0123456789:;<=>?"
  1912.                                "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_"
  1913.                                "`abcdefghijklmnopqrstuvwxyz{|}~177"
  1914.                                "200201202203204205206207"
  1915.                                "210211212213214215216217"
  1916.                                "220221222223224225226227"
  1917.                                "230231232233234235236237"
  1918.                                "240241242243244245246247"
  1919.                                "250251252253254255256257"
  1920.                                "260261262263264265266267"
  1921.                                "270271272273274275276277"
  1922.                                "300301302303304305306307"
  1923.                                "310311312313314315316317"
  1924.                                "320321322323324325326327"
  1925.                                "330331332333334335336337"
  1926.                                "340341342343344345346347"
  1927.                                "350351352353354355356357"
  1928.                                "360361362363364365366367"
  1929.                                "370371372373374375376377")
  1932. ///////////////////////////////////////////////////////////////////////
  1934. PASN_BMPString::PASN_BMPString(unsigned tag, TagClass tagClass)
  1935.   : PASN_ConstrainedObject(tag, tagClass)
  1936. {
  1937.   firstChar = 0;
  1938.   lastChar = 0xffff;
  1939.   charSetAlignedBits = 16;
  1940.   charSetUnalignedBits = 16;
  1941. }
  1944. PASN_BMPString::PASN_BMPString(const PASN_BMPString & other)
  1945.   : PASN_ConstrainedObject(other),
  1946.     value(other.value, other.value.GetSize()),
  1947.     characterSet(other.characterSet)
  1948. {
  1949.   firstChar = other.firstChar;
  1950.   lastChar = other.lastChar;
  1951.   charSetAlignedBits = other.charSetAlignedBits;
  1952.   charSetUnalignedBits = other.charSetUnalignedBits;
  1953. }
  1956. PASN_BMPString & PASN_BMPString::operator=(const PASN_BMPString & other)
  1957. {
  1958.   PASN_ConstrainedObject::operator=(other);
  1960.   value = PWORDArray(other.value, other.value.GetSize());
  1961.   characterSet = other.characterSet;
  1962.   firstChar = other.firstChar;
  1963.   lastChar = other.lastChar;
  1964.   charSetAlignedBits = other.charSetAlignedBits;
  1965.   charSetUnalignedBits = other.charSetUnalignedBits;
  1967.   return *this;
  1968. }
  1971. BOOL PASN_BMPString::IsLegalCharacter(WORD ch)
  1972. {
  1973.   if (ch < firstChar)
  1974.     return FALSE;
  1976.   if (ch > lastChar)
  1977.     return FALSE;
  1979.   if (characterSet.IsEmpty())
  1980.     return TRUE;
  1982.   const WORD * wptr = characterSet;
  1983.   PINDEX count = characterSet.GetSize();
  1984.   while (count-- > 0) {
  1985.     if (*wptr == ch)
  1986.       return TRUE;
  1987.     wptr++;
  1988.   }
  1990.   return FALSE;
  1991. }
  1994. PASN_BMPString & PASN_BMPString::operator=(const PString & str)
  1995. {
  1996.   PINDEX sz = str.GetLength();
  1997.   value.SetSize(sz);
  1999.   PINDEX count = 0;
  2000.   for (PINDEX i = 0; i < sz; i++) {
  2001.     WORD c = (BYTE)str[i];
  2002.     if (IsLegalCharacter(c))
  2003.       value[count++] = c;
  2004.   }
  2006.   value.SetSize(count);
  2007.   return *this;
  2008. }
  2011. PASN_BMPString & PASN_BMPString::operator=(const PWORDArray & array)
  2012. {
  2013.   PINDEX sz = array.GetSize();
  2014.   value.SetSize(sz);
  2016.   PINDEX count = 0;
  2017.   for (PINDEX i = 0; i < sz; i++) {
  2018.     WORD c = array[i];
  2019.     if (IsLegalCharacter(c))
  2020.       value[count++] = c;
  2021.   }
  2023.   value.SetSize(count);
  2024.   return *this;
  2025. }
  2028. PString PASN_BMPString::GetValue() const
  2029. {
  2030.   PString str;
  2031.   for (PINDEX i = 0; i < value.GetSize(); i++) {
  2032.     if (value[i] < 256)
  2033.       str += (char)value[i];
  2034.   }
  2035.   return str;
  2036. }
  2039. void PASN_BMPString::SetCharacterSet(ConstraintType ctype, const char * charSet)
  2040. {
  2041.   PWORDArray array(strlen(charSet));
  2043.   PINDEX count = 0;
  2044.   while (*charSet != '')
  2045.     array[count++] = (BYTE)*charSet++;
  2047.   SetCharacterSet(ctype, array);
  2048. }
  2051. void PASN_BMPString::SetCharacterSet(ConstraintType ctype, const PWORDArray & charSet)
  2052. {
  2053.   if (ctype == Unconstrained) {
  2054.     firstChar = 0;
  2055.     lastChar = 0xffff;
  2056.     characterSet.SetSize(0);
  2057.   }
  2058.   else {
  2059.     characterSet = charSet;
  2061.     charSetUnalignedBits = CountBits(lastChar - firstChar + 1);
  2062.     if (!charSet.IsEmpty()) {
  2063.       unsigned count = 0;
  2064.       for (PINDEX i = 0; i < charSet.GetSize(); i++) {
  2065.         if (characterSet[i] >= firstChar && characterSet[i] <= lastChar)
  2066.           count++;
  2067.       }
  2068.       count = CountBits(count);
  2069.       if (charSetUnalignedBits > count)
  2070.         charSetUnalignedBits = count;
  2071.     }
  2073.     charSetAlignedBits = 1;
  2074.     while (charSetUnalignedBits > charSetAlignedBits)
  2075.       charSetAlignedBits <<= 1;
  2077.     SetValue(value);
  2078.   }
  2079. }
  2082. void PASN_BMPString::SetCharacterSet(ConstraintType ctype, unsigned first, unsigned last)
  2083. {
  2084.   if (ctype != Unconstrained) {
  2085.     PAssert(first < 0x10000 && last < 0x10000 && last > first, PInvalidParameter);
  2086.     firstChar = (WORD)first;
  2087.     lastChar = (WORD)last;
  2088.   }
  2089.   SetCharacterSet(ctype, characterSet);
  2090. }
  2093. PObject * PASN_BMPString::Clone() const
  2094. {
  2095.   PAssert(IsClass(PASN_BMPString::Class()), PInvalidCast);
  2096.   return new PASN_BMPString(*this);
  2097. }
  2100. PObject::Comparison PASN_BMPString::Compare(const PObject & obj) const
  2101. {
  2102.   PAssert(obj.IsDescendant(PASN_BMPString::Class()), PInvalidCast);
  2103.   const PASN_BMPString & other = (const PASN_BMPString &)obj;
  2104.   return value.Compare(other.value);
  2105. }
  2108. void PASN_BMPString::PrintOn(ostream & strm) const
  2109. {
  2110.   int indent = strm.precision() + 2;
  2111.   PINDEX sz = value.GetSize();
  2112.   strm << ' ' << sz << " characters {n";
  2113.   PINDEX i = 0;
  2114.   while (i < sz) {
  2115.     strm << setw(indent) << " " << hex << setfill('0');
  2116.     PINDEX j;
  2117.     for (j = 0; j < 8; j++)
  2118.       if (i+j < sz)
  2119.         strm << setw(4) << value[i+j] << ' ';
  2120.       else
  2121.         strm << "     ";
  2122.     strm << "  ";
  2123.     for (j = 0; j < 8; j++) {
  2124.       if (i+j < sz) {
  2125.         WORD c = value[i+j];
  2126.         if (c < 128 && isprint(c))
  2127.           strm << (char)c;
  2128.         else
  2129.           strm << ' ';
  2130.       }
  2131.     }
  2132.     strm << dec << setfill(' ') << 'n';
  2133.     i += 8;
  2134.   }
  2135.   strm << setw(indent-1) << "}";
  2136. }
  2139. PString PASN_BMPString::GetTypeAsString() const
  2140. {
  2141.   return "BMP String";
  2142. }
  2145. PINDEX PASN_BMPString::GetDataLength() const
  2146. {
  2147.   return value.GetSize()*2;
  2148. }
  2151. BOOL PASN_BMPString::Decode(PASN_Stream & strm)
  2152. {
  2153.   return strm.BMPStringDecode(*this);
  2154. }
  2157. void PASN_BMPString::Encode(PASN_Stream & strm) const
  2158. {
  2159.   strm.BMPStringEncode(*this);
  2160. }
  2163. BOOL PASN_BMPString::DecodeBER(PBER_Stream & strm, unsigned len)
  2164. {
  2165.   value.SetSize(len/2);
  2166.   return strm.BlockDecode((BYTE *)value.GetPointer(len), len) == len;
  2167. }
  2170. void PASN_BMPString::EncodeBER(PBER_Stream & strm) const
  2171. {
  2172.   strm.BlockEncode((const BYTE *)(const WORD *)value, value.GetSize()*2);
  2173. }
  2176. BOOL PASN_BMPString::DecodePER(PPER_Stream & strm)
  2177. {
  2178.   // X.691 Section 26
  2180.   unsigned len;
  2181.   if (ConstrainedLengthDecode(strm, len) < 0)
  2182.     return FALSE;
  2184.   value.SetSize(len);
  2186.   PINDEX nBits = strm.IsAligned() ? charSetAlignedBits : charSetUnalignedBits;
  2188.   if ((constraint == Unconstrained || upperLimit*nBits > 16) && strm.IsAligned())
  2189.     strm.ByteAlign();
  2191.   for (PINDEX i = 0; i < (PINDEX)len; i++) {
  2192.     if (strm.IsAtEnd())
  2193.       return FALSE;
  2194.     if (characterSet.IsEmpty())
  2195.       value[i] = (WORD)(strm.MultiBitDecode(nBits) + firstChar);
  2196.     else
  2197.       value[i] = characterSet[strm.MultiBitDecode(nBits)];
  2198.   }
  2200.   return TRUE;
  2201. }
  2204. void PASN_BMPString::EncodePER(PPER_Stream & strm) const
  2205. {
  2206.   // X.691 Section 26
  2208.   PINDEX len = value.GetSize();
  2209.   ConstrainedLengthEncode(strm, len);
  2211.   PINDEX nBits = strm.IsAligned() ? charSetAlignedBits : charSetUnalignedBits;
  2213.   if ((constraint == Unconstrained || upperLimit*nBits > 16) && strm.IsAligned())
  2214.     strm.ByteAlign();
  2216.   for (PINDEX i = 0; i < len; i++) {
  2217.     if (characterSet.IsEmpty())
  2218.       strm.MultiBitEncode(value[i] - firstChar, nBits);
  2219.     else {
  2220.       for (PINDEX pos = 0; pos < characterSet.GetSize(); pos++) {
  2221.         if (characterSet[pos] == value[i]) {
  2222.           strm.MultiBitEncode(pos, nBits);
  2223.           break;
  2224.         }
  2225.       }
  2226.     }
  2227.   }
  2228. }
  2231. BOOL PBER_Stream::BMPStringDecode(PASN_BMPString & value)
  2232. {
  2233.   unsigned len;
  2234.   if (!HeaderDecode(value, len))
  2235.     return FALSE;
  2237.   return value.DecodeBER(*this, len);
  2238. }
  2241. void PBER_Stream::BMPStringEncode(const PASN_BMPString & value)
  2242. {
  2243.   HeaderEncode(value);
  2244.   value.EncodeBER(*this);
  2245. }
  2248. BOOL PPER_Stream::BMPStringDecode(PASN_BMPString & value)
  2249. {
  2250.   return value.DecodePER(*this);
  2251. }
  2254. void PPER_Stream::BMPStringEncode(const PASN_BMPString & value)
  2255. {
  2256.   value.EncodePER(*this);
  2257. }
  2260. ///////////////////////////////////////////////////////////////////////
  2262. PASN_Choice::PASN_Choice(unsigned nChoices, BOOL extend)
  2263.   : PASN_Object(0, ApplicationTagClass, extend)
  2264. {
  2265.   numChoices = nChoices;
  2266.   choice = NULL;
  2267. }
  2270. PASN_Choice::PASN_Choice(unsigned tag, TagClass tagClass,
  2271.                          unsigned upper, BOOL extend)
  2272.   : PASN_Object(tag, tagClass, extend)
  2273. {
  2274.   numChoices = upper;
  2275.   choice = NULL;
  2276. }
  2279. PASN_Choice::PASN_Choice(unsigned tag, TagClass tagClass,
  2280.                          unsigned upper, BOOL extend, const PString & nameSpec)
  2281.   : PASN_Object(tag, tagClass, extend),
  2282.     names(BuildNamesDict(nameSpec))
  2283. {
  2284.   numChoices = upper;
  2285.   choice = NULL;
  2286. }
  2289. PASN_Choice::PASN_Choice(const PASN_Choice & other)
  2290.   : PASN_Object(other),
  2291.     names(other.names)
  2292. {
  2293.   numChoices = other.numChoices;
  2295.   if (other.choice != NULL)
  2296.     choice = (PASN_Object *)other.choice->Clone();
  2297.   else
  2298.     choice = NULL;
  2299. }
  2302. PASN_Choice & PASN_Choice::operator=(const PASN_Choice & other)
  2303. {
  2304.   delete choice;
  2306.   PASN_Object::operator=(other);
  2308.   numChoices = other.numChoices;
  2309.   names = other.names;
  2311.   if (other.choice != NULL)
  2312.     choice = (PASN_Object *)other.choice->Clone();
  2313.   else
  2314.     choice = NULL;
  2316.   return *this;
  2317. }
  2320. PASN_Choice::~PASN_Choice()
  2321. {
  2322.   delete choice;
  2323. }
  2326. void PASN_Choice::SetTag(unsigned newTag, TagClass tagClass)
  2327. {
  2328.   PASN_Object::SetTag(newTag, tagClass);
  2330.   delete choice;
  2332.   if (CreateObject())
  2333.     choice->SetTag(newTag, tagClass);
  2334. }
  2337. PString PASN_Choice::GetTagName() const
  2338. {
  2339.   if (tag == UINT_MAX)
  2340.     return "<uninitialised>";
  2342.   if (names.Contains(tag))
  2343.     return names[tag];
  2345.   if (choice != NULL && choice->IsDescendant(PASN_Choice::Class()) &&
  2346.       choice->GetTag() == tag && choice->GetTagClass() == tagClass)
  2347.     return PString(choice->GetClass()) + "->" + ((PASN_Choice *)choice)->GetTagName();
  2349.   return psprintf("<%u>", tag);
  2350. }
  2353. PASN_Object & PASN_Choice::GetObject() const
  2354. {
  2355.   PAssert(choice != NULL, "NULL Choice");
  2356.   return *choice;
  2357. }
  2360. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2362. PASN_Choice::operator PASN_Null &() const
  2363. {
  2364.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Null::Class()), PInvalidCast);
  2365.   return *(PASN_Null *)choice;
  2366. }
  2369. PASN_Choice::operator PASN_Boolean &() const
  2370. {
  2371.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Boolean::Class()), PInvalidCast);
  2372.   return *(PASN_Boolean *)choice;
  2373. }
  2376. PASN_Choice::operator PASN_Integer &() const
  2377. {
  2378.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Integer::Class()), PInvalidCast);
  2379.   return *(PASN_Integer *)choice;
  2380. }
  2383. PASN_Choice::operator PASN_Enumeration &() const
  2384. {
  2385.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Enumeration::Class()), PInvalidCast);
  2386.   return *(PASN_Enumeration *)choice;
  2387. }
  2390. PASN_Choice::operator PASN_Real &() const
  2391. {
  2392.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Real::Class()), PInvalidCast);
  2393.   return *(PASN_Real *)choice;
  2394. }
  2397. PASN_Choice::operator PASN_ObjectId &() const
  2398. {
  2399.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_ObjectId::Class()), PInvalidCast);
  2400.   return *(PASN_ObjectId *)choice;
  2401. }
  2404. PASN_Choice::operator PASN_BitString &() const
  2405. {
  2406.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_BitString::Class()), PInvalidCast);
  2407.   return *(PASN_BitString *)choice;
  2408. }
  2411. PASN_Choice::operator PASN_OctetString &() const
  2412. {
  2413.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_OctetString::Class()), PInvalidCast);
  2414.   return *(PASN_OctetString *)choice;
  2415. }
  2418. PASN_Choice::operator PASN_NumericString &() const
  2419. {
  2420.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_NumericString::Class()), PInvalidCast);
  2421.   return *(PASN_NumericString *)choice;
  2422. }
  2425. PASN_Choice::operator PASN_PrintableString &() const
  2426. {
  2427.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_PrintableString::Class()), PInvalidCast);
  2428.   return *(PASN_PrintableString *)choice;
  2429. }
  2432. PASN_Choice::operator PASN_VisibleString &() const
  2433. {
  2434.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_VisibleString::Class()), PInvalidCast);
  2435.   return *(PASN_VisibleString *)choice;
  2436. }
  2439. PASN_Choice::operator PASN_IA5String &() const
  2440. {
  2441.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_IA5String::Class()), PInvalidCast);
  2442.   return *(PASN_IA5String *)choice;
  2443. }
  2446. PASN_Choice::operator PASN_GeneralString &() const
  2447. {
  2448.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_GeneralString::Class()), PInvalidCast);
  2449.   return *(PASN_GeneralString *)choice;
  2450. }
  2453. PASN_Choice::operator PASN_BMPString &() const
  2454. {
  2455.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_BMPString::Class()), PInvalidCast);
  2456.   return *(PASN_BMPString *)choice;
  2457. }
  2460. PASN_Choice::operator PASN_Sequence &() const
  2461. {
  2462.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Sequence::Class()), PInvalidCast);
  2463.   return *(PASN_Sequence *)choice;
  2464. }
  2467. #else
  2470. PASN_Choice::operator PASN_Null &()
  2471. {
  2472.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Null::Class()), PInvalidCast);
  2473.   return *(PASN_Null *)choice;
  2474. }
  2477. PASN_Choice::operator PASN_Boolean &()
  2478. {
  2479.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Boolean::Class()), PInvalidCast);
  2480.   return *(PASN_Boolean *)choice;
  2481. }
  2484. PASN_Choice::operator PASN_Integer &()
  2485. {
  2486.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Integer::Class()), PInvalidCast);
  2487.   return *(PASN_Integer *)choice;
  2488. }
  2491. PASN_Choice::operator PASN_Enumeration &()
  2492. {
  2493.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Enumeration::Class()), PInvalidCast);
  2494.   return *(PASN_Enumeration *)choice;
  2495. }
  2498. PASN_Choice::operator PASN_Real &()
  2499. {
  2500.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Real::Class()), PInvalidCast);
  2501.   return *(PASN_Real *)choice;
  2502. }
  2505. PASN_Choice::operator PASN_ObjectId &()
  2506. {
  2507.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_ObjectId::Class()), PInvalidCast);
  2508.   return *(PASN_ObjectId *)choice;
  2509. }
  2512. PASN_Choice::operator PASN_BitString &()
  2513. {
  2514.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_BitString::Class()), PInvalidCast);
  2515.   return *(PASN_BitString *)choice;
  2516. }
  2519. PASN_Choice::operator PASN_OctetString &()
  2520. {
  2521.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_OctetString::Class()), PInvalidCast);
  2522.   return *(PASN_OctetString *)choice;
  2523. }
  2526. PASN_Choice::operator PASN_NumericString &()
  2527. {
  2528.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_NumericString::Class()), PInvalidCast);
  2529.   return *(PASN_NumericString *)choice;
  2530. }
  2533. PASN_Choice::operator PASN_PrintableString &()
  2534. {
  2535.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_PrintableString::Class()), PInvalidCast);
  2536.   return *(PASN_PrintableString *)choice;
  2537. }
  2540. PASN_Choice::operator PASN_VisibleString &()
  2541. {
  2542.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_VisibleString::Class()), PInvalidCast);
  2543.   return *(PASN_VisibleString *)choice;
  2544. }
  2547. PASN_Choice::operator PASN_IA5String &()
  2548. {
  2549.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_IA5String::Class()), PInvalidCast);
  2550.   return *(PASN_IA5String *)choice;
  2551. }
  2554. PASN_Choice::operator PASN_GeneralString &()
  2555. {
  2556.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_GeneralString::Class()), PInvalidCast);
  2557.   return *(PASN_GeneralString *)choice;
  2558. }
  2561. PASN_Choice::operator PASN_BMPString &()
  2562. {
  2563.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_BMPString::Class()), PInvalidCast);
  2564.   return *(PASN_BMPString *)choice;
  2565. }
  2568. PASN_Choice::operator PASN_Sequence &()
  2569. {
  2570.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Sequence::Class()), PInvalidCast);
  2571.   return *(PASN_Sequence *)choice;
  2572. }
  2575. PASN_Choice::operator const PASN_Null &() const
  2576. {
  2577.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Null::Class()), PInvalidCast);
  2578.   return *(const PASN_Null *)choice;
  2579. }
  2582. PASN_Choice::operator const PASN_Boolean &() const
  2583. {
  2584.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Boolean::Class()), PInvalidCast);
  2585.   return *(const PASN_Boolean *)choice;
  2586. }
  2589. PASN_Choice::operator const PASN_Integer &() const
  2590. {
  2591.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Integer::Class()), PInvalidCast);
  2592.   return *(const PASN_Integer *)choice;
  2593. }
  2596. PASN_Choice::operator const PASN_Enumeration &() const
  2597. {
  2598.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Enumeration::Class()), PInvalidCast);
  2599.   return *(const PASN_Enumeration *)choice;
  2600. }
  2603. PASN_Choice::operator const PASN_Real &() const
  2604. {
  2605.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Real::Class()), PInvalidCast);
  2606.   return *(const PASN_Real *)choice;
  2607. }
  2610. PASN_Choice::operator const PASN_ObjectId &() const
  2611. {
  2612.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_ObjectId::Class()), PInvalidCast);
  2613.   return *(const PASN_ObjectId *)choice;
  2614. }
  2617. PASN_Choice::operator const PASN_BitString &() const
  2618. {
  2619.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_BitString::Class()), PInvalidCast);
  2620.   return *(const PASN_BitString *)choice;
  2621. }
  2624. PASN_Choice::operator const PASN_OctetString &() const
  2625. {
  2626.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_OctetString::Class()), PInvalidCast);
  2627.   return *(const PASN_OctetString *)choice;
  2628. }
  2631. PASN_Choice::operator const PASN_NumericString &() const
  2632. {
  2633.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_NumericString::Class()), PInvalidCast);
  2634.   return *(const PASN_NumericString *)choice;
  2635. }
  2638. PASN_Choice::operator const PASN_PrintableString &() const
  2639. {
  2640.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_PrintableString::Class()), PInvalidCast);
  2641.   return *(const PASN_PrintableString *)choice;
  2642. }
  2645. PASN_Choice::operator const PASN_VisibleString &() const
  2646. {
  2647.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_VisibleString::Class()), PInvalidCast);
  2648.   return *(const PASN_VisibleString *)choice;
  2649. }
  2652. PASN_Choice::operator const PASN_IA5String &() const
  2653. {
  2654.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_IA5String::Class()), PInvalidCast);
  2655.   return *(const PASN_IA5String *)choice;
  2656. }
  2659. PASN_Choice::operator const PASN_GeneralString &() const
  2660. {
  2661.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_GeneralString::Class()), PInvalidCast);
  2662.   return *(const PASN_GeneralString *)choice;
  2663. }
  2666. PASN_Choice::operator const PASN_BMPString &() const
  2667. {
  2668.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_BMPString::Class()), PInvalidCast);
  2669.   return *(const PASN_BMPString *)choice;
  2670. }
  2673. PASN_Choice::operator const PASN_Sequence &() const
  2674. {
  2675.   PAssert(PAssertNULL(choice)->IsDescendant(PASN_Sequence::Class()), PInvalidCast);
  2676.   return *(const PASN_Sequence *)choice;
  2677. }
  2680. #endif
  2683. PObject::Comparison PASN_Choice::Compare(const PObject & obj) const
  2684. {
  2685.   PAssert(obj.IsDescendant(PASN_Choice::Class()), PInvalidCast);
  2686.   const PASN_Choice & other = (const PASN_Choice &)obj;
  2688.   if (choice == other.choice)
  2689.     return EqualTo;
  2691.   if (choice == NULL)
  2692.     return LessThan;
  2694.   if (other.choice == NULL)
  2695.     return GreaterThan;
  2697.   if (tag < other.tag)
  2698.     return LessThan;
  2700.   if (tag > other.tag)
  2701.     return GreaterThan;
  2703.   return choice->Compare(*other.choice);
  2704. }
  2707. void PASN_Choice::PrintOn(ostream & strm) const
  2708. {
  2709.   strm << GetTagName();
  2711.   if (choice != NULL)
  2712.     strm << ' ' << *choice;
  2713.   else
  2714.     strm << " (NULL)";
  2715. }
  2718. PString PASN_Choice::GetTypeAsString() const
  2719. {
  2720.   return "Choice";
  2721. }
  2724. PINDEX PASN_Choice::GetDataLength() const
  2725. {
  2726.   if (choice != NULL)
  2727.     return choice->GetDataLength();
  2728.   return 0;
  2729. }
  2732. BOOL PASN_Choice::IsPrimitive() const
  2733. {
  2734.   if (choice != NULL)
  2735.     return choice->IsPrimitive();
  2736.   return FALSE;
  2737. }
  2740. BOOL PASN_Choice::Decode(PASN_Stream & strm)
  2741. {
  2742.   return strm.ChoiceDecode(*this);
  2743. }
  2746. void PASN_Choice::Encode(PASN_Stream & strm) const
  2747. {
  2748.   strm.ChoiceEncode(*this);
  2749. }
  2752. BOOL PASN_Choice::DecodePER(PPER_Stream & strm)
  2753. {
  2754.   // X.691 Section 22
  2755.   delete choice;
  2757.   if (strm.IsAtEnd()) {
  2758.     choice = NULL;
  2759.     return FALSE;
  2760.   }
  2762.   BOOL ok = TRUE;
  2764.   if (extendable) {
  2765.     if (strm.SingleBitDecode()) {
  2766.       tag = strm.SmallUnsignedDecode() + numChoices;
  2767.       unsigned len;
  2768.       if (strm.LengthDecode(0, INT_MAX, len) != 0)
  2769.         return FALSE;
  2770.       if (CreateObject()) {
  2771.         PINDEX nextPos = strm.GetPosition() + len;
  2772.         ok = choice->Decode(strm);
  2773.         strm.SetPosition(nextPos);
  2774.       }
  2775.       else {
  2776.         PASN_OctetString * open_type = new PASN_OctetString;
  2777.         open_type->SetConstraints(PASN_ConstrainedObject::FixedConstraint, len, len);
  2778.         open_type->Decode(strm);
  2779.         if (open_type->GetSize() > 0)
  2780.           choice = open_type;
  2781.         else {
  2782.           delete open_type;
  2783.           ok = FALSE;
  2784.         }
  2785.       }
  2786.       return ok;
  2787.     }
  2788.   }
  2790.   if (numChoices < 2)
  2791.     tag = 0;
  2792.   else {
  2793.     if (strm.UnsignedDecode(0, numChoices-1, tag) < 0)
  2794.       return FALSE;
  2795.   }
  2797.   if (CreateObject())
  2798.     ok = choice->Decode(strm);
  2800.   return ok;
  2801. }
  2804. void PASN_Choice::EncodePER(PPER_Stream & strm) const
  2805. {
  2806.   PAssert(tag != UINT_MAX, PLogicError);
  2808.   if (extendable) {
  2809.     BOOL extended = tag >= numChoices;
  2810.     strm.SingleBitEncode(extended);
  2811.     if (extended) {
  2812.       strm.SmallUnsignedEncode(tag - numChoices);
  2813.       strm.AnyTypeEncode(choice);
  2814.       return;
  2815.     }
  2816.   }
  2818.   if (numChoices > 1)
  2819.     strm.UnsignedEncode(tag, 0, numChoices-1);
  2821.   if (choice != NULL)
  2822.     choice->Encode(strm);
  2823. }
  2826. BOOL PBER_Stream::ChoiceDecode(PASN_Choice & value)
  2827. {
  2828.   PINDEX savedPosition = GetPosition();
  2830.   unsigned tag;
  2831.   PASN_Object::TagClass tagClass;
  2832.   BOOL primitive;
  2833.   unsigned entryLen;
  2834.   if (!HeaderDecode(tag, tagClass, primitive, entryLen))
  2835.     return FALSE;
  2837.   SetPosition(savedPosition);
  2839.   value.SetTag(tag, tagClass);
  2840.   if (value.IsValid())
  2841.     return value.GetObject().Decode(*this);
  2843.   return TRUE;
  2844. }
  2847. void PBER_Stream::ChoiceEncode(const PASN_Choice & value)
  2848. {
  2849.   if (value.IsValid())
  2850.     value.GetObject().Encode(*this);
  2851. }
  2854. BOOL PPER_Stream::ChoiceDecode(PASN_Choice & value)
  2855. {
  2856.   return value.DecodePER(*this);
  2857. }
  2860. void PPER_Stream::ChoiceEncode(const PASN_Choice & value)
  2861. {
  2862.   value.EncodePER(*this);
  2863. }
  2866. ///////////////////////////////////////////////////////////////////////
  2868. PASN_Sequence::PASN_Sequence(unsigned tag, TagClass tagClass,
  2869.                              unsigned nOpts, BOOL extend, unsigned nExtend)
  2870.   : PASN_Object(tag, tagClass, extend)
  2871. {
  2872.   optionMap.SetConstraints(PASN_ConstrainedObject::FixedConstraint, nOpts, nOpts);
  2873.   knownExtensions = nExtend;
  2874.   totalExtensions = 0;
  2875.   endBasicEncoding = 0;
  2876. }
  2879. PASN_Sequence::PASN_Sequence(const PASN_Sequence & other)
  2880.   : PASN_Object(other),
  2881.     fields(other.fields.GetSize()),
  2882.     optionMap(other.optionMap),
  2883.     extensionMap(other.extensionMap)
  2884. {
  2885.   for (PINDEX i = 0; i < other.fields.GetSize(); i++)
  2886.     fields.SetAt(i, other.fields[i].Clone());
  2888.   knownExtensions = other.knownExtensions;
  2889.   totalExtensions = other.totalExtensions;
  2890.   endBasicEncoding = 0;
  2891. }
  2894. PASN_Sequence & PASN_Sequence::operator=(const PASN_Sequence & other)
  2895. {
  2896.   PASN_Object::operator=(other);
  2898.   fields.SetSize(other.fields.GetSize());
  2899.   for (PINDEX i = 0; i < other.fields.GetSize(); i++)
  2900.     fields.SetAt(i, other.fields[i].Clone());
  2902.   optionMap = other.optionMap;
  2903.   knownExtensions = other.knownExtensions;
  2904.   totalExtensions = other.totalExtensions;
  2905.   extensionMap = other.extensionMap;
  2907.   return *this;
  2908. }
  2911. BOOL PASN_Sequence::HasOptionalField(PINDEX opt) const
  2912. {
  2913.   if (opt < (PINDEX)optionMap.GetSize())
  2914.     return optionMap[opt];
  2915.   else
  2916.     return extensionMap[opt - optionMap.GetSize()];
  2917. }
  2920. void PASN_Sequence::IncludeOptionalField(PINDEX opt)
  2921. {
  2922.   if (opt < (PINDEX)optionMap.GetSize())
  2923.     optionMap.Set(opt);
  2924.   else {
  2925.     PAssert(extendable, "Must be extendable type");
  2926.     opt -= optionMap.GetSize();
  2927.     if (opt >= (PINDEX)extensionMap.GetSize())
  2928.       extensionMap.SetSize(opt+1);
  2929.     extensionMap.Set(opt);
  2930.   }
  2931. }
  2934. void PASN_Sequence::RemoveOptionalField(PINDEX opt)
  2935. {
  2936.   if (opt < (PINDEX)optionMap.GetSize())
  2937.     optionMap.Clear(opt);
  2938.   else {
  2939.     PAssert(extendable, "Must be extendable type");
  2940.     opt -= optionMap.GetSize();
  2941.     extensionMap.Clear(opt);
  2942.   }
  2943. }
  2946. PObject::Comparison PASN_Sequence::Compare(const PObject & obj) const
  2947. {
  2948.   PAssert(obj.IsDescendant(PASN_Sequence::Class()), PInvalidCast);
  2949.   const PASN_Sequence & other = (const PASN_Sequence &)obj;
  2950.   return fields.Compare(other.fields);
  2951. }
  2954. PObject * PASN_Sequence::Clone() const
  2955. {
  2956.   PAssert(IsClass(PASN_Sequence::Class()), PInvalidCast);
  2957.   return new PASN_Sequence(*this);
  2958. }
  2961. void PASN_Sequence::PrintOn(ostream & strm) const
  2962. {
  2963.   int indent = strm.precision() + 2;
  2964.   strm << "{n";
  2965.   for (PINDEX i = 0; i < fields.GetSize(); i++) {
  2966.     strm << setw(indent+6) << "field[" << i << "] <";
  2967.     switch (fields[i].GetTagClass()) {
  2968.       case UniversalTagClass :
  2969.         strm << "Universal";
  2970.         break;
  2971.       case ApplicationTagClass :
  2972.         strm << "Application";
  2973.         break;
  2974.       case ContextSpecificTagClass :
  2975.         strm << "ContextSpecific";
  2976.         break;
  2977.       case PrivateTagClass :
  2978.         strm << "Private";
  2979.       default :
  2980.         break;
  2981.     }
  2982.     strm << '-' << fields[i].GetTag() << '-'
  2983.          << fields[i].GetTypeAsString() << "> = "
  2984.          << fields[i] << 'n';
  2985.   }
  2986.   strm << setw(indent-1) << "}";
  2987. }
  2990. PString PASN_Sequence::GetTypeAsString() const
  2991. {
  2992.   return "Sequence";
  2993. }
  2996. PINDEX PASN_Sequence::GetDataLength() const
  2997. {
  2998.   PINDEX len = 0;
  2999.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  3000.     len += fields[i].GetObjectLength();
  3001.   return len;
  3002. }
  3005. BOOL PASN_Sequence::IsPrimitive() const
  3006. {
  3007.   return FALSE;
  3008. }
  3011. BOOL PASN_Sequence::Decode(PASN_Stream & strm)
  3012. {
  3013.   return PreambleDecode(strm) && UnknownExtensionsDecode(strm);
  3014. }
  3017. void PASN_Sequence::Encode(PASN_Stream & strm) const
  3018. {
  3019.   PreambleEncode(strm);
  3020.   UnknownExtensionsEncode(strm);
  3021. }
  3024. BOOL PASN_Sequence::PreambleDecode(PASN_Stream & strm)
  3025. {
  3026.   return strm.SequencePreambleDecode(*this);
  3027. }
  3030. void PASN_Sequence::PreambleEncode(PASN_Stream & strm) const
  3031. {
  3032.   strm.SequencePreambleEncode(*this);
  3033. }
  3036. BOOL PASN_Sequence::KnownExtensionDecode(PASN_Stream & strm, PINDEX fld, PASN_Object & field)
  3037. {
  3038.   return strm.SequenceKnownDecode(*this, fld, field);
  3039. }
  3042. void PASN_Sequence::KnownExtensionEncode(PASN_Stream & strm, PINDEX fld, const PASN_Object & field) const
  3043. {
  3044.   strm.SequenceKnownEncode(*this, fld, field);
  3045. }
  3048. BOOL PASN_Sequence::UnknownExtensionsDecode(PASN_Stream & strm)
  3049. {
  3050.   return strm.SequenceUnknownDecode(*this);
  3051. }
  3054. void PASN_Sequence::UnknownExtensionsEncode(PASN_Stream & strm) const
  3055. {
  3056.   strm.SequenceUnknownEncode(*this);
  3057. }
  3060. BOOL PASN_Sequence::PreambleDecodeBER(PBER_Stream & strm)
  3061. {
  3062.   fields.RemoveAll();
  3064.   unsigned len;
  3065.   if (!strm.HeaderDecode(*this, len))
  3066.     return FALSE;
  3068.   endBasicEncoding = strm.GetPosition() + len;
  3069.   return !strm.IsAtEnd();
  3070. }
  3073. void PASN_Sequence::PreambleEncodeBER(PBER_Stream & strm) const
  3074. {
  3075.   strm.HeaderEncode(*this);
  3076. }
  3079. BOOL PASN_Sequence::KnownExtensionDecodeBER(PBER_Stream & strm, PINDEX, PASN_Object & field)
  3080. {
  3081.   if (strm.GetPosition() >= endBasicEncoding)
  3082.     return FALSE;
  3084.   return field.Decode(strm);
  3085. }
  3088. void PASN_Sequence::KnownExtensionEncodeBER(PBER_Stream & strm, PINDEX, const PASN_Object & field) const
  3089. {
  3090.   field.Encode(strm);
  3091. }
  3094. BOOL PASN_Sequence::UnknownExtensionsDecodeBER(PBER_Stream & strm)
  3095. {
  3096.   while (strm.GetPosition() < endBasicEncoding) {
  3097.     PINDEX savedPosition = strm.GetPosition();
  3099.     unsigned tag;
  3100.     PASN_Object::TagClass tagClass;
  3101.     BOOL primitive;
  3102.     unsigned entryLen;
  3103.     if (!strm.HeaderDecode(tag, tagClass, primitive, entryLen))
  3104.       return FALSE;
  3106.     PINDEX nextEntryPosition = strm.GetPosition() + entryLen;
  3107.     strm.SetPosition(savedPosition);
  3109.     PASN_Object * obj = strm.CreateObject(tag, tagClass, primitive);
  3110.     if (obj == NULL)
  3111.       strm.SetPosition(nextEntryPosition);
  3112.     else {
  3113.       if (!obj->Decode(strm))
  3114.         return FALSE;
  3116.       fields.Append(obj);
  3117.     }
  3118.   }
  3120.   return TRUE;
  3121. }
  3124. void PASN_Sequence::UnknownExtensionsEncodeBER(PBER_Stream & strm) const
  3125. {
  3126.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  3127.     fields[i].Encode(strm);
  3128. }
  3131. BOOL PASN_Sequence::PreambleDecodePER(PPER_Stream & strm)
  3132. {
  3133.   // X.691 Section 18
  3135.   if (extendable) {
  3136.     if (strm.IsAtEnd())
  3137.       return FALSE;
  3138.     totalExtensions = strm.SingleBitDecode() ? -1 : 0;  // 18.1
  3139.   }
  3140.   else
  3141.     totalExtensions = 0;
  3142.   return optionMap.Decode(strm);  // 18.2
  3143. }
  3146. void PASN_Sequence::PreambleEncodePER(PPER_Stream & strm) const
  3147. {
  3148.   // X.691 Section 18
  3150.   if (extendable) {
  3151.     BOOL hasExtensions = FALSE;
  3152.     for (unsigned i = 0; i < extensionMap.GetSize(); i++) {
  3153.       if (extensionMap[i]) {
  3154.         hasExtensions = TRUE;
  3155.         break;
  3156.       }
  3157.     }
  3158.     strm.SingleBitEncode(hasExtensions);  // 18.1
  3159.     ((PASN_Sequence*)this)->totalExtensions = hasExtensions ? -1 : 0;
  3160.   }
  3161.   optionMap.Encode(strm);  // 18.2
  3162. }
  3165. BOOL PASN_Sequence::NoExtensionsToDecode(PPER_Stream & strm)
  3166. {
  3167.   if (totalExtensions == 0)
  3168.     return TRUE;
  3170.   if (totalExtensions < 0) {
  3171.     totalExtensions = strm.SmallUnsignedDecode() + 1;
  3172.     extensionMap.SetConstraints(PASN_ConstrainedObject::FixedConstraint,
  3173.                                 totalExtensions, totalExtensions);
  3174.     extensionMap.Decode(strm);
  3175.   }
  3177.   return FALSE;
  3178. }
  3181. BOOL PASN_Sequence::NoExtensionsToEncode(PPER_Stream & strm)
  3182. {
  3183.   if (totalExtensions == 0)
  3184.     return TRUE;
  3186.   if (totalExtensions < 0) {
  3187.     totalExtensions = extensionMap.GetSize();
  3188.     strm.SmallUnsignedEncode(totalExtensions-1);
  3189.     extensionMap.SetConstraints(PASN_ConstrainedObject::FixedConstraint,
  3190.                                 totalExtensions, totalExtensions);
  3191.     extensionMap.Encode(strm);
  3192.   }
  3194.   return FALSE;
  3195. }
  3198. BOOL PASN_Sequence::KnownExtensionDecodePER(PPER_Stream & strm, PINDEX fld, PASN_Object & field)
  3199. {
  3200.   if (NoExtensionsToDecode(strm))
  3201.     return TRUE;
  3203.   if (!extensionMap[fld-optionMap.GetSize()])
  3204.     return TRUE;
  3206.   unsigned len;
  3207.   if (strm.LengthDecode(0, INT_MAX, len) != 0)
  3208.     return FALSE;
  3210.   PINDEX nextExtensionPosition = strm.GetPosition() + len;
  3211.   BOOL ok = field.Decode(strm);
  3212.   strm.SetPosition(nextExtensionPosition);
  3213.   return ok;
  3214. }
  3217. void PASN_Sequence::KnownExtensionEncodePER(PPER_Stream & strm, PINDEX fld, const PASN_Object & field) const
  3218. {
  3219.   if (((PASN_Sequence*)this)->NoExtensionsToEncode(strm))
  3220.     return;
  3222.   if (!extensionMap[fld-optionMap.GetSize()])
  3223.     return;
  3225.   strm.AnyTypeEncode(&field);
  3226. }
  3229. BOOL PASN_Sequence::UnknownExtensionsDecodePER(PPER_Stream & strm)
  3230. {
  3231.   if (NoExtensionsToDecode(strm))
  3232.     return TRUE;
  3234.   if (totalExtensions <= knownExtensions)
  3235.     return TRUE;  // Already read them
  3237.   PINDEX unknownCount = totalExtensions - knownExtensions;
  3238.   if (fields.GetSize() >= unknownCount)
  3239.     return TRUE;  // Already read them
  3241.   fields.SetSize(unknownCount);
  3243.   PINDEX i;
  3244.   for (i = 0; i < fields.GetSize(); i++)
  3245.     fields.SetAt(i, new PASN_OctetString);
  3247.   for (i = knownExtensions; i < (PINDEX)extensionMap.GetSize(); i++) {
  3248.     if (extensionMap[i])
  3249.       if (!fields[i-knownExtensions].Decode(strm))
  3250.         return FALSE;
  3251.   }
  3253.   return TRUE;
  3254. }
  3257. void PASN_Sequence::UnknownExtensionsEncodePER(PPER_Stream & strm) const
  3258. {
  3259.   if (((PASN_Sequence*)this)->NoExtensionsToEncode(strm))
  3260.     return;
  3262.   int i;
  3263.   for (i = knownExtensions; i < totalExtensions; i++) {
  3264.     if (extensionMap[i])
  3265.       fields[i-knownExtensions].Encode(strm);
  3266.   }
  3267. }
  3270. BOOL PBER_Stream::SequencePreambleDecode(PASN_Sequence & seq)
  3271. {
  3272.   return seq.PreambleDecodeBER(*this);
  3273. }
  3276. void PBER_Stream::SequencePreambleEncode(const PASN_Sequence & seq)
  3277. {
  3278.   seq.PreambleEncodeBER(*this);
  3279. }
  3282. BOOL PBER_Stream::SequenceKnownDecode(PASN_Sequence & seq, PINDEX fld, PASN_Object & field)
  3283. {
  3284.   return seq.KnownExtensionDecodeBER(*this, fld, field);
  3285. }
  3288. void PBER_Stream::SequenceKnownEncode(const PASN_Sequence & seq, PINDEX fld, const PASN_Object & field)
  3289. {
  3290.   seq.KnownExtensionEncodeBER(*this, fld, field);
  3291. }
  3294. BOOL PBER_Stream::SequenceUnknownDecode(PASN_Sequence & seq)
  3295. {
  3296.   return seq.UnknownExtensionsDecodeBER(*this);
  3297. }
  3300. void PBER_Stream::SequenceUnknownEncode(const PASN_Sequence & seq)
  3301. {
  3302.   seq.UnknownExtensionsEncodeBER(*this);
  3303. }
  3306. BOOL PPER_Stream::SequencePreambleDecode(PASN_Sequence & seq)
  3307. {
  3308.   return seq.PreambleDecodePER(*this);
  3309. }
  3312. void PPER_Stream::SequencePreambleEncode(const PASN_Sequence & seq)
  3313. {
  3314.   seq.PreambleEncodePER(*this);
  3315. }
  3318. BOOL PPER_Stream::SequenceKnownDecode(PASN_Sequence & seq, PINDEX fld, PASN_Object & field)
  3319. {
  3320.   return seq.KnownExtensionDecodePER(*this, fld, field);
  3321. }
  3324. void PPER_Stream::SequenceKnownEncode(const PASN_Sequence & seq, PINDEX fld, const PASN_Object & field)
  3325. {
  3326.   seq.KnownExtensionEncodePER(*this, fld, field);
  3327. }
  3330. BOOL PPER_Stream::SequenceUnknownDecode(PASN_Sequence & seq)
  3331. {
  3332.   return seq.UnknownExtensionsDecodePER(*this);
  3333. }
  3336. void PPER_Stream::SequenceUnknownEncode(const PASN_Sequence & seq)
  3337. {
  3338.   seq.UnknownExtensionsEncodePER(*this);
  3339. }
  3342. ///////////////////////////////////////////////////////////////////////
  3344. PASN_Set::PASN_Set(unsigned tag, TagClass tagClass,
  3345.                    unsigned nOpts, BOOL extend, unsigned nExtend)
  3346.   : PASN_Sequence(tag, tagClass, nOpts, extend, nExtend)
  3347. {
  3348. }
  3351. PObject * PASN_Set::Clone() const
  3352. {
  3353.   PAssert(IsClass(PASN_Set::Class()), PInvalidCast);
  3354.   return new PASN_Set(*this);
  3355. }
  3358. PString PASN_Set::GetTypeAsString() const
  3359. {
  3360.   return "Set";
  3361. }
  3364. ///////////////////////////////////////////////////////////////////////
  3366. PASN_Array::PASN_Array(unsigned tag, TagClass tagClass)
  3367.   : PASN_ConstrainedObject(tag, tagClass)
  3368. {
  3369. }
  3372. PASN_Array::PASN_Array(const PASN_Array & other)
  3373.   : PASN_ConstrainedObject(other),
  3374.     array(other.array.GetSize())
  3375. {
  3376.   for (PINDEX i = 0; i < other.array.GetSize(); i++)
  3377.     array.SetAt(i, other.array[i].Clone());
  3378. }
  3381. PASN_Array & PASN_Array::operator=(const PASN_Array & other)
  3382. {
  3383.   PASN_ConstrainedObject::operator=(other);
  3385.   array.SetSize(other.array.GetSize());
  3386.   for (PINDEX i = 0; i < other.array.GetSize(); i++)
  3387.     array.SetAt(i, other.array[i].Clone());
  3389.   return *this;
  3390. }
  3393. void PASN_Array::SetSize(PINDEX newSize)
  3394. {
  3395.   PINDEX originalSize = array.GetSize();
  3396.   array.SetSize(newSize);
  3397.   for (PINDEX i = originalSize; i < newSize; i++)
  3398.     array.SetAt(i, CreateObject());
  3399. }
  3402. PObject::Comparison PASN_Array::Compare(const PObject & obj) const
  3403. {
  3404.   PAssert(obj.IsDescendant(PASN_Array::Class()), PInvalidCast);
  3405.   const PASN_Array & other = (const PASN_Array &)obj;
  3406.   return array.Compare(other.array);
  3407. }
  3410. void PASN_Array::PrintOn(ostream & strm) const
  3411. {
  3412.   int indent = strm.precision() + 2;
  3413.   strm << array.GetSize() << " entries {n";
  3414.   for (PINDEX i = 0; i < array.GetSize(); i++)
  3415.     strm << setw(indent+1) << "[" << i << "]=" << setprecision(indent) << array[i] << 'n';
  3416.   strm << setw(indent-1) << "}";
  3417. }
  3420. PString PASN_Array::GetTypeAsString() const
  3421. {
  3422.   return "Array";
  3423. }
  3426. PINDEX PASN_Array::GetDataLength() const
  3427. {
  3428.   PINDEX len = 0;
  3429.   for (PINDEX i = 0; i < array.GetSize(); i++)
  3430.     len += array[i].GetObjectLength();
  3431.   return len;
  3432. }
  3435. BOOL PASN_Array::IsPrimitive() const
  3436. {
  3437.   return FALSE;
  3438. }
  3441. BOOL PASN_Array::Decode(PASN_Stream & strm)
  3442. {
  3443.   return strm.ArrayDecode(*this);
  3444. }
  3447. void PASN_Array::Encode(PASN_Stream & strm) const
  3448. {
  3449.   strm.ArrayEncode(*this);
  3450. }
  3453. BOOL PBER_Stream::ArrayDecode(PASN_Array & array)
  3454. {
  3455.   array.RemoveAll();
  3457.   unsigned len;
  3458.   if (!HeaderDecode(array, len))
  3459.     return FALSE;
  3461.   PINDEX endOffset = byteOffset + len;
  3462.   PINDEX count = 0;
  3463.   while (byteOffset < endOffset) {
  3464.     array.SetSize(count+1);
  3465.     if (!array[count].Decode(*this))
  3466.       return FALSE;
  3467.     count++;
  3468.   }
  3470.   byteOffset = endOffset;
  3472.   return TRUE;
  3473. }
  3476. void PBER_Stream::ArrayEncode(const PASN_Array & array)
  3477. {
  3478.   HeaderEncode(array);
  3479.   for (PINDEX i = 0; i < array.GetSize(); i++)
  3480.     array[i].Encode(*this);
  3481. }
  3484. BOOL PPER_Stream::ArrayDecode(PASN_Array & array)
  3485. {
  3486.   array.RemoveAll();
  3488.   unsigned size;
  3489.   if (array.ConstrainedLengthDecode(*this, size) < 0)
  3490.     return FALSE;
  3492.   array.SetSize(size);
  3494.   for (PINDEX i = 0; i < (PINDEX)size; i++) {
  3495.     if (!array[i].Decode(*this))
  3496.       return FALSE;
  3497.   }
  3499.   return TRUE;
  3500. }
  3503. void PPER_Stream::ArrayEncode(const PASN_Array & array)
  3504. {
  3505.   PINDEX size = array.GetSize();
  3506.   array.ConstrainedLengthEncode(*this, size);
  3507.   for (PINDEX i = 0; i < size; i++)
  3508.     array[i].Encode(*this);
  3509. }
  3512. ///////////////////////////////////////////////////////////////////////
  3514. PASN_Stream::PASN_Stream()
  3515. {
  3516.   Construct();
  3517. }
  3520. PASN_Stream::PASN_Stream(const PBYTEArray & bytes)
  3521.   : PBYTEArray(bytes)
  3522. {
  3523.   Construct();
  3524. }
  3527. PASN_Stream::PASN_Stream(const BYTE * buf, PINDEX size)
  3528.   : PBYTEArray(buf, size)
  3529. {
  3530.   Construct();
  3531. }
  3534. void PASN_Stream::Construct()
  3535. {
  3536.   byteOffset = 0;
  3537.   bitOffset = 8;
  3538. }
  3541. void PASN_Stream::PrintOn(ostream & strm) const
  3542. {
  3543.   int indent = strm.precision() + 2;
  3544.   strm << " size=" << GetSize()
  3545.        << " pos=" << byteOffset << '.' << (8-bitOffset)
  3546.        << " {n";
  3547.   PINDEX i = 0;
  3548.   while (i < GetSize()) {
  3549.     strm << setw(indent) << " " << hex << setfill('0');
  3550.     PINDEX j;
  3551.     for (j = 0; j < 16; j++)
  3552.       if (i+j < GetSize())
  3553.         strm << setw(2) << (unsigned)(BYTE)theArray[i+j] << ' ';
  3554.       else
  3555.         strm << "   ";
  3556.     strm << "  ";
  3557.     for (j = 0; j < 16; j++) {
  3558.       if (i+j < GetSize()) {
  3559.         if (isprint(theArray[i+j]))
  3560.           strm << theArray[i+j];
  3561.         else
  3562.           strm << ' ';
  3563.       }
  3564.     }
  3565.     strm << dec << setfill(' ') << 'n';
  3566.     i += 16;
  3567.   }
  3568.   strm << setw(indent-1) << "}";
  3569. }
  3572. void PASN_Stream::SetPosition(PINDEX newPos)
  3573. {
  3574.   PAssert(byteOffset != P_MAX_INDEX, PLogicError);
  3576.   if (newPos > GetSize())
  3577.     byteOffset = GetSize();
  3578.   else
  3579.     byteOffset = newPos;
  3580.   bitOffset = 8;
  3581. }
  3584. void PASN_Stream::ResetDecoder()
  3585. {
  3586.   byteOffset = 0;
  3587.   bitOffset = 8;
  3588. }
  3591. void PASN_Stream::BeginEncoding()
  3592. {
  3593.   bitOffset = 8;
  3594.   byteOffset = 0;
  3595.   PBYTEArray::operator=(PBYTEArray(20));
  3596. }
  3599. void PASN_Stream::CompleteEncoding()
  3600. {
  3601.   if (byteOffset != P_MAX_INDEX) {
  3602.     if (bitOffset != 8) {
  3603.       bitOffset = 8;
  3604.       byteOffset++;
  3605.     }
  3606.     SetSize(byteOffset);
  3607.     byteOffset = P_MAX_INDEX;
  3608.   }
  3609. }
  3612. BYTE PASN_Stream::ByteDecode()
  3613. {
  3614.   if (byteOffset >= GetSize())
  3615.     return 0;
  3617.   bitOffset = 8;
  3618.   return theArray[byteOffset++];
  3619. }
  3622. void PASN_Stream::ByteEncode(unsigned value)
  3623. {
  3624.   PAssert(byteOffset != P_MAX_INDEX, PLogicError);
  3626.   if (bitOffset != 8) {
  3627.     bitOffset = 8;
  3628.     byteOffset++;
  3629.   }
  3630.   if (byteOffset >= GetSize())
  3631.     SetSize(byteOffset+10);
  3632.   theArray[byteOffset++] = (BYTE)value;
  3633. }
  3636. unsigned PASN_Stream::BlockDecode(BYTE * bufptr, unsigned nBytes)
  3637. {
  3638.   ByteAlign();
  3640.   if (byteOffset+nBytes > (unsigned)GetSize())
  3641.     nBytes = GetSize() - byteOffset;
  3643.   if (nBytes == 0)
  3644.     return 0;
  3646.   memcpy(bufptr, &theArray[byteOffset], nBytes);
  3647.   byteOffset += nBytes;
  3648.   return nBytes;
  3649. }
  3652. void PASN_Stream::BlockEncode(const BYTE * bufptr, PINDEX nBytes)
  3653. {
  3654.   PAssert(byteOffset != P_MAX_INDEX, PLogicError);
  3656.   if (nBytes == 0)
  3657.     return;
  3659.   ByteAlign();
  3660.   if (byteOffset+nBytes >= GetSize())
  3661.     SetSize(byteOffset+nBytes+10);
  3663.   memcpy(theArray+byteOffset, bufptr, nBytes);
  3664.   byteOffset += nBytes;
  3665. }
  3668. void PASN_Stream::ByteAlign()
  3669. {
  3670.   PAssert(byteOffset != P_MAX_INDEX, PLogicError);
  3672.   if (bitOffset != 8) {
  3673.     bitOffset = 8;
  3674.     byteOffset++;
  3675.   }
  3676. }
  3679. ///////////////////////////////////////////////////////////////////////
  3681. PBER_Stream::PBER_Stream()
  3682. {
  3683. }
  3686. PBER_Stream::PBER_Stream(const PBYTEArray & bytes)
  3687.   : PASN_Stream(bytes)
  3688. {
  3689. }
  3692. PBER_Stream::PBER_Stream(const BYTE * buf, PINDEX size)
  3693.   : PASN_Stream(buf, size)
  3694. {
  3695. }
  3698. PBER_Stream & PBER_Stream::operator=(const PBYTEArray & bytes)
  3699. {
  3700.   PBYTEArray::operator=(bytes);
  3701.   ResetDecoder();
  3702.   return *this;
  3703. }
  3706. BOOL PBER_Stream::Read(PChannel & chan)
  3707. {
  3708.   SetSize(0);
  3709.   PINDEX offset = 0;
  3711.   // read the sequence header
  3712.   int b;
  3713.   if ((b = chan.ReadChar()) < 0)
  3714.     return FALSE;
  3716.   SetAt(offset++, (char)b);
  3718.   // only support direct read of simple sequences
  3719.   if ((b&0x1f) == 0x1f) {
  3720.     do {
  3721.       if ((b = chan.ReadChar()) < 0)
  3722.         return FALSE;
  3723.       SetAt(offset++, (char)b);
  3724.     } while ((b & 0x80) != 0);
  3725.   }
  3727.   // read the first byte of the ASN length
  3728.   if ((b = chan.ReadChar()) < 0)
  3729.     return FALSE;
  3731.   SetAt(offset++, (char)b);
  3733.   // determine how many bytes in the length
  3734.   PINDEX dataLen = 0;
  3735.   if ((b & 0x80) == 0)
  3736.     dataLen = b;
  3737.   else {
  3738.     PINDEX lenLen = b&0x7f;
  3739.     SetSize(lenLen+2);
  3740.     while (lenLen-- > 0) {
  3741.       // read the length
  3742.       if ((b = chan.ReadChar()) < 0)
  3743.         return FALSE;
  3744.       dataLen = (dataLen << 8) | b;
  3745.       SetAt(offset++, (char)b);
  3746.     }
  3747.   }
  3749.   // read the data, all of it
  3750.   BYTE * bufptr = GetPointer(dataLen+offset) + offset;
  3751.   while (dataLen > 0) {
  3752.     if (!chan.Read(bufptr, dataLen))
  3753.       return FALSE;
  3754.     PINDEX readbytes = chan.GetLastReadCount();
  3755.     bufptr += readbytes;
  3756.     dataLen -= readbytes;
  3757.   }
  3758.   return TRUE;
  3759. }
  3762. BOOL PBER_Stream::Write(PChannel & chan)
  3763. {
  3764.   CompleteEncoding();
  3765.   return chan.Write(theArray, GetSize());
  3766. }
  3769. PASN_Object * PBER_Stream::CreateObject(unsigned tag,
  3770.                                         PASN_Object::TagClass tagClass,
  3771.                                         BOOL primitive) const
  3772. {
  3773.   if (tagClass == PASN_Object::UniversalTagClass) {
  3774.     switch (tag) {
  3775.       case PASN_Object::UniversalBoolean :
  3776.         return new PASN_Boolean();
  3778.       case PASN_Object::UniversalInteger :
  3779.         return new PASN_Integer();
  3781.       case PASN_Object::UniversalBitString :
  3782.         return new PASN_BitString();
  3784.       case PASN_Object::UniversalOctetString :
  3785.         return new PASN_OctetString();
  3787.       case PASN_Object::UniversalNull :
  3788.         return new PASN_Null();
  3790.       case PASN_Object::UniversalObjectId :
  3791.         return new PASN_ObjectId();
  3793.       case PASN_Object::UniversalReal :
  3794.         return new PASN_Real();
  3796.       case PASN_Object::UniversalEnumeration :
  3797.         return new PASN_Enumeration();
  3799.       case PASN_Object::UniversalSequence :
  3800.         return new PASN_Sequence();
  3802.       case PASN_Object::UniversalSet :
  3803.         return new PASN_Set();
  3805.       case PASN_Object::UniversalNumericString :
  3806.         return new PASN_NumericString();
  3808.       case PASN_Object::UniversalPrintableString :
  3809.         return new PASN_PrintableString();
  3811.       case PASN_Object::UniversalIA5String :
  3812.         return new PASN_IA5String();
  3814.       case PASN_Object::UniversalVisibleString :
  3815.         return new PASN_VisibleString();
  3817.       case PASN_Object::UniversalGeneralString :
  3818.         return new PASN_GeneralString();
  3820.       case PASN_Object::UniversalBMPString :
  3821.         return new PASN_BMPString();
  3822.     }
  3823.   }
  3825.   if (primitive)
  3826.     return new PASN_OctetString(tag, tagClass);
  3827.   else
  3828.     return new PASN_Sequence(tag, tagClass, 0, FALSE, 0);
  3829. }
  3832. BOOL PBER_Stream::HeaderDecode(unsigned & tagVal,
  3833.                                PASN_Object::TagClass & tagClass,
  3834.                                BOOL & primitive,
  3835.                                unsigned & len)
  3836. {
  3837.   BYTE ident = ByteDecode();
  3838.   tagClass = (PASN_Object::TagClass)(ident>>6);
  3839.   primitive = (ident&0x20) == 0;
  3840.   tagVal = ident&31;
  3841.   if (tagVal == 31) {
  3842.     BYTE b;
  3843.     tagVal = 0;
  3844.     do {
  3845.       if (IsAtEnd())
  3846.         return FALSE;
  3848.       b = ByteDecode();
  3849.       tagVal = (tagVal << 7) | (b&0x7f);
  3850.     } while ((b&0x80) != 0);
  3851.   }
  3853.   if (IsAtEnd())
  3854.     return FALSE;
  3856.   BYTE len_len = ByteDecode();
  3857.   if ((len_len & 0x80) == 0) {
  3858.     len = len_len;
  3859.     return TRUE;
  3860.   }
  3862.   len_len &= 0x7f;
  3864.   len = 0;
  3865.   while (len_len-- > 0) {
  3866.     if (IsAtEnd())
  3867.       return FALSE;
  3869.     len = (len << 8) | ByteDecode();
  3870.   }
  3872.   return TRUE;
  3873. }
  3876. BOOL PBER_Stream::HeaderDecode(PASN_Object & obj, unsigned & len)
  3877. {
  3878.   PINDEX pos = byteOffset;
  3880.   unsigned tagVal;
  3881.   PASN_Object::TagClass tagClass;
  3882.   BOOL primitive;
  3883.   if (HeaderDecode(tagVal, tagClass, primitive, len) &&
  3884.               tagVal == obj.GetTag() && tagClass == obj.GetTagClass())
  3885.     return TRUE;
  3887.   byteOffset = pos;
  3888.   return FALSE;
  3889. }
  3892. void PBER_Stream::HeaderEncode(const PASN_Object & obj)
  3893. {
  3894.   BYTE ident = (BYTE)(obj.GetTagClass() << 6);
  3895.   if (!obj.IsPrimitive())
  3896.     ident |= 0x20;
  3897.   unsigned tag = obj.GetTag();
  3898.   if (tag < 31)
  3899.     ByteEncode(ident|tag);
  3900.   else {
  3901.     ByteEncode(ident|31);
  3902.     unsigned count = (CountBits(tag)+6)/7;
  3903.     while (count-- > 1)
  3904.       ByteEncode((tag >> (count*7))&0x7f);
  3905.     ByteEncode(tag&0x7f);
  3906.   }
  3908.   PINDEX len = obj.GetDataLength();
  3909.   if (len < 128)
  3910.     ByteEncode(len);
  3911.   else {
  3912.     PINDEX count = (CountBits(len+1)+7)/8;
  3913.     ByteEncode(count|0x80);
  3914.     while (count-- > 0)
  3915.       ByteEncode(len >> (count*8));
  3916.   }
  3917. }
  3921. ///////////////////////////////////////////////////////////////////////
  3923. PPER_Stream::PPER_Stream(BOOL alignment)
  3924. {
  3925.   aligned = alignment;
  3926. }
  3929. PPER_Stream::PPER_Stream(const PBYTEArray & bytes, BOOL alignment)
  3930.   : PASN_Stream(bytes)
  3931. {
  3932.   aligned = alignment;
  3933. }
  3936. PPER_Stream::PPER_Stream(const BYTE * buf, PINDEX size, BOOL alignment)
  3937.   : PASN_Stream(buf, size)
  3938. {
  3939.   aligned = alignment;
  3940. }
  3943. PPER_Stream & PPER_Stream::operator=(const PBYTEArray & bytes)
  3944. {
  3945.   PBYTEArray::operator=(bytes);
  3946.   ResetDecoder();
  3947.   aligned = TRUE;
  3948.   return *this;
  3949. }
  3952. unsigned PPER_Stream::GetBitsLeft() const
  3953. {
  3954.   return (GetSize() - byteOffset)*8 - (8 - bitOffset);
  3955. }
  3958. BOOL PPER_Stream::Read(PChannel & chan)
  3959. {
  3960.   ResetDecoder();
  3961.   SetSize(0);
  3963.   // Get RFC1006 TPKT length
  3964.   BYTE tpkt[4];
  3965.   if (!chan.ReadBlock(tpkt, sizeof(tpkt)))
  3966.     return FALSE;
  3968.   if (tpkt[0] != 3) // Only support version 3
  3969.     return TRUE;
  3971.   PINDEX data_len = ((tpkt[2] << 8)|tpkt[3]) - 4;
  3973.   return chan.ReadBlock(GetPointer(data_len), data_len);
  3974. }
  3977. BOOL PPER_Stream::Write(PChannel & chan)
  3978. {
  3979.   CompleteEncoding();
  3981.   PINDEX size = GetSize();
  3983.   // Put RFC1006 TPKT length
  3984.   BYTE tpkt[4];
  3985.   tpkt[0] = 3;  // Version 3
  3986.   tpkt[1] = 0;
  3988.   PINDEX len = size + sizeof(tpkt);
  3989.   tpkt[2] = (BYTE)(len >> 8);
  3990.   tpkt[3] = (BYTE)len;
  3992.   return chan.Write(tpkt, sizeof(tpkt)) && chan.Write(theArray, size);
  3993. }
  3996. BOOL PPER_Stream::SingleBitDecode()
  3997. {
  3998.   if ((GetSize() - byteOffset)*8 - (8 - bitOffset) == 0)
  3999.     return FALSE;
  4001.   bitOffset--;
  4002.   BOOL value = (theArray[byteOffset] & (1 << bitOffset)) != 0;
  4004.   if (bitOffset == 0) {
  4005.     bitOffset = 8;
  4006.     byteOffset++;
  4007.   }
  4009.   return value;
  4010. }
  4013. void PPER_Stream::SingleBitEncode(BOOL value)
  4014. {
  4015.   PAssert(byteOffset != P_MAX_INDEX, PLogicError);
  4017.   if (byteOffset >= GetSize())
  4018.     SetSize(byteOffset+10);
  4020.   bitOffset--;
  4022.   if (value)
  4023.     theArray[byteOffset] |= 1 << bitOffset;
  4025.   if (bitOffset == 0)
  4026.     ByteAlign();
  4027. }
  4030. int PPER_Stream::MultiBitDecode(unsigned nBits)
  4031. {
  4032.   PAssert(nBits <= 32, PInvalidParameter);
  4034.   unsigned bitsLeft = (GetSize() - byteOffset)*8 - (8 - bitOffset);
  4035.   if (nBits > bitsLeft)
  4036.     nBits = bitsLeft;
  4038.   if (nBits == 0)
  4039.     return 0;
  4041.   if (nBits < bitOffset) {
  4042.     bitOffset -= nBits;
  4043.     return (theArray[byteOffset] >> bitOffset) & ((1 << nBits) - 1);
  4044.   }
  4046.   int val = theArray[byteOffset] & ((1 << bitOffset) - 1);
  4047.   nBits -= bitOffset;
  4048.   bitOffset = 8;
  4049.   byteOffset++;
  4051.   while (nBits >= 8) {
  4052.     val = (val << 8) | (BYTE)theArray[byteOffset];
  4053.     byteOffset++;
  4054.     nBits -= 8;
  4055.   }
  4057.   if (nBits > 0) {
  4058.     bitOffset = 8 - nBits;
  4059.     val = (val << nBits) | ((BYTE)theArray[byteOffset] >> bitOffset);
  4060.   }
  4062.   return val;
  4063. }
  4066. void PPER_Stream::MultiBitEncode(int value, unsigned nBits)
  4067. {
  4068.   PAssert(byteOffset != P_MAX_INDEX, PLogicError);
  4070.   if (nBits == 0)
  4071.     return;
  4073.   if (byteOffset+nBits/8+1 >= (unsigned)GetSize())
  4074.     SetSize(byteOffset+10);
  4076.   // Make sure value is in bounds of bit available.
  4077.   if (nBits < sizeof(int)*8)
  4078.     value &= ((1 << nBits) - 1);
  4080.   if (nBits < bitOffset) {
  4081.     bitOffset -= nBits;
  4082.     theArray[byteOffset] |= value << bitOffset;
  4083.     return;
  4084.   }
  4086.   nBits -= bitOffset;
  4087.   theArray[byteOffset] |= (BYTE)(value >> nBits);
  4088.   bitOffset = 8;
  4089.   byteOffset++;
  4091.   while (nBits >= 8) {
  4092.     nBits -= 8;
  4093.     theArray[byteOffset] = (BYTE)(value >> nBits);
  4094.     byteOffset++;
  4095.   }
  4097.   if (nBits > 0) {
  4098.     bitOffset = 8 - nBits;
  4099.     theArray[byteOffset] |= (BYTE)((value & ((1 << nBits)-1)) << bitOffset);
  4100.   }
  4101. }
  4104. unsigned PPER_Stream::SmallUnsignedDecode()
  4105. {
  4106.   // X.691 Section 10.6
  4108.   if (!SingleBitDecode())
  4109.     return MultiBitDecode(6);      // 10.6.1
  4111.   unsigned len;
  4112.   if (LengthDecode(0, INT_MAX, len) != 0)  // 10.6.2
  4113.     return FALSE;
  4115.   ByteAlign();
  4116.   return MultiBitDecode(len*8);
  4117. }
  4120. void PPER_Stream::SmallUnsignedEncode(unsigned value)
  4121. {
  4122.   if (value < 64) {
  4123.     MultiBitEncode(value, 7);
  4124.     return;
  4125.   }
  4127.   SingleBitEncode(1);  // 10.6.2
  4129.   PINDEX len = 4;
  4130.   if (value < 256)
  4131.     len = 1;
  4132.   else if (value < 65536)
  4133.     len = 2;
  4134.   else if (value < 0x1000000)
  4135.     len = 3;
  4136.   LengthEncode(len, 0, INT_MAX);  // 10.9
  4137.   ByteAlign();
  4138.   MultiBitEncode(value, len*8);
  4139. }
  4142. int PPER_Stream::UnsignedDecode(unsigned lower, unsigned upper, unsigned & value)
  4143. {
  4144.   // X.691 section 10.5
  4146.   if (lower == upper) { // 10.5.4
  4147.     value = lower;
  4148.     return 0;
  4149.   }
  4151.   if (IsAtEnd())
  4152.     return -1;
  4154.   unsigned range = (upper - lower) + 1;
  4155.   unsigned nBits = CountBits(range);
  4157.   if (aligned && (range == 0 || range > 255)) { // not 10.5.6 and not 10.5.7.1
  4158.     if (nBits > 16) {                           // not 10.5.7.4
  4159.       LengthDecode(1, (nBits+7)/8, nBits);      // 12.2.6
  4160.       nBits *= 8;
  4161.     }
  4162.     else if (nBits > 8)    // not 10.5.7.2
  4163.       nBits = 16;          // 10.5.7.3
  4164.     ByteAlign();           // 10.7.5.2 - 10.7.5.4
  4165.   }
  4167.   value = MultiBitDecode(nBits) + lower;
  4168.   return 0;
  4169. }
  4172. void PPER_Stream::UnsignedEncode(int value, unsigned lower, unsigned upper)
  4173. {
  4174.   // X.691 section 10.5
  4176.   if (lower == upper) // 10.5.4
  4177.     return;
  4179.   unsigned range = (upper - lower) + 1;
  4180.   PINDEX nBits = CountBits(range);
  4182.   if (aligned && (range == 0 || range > 255)) { // not 10.5.6 and not 10.5.7.1
  4183.     if (nBits > 16) {                           // not 10.5.7.4
  4184.       int numBytes = value == 0 ? 1 : (((CountBits(value - lower + 1))+7)/8);
  4185.       LengthEncode(numBytes, 1, (nBits+7)/8);    // 12.2.6
  4186.       nBits = numBytes*8;
  4187.     }
  4188.     else if (nBits > 8)      // not 10.5.7.2
  4189.       nBits = 16;            // 10.5.7.3
  4190.     ByteAlign();             // 10.7.5.2 - 10.7.5.4
  4191.   }
  4193.   MultiBitEncode(value - lower, nBits);
  4194. }
  4197. int PPER_Stream::LengthDecode(unsigned lower, unsigned upper, unsigned & len)
  4198. {
  4199.   // X.691 section 10.9
  4201.   if (upper != INT_MAX && !aligned) {
  4202.     PAssert(upper - lower < 0x10000, PUnimplementedFunction);  // 10.9.4.2 unsupported
  4203.     return lower + MultiBitDecode(CountBits(upper - lower + 1));   // 10.9.4.1
  4204.   }
  4206.   if (upper < 65536)  // 10.9.3.3
  4207.     return UnsignedDecode(lower, upper, len);
  4209.   // 10.9.3.5
  4210.   ByteAlign();
  4211.   if (IsAtEnd())
  4212.     return -1;
  4214.   if (SingleBitDecode() == 0) {
  4215.     len = MultiBitDecode(7);   // 10.9.3.6
  4216.     return 0;
  4217.   }
  4219.   if (SingleBitDecode() == 0) {
  4220.     len = MultiBitDecode(14);    // 10.9.3.7
  4221.     return 0;
  4222.   }
  4224.   PAssertAlways(PUnimplementedFunction);  // 10.9.3.8 unsupported
  4225.   return 1;
  4226. }
  4229. void PPER_Stream::LengthEncode(unsigned len, unsigned lower, unsigned upper)
  4230. {
  4231.   // X.691 section 10.9
  4233.   if (upper != INT_MAX && !aligned) {
  4234.     PAssert(upper - lower < 0x10000, PUnimplementedFunction);  // 10.9.4.2 unsupperted
  4235.     MultiBitEncode(len - lower, CountBits(upper - lower + 1));   // 10.9.4.1
  4236.     return;
  4237.   }
  4239.   if (upper < 65536) { // 10.9.3.3
  4240.     UnsignedEncode(len, lower, upper);
  4241.     return;
  4242.   }
  4244.   ByteAlign();
  4246.   if (len < 128) {
  4247.     MultiBitEncode(len, 8);   // 10.9.3.6
  4248.     return;
  4249.   }
  4251.   SingleBitEncode(TRUE);
  4253.   if (len < 0x2000) {
  4254.     MultiBitEncode(len, 15);    // 10.9.3.7
  4255.     return;
  4256.   }
  4258.   SingleBitEncode(TRUE);
  4259.   PAssert(len < 0x2000, PUnimplementedFunction);  // 10.9.3.8 unsupported
  4260. }
  4263. void PPER_Stream::AnyTypeEncode(const PASN_Object * value)
  4264. {
  4265.   PPER_Stream substream;
  4267.   if (value != NULL)
  4268.     value->Encode(substream);
  4270.   if (substream.GetPosition() == 0)   // Make sure extension has at least one
  4271.     substream.SingleBitEncode(FALSE); // byte in its ANY type encoding.
  4273.   substream.CompleteEncoding();
  4275.   PINDEX nBytes = substream.GetSize();
  4276.   LengthEncode(nBytes, 0, INT_MAX);
  4277.   BlockEncode(substream.GetPointer(), nBytes);
  4278. }
  4281. // PERASN.CXX