SecurityASN1/inc/sm_x509af.h

   1 //   NOTE: this is a machine generated file--editing not recommended
   2 //
   3 // sm_x509af.h - class definitions for ASN.1 module AuthenticationFramework
   4 //
   5 //   This file was generated by snacc on Wed Jun 27 16:40:55 2001
   6 //   UBC snacc by Mike Sample
   7 //   A couple of enhancements made by IBM European Networking Center
   8
   9 #ifndef _sm_x509af_h_
  10 #define _sm_x509af_h_
  11
  12
  13 //------------------------------------------------------------------------------
  14 // class declarations:
  15
  16 class Version;
  17 class AttributeCertificateAssertionSetOf;
  18 class AttributeCertificateInfoSeqOf;
  19 class AlgorithmIdentifier;
  20 class Time;
  21 class Extension;
  22 class AttCertValidityPeriod;
  23 class Validity;
  24 class SubjectPublicKeyInfo;
  25 class Extensions;
  26 class IssuerSerial;
  27 class AttributeCertificateAssertionChoice;
  28 class AttributeCertificateInfoChoice;
  29 class CRLToSignSeqOfSeq;
  30 class CRLToSignSeqOf;
  31 class CertificateToSign;
  32 class CRLToSign;
  33 class AttributeCertificateInfo;
  34 class Certificate;
  35 class CrossCertificates;
  36 class CertificatePair;
  37 class CertificateList;
  38 class AttributeCertificate;
  39 class CertificationPathSeqOf;
  40 class ForwardCertificationPath;
  41 class ACPathData;
  42 class AttributeCertificationPathSeqOf;
  43 class Certificates;
  44 class CertificationPath;
  45 class AttributeCertificationPath;
  46 class AttributeCertificateAssertion;
  47
  48 //------------------------------------------------------------------------------
  49 // class definitions:
  50
  51 typedef enum AuthenticationFrameworkAnyId
  52 {
  53
  54 } AuthenticationFrameworkAnyId;
  55
  56
  57 /* INTEGER { v1 (0), v2 (1), v3 (2) }  */
  58 class Version: public AsnInt
  59 {
  60 public:
  61                         Version(): AsnInt() {}
  62                         Version (int i): AsnInt (i) {}
  63   enum
  64   {
  65     v1 = 0,
  66     v2 = 1,
  67     v3 = 2
  68   };
  69 };
  70
  71
  72 /* OCTET STRING (SIZE (0..ub-password-length)) */
  73 typedef AsnOcts UserPassword;
  74
  75 class AttributeCertificateAssertionSetOf: public AsnType
  76 {
  77 protected:
  78   unsigned long int     count;
  79   struct AsnListElmt
  80   {
  81     AsnListElmt *next;
  82     AsnListElmt *prev;
  83     AttributeType       *elmt;
  84   }                     *first, *curr, *last;
  85
  86 public:
  87                         AttributeCertificateAssertionSetOf() { count = 0; first = curr = last = NULL; }
  88                         AttributeCertificateAssertionSetOf (const AttributeCertificateAssertionSetOf &);
  89   virtual               ~AttributeCertificateAssertionSetOf();
  90   virtual AsnType       *Clone() const;
  91
  92   virtual AsnType       *Copy() const;
  93
  94   AttributeCertificateAssertionSetOf            &operator = (const AttributeCertificateAssertionSetOf &);
  95   void          SetCurrElmt (unsigned long int index);
  96   unsigned long int     GetCurrElmtIndex();
  97   void          SetCurrToFirst() { curr = first; }
  98   void          SetCurrToLast()  { curr = last; }
  99   // reading member fcns
 100   int                   Count() const   { return count; }
 101   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 102   AttributeType *First() const  { return count > 0 ? first->elmt : NULL; }
 103   AttributeType *Last() const   { return count > 0 ? last->elmt : NULL; }
 104   AttributeType *Curr() const   { return curr ? curr->elmt : NULL; }
 105   AttributeType *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 106   AttributeType *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 107
 108   // routines that move the curr elmt
 109   AttributeType *GoNext() { if (curr) curr = curr->next; return Curr(); }
 110   AttributeType *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 111
 112   // write & alloc fcns - returns new elmt
 113   AttributeType *Append();  // add elmt to end of list
 114   AttributeType *Prepend(); // add elmt to beginning of list
 115   AttributeType *InsertBefore(); //insert elmt before current elmt
 116   AttributeType *InsertAfter(); //insert elmt after current elmt
 117
 118   // write & alloc & copy - returns list after copying elmt
 119   AttributeCertificateAssertionSetOf    &AppendCopy (AttributeType &elmt);  // add elmt to end of list
 120   AttributeCertificateAssertionSetOf    &PrependCopy (AttributeType &elmt); // add elmt to beginning of list
 121   AttributeCertificateAssertionSetOf    &InsertBeforeAndCopy (AttributeType &elmt); //insert elmt before current elmt
 122   AttributeCertificateAssertionSetOf    &InsertAfterAndCopy (AttributeType &elmt); //insert elmt after current elmt
 123
 124   // removing the current elmt from the list
 125   void          RemoveCurrFromList();
 126
 127   // encode and decode routines
 128   AsnLen                BEnc (BUF_TYPE b);
 129   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 130   AsnLen                BEncContent (BUF_TYPE b);
 131   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 132
 133   PDU_MEMBER_MACROS
 134   void          Print (ostream &os) const;
 135 };
 136
 137
 138 class AttributeCertificateInfoSeqOf: public AsnType
 139 {
 140 protected:
 141   unsigned long int     count;
 142   struct AsnListElmt
 143   {
 144     AsnListElmt *next;
 145     AsnListElmt *prev;
 146     Attribute   *elmt;
 147   }                     *first, *curr, *last;
 148
 149 public:
 150                         AttributeCertificateInfoSeqOf() { count = 0; first = curr = last = NULL; }
 151                         AttributeCertificateInfoSeqOf (const AttributeCertificateInfoSeqOf &);
 152   virtual               ~AttributeCertificateInfoSeqOf();
 153   virtual AsnType       *Clone() const;
 154
 155   virtual AsnType       *Copy() const;
 156
 157   AttributeCertificateInfoSeqOf         &operator = (const AttributeCertificateInfoSeqOf &);
 158   void          SetCurrElmt (unsigned long int index);
 159   unsigned long int     GetCurrElmtIndex();
 160   void          SetCurrToFirst() { curr = first; }
 161   void          SetCurrToLast()  { curr = last; }
 162   // reading member fcns
 163   int                   Count() const   { return count; }
 164   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 165   Attribute     *First() const  { return count > 0 ? first->elmt : NULL; }
 166   Attribute     *Last() const   { return count > 0 ? last->elmt : NULL; }
 167   Attribute     *Curr() const   { return curr ? curr->elmt : NULL; }
 168   Attribute     *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 169   Attribute     *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 170
 171   // routines that move the curr elmt
 172   Attribute     *GoNext() { if (curr) curr = curr->next; return Curr(); }
 173   Attribute     *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 174
 175   // write & alloc fcns - returns new elmt
 176   Attribute     *Append();  // add elmt to end of list
 177   Attribute     *Prepend(); // add elmt to beginning of list
 178   Attribute     *InsertBefore(); //insert elmt before current elmt
 179   Attribute     *InsertAfter(); //insert elmt after current elmt
 180
 181   // write & alloc & copy - returns list after copying elmt
 182   AttributeCertificateInfoSeqOf &AppendCopy (Attribute &elmt);  // add elmt to end of list
 183   AttributeCertificateInfoSeqOf &PrependCopy (Attribute &elmt); // add elmt to beginning of list
 184   AttributeCertificateInfoSeqOf &InsertBeforeAndCopy (Attribute &elmt); //insert elmt before current elmt
 185   AttributeCertificateInfoSeqOf &InsertAfterAndCopy (Attribute &elmt); //insert elmt after current elmt
 186
 187   // removing the current elmt from the list
 188   void          RemoveCurrFromList();
 189
 190   // encode and decode routines
 191   AsnLen                BEnc (BUF_TYPE b);
 192   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 193   AsnLen                BEncContent (BUF_TYPE b);
 194   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 195
 196   PDU_MEMBER_MACROS
 197   void          Print (ostream &os) const;
 198 };
 199
 200
 201 /* BigIntegerStr */
 202 typedef BigIntegerStr CertificateSerialNumber;
 203
 204 class AlgorithmIdentifier: public AsnType
 205 {
 206 public:
 207   AsnOid                algorithm;
 208   AsnAny                *parameters;
 209
 210                         AlgorithmIdentifier();
 211                         AlgorithmIdentifier (const AlgorithmIdentifier &);
 212   virtual               ~AlgorithmIdentifier();
 213   virtual AsnType       *Clone() const;
 214
 215   virtual AsnType       *Copy() const;
 216
 217   AlgorithmIdentifier           &operator = (const AlgorithmIdentifier &);
 218   AsnLen                BEncContent (BUF_TYPE b);
 219   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 220
 221   AsnLen                BEnc (BUF_TYPE b);
 222   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 223   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 224   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 225
 226   void          Print (ostream &os) const;
 227 };
 228
 229
 230 class Time: public AsnType
 231 {
 232 public:
 233   enum ChoiceIdEnum
 234   {
 235      utcTimeCid = 0,
 236      generalizedTimeCid = 1
 237   };
 238
 239   enum ChoiceIdEnum     choiceId;
 240   union
 241   {
 242      UTCTime            *utcTime;
 243      GeneralizedTime            *generalizedTime;
 244   };
 245
 246
 247                         Time();
 248                         Time (const Time &);
 249   virtual               ~Time();
 250
 251   virtual AsnType       *Clone() const;
 252
 253   virtual AsnType       *Copy() const;
 254
 255   Time          &operator = (const Time &);
 256   AsnLen                BEncContent (BUF_TYPE b);
 257   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 258   AsnLen                BEnc (BUF_TYPE b);
 259   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 260   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 261   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 262
 263   void                  Print (ostream &os) const;
 264 };
 265
 266
 267 class Extension: public AsnType
 268 {
 269 public:
 270   AsnOid                extnId;
 271   AsnBool               *critical;
 272   AsnOcts               extnValue;
 273
 274                         Extension();
 275                         Extension (const Extension &);
 276   virtual               ~Extension();
 277   virtual AsnType       *Clone() const;
 278
 279   virtual AsnType       *Copy() const;
 280
 281   Extension             &operator = (const Extension &);
 282   AsnLen                BEncContent (BUF_TYPE b);
 283   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 284
 285   AsnLen                BEnc (BUF_TYPE b);
 286   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 287   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 288   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 289
 290   void          Print (ostream &os) const;
 291 };
 292
 293
 294 class AttCertValidityPeriod: public AsnType
 295 {
 296 public:
 297   GeneralizedTime               notBeforeTime;
 298   GeneralizedTime               notAfterTime;
 299
 300                         AttCertValidityPeriod();
 301                         AttCertValidityPeriod (const AttCertValidityPeriod &);
 302   virtual               ~AttCertValidityPeriod();
 303   virtual AsnType       *Clone() const;
 304
 305   virtual AsnType       *Copy() const;
 306
 307   AttCertValidityPeriod         &operator = (const AttCertValidityPeriod &);
 308   AsnLen                BEncContent (BUF_TYPE b);
 309   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 310
 311   AsnLen                BEnc (BUF_TYPE b);
 312   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 313   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 314   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 315
 316   void          Print (ostream &os) const;
 317 };
 318
 319
 320 class Validity: public AsnType
 321 {
 322 public:
 323   Time          *notBefore;
 324   Time          *notAfter;
 325
 326                         Validity();
 327                         Validity (const Validity &);
 328   virtual               ~Validity();
 329   virtual AsnType       *Clone() const;
 330
 331   virtual AsnType       *Copy() const;
 332
 333   Validity              &operator = (const Validity &);
 334   AsnLen                BEncContent (BUF_TYPE b);
 335   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 336
 337   AsnLen                BEnc (BUF_TYPE b);
 338   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 339   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 340   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 341
 342   void          Print (ostream &os) const;
 343 };
 344
 345
 346 class SubjectPublicKeyInfo: public AsnType
 347 {
 348 public:
 349   AlgorithmIdentifier           *algorithm;
 350   AsnBits               subjectPublicKey;
 351
 352                         SubjectPublicKeyInfo();
 353                         SubjectPublicKeyInfo (const SubjectPublicKeyInfo &);
 354   virtual               ~SubjectPublicKeyInfo();
 355   virtual AsnType       *Clone() const;
 356
 357   virtual AsnType       *Copy() const;
 358
 359   SubjectPublicKeyInfo          &operator = (const SubjectPublicKeyInfo &);
 360   AsnLen                BEncContent (BUF_TYPE b);
 361   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 362
 363   AsnLen                BEnc (BUF_TYPE b);
 364   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 365   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 366   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 367
 368   void          Print (ostream &os) const;
 369 };
 370
 371
 372 class Extensions: public AsnType
 373 {
 374 protected:
 375   unsigned long int     count;
 376   struct AsnListElmt
 377   {
 378     AsnListElmt *next;
 379     AsnListElmt *prev;
 380     Extension   *elmt;
 381   }                     *first, *curr, *last;
 382
 383 public:
 384                         Extensions() { count = 0; first = curr = last = NULL; }
 385                         Extensions (const Extensions &);
 386   virtual               ~Extensions();
 387   virtual AsnType       *Clone() const;
 388
 389   virtual AsnType       *Copy() const;
 390
 391   Extensions            &operator = (const Extensions &);
 392   void          SetCurrElmt (unsigned long int index);
 393   unsigned long int     GetCurrElmtIndex();
 394   void          SetCurrToFirst() { curr = first; }
 395   void          SetCurrToLast()  { curr = last; }
 396   // reading member fcns
 397   int                   Count() const   { return count; }
 398   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 399   Extension     *First() const  { return count > 0 ? first->elmt : NULL; }
 400   Extension     *Last() const   { return count > 0 ? last->elmt : NULL; }
 401   Extension     *Curr() const   { return curr ? curr->elmt : NULL; }
 402   Extension     *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 403   Extension     *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 404
 405   // routines that move the curr elmt
 406   Extension     *GoNext() { if (curr) curr = curr->next; return Curr(); }
 407   Extension     *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 408
 409   // write & alloc fcns - returns new elmt
 410   Extension     *Append();  // add elmt to end of list
 411   Extension     *Prepend(); // add elmt to beginning of list
 412   Extension     *InsertBefore(); //insert elmt before current elmt
 413   Extension     *InsertAfter(); //insert elmt after current elmt
 414
 415   // write & alloc & copy - returns list after copying elmt
 416   Extensions    &AppendCopy (Extension &elmt);  // add elmt to end of list
 417   Extensions    &PrependCopy (Extension &elmt); // add elmt to beginning of list
 418   Extensions    &InsertBeforeAndCopy (Extension &elmt); //insert elmt before current elmt
 419   Extensions    &InsertAfterAndCopy (Extension &elmt); //insert elmt after current elmt
 420
 421   // removing the current elmt from the list
 422   void          RemoveCurrFromList();
 423
 424   // encode and decode routines
 425   AsnLen                BEnc (BUF_TYPE b);
 426   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 427   AsnLen                BEncContent (BUF_TYPE b);
 428   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 429
 430   PDU_MEMBER_MACROS
 431   void          Print (ostream &os) const;
 432 };
 433
 434
 435 class IssuerSerial: public AsnType
 436 {
 437 public:
 438   GeneralNames          issuer;
 439   CertificateSerialNumber               serial;
 440   UniqueIdentifier              *issuerUID;
 441
 442                         IssuerSerial();
 443                         IssuerSerial (const IssuerSerial &);
 444   virtual               ~IssuerSerial();
 445   virtual AsnType       *Clone() const;
 446
 447   virtual AsnType       *Copy() const;
 448
 449   IssuerSerial          &operator = (const IssuerSerial &);
 450   AsnLen                BEncContent (BUF_TYPE b);
 451   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 452
 453   AsnLen                BEnc (BUF_TYPE b);
 454   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 455   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 456   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 457
 458   void          Print (ostream &os) const;
 459 };
 460
 461
 462 class AttributeCertificateAssertionChoice: public AsnType
 463 {
 464 public:
 465   enum ChoiceIdEnum
 466   {
 467      baseCertificateIDCid = 0,
 468      subjectNameCid = 1
 469   };
 470
 471   enum ChoiceIdEnum     choiceId;
 472   union
 473   {
 474      IssuerSerial               *baseCertificateID;
 475      Name               *subjectName;
 476   };
 477
 478
 479                         AttributeCertificateAssertionChoice();
 480                         AttributeCertificateAssertionChoice (const AttributeCertificateAssertionChoice &);
 481   virtual               ~AttributeCertificateAssertionChoice();
 482
 483   virtual AsnType       *Clone() const;
 484
 485   virtual AsnType       *Copy() const;
 486
 487   AttributeCertificateAssertionChoice           &operator = (const AttributeCertificateAssertionChoice &);
 488   AsnLen                BEncContent (BUF_TYPE b);
 489   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 490   AsnLen                BEnc (BUF_TYPE b);
 491   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 492   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 493   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 494
 495   void                  Print (ostream &os) const;
 496 };
 497
 498
 499 class AttributeCertificateInfoChoice: public AsnType
 500 {
 501 public:
 502   enum ChoiceIdEnum
 503   {
 504      baseCertificateIDCid = 0,
 505      subjectNameCid = 1
 506   };
 507
 508   enum ChoiceIdEnum     choiceId;
 509   union
 510   {
 511      IssuerSerial               *baseCertificateID;
 512      GeneralNames               *subjectName;
 513   };
 514
 515
 516                         AttributeCertificateInfoChoice();
 517                         AttributeCertificateInfoChoice (const AttributeCertificateInfoChoice &);
 518   virtual               ~AttributeCertificateInfoChoice();
 519
 520   virtual AsnType       *Clone() const;
 521
 522   virtual AsnType       *Copy() const;
 523
 524   AttributeCertificateInfoChoice                &operator = (const AttributeCertificateInfoChoice &);
 525   AsnLen                BEncContent (BUF_TYPE b);
 526   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 527   AsnLen                BEnc (BUF_TYPE b);
 528   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 529   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 530   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 531
 532   void                  Print (ostream &os) const;
 533 };
 534
 535
 536 class CRLToSignSeqOfSeq: public AsnType
 537 {
 538 public:
 539   CertificateSerialNumber               userCertificate;
 540   Time          *revocationDate;
 541   Extensions            *crlEntryExtensions;
 542
 543                         CRLToSignSeqOfSeq();
 544                         CRLToSignSeqOfSeq (const CRLToSignSeqOfSeq &);
 545   virtual               ~CRLToSignSeqOfSeq();
 546   virtual AsnType       *Clone() const;
 547
 548   virtual AsnType       *Copy() const;
 549
 550   CRLToSignSeqOfSeq             &operator = (const CRLToSignSeqOfSeq &);
 551   AsnLen                BEncContent (BUF_TYPE b);
 552   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 553
 554   AsnLen                BEnc (BUF_TYPE b);
 555   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 556   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 557   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 558
 559   void          Print (ostream &os) const;
 560 };
 561
 562
 563 class CRLToSignSeqOf: public AsnType
 564 {
 565 protected:
 566   unsigned long int     count;
 567   struct AsnListElmt
 568   {
 569     AsnListElmt *next;
 570     AsnListElmt *prev;
 571     CRLToSignSeqOfSeq   *elmt;
 572   }                     *first, *curr, *last;
 573
 574 public:
 575                         CRLToSignSeqOf() { count = 0; first = curr = last = NULL; }
 576                         CRLToSignSeqOf (const CRLToSignSeqOf &);
 577   virtual               ~CRLToSignSeqOf();
 578   virtual AsnType       *Clone() const;
 579
 580   virtual AsnType       *Copy() const;
 581
 582   CRLToSignSeqOf                &operator = (const CRLToSignSeqOf &);
 583   void          SetCurrElmt (unsigned long int index);
 584   unsigned long int     GetCurrElmtIndex();
 585   void          SetCurrToFirst() { curr = first; }
 586   void          SetCurrToLast()  { curr = last; }
 587   // reading member fcns
 588   int                   Count() const   { return count; }
 589   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 590   CRLToSignSeqOfSeq     *First() const  { return count > 0 ? first->elmt : NULL; }
 591   CRLToSignSeqOfSeq     *Last() const   { return count > 0 ? last->elmt : NULL; }
 592   CRLToSignSeqOfSeq     *Curr() const   { return curr ? curr->elmt : NULL; }
 593   CRLToSignSeqOfSeq     *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 594   CRLToSignSeqOfSeq     *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 595
 596   // routines that move the curr elmt
 597   CRLToSignSeqOfSeq     *GoNext() { if (curr) curr = curr->next; return Curr(); }
 598   CRLToSignSeqOfSeq     *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 599
 600   // write & alloc fcns - returns new elmt
 601   CRLToSignSeqOfSeq     *Append();  // add elmt to end of list
 602   CRLToSignSeqOfSeq     *Prepend(); // add elmt to beginning of list
 603   CRLToSignSeqOfSeq     *InsertBefore(); //insert elmt before current elmt
 604   CRLToSignSeqOfSeq     *InsertAfter(); //insert elmt after current elmt
 605
 606   // write & alloc & copy - returns list after copying elmt
 607   CRLToSignSeqOf        &AppendCopy (CRLToSignSeqOfSeq &elmt);  // add elmt to end of list
 608   CRLToSignSeqOf        &PrependCopy (CRLToSignSeqOfSeq &elmt); // add elmt to beginning of list
 609   CRLToSignSeqOf        &InsertBeforeAndCopy (CRLToSignSeqOfSeq &elmt); //insert elmt before current elmt
 610   CRLToSignSeqOf        &InsertAfterAndCopy (CRLToSignSeqOfSeq &elmt); //insert elmt after current elmt
 611
 612   // removing the current elmt from the list
 613   void          RemoveCurrFromList();
 614
 615   // encode and decode routines
 616   AsnLen                BEnc (BUF_TYPE b);
 617   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 618   AsnLen                BEncContent (BUF_TYPE b);
 619   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 620
 621   PDU_MEMBER_MACROS
 622   void          Print (ostream &os) const;
 623 };
 624
 625
 626 class CertificateToSign: public AsnType
 627 {
 628 public:
 629   Version               *version;
 630   CertificateSerialNumber               serialNumber;
 631   AlgorithmIdentifier           *signature;
 632   Name          *issuer;
 633   Validity              *validity;
 634   Name          *subject;
 635   SubjectPublicKeyInfo          *subjectPublicKeyInfo;
 636   UniqueIdentifier              *issuerUniqueIdentifier;
 637   UniqueIdentifier              *subjectUniqueIdentifier;
 638   Extensions            *extensions;
 639
 640                         CertificateToSign();
 641                         CertificateToSign (const CertificateToSign &);
 642   virtual               ~CertificateToSign();
 643   virtual AsnType       *Clone() const;
 644
 645   virtual AsnType       *Copy() const;
 646
 647   CertificateToSign             &operator = (const CertificateToSign &);
 648   AsnLen                BEncContent (BUF_TYPE b);
 649   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 650
 651   AsnLen                BEnc (BUF_TYPE b);
 652   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 653   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 654   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 655
 656   void          Print (ostream &os) const;
 657 };
 658
 659
 660 class CRLToSign: public AsnType
 661 {
 662 public:
 663   Version               *version;
 664   AlgorithmIdentifier           *signature;
 665   Name          *issuer;
 666   Time          *thisUpdate;
 667   Time          *nextUpdate;
 668   CRLToSignSeqOf                *revokedCertificates;
 669   Extensions            *crlExtensions;
 670
 671                         CRLToSign();
 672                         CRLToSign (const CRLToSign &);
 673   virtual               ~CRLToSign();
 674   virtual AsnType       *Clone() const;
 675
 676   virtual AsnType       *Copy() const;
 677
 678   CRLToSign             &operator = (const CRLToSign &);
 679   AsnLen                BEncContent (BUF_TYPE b);
 680   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 681
 682   AsnLen                BEnc (BUF_TYPE b);
 683   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 684   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 685   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 686
 687   void          Print (ostream &os) const;
 688 };
 689
 690
 691 class AttributeCertificateInfo: public AsnType
 692 {
 693 public:
 694   Version               *version;
 695   AttributeCertificateInfoChoice                *subject;
 696   GeneralNames          issuer;
 697   AlgorithmIdentifier           *signature;
 698   CertificateSerialNumber               serialNumber;
 699   AttCertValidityPeriod         *attCertValidityPeriod;
 700   AttributeCertificateInfoSeqOf         attributes;
 701   UniqueIdentifier              *issuerUniqueID;
 702   Extensions            *extensions;
 703
 704                         AttributeCertificateInfo();
 705                         AttributeCertificateInfo (const AttributeCertificateInfo &);
 706   virtual               ~AttributeCertificateInfo();
 707   virtual AsnType       *Clone() const;
 708
 709   virtual AsnType       *Copy() const;
 710
 711   AttributeCertificateInfo              &operator = (const AttributeCertificateInfo &);
 712   AsnLen                BEncContent (BUF_TYPE b);
 713   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 714
 715   AsnLen                BEnc (BUF_TYPE b);
 716   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 717   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 718   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 719
 720   void          Print (ostream &os) const;
 721 };
 722
 723
 724 class Certificate: public AsnType
 725 {
 726 public:
 727   CertificateToSign             *certificateToSign;
 728   AlgorithmIdentifier           *algorithmIdentifier;
 729   AsnBits               signatureValue;
 730
 731                         Certificate();
 732                         Certificate (const Certificate &);
 733   virtual               ~Certificate();
 734   virtual AsnType       *Clone() const;
 735
 736   virtual AsnType       *Copy() const;
 737
 738   Certificate           &operator = (const Certificate &);
 739   AsnLen                BEncContent (BUF_TYPE b);
 740   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 741
 742   AsnLen                BEnc (BUF_TYPE b);
 743   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 744   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 745   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 746
 747   void          Print (ostream &os) const;
 748 };
 749
 750
 751 class CrossCertificates: public AsnType
 752 {
 753 protected:
 754   unsigned long int     count;
 755   struct AsnListElmt
 756   {
 757     AsnListElmt *next;
 758     AsnListElmt *prev;
 759     Certificate *elmt;
 760   }                     *first, *curr, *last;
 761
 762 public:
 763                         CrossCertificates() { count = 0; first = curr = last = NULL; }
 764                         CrossCertificates (const CrossCertificates &);
 765   virtual               ~CrossCertificates();
 766   virtual AsnType       *Clone() const;
 767
 768   virtual AsnType       *Copy() const;
 769
 770   CrossCertificates             &operator = (const CrossCertificates &);
 771   void          SetCurrElmt (unsigned long int index);
 772   unsigned long int     GetCurrElmtIndex();
 773   void          SetCurrToFirst() { curr = first; }
 774   void          SetCurrToLast()  { curr = last; }
 775   // reading member fcns
 776   int                   Count() const   { return count; }
 777   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 778   Certificate   *First() const  { return count > 0 ? first->elmt : NULL; }
 779   Certificate   *Last() const   { return count > 0 ? last->elmt : NULL; }
 780   Certificate   *Curr() const   { return curr ? curr->elmt : NULL; }
 781   Certificate   *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 782   Certificate   *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 783
 784   // routines that move the curr elmt
 785   Certificate   *GoNext() { if (curr) curr = curr->next; return Curr(); }
 786   Certificate   *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 787
 788   // write & alloc fcns - returns new elmt
 789   Certificate   *Append();  // add elmt to end of list
 790   Certificate   *Prepend(); // add elmt to beginning of list
 791   Certificate   *InsertBefore(); //insert elmt before current elmt
 792   Certificate   *InsertAfter(); //insert elmt after current elmt
 793
 794   // write & alloc & copy - returns list after copying elmt
 795   CrossCertificates     &AppendCopy (Certificate &elmt);  // add elmt to end of list
 796   CrossCertificates     &PrependCopy (Certificate &elmt); // add elmt to beginning of list
 797   CrossCertificates     &InsertBeforeAndCopy (Certificate &elmt); //insert elmt before current elmt
 798   CrossCertificates     &InsertAfterAndCopy (Certificate &elmt); //insert elmt after current elmt
 799
 800   // removing the current elmt from the list
 801   void          RemoveCurrFromList();
 802
 803   // encode and decode routines
 804   AsnLen                BEnc (BUF_TYPE b);
 805   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 806   AsnLen                BEncContent (BUF_TYPE b);
 807   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 808
 809   PDU_MEMBER_MACROS
 810   void          Print (ostream &os) const;
 811 };
 812
 813
 814 class CertificatePair: public AsnType
 815 {
 816 public:
 817   Certificate           *forward;
 818   Certificate           *reverse;
 819
 820                         CertificatePair();
 821                         CertificatePair (const CertificatePair &);
 822   virtual               ~CertificatePair();
 823   virtual AsnType       *Clone() const;
 824
 825   virtual AsnType       *Copy() const;
 826
 827   CertificatePair               &operator = (const CertificatePair &);
 828   AsnLen                BEncContent (BUF_TYPE b);
 829   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 830
 831   AsnLen                BEnc (BUF_TYPE b);
 832   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 833   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 834   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 835
 836   void          Print (ostream &os) const;
 837 };
 838
 839
 840 class CertificateList: public AsnType
 841 {
 842 public:
 843   CRLToSign             *crlToSign;
 844   AlgorithmIdentifier           *algorithmIdentifier;
 845   AsnBits               signatureValue;
 846
 847                         CertificateList();
 848                         CertificateList (const CertificateList &);
 849   virtual               ~CertificateList();
 850   virtual AsnType       *Clone() const;
 851
 852   virtual AsnType       *Copy() const;
 853
 854   CertificateList               &operator = (const CertificateList &);
 855   AsnLen                BEncContent (BUF_TYPE b);
 856   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 857
 858   AsnLen                BEnc (BUF_TYPE b);
 859   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 860   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 861   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 862
 863   void          Print (ostream &os) const;
 864 };
 865
 866
 867 class AttributeCertificate: public AsnType
 868 {
 869 public:
 870   AttributeCertificateInfo              *attributeCertificateInfo;
 871   AlgorithmIdentifier           *algorithmIdentifier;
 872   AsnBits               signatureValue;
 873
 874                         AttributeCertificate();
 875                         AttributeCertificate (const AttributeCertificate &);
 876   virtual               ~AttributeCertificate();
 877   virtual AsnType       *Clone() const;
 878
 879   virtual AsnType       *Copy() const;
 880
 881   AttributeCertificate          &operator = (const AttributeCertificate &);
 882   AsnLen                BEncContent (BUF_TYPE b);
 883   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 884
 885   AsnLen                BEnc (BUF_TYPE b);
 886   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 887   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
 888   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
 889
 890   void          Print (ostream &os) const;
 891 };
 892
 893
 894 class CertificationPathSeqOf: public AsnType
 895 {
 896 protected:
 897   unsigned long int     count;
 898   struct AsnListElmt
 899   {
 900     AsnListElmt *next;
 901     AsnListElmt *prev;
 902     CertificatePair     *elmt;
 903   }                     *first, *curr, *last;
 904
 905 public:
 906                         CertificationPathSeqOf() { count = 0; first = curr = last = NULL; }
 907                         CertificationPathSeqOf (const CertificationPathSeqOf &);
 908   virtual               ~CertificationPathSeqOf();
 909   virtual AsnType       *Clone() const;
 910
 911   virtual AsnType       *Copy() const;
 912
 913   CertificationPathSeqOf                &operator = (const CertificationPathSeqOf &);
 914   void          SetCurrElmt (unsigned long int index);
 915   unsigned long int     GetCurrElmtIndex();
 916   void          SetCurrToFirst() { curr = first; }
 917   void          SetCurrToLast()  { curr = last; }
 918   // reading member fcns
 919   int                   Count() const   { return count; }
 920   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 921   CertificatePair       *First() const  { return count > 0 ? first->elmt : NULL; }
 922   CertificatePair       *Last() const   { return count > 0 ? last->elmt : NULL; }
 923   CertificatePair       *Curr() const   { return curr ? curr->elmt : NULL; }
 924   CertificatePair       *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 925   CertificatePair       *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 926
 927   // routines that move the curr elmt
 928   CertificatePair       *GoNext() { if (curr) curr = curr->next; return Curr(); }
 929   CertificatePair       *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 930
 931   // write & alloc fcns - returns new elmt
 932   CertificatePair       *Append();  // add elmt to end of list
 933   CertificatePair       *Prepend(); // add elmt to beginning of list
 934   CertificatePair       *InsertBefore(); //insert elmt before current elmt
 935   CertificatePair       *InsertAfter(); //insert elmt after current elmt
 936
 937   // write & alloc & copy - returns list after copying elmt
 938   CertificationPathSeqOf        &AppendCopy (CertificatePair &elmt);  // add elmt to end of list
 939   CertificationPathSeqOf        &PrependCopy (CertificatePair &elmt); // add elmt to beginning of list
 940   CertificationPathSeqOf        &InsertBeforeAndCopy (CertificatePair &elmt); //insert elmt before current elmt
 941   CertificationPathSeqOf        &InsertAfterAndCopy (CertificatePair &elmt); //insert elmt after current elmt
 942
 943   // removing the current elmt from the list
 944   void          RemoveCurrFromList();
 945
 946   // encode and decode routines
 947   AsnLen                BEnc (BUF_TYPE b);
 948   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 949   AsnLen                BEncContent (BUF_TYPE b);
 950   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 951
 952   PDU_MEMBER_MACROS
 953   void          Print (ostream &os) const;
 954 };
 955
 956
 957 class ForwardCertificationPath: public AsnType
 958 {
 959 protected:
 960   unsigned long int     count;
 961   struct AsnListElmt
 962   {
 963     AsnListElmt *next;
 964     AsnListElmt *prev;
 965     CrossCertificates   *elmt;
 966   }                     *first, *curr, *last;
 967
 968 public:
 969                         ForwardCertificationPath() { count = 0; first = curr = last = NULL; }
 970                         ForwardCertificationPath (const ForwardCertificationPath &);
 971   virtual               ~ForwardCertificationPath();
 972   virtual AsnType       *Clone() const;
 973
 974   virtual AsnType       *Copy() const;
 975
 976   ForwardCertificationPath              &operator = (const ForwardCertificationPath &);
 977   void          SetCurrElmt (unsigned long int index);
 978   unsigned long int     GetCurrElmtIndex();
 979   void          SetCurrToFirst() { curr = first; }
 980   void          SetCurrToLast()  { curr = last; }
 981   // reading member fcns
 982   int                   Count() const   { return count; }
 983   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 984   CrossCertificates     *First() const  { return count > 0 ? first->elmt : NULL; }
 985   CrossCertificates     *Last() const   { return count > 0 ? last->elmt : NULL; }
 986   CrossCertificates     *Curr() const   { return curr ? curr->elmt : NULL; }
 987   CrossCertificates     *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 988   CrossCertificates     *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 989
 990   // routines that move the curr elmt
 991   CrossCertificates     *GoNext() { if (curr) curr = curr->next; return Curr(); }
 992   CrossCertificates     *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 993
 994   // write & alloc fcns - returns new elmt
 995   CrossCertificates     *Append();  // add elmt to end of list
 996   CrossCertificates     *Prepend(); // add elmt to beginning of list
 997   CrossCertificates     *InsertBefore(); //insert elmt before current elmt
 998   CrossCertificates     *InsertAfter(); //insert elmt after current elmt
 999
1000   // write & alloc & copy - returns list after copying elmt
1001   ForwardCertificationPath      &AppendCopy (CrossCertificates &elmt);  // add elmt to end of list
1002   ForwardCertificationPath      &PrependCopy (CrossCertificates &elmt); // add elmt to beginning of list
1003   ForwardCertificationPath      &InsertBeforeAndCopy (CrossCertificates &elmt); //insert elmt before current elmt
1004   ForwardCertificationPath      &InsertAfterAndCopy (CrossCertificates &elmt); //insert elmt after current elmt
1005
1006   // removing the current elmt from the list
1007   void          RemoveCurrFromList();
1008
1009   // encode and decode routines
1010   AsnLen                BEnc (BUF_TYPE b);
1011   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
1012   AsnLen                BEncContent (BUF_TYPE b);
1013   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
1014
1015   PDU_MEMBER_MACROS
1016   void          Print (ostream &os) const;
1017 };
1018
1019
1020 class ACPathData: public AsnType
1021 {
1022 public:
1023   Certificate           *certificate;
1024   AttributeCertificate          *attributeCertificate;
1025
1026                         ACPathData();
1027                         ACPathData (const ACPathData &);
1028   virtual               ~ACPathData();
1029   virtual AsnType       *Clone() const;
1030
1031   virtual AsnType       *Copy() const;
1032
1033   ACPathData            &operator = (const ACPathData &);
1034   AsnLen                BEncContent (BUF_TYPE b);
1035   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
1036
1037   AsnLen                BEnc (BUF_TYPE b);
1038   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
1039   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
1040   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
1041
1042   void          Print (ostream &os) const;
1043 };
1044
1045
1046 class AttributeCertificationPathSeqOf: public AsnType
1047 {
1048 protected:
1049   unsigned long int     count;
1050   struct AsnListElmt
1051   {
1052     AsnListElmt *next;
1053     AsnListElmt *prev;
1054     ACPathData  *elmt;
1055   }                     *first, *curr, *last;
1056
1057 public:
1058                         AttributeCertificationPathSeqOf() { count = 0; first = curr = last = NULL; }
1059                         AttributeCertificationPathSeqOf (const AttributeCertificationPathSeqOf &);
1060   virtual               ~AttributeCertificationPathSeqOf();
1061   virtual AsnType       *Clone() const;
1062
1063   virtual AsnType       *Copy() const;
1064
1065   AttributeCertificationPathSeqOf               &operator = (const AttributeCertificationPathSeqOf &);
1066   void          SetCurrElmt (unsigned long int index);
1067   unsigned long int     GetCurrElmtIndex();
1068   void          SetCurrToFirst() { curr = first; }
1069   void          SetCurrToLast()  { curr = last; }
1070   // reading member fcns
1071   int                   Count() const   { return count; }
1072   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
1073   ACPathData    *First() const  { return count > 0 ? first->elmt : NULL; }
1074   ACPathData    *Last() const   { return count > 0 ? last->elmt : NULL; }
1075   ACPathData    *Curr() const   { return curr ? curr->elmt : NULL; }
1076   ACPathData    *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
1077   ACPathData    *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
1078
1079   // routines that move the curr elmt
1080   ACPathData    *GoNext() { if (curr) curr = curr->next; return Curr(); }
1081   ACPathData    *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
1082
1083   // write & alloc fcns - returns new elmt
1084   ACPathData    *Append();  // add elmt to end of list
1085   ACPathData    *Prepend(); // add elmt to beginning of list
1086   ACPathData    *InsertBefore(); //insert elmt before current elmt
1087   ACPathData    *InsertAfter(); //insert elmt after current elmt
1088
1089   // write & alloc & copy - returns list after copying elmt
1090   AttributeCertificationPathSeqOf       &AppendCopy (ACPathData &elmt);  // add elmt to end of list
1091   AttributeCertificationPathSeqOf       &PrependCopy (ACPathData &elmt); // add elmt to beginning of list
1092   AttributeCertificationPathSeqOf       &InsertBeforeAndCopy (ACPathData &elmt); //insert elmt before current elmt
1093   AttributeCertificationPathSeqOf       &InsertAfterAndCopy (ACPathData &elmt); //insert elmt after current elmt
1094
1095   // removing the current elmt from the list
1096   void          RemoveCurrFromList();
1097
1098   // encode and decode routines
1099   AsnLen                BEnc (BUF_TYPE b);
1100   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
1101   AsnLen                BEncContent (BUF_TYPE b);
1102   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
1103
1104   PDU_MEMBER_MACROS
1105   void          Print (ostream &os) const;
1106 };
1107
1108
1109 class Certificates: public AsnType
1110 {
1111 public:
1112   Certificate           *userCertificate;
1113   ForwardCertificationPath              *certificationPath;
1114
1115                         Certificates();
1116                         Certificates (const Certificates &);
1117   virtual               ~Certificates();
1118   virtual AsnType       *Clone() const;
1119
1120   virtual AsnType       *Copy() const;
1121
1122   Certificates          &operator = (const Certificates &);
1123   AsnLen                BEncContent (BUF_TYPE b);
1124   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
1125
1126   AsnLen                BEnc (BUF_TYPE b);
1127   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
1128   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
1129   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
1130
1131   void          Print (ostream &os) const;
1132 };
1133
1134
1135 class CertificationPath: public AsnType
1136 {
1137 public:
1138   Certificate           *userCertificate;
1139   CertificationPathSeqOf                *theCACertificates;
1140
1141                         CertificationPath();
1142                         CertificationPath (const CertificationPath &);
1143   virtual               ~CertificationPath();
1144   virtual AsnType       *Clone() const;
1145
1146   virtual AsnType       *Copy() const;
1147
1148   CertificationPath             &operator = (const CertificationPath &);
1149   AsnLen                BEncContent (BUF_TYPE b);
1150   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
1151
1152   AsnLen                BEnc (BUF_TYPE b);
1153   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
1154   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
1155   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
1156
1157   void          Print (ostream &os) const;
1158 };
1159
1160
1161 class AttributeCertificationPath: public AsnType
1162 {
1163 public:
1164   AttributeCertificate          *attributeCertificate;
1165   AttributeCertificationPathSeqOf               *acPath;
1166
1167                         AttributeCertificationPath();
1168                         AttributeCertificationPath (const AttributeCertificationPath &);
1169   virtual               ~AttributeCertificationPath();
1170   virtual AsnType       *Clone() const;
1171
1172   virtual AsnType       *Copy() const;
1173
1174   AttributeCertificationPath            &operator = (const AttributeCertificationPath &);
1175   AsnLen                BEncContent (BUF_TYPE b);
1176   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
1177
1178   AsnLen                BEnc (BUF_TYPE b);
1179   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
1180   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
1181   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
1182
1183   void          Print (ostream &os) const;
1184 };
1185
1186
1187 class AttributeCertificateAssertion: public AsnType
1188 {
1189 public:
1190   AttributeCertificateAssertionChoice           *subject;
1191   Name          *issuer;
1192   GeneralizedTime               *attCertValidity;
1193   AttributeCertificateAssertionSetOf            *attType;
1194
1195                         AttributeCertificateAssertion();
1196                         AttributeCertificateAssertion (const AttributeCertificateAssertion &);
1197   virtual               ~AttributeCertificateAssertion();
1198   virtual AsnType       *Clone() const;
1199
1200   virtual AsnType       *Copy() const;
1201
1202   AttributeCertificateAssertion         &operator = (const AttributeCertificateAssertion &);
1203   AsnLen                BEncContent (BUF_TYPE b);
1204   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
1205
1206   AsnLen                BEnc (BUF_TYPE b);
1207   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
1208   int                   BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
1209   int                   BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
1210
1211   void          Print (ostream &os) const;
1212 };
1213
1214
1215 /* Certificate */
1216 typedef Certificate UserCertificate;
1217
1218 /* Certificate */
1219 typedef Certificate CACertificate;
1220
1221 /* CertificatePair */
1222 typedef CertificatePair CrossCertificatePair;
1223
1224 /* CertificateList */
1225 typedef CertificateList AuthorityRevocationList;
1226
1227 /* CertificateList */
1228 typedef CertificateList CertificateRevocationList;
1229
1230 /* CertificateList */
1231 typedef CertificateList AttributeCertificateRevocationList;
1232
1233 //------------------------------------------------------------------------------
1234 // externs for value defs
1235
1236 #define id_at_userPassword_arc 2, 5, 4, 35
1237 #define id_at_userPassword     AsnOid(id_at_userPassword_arc)
1238 #define id_at_userCertificate_arc 2, 5, 4, 36
1239 #define id_at_userCertificate     AsnOid(id_at_userCertificate_arc)
1240 #define id_at_cAcertificate_arc 2, 5, 4, 37
1241 #define id_at_cAcertificate     AsnOid(id_at_cAcertificate_arc)
1242 #define id_at_authorityRevocationList_arc 2, 5, 4, 38
1243 #define id_at_authorityRevocationList     AsnOid(id_at_authorityRevocationList_arc)
1244 #define id_at_certificateRevocationList_arc 2, 5, 4, 39
1245 #define id_at_certificateRevocationList     AsnOid(id_at_certificateRevocationList_arc)
1246 #define id_at_crossCertificatePair_arc 2, 5, 4, 40
1247 #define id_at_crossCertificatePair     AsnOid(id_at_crossCertificatePair_arc)
1248 #define id_at_attributeCertificate_arc 2, 5, 4, 58
1249 #define id_at_attributeCertificate     AsnOid(id_at_attributeCertificate_arc)
1250 //------------------------------------------------------------------------------
1251
1252 #endif /* conditional include of sm_x509af.h */