src/asn/h235.cxx

   1 //
   2 // h235.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #ifdef P_USE_PRAGMA
   8 #pragma implementation "h235.h"
   9 #endif
  10
  11 #include <ptlib.h>
  12 #include "asn/h235.h"
  13
  14 #define new PNEW
  15
  16
  17 #if ! H323_DISABLE_H235
  18
  19 #include "h235_t.cxx"
  20
  21 //
  22 // ChallengeString
  23 //
  24
  25 H235_ChallengeString::H235_ChallengeString(unsigned tag, PASN_Object::TagClass tagClass)
  26   : PASN_OctetString(tag, tagClass)
  27 {
  28   SetConstraints(PASN_Object::FixedConstraint, 8, 128);
  29 }
  30
  31
  32 H235_ChallengeString::H235_ChallengeString(const char * v)
  33 {
  34   SetValue(v);
  35 }
  36
  37
  38 H235_ChallengeString::H235_ChallengeString(const PString & v)
  39 {
  40   SetValue(v);
  41 }
  42
  43
  44 H235_ChallengeString::H235_ChallengeString(const PBYTEArray & v)
  45 {
  46   SetValue(v);
  47 }
  48
  49
  50 H235_ChallengeString & H235_ChallengeString::operator=(const char * v)
  51 {
  52   SetValue(v);
  53   return *this;
  54 }
  55
  56
  57 H235_ChallengeString & H235_ChallengeString::operator=(const PString & v)
  58 {
  59   SetValue(v);
  60   return *this;
  61 }
  62
  63
  64 H235_ChallengeString & H235_ChallengeString::operator=(const PBYTEArray & v)
  65 {
  66   SetValue(v);
  67   return *this;
  68 }
  69
  70
  71 PObject * H235_ChallengeString::Clone() const
  72 {
  73 #ifndef PASN_LEANANDMEAN
  74   PAssert(IsClass(H235_ChallengeString::Class()), PInvalidCast);
  75 #endif
  76   return new H235_ChallengeString(*this);
  77 }
  78
  79
  80 //
  81 // TimeStamp
  82 //
  83
  84 H235_TimeStamp::H235_TimeStamp(unsigned tag, PASN_Object::TagClass tagClass)
  85   : PASN_Integer(tag, tagClass)
  86 {
  87   SetConstraints(PASN_Object::FixedConstraint, 1, 4294967295U);
  88 }
  89
  90
  91 H235_TimeStamp & H235_TimeStamp::operator=(int v)
  92 {
  93   SetValue(v);
  94   return *this;
  95 }
  96
  97
  98 H235_TimeStamp & H235_TimeStamp::operator=(unsigned v)
  99 {
 100   SetValue(v);
 101   return *this;
 102 }
 103
 104
 105 PObject * H235_TimeStamp::Clone() const
 106 {
 107 #ifndef PASN_LEANANDMEAN
 108   PAssert(IsClass(H235_TimeStamp::Class()), PInvalidCast);
 109 #endif
 110   return new H235_TimeStamp(*this);
 111 }
 112
 113
 114 //
 115 // RandomVal
 116 //
 117
 118 H235_RandomVal::H235_RandomVal(unsigned tag, PASN_Object::TagClass tagClass)
 119   : PASN_Integer(tag, tagClass)
 120 {
 121 }
 122
 123
 124 H235_RandomVal & H235_RandomVal::operator=(int v)
 125 {
 126   SetValue(v);
 127   return *this;
 128 }
 129
 130
 131 H235_RandomVal & H235_RandomVal::operator=(unsigned v)
 132 {
 133   SetValue(v);
 134   return *this;
 135 }
 136
 137
 138 PObject * H235_RandomVal::Clone() const
 139 {
 140 #ifndef PASN_LEANANDMEAN
 141   PAssert(IsClass(H235_RandomVal::Class()), PInvalidCast);
 142 #endif
 143   return new H235_RandomVal(*this);
 144 }
 145
 146
 147 //
 148 // Password
 149 //
 150
 151 H235_Password::H235_Password(unsigned tag, PASN_Object::TagClass tagClass)
 152   : PASN_BMPString(tag, tagClass)
 153 {
 154   SetConstraints(PASN_Object::FixedConstraint, 1, 128);
 155 }
 156
 157
 158 H235_Password & H235_Password::operator=(const char * v)
 159 {
 160   SetValue(v);
 161   return *this;
 162 }
 163
 164
 165 H235_Password & H235_Password::operator=(const PString & v)
 166 {
 167   SetValue(v);
 168   return *this;
 169 }
 170
 171
 172 H235_Password & H235_Password::operator=(const PWORDArray & v)
 173 {
 174   SetValue(v);
 175   return *this;
 176 }
 177
 178
 179 H235_Password & H235_Password::operator=(const PASN_BMPString & v)
 180 {
 181   SetValue(v);
 182   return *this;
 183 }
 184
 185
 186 PObject * H235_Password::Clone() const
 187 {
 188 #ifndef PASN_LEANANDMEAN
 189   PAssert(IsClass(H235_Password::Class()), PInvalidCast);
 190 #endif
 191   return new H235_Password(*this);
 192 }
 193
 194
 195 //
 196 // Identifier
 197 //
 198
 199 H235_Identifier::H235_Identifier(unsigned tag, PASN_Object::TagClass tagClass)
 200   : PASN_BMPString(tag, tagClass)
 201 {
 202   SetConstraints(PASN_Object::FixedConstraint, 1, 128);
 203 }
 204
 205
 206 H235_Identifier & H235_Identifier::operator=(const char * v)
 207 {
 208   SetValue(v);
 209   return *this;
 210 }
 211
 212
 213 H235_Identifier & H235_Identifier::operator=(const PString & v)
 214 {
 215   SetValue(v);
 216   return *this;
 217 }
 218
 219
 220 H235_Identifier & H235_Identifier::operator=(const PWORDArray & v)
 221 {
 222   SetValue(v);
 223   return *this;
 224 }
 225
 226
 227 H235_Identifier & H235_Identifier::operator=(const PASN_BMPString & v)
 228 {
 229   SetValue(v);
 230   return *this;
 231 }
 232
 233
 234 PObject * H235_Identifier::Clone() const
 235 {
 236 #ifndef PASN_LEANANDMEAN
 237   PAssert(IsClass(H235_Identifier::Class()), PInvalidCast);
 238 #endif
 239   return new H235_Identifier(*this);
 240 }
 241
 242
 243 //
 244 // KeyMaterial
 245 //
 246
 247 H235_KeyMaterial::H235_KeyMaterial(unsigned tag, PASN_Object::TagClass tagClass)
 248   : PASN_BitString(tag, tagClass)
 249 {
 250   SetConstraints(PASN_Object::FixedConstraint, 1, 2048);
 251 }
 252
 253
 254 PObject * H235_KeyMaterial::Clone() const
 255 {
 256 #ifndef PASN_LEANANDMEAN
 257   PAssert(IsClass(H235_KeyMaterial::Class()), PInvalidCast);
 258 #endif
 259   return new H235_KeyMaterial(*this);
 260 }
 261
 262
 263 //
 264 // NonStandardParameter
 265 //
 266
 267 H235_NonStandardParameter::H235_NonStandardParameter(unsigned tag, PASN_Object::TagClass tagClass)
 268   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
 269 {
 270 }
 271
 272
 273 #ifndef PASN_NOPRINTON
 274 void H235_NonStandardParameter::PrintOn(ostream & strm) const
 275 {
 276   int indent = strm.precision() + 2;
 277   strm << "{\n";
 278   strm << setw(indent+24) << "nonStandardIdentifier = " << setprecision(indent) << m_nonStandardIdentifier << '\n';
 279   strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
 280   strm << setw(indent-1) << setprecision(indent-2) << "}";
 281 }
 282 #endif
 283
 284
 285 PObject::Comparison H235_NonStandardParameter::Compare(const PObject & obj) const
 286 {
 287 #ifndef PASN_LEANANDMEAN
 288   PAssert(PIsDescendant(&obj, H235_NonStandardParameter), PInvalidCast);
 289 #endif
 290   const H235_NonStandardParameter & other = (const H235_NonStandardParameter &)obj;
 291
 292   Comparison result;
 293
 294   if ((result = m_nonStandardIdentifier.Compare(other.m_nonStandardIdentifier)) != EqualTo)
 295     return result;
 296   if ((result = m_data.Compare(other.m_data)) != EqualTo)
 297     return result;
 298
 299   return PASN_Sequence::Compare(other);
 300 }
 301
 302
 303 PINDEX H235_NonStandardParameter::GetDataLength() const
 304 {
 305   PINDEX length = 0;
 306   length += m_nonStandardIdentifier.GetObjectLength();
 307   length += m_data.GetObjectLength();
 308   return length;
 309 }
 310
 311
 312 BOOL H235_NonStandardParameter::Decode(PASN_Stream & strm)
 313 {
 314   if (!PreambleDecode(strm))
 315     return FALSE;
 316
 317   if (!m_nonStandardIdentifier.Decode(strm))
 318     return FALSE;
 319   if (!m_data.Decode(strm))
 320     return FALSE;
 321
 322   return UnknownExtensionsDecode(strm);
 323 }
 324
 325
 326 void H235_NonStandardParameter::Encode(PASN_Stream & strm) const
 327 {
 328   PreambleEncode(strm);
 329
 330   m_nonStandardIdentifier.Encode(strm);
 331   m_data.Encode(strm);
 332
 333   UnknownExtensionsEncode(strm);
 334 }
 335
 336
 337 PObject * H235_NonStandardParameter::Clone() const
 338 {
 339 #ifndef PASN_LEANANDMEAN
 340   PAssert(IsClass(H235_NonStandardParameter::Class()), PInvalidCast);
 341 #endif
 342   return new H235_NonStandardParameter(*this);
 343 }
 344
 345
 346 //
 347 // DHset
 348 //
 349
 350 H235_DHset::H235_DHset(unsigned tag, PASN_Object::TagClass tagClass)
 351   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 352 {
 353   m_halfkey.SetConstraints(PASN_Object::FixedConstraint, 0, 2048);
 354   m_modSize.SetConstraints(PASN_Object::FixedConstraint, 0, 2048);
 355   m_generator.SetConstraints(PASN_Object::FixedConstraint, 0, 2048);
 356 }
 357
 358
 359 #ifndef PASN_NOPRINTON
 360 void H235_DHset::PrintOn(ostream & strm) const
 361 {
 362   int indent = strm.precision() + 2;
 363   strm << "{\n";
 364   strm << setw(indent+10) << "halfkey = " << setprecision(indent) << m_halfkey << '\n';
 365   strm << setw(indent+10) << "modSize = " << setprecision(indent) << m_modSize << '\n';
 366   strm << setw(indent+12) << "generator = " << setprecision(indent) << m_generator << '\n';
 367   strm << setw(indent-1) << setprecision(indent-2) << "}";
 368 }
 369 #endif
 370
 371
 372 PObject::Comparison H235_DHset::Compare(const PObject & obj) const
 373 {
 374 #ifndef PASN_LEANANDMEAN
 375   PAssert(PIsDescendant(&obj, H235_DHset), PInvalidCast);
 376 #endif
 377   const H235_DHset & other = (const H235_DHset &)obj;
 378
 379   Comparison result;
 380
 381   if ((result = m_halfkey.Compare(other.m_halfkey)) != EqualTo)
 382     return result;
 383   if ((result = m_modSize.Compare(other.m_modSize)) != EqualTo)
 384     return result;
 385   if ((result = m_generator.Compare(other.m_generator)) != EqualTo)
 386     return result;
 387
 388   return PASN_Sequence::Compare(other);
 389 }
 390
 391
 392 PINDEX H235_DHset::GetDataLength() const
 393 {
 394   PINDEX length = 0;
 395   length += m_halfkey.GetObjectLength();
 396   length += m_modSize.GetObjectLength();
 397   length += m_generator.GetObjectLength();
 398   return length;
 399 }
 400
 401
 402 BOOL H235_DHset::Decode(PASN_Stream & strm)
 403 {
 404   if (!PreambleDecode(strm))
 405     return FALSE;
 406
 407   if (!m_halfkey.Decode(strm))
 408     return FALSE;
 409   if (!m_modSize.Decode(strm))
 410     return FALSE;
 411   if (!m_generator.Decode(strm))
 412     return FALSE;
 413
 414   return UnknownExtensionsDecode(strm);
 415 }
 416
 417
 418 void H235_DHset::Encode(PASN_Stream & strm) const
 419 {
 420   PreambleEncode(strm);
 421
 422   m_halfkey.Encode(strm);
 423   m_modSize.Encode(strm);
 424   m_generator.Encode(strm);
 425
 426   UnknownExtensionsEncode(strm);
 427 }
 428
 429
 430 PObject * H235_DHset::Clone() const
 431 {
 432 #ifndef PASN_LEANANDMEAN
 433   PAssert(IsClass(H235_DHset::Class()), PInvalidCast);
 434 #endif
 435   return new H235_DHset(*this);
 436 }
 437
 438
 439 //
 440 // ECpoint
 441 //
 442
 443 H235_ECpoint::H235_ECpoint(unsigned tag, PASN_Object::TagClass tagClass)
 444   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
 445 {
 446   m_x.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
 447   m_y.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
 448 }
 449
 450
 451 #ifndef PASN_NOPRINTON
 452 void H235_ECpoint::PrintOn(ostream & strm) const
 453 {
 454   int indent = strm.precision() + 2;
 455   strm << "{\n";
 456   if (HasOptionalField(e_x))
 457     strm << setw(indent+4) << "x = " << setprecision(indent) << m_x << '\n';
 458   if (HasOptionalField(e_y))
 459     strm << setw(indent+4) << "y = " << setprecision(indent) << m_y << '\n';
 460   strm << setw(indent-1) << setprecision(indent-2) << "}";
 461 }
 462 #endif
 463
 464
 465 PObject::Comparison H235_ECpoint::Compare(const PObject & obj) const
 466 {
 467 #ifndef PASN_LEANANDMEAN
 468   PAssert(PIsDescendant(&obj, H235_ECpoint), PInvalidCast);
 469 #endif
 470   const H235_ECpoint & other = (const H235_ECpoint &)obj;
 471
 472   Comparison result;
 473
 474   if ((result = m_x.Compare(other.m_x)) != EqualTo)
 475     return result;
 476   if ((result = m_y.Compare(other.m_y)) != EqualTo)
 477     return result;
 478
 479   return PASN_Sequence::Compare(other);
 480 }
 481
 482
 483 PINDEX H235_ECpoint::GetDataLength() const
 484 {
 485   PINDEX length = 0;
 486   if (HasOptionalField(e_x))
 487     length += m_x.GetObjectLength();
 488   if (HasOptionalField(e_y))
 489     length += m_y.GetObjectLength();
 490   return length;
 491 }
 492
 493
 494 BOOL H235_ECpoint::Decode(PASN_Stream & strm)
 495 {
 496   if (!PreambleDecode(strm))
 497     return FALSE;
 498
 499   if (HasOptionalField(e_x) && !m_x.Decode(strm))
 500     return FALSE;
 501   if (HasOptionalField(e_y) && !m_y.Decode(strm))
 502     return FALSE;
 503
 504   return UnknownExtensionsDecode(strm);
 505 }
 506
 507
 508 void H235_ECpoint::Encode(PASN_Stream & strm) const
 509 {
 510   PreambleEncode(strm);
 511
 512   if (HasOptionalField(e_x))
 513     m_x.Encode(strm);
 514   if (HasOptionalField(e_y))
 515     m_y.Encode(strm);
 516
 517   UnknownExtensionsEncode(strm);
 518 }
 519
 520
 521 PObject * H235_ECpoint::Clone() const
 522 {
 523 #ifndef PASN_LEANANDMEAN
 524   PAssert(IsClass(H235_ECpoint::Class()), PInvalidCast);
 525 #endif
 526   return new H235_ECpoint(*this);
 527 }
 528
 529
 530
 531 #ifndef PASN_NOPRINTON
 532 const static PASN_Names Names_H235_ECKASDH[]={
 533       {"eckasdhp",0}
 534      ,{"eckasdh2",1}
 535 };
 536 #endif
 537 //
 538 // ECKASDH
 539 //
 540
 541 H235_ECKASDH::H235_ECKASDH(unsigned tag, PASN_Object::TagClass tagClass)
 542   : PASN_Choice(tag, tagClass, 2, TRUE
 543 #ifndef PASN_NOPRINTON
 544     ,(const PASN_Names *)Names_H235_ECKASDH,2
 545 #endif
 546 )
 547 {
 548 }
 549
 550
 551 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 552 H235_ECKASDH::operator H235_ECKASDH_eckasdhp &() const
 553 #else
 554 H235_ECKASDH::operator H235_ECKASDH_eckasdhp &()
 555 {
 556 #ifndef PASN_LEANANDMEAN
 557   PAssert(PIsDescendant(PAssertNULL(choice), H235_ECKASDH_eckasdhp), PInvalidCast);
 558 #endif
 559   return *(H235_ECKASDH_eckasdhp *)choice;
 560 }
 561
 562
 563 H235_ECKASDH::operator const H235_ECKASDH_eckasdhp &() const
 564 #endif
 565 {
 566 #ifndef PASN_LEANANDMEAN
 567   PAssert(PIsDescendant(PAssertNULL(choice), H235_ECKASDH_eckasdhp), PInvalidCast);
 568 #endif
 569   return *(H235_ECKASDH_eckasdhp *)choice;
 570 }
 571
 572
 573 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 574 H235_ECKASDH::operator H235_ECKASDH_eckasdh2 &() const
 575 #else
 576 H235_ECKASDH::operator H235_ECKASDH_eckasdh2 &()
 577 {
 578 #ifndef PASN_LEANANDMEAN
 579   PAssert(PIsDescendant(PAssertNULL(choice), H235_ECKASDH_eckasdh2), PInvalidCast);
 580 #endif
 581   return *(H235_ECKASDH_eckasdh2 *)choice;
 582 }
 583
 584
 585 H235_ECKASDH::operator const H235_ECKASDH_eckasdh2 &() const
 586 #endif
 587 {
 588 #ifndef PASN_LEANANDMEAN
 589   PAssert(PIsDescendant(PAssertNULL(choice), H235_ECKASDH_eckasdh2), PInvalidCast);
 590 #endif
 591   return *(H235_ECKASDH_eckasdh2 *)choice;
 592 }
 593
 594
 595 BOOL H235_ECKASDH::CreateObject()
 596 {
 597   switch (tag) {
 598     case e_eckasdhp :
 599       choice = new H235_ECKASDH_eckasdhp();
 600       return TRUE;
 601     case e_eckasdh2 :
 602       choice = new H235_ECKASDH_eckasdh2();
 603       return TRUE;
 604   }
 605
 606   choice = NULL;
 607   return FALSE;
 608 }
 609
 610
 611 PObject * H235_ECKASDH::Clone() const
 612 {
 613 #ifndef PASN_LEANANDMEAN
 614   PAssert(IsClass(H235_ECKASDH::Class()), PInvalidCast);
 615 #endif
 616   return new H235_ECKASDH(*this);
 617 }
 618
 619
 620 //
 621 // ECGDSASignature
 622 //
 623
 624 H235_ECGDSASignature::H235_ECGDSASignature(unsigned tag, PASN_Object::TagClass tagClass)
 625   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
 626 {
 627   m_r.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
 628   m_s.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
 629 }
 630
 631
 632 #ifndef PASN_NOPRINTON
 633 void H235_ECGDSASignature::PrintOn(ostream & strm) const
 634 {
 635   int indent = strm.precision() + 2;
 636   strm << "{\n";
 637   strm << setw(indent+4) << "r = " << setprecision(indent) << m_r << '\n';
 638   strm << setw(indent+4) << "s = " << setprecision(indent) << m_s << '\n';
 639   strm << setw(indent-1) << setprecision(indent-2) << "}";
 640 }
 641 #endif
 642
 643
 644 PObject::Comparison H235_ECGDSASignature::Compare(const PObject & obj) const
 645 {
 646 #ifndef PASN_LEANANDMEAN
 647   PAssert(PIsDescendant(&obj, H235_ECGDSASignature), PInvalidCast);
 648 #endif
 649   const H235_ECGDSASignature & other = (const H235_ECGDSASignature &)obj;
 650
 651   Comparison result;
 652
 653   if ((result = m_r.Compare(other.m_r)) != EqualTo)
 654     return result;
 655   if ((result = m_s.Compare(other.m_s)) != EqualTo)
 656     return result;
 657
 658   return PASN_Sequence::Compare(other);
 659 }
 660
 661
 662 PINDEX H235_ECGDSASignature::GetDataLength() const
 663 {
 664   PINDEX length = 0;
 665   length += m_r.GetObjectLength();
 666   length += m_s.GetObjectLength();
 667   return length;
 668 }
 669
 670
 671 BOOL H235_ECGDSASignature::Decode(PASN_Stream & strm)
 672 {
 673   if (!PreambleDecode(strm))
 674     return FALSE;
 675
 676   if (!m_r.Decode(strm))
 677     return FALSE;
 678   if (!m_s.Decode(strm))
 679     return FALSE;
 680
 681   return UnknownExtensionsDecode(strm);
 682 }
 683
 684
 685 void H235_ECGDSASignature::Encode(PASN_Stream & strm) const
 686 {
 687   PreambleEncode(strm);
 688
 689   m_r.Encode(strm);
 690   m_s.Encode(strm);
 691
 692   UnknownExtensionsEncode(strm);
 693 }
 694
 695
 696 PObject * H235_ECGDSASignature::Clone() const
 697 {
 698 #ifndef PASN_LEANANDMEAN
 699   PAssert(IsClass(H235_ECGDSASignature::Class()), PInvalidCast);
 700 #endif
 701   return new H235_ECGDSASignature(*this);
 702 }
 703
 704
 705 //
 706 // TypedCertificate
 707 //
 708
 709 H235_TypedCertificate::H235_TypedCertificate(unsigned tag, PASN_Object::TagClass tagClass)
 710   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 711 {
 712 }
 713
 714
 715 #ifndef PASN_NOPRINTON
 716 void H235_TypedCertificate::PrintOn(ostream & strm) const
 717 {
 718   int indent = strm.precision() + 2;
 719   strm << "{\n";
 720   strm << setw(indent+7) << "type = " << setprecision(indent) << m_type << '\n';
 721   strm << setw(indent+14) << "certificate = " << setprecision(indent) << m_certificate << '\n';
 722   strm << setw(indent-1) << setprecision(indent-2) << "}";
 723 }
 724 #endif
 725
 726
 727 PObject::Comparison H235_TypedCertificate::Compare(const PObject & obj) const
 728 {
 729 #ifndef PASN_LEANANDMEAN
 730   PAssert(PIsDescendant(&obj, H235_TypedCertificate), PInvalidCast);
 731 #endif
 732   const H235_TypedCertificate & other = (const H235_TypedCertificate &)obj;
 733
 734   Comparison result;
 735
 736   if ((result = m_type.Compare(other.m_type)) != EqualTo)
 737     return result;
 738   if ((result = m_certificate.Compare(other.m_certificate)) != EqualTo)
 739     return result;
 740
 741   return PASN_Sequence::Compare(other);
 742 }
 743
 744
 745 PINDEX H235_TypedCertificate::GetDataLength() const
 746 {
 747   PINDEX length = 0;
 748   length += m_type.GetObjectLength();
 749   length += m_certificate.GetObjectLength();
 750   return length;
 751 }
 752
 753
 754 BOOL H235_TypedCertificate::Decode(PASN_Stream & strm)
 755 {
 756   if (!PreambleDecode(strm))
 757     return FALSE;
 758
 759   if (!m_type.Decode(strm))
 760     return FALSE;
 761   if (!m_certificate.Decode(strm))
 762     return FALSE;
 763
 764   return UnknownExtensionsDecode(strm);
 765 }
 766
 767
 768 void H235_TypedCertificate::Encode(PASN_Stream & strm) const
 769 {
 770   PreambleEncode(strm);
 771
 772   m_type.Encode(strm);
 773   m_certificate.Encode(strm);
 774
 775   UnknownExtensionsEncode(strm);
 776 }
 777
 778
 779 PObject * H235_TypedCertificate::Clone() const
 780 {
 781 #ifndef PASN_LEANANDMEAN
 782   PAssert(IsClass(H235_TypedCertificate::Class()), PInvalidCast);
 783 #endif
 784   return new H235_TypedCertificate(*this);
 785 }
 786
 787
 788
 789 #ifndef PASN_NOPRINTON
 790 const static PASN_Names Names_H235_AuthenticationBES[]={
 791       {"default",0}
 792      ,{"radius",1}
 793 };
 794 #endif
 795 //
 796 // AuthenticationBES
 797 //
 798
 799 H235_AuthenticationBES::H235_AuthenticationBES(unsigned tag, PASN_Object::TagClass tagClass)
 800   : PASN_Choice(tag, tagClass, 2, TRUE
 801 #ifndef PASN_NOPRINTON
 802     ,(const PASN_Names *)Names_H235_AuthenticationBES,2
 803 #endif
 804 )
 805 {
 806 }
 807
 808
 809 BOOL H235_AuthenticationBES::CreateObject()
 810 {
 811   choice = (tag <= e_radius) ? new PASN_Null() : NULL;
 812   return choice != NULL;
 813 }
 814
 815
 816 PObject * H235_AuthenticationBES::Clone() const
 817 {
 818 #ifndef PASN_LEANANDMEAN
 819   PAssert(IsClass(H235_AuthenticationBES::Class()), PInvalidCast);
 820 #endif
 821   return new H235_AuthenticationBES(*this);
 822 }
 823
 824
 825
 826 #ifndef PASN_NOPRINTON
 827 const static PASN_Names Names_H235_AuthenticationMechanism[]={
 828       {"dhExch",0}
 829      ,{"pwdSymEnc",1}
 830      ,{"pwdHash",2}
 831      ,{"certSign",3}
 832      ,{"ipsec",4}
 833      ,{"tls",5}
 834      ,{"nonStandard",6}
 835      ,{"authenticationBES",7}
 836      ,{"keyExch",8}
 837 };
 838 #endif
 839 //
 840 // AuthenticationMechanism
 841 //
 842
 843 H235_AuthenticationMechanism::H235_AuthenticationMechanism(unsigned tag, PASN_Object::TagClass tagClass)
 844   : PASN_Choice(tag, tagClass, 7, TRUE
 845 #ifndef PASN_NOPRINTON
 846     ,(const PASN_Names *)Names_H235_AuthenticationMechanism,9
 847 #endif
 848 )
 849 {
 850 }
 851
 852
 853 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 854 H235_AuthenticationMechanism::operator H235_NonStandardParameter &() const
 855 #else
 856 H235_AuthenticationMechanism::operator H235_NonStandardParameter &()
 857 {
 858 #ifndef PASN_LEANANDMEAN
 859   PAssert(PIsDescendant(PAssertNULL(choice), H235_NonStandardParameter), PInvalidCast);
 860 #endif
 861   return *(H235_NonStandardParameter *)choice;
 862 }
 863
 864
 865 H235_AuthenticationMechanism::operator const H235_NonStandardParameter &() const
 866 #endif
 867 {
 868 #ifndef PASN_LEANANDMEAN
 869   PAssert(PIsDescendant(PAssertNULL(choice), H235_NonStandardParameter), PInvalidCast);
 870 #endif
 871   return *(H235_NonStandardParameter *)choice;
 872 }
 873
 874
 875 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 876 H235_AuthenticationMechanism::operator H235_AuthenticationBES &() const
 877 #else
 878 H235_AuthenticationMechanism::operator H235_AuthenticationBES &()
 879 {
 880 #ifndef PASN_LEANANDMEAN
 881   PAssert(PIsDescendant(PAssertNULL(choice), H235_AuthenticationBES), PInvalidCast);
 882 #endif
 883   return *(H235_AuthenticationBES *)choice;
 884 }
 885
 886
 887 H235_AuthenticationMechanism::operator const H235_AuthenticationBES &() const
 888 #endif
 889 {
 890 #ifndef PASN_LEANANDMEAN
 891   PAssert(PIsDescendant(PAssertNULL(choice), H235_AuthenticationBES), PInvalidCast);
 892 #endif
 893   return *(H235_AuthenticationBES *)choice;
 894 }
 895
 896
 897 BOOL H235_AuthenticationMechanism::CreateObject()
 898 {
 899   switch (tag) {
 900     case e_dhExch :
 901     case e_pwdSymEnc :
 902     case e_pwdHash :
 903     case e_certSign :
 904     case e_ipsec :
 905     case e_tls :
 906       choice = new PASN_Null();
 907       return TRUE;
 908     case e_nonStandard :
 909       choice = new H235_NonStandardParameter();
 910       return TRUE;
 911     case e_authenticationBES :
 912       choice = new H235_AuthenticationBES();
 913       return TRUE;
 914     case e_keyExch :
 915       choice = new PASN_ObjectId();
 916       return TRUE;
 917   }
 918
 919   choice = NULL;
 920   return FALSE;
 921 }
 922
 923
 924 PObject * H235_AuthenticationMechanism::Clone() const
 925 {
 926 #ifndef PASN_LEANANDMEAN
 927   PAssert(IsClass(H235_AuthenticationMechanism::Class()), PInvalidCast);
 928 #endif
 929   return new H235_AuthenticationMechanism(*this);
 930 }
 931
 932
 933
 934 #ifndef PASN_NOPRINTON
 935 const static PASN_Names Names_H235_Element[]={
 936       {"octets",0}
 937      ,{"integer",1}
 938      ,{"bits",2}
 939      ,{"name",3}
 940      ,{"flag",4}
 941 };
 942 #endif
 943 //
 944 // Element
 945 //
 946
 947 H235_Element::H235_Element(unsigned tag, PASN_Object::TagClass tagClass)
 948   : PASN_Choice(tag, tagClass, 5, TRUE
 949 #ifndef PASN_NOPRINTON
 950     ,(const PASN_Names *)Names_H235_Element,5
 951 #endif
 952 )
 953 {
 954 }
 955
 956
 957 BOOL H235_Element::CreateObject()
 958 {
 959   switch (tag) {
 960     case e_octets :
 961       choice = new PASN_OctetString();
 962       return TRUE;
 963     case e_integer :
 964       choice = new PASN_Integer();
 965       return TRUE;
 966     case e_bits :
 967       choice = new PASN_BitString();
 968       return TRUE;
 969     case e_name :
 970       choice = new PASN_BMPString();
 971       return TRUE;
 972     case e_flag :
 973       choice = new PASN_Boolean();
 974       return TRUE;
 975   }
 976
 977   choice = NULL;
 978   return FALSE;
 979 }
 980
 981
 982 PObject * H235_Element::Clone() const
 983 {
 984 #ifndef PASN_LEANANDMEAN
 985   PAssert(IsClass(H235_Element::Class()), PInvalidCast);
 986 #endif
 987   return new H235_Element(*this);
 988 }
 989
 990
 991 //
 992 // IV8
 993 //
 994
 995 H235_IV8::H235_IV8(unsigned tag, PASN_Object::TagClass tagClass)
 996   : PASN_OctetString(tag, tagClass)
 997 {
 998   SetConstraints(PASN_Object::FixedConstraint, 8);
 999 }
1000
1001
1002 H235_IV8::H235_IV8(const char * v)
1003 {
1004   SetValue(v);
1005 }
1006
1007
1008 H235_IV8::H235_IV8(const PString & v)
1009 {
1010   SetValue(v);
1011 }
1012
1013
1014 H235_IV8::H235_IV8(const PBYTEArray & v)
1015 {
1016   SetValue(v);
1017 }
1018
1019
1020 H235_IV8 & H235_IV8::operator=(const char * v)
1021 {
1022   SetValue(v);
1023   return *this;
1024 }
1025
1026
1027 H235_IV8 & H235_IV8::operator=(const PString & v)
1028 {
1029   SetValue(v);
1030   return *this;
1031 }
1032
1033
1034 H235_IV8 & H235_IV8::operator=(const PBYTEArray & v)
1035 {
1036   SetValue(v);
1037   return *this;
1038 }
1039
1040
1041 PObject * H235_IV8::Clone() const
1042 {
1043 #ifndef PASN_LEANANDMEAN
1044   PAssert(IsClass(H235_IV8::Class()), PInvalidCast);
1045 #endif
1046   return new H235_IV8(*this);
1047 }
1048
1049
1050 //
1051 // IV16
1052 //
1053
1054 H235_IV16::H235_IV16(unsigned tag, PASN_Object::TagClass tagClass)
1055   : PASN_OctetString(tag, tagClass)
1056 {
1057   SetConstraints(PASN_Object::FixedConstraint, 16);
1058 }
1059
1060
1061 H235_IV16::H235_IV16(const char * v)
1062 {
1063   SetValue(v);
1064 }
1065
1066
1067 H235_IV16::H235_IV16(const PString & v)
1068 {
1069   SetValue(v);
1070 }
1071
1072
1073 H235_IV16::H235_IV16(const PBYTEArray & v)
1074 {
1075   SetValue(v);
1076 }
1077
1078
1079 H235_IV16 & H235_IV16::operator=(const char * v)
1080 {
1081   SetValue(v);
1082   return *this;
1083 }
1084
1085
1086 H235_IV16 & H235_IV16::operator=(const PString & v)
1087 {
1088   SetValue(v);
1089   return *this;
1090 }
1091
1092
1093 H235_IV16 & H235_IV16::operator=(const PBYTEArray & v)
1094 {
1095   SetValue(v);
1096   return *this;
1097 }
1098
1099
1100 PObject * H235_IV16::Clone() const
1101 {
1102 #ifndef PASN_LEANANDMEAN
1103   PAssert(IsClass(H235_IV16::Class()), PInvalidCast);
1104 #endif
1105   return new H235_IV16(*this);
1106 }
1107
1108
1109 //
1110 // Params
1111 //
1112
1113 H235_Params::H235_Params(unsigned tag, PASN_Object::TagClass tagClass)
1114   : PASN_Sequence(tag, tagClass, 2, TRUE, 3)
1115 {
1116 }
1117
1118
1119 #ifndef PASN_NOPRINTON
1120 void H235_Params::PrintOn(ostream & strm) const
1121 {
1122   int indent = strm.precision() + 2;
1123   strm << "{\n";
1124   if (HasOptionalField(e_ranInt))
1125     strm << setw(indent+9) << "ranInt = " << setprecision(indent) << m_ranInt << '\n';
1126   if (HasOptionalField(e_iv8))
1127     strm << setw(indent+6) << "iv8 = " << setprecision(indent) << m_iv8 << '\n';
1128   if (HasOptionalField(e_iv16))
1129     strm << setw(indent+7) << "iv16 = " << setprecision(indent) << m_iv16 << '\n';
1130   if (HasOptionalField(e_iv))
1131     strm << setw(indent+5) << "iv = " << setprecision(indent) << m_iv << '\n';
1132   if (HasOptionalField(e_clearSalt))
1133     strm << setw(indent+12) << "clearSalt = " << setprecision(indent) << m_clearSalt << '\n';
1134   strm << setw(indent-1) << setprecision(indent-2) << "}";
1135 }
1136 #endif
1137
1138
1139 PObject::Comparison H235_Params::Compare(const PObject & obj) const
1140 {
1141 #ifndef PASN_LEANANDMEAN
1142   PAssert(PIsDescendant(&obj, H235_Params), PInvalidCast);
1143 #endif
1144   const H235_Params & other = (const H235_Params &)obj;
1145
1146   Comparison result;
1147
1148   if ((result = m_ranInt.Compare(other.m_ranInt)) != EqualTo)
1149     return result;
1150   if ((result = m_iv8.Compare(other.m_iv8)) != EqualTo)
1151     return result;
1152
1153   return PASN_Sequence::Compare(other);
1154 }
1155
1156
1157 PINDEX H235_Params::GetDataLength() const
1158 {
1159   PINDEX length = 0;
1160   if (HasOptionalField(e_ranInt))
1161     length += m_ranInt.GetObjectLength();
1162   if (HasOptionalField(e_iv8))
1163     length += m_iv8.GetObjectLength();
1164   return length;
1165 }
1166
1167
1168 BOOL H235_Params::Decode(PASN_Stream & strm)
1169 {
1170   if (!PreambleDecode(strm))
1171     return FALSE;
1172
1173   if (HasOptionalField(e_ranInt) && !m_ranInt.Decode(strm))
1174     return FALSE;
1175   if (HasOptionalField(e_iv8) && !m_iv8.Decode(strm))
1176     return FALSE;
1177   if (!KnownExtensionDecode(strm, e_iv16, m_iv16))
1178     return FALSE;
1179   if (!KnownExtensionDecode(strm, e_iv, m_iv))
1180     return FALSE;
1181   if (!KnownExtensionDecode(strm, e_clearSalt, m_clearSalt))
1182     return FALSE;
1183
1184   return UnknownExtensionsDecode(strm);
1185 }
1186
1187
1188 void H235_Params::Encode(PASN_Stream & strm) const
1189 {
1190   PreambleEncode(strm);
1191
1192   if (HasOptionalField(e_ranInt))
1193     m_ranInt.Encode(strm);
1194   if (HasOptionalField(e_iv8))
1195     m_iv8.Encode(strm);
1196   KnownExtensionEncode(strm, e_iv16, m_iv16);
1197   KnownExtensionEncode(strm, e_iv, m_iv);
1198   KnownExtensionEncode(strm, e_clearSalt, m_clearSalt);
1199
1200   UnknownExtensionsEncode(strm);
1201 }
1202
1203
1204 PObject * H235_Params::Clone() const
1205 {
1206 #ifndef PASN_LEANANDMEAN
1207   PAssert(IsClass(H235_Params::Class()), PInvalidCast);
1208 #endif
1209   return new H235_Params(*this);
1210 }
1211
1212
1213 //
1214 // ReturnSig
1215 //
1216
1217 H235_ReturnSig::H235_ReturnSig(unsigned tag, PASN_Object::TagClass tagClass)
1218   : PASN_Sequence(tag, tagClass, 2, FALSE, 0)
1219 {
1220 }
1221
1222
1223 #ifndef PASN_NOPRINTON
1224 void H235_ReturnSig::PrintOn(ostream & strm) const
1225 {
1226   int indent = strm.precision() + 2;
1227   strm << "{\n";
1228   strm << setw(indent+12) << "generalId = " << setprecision(indent) << m_generalId << '\n';
1229   strm << setw(indent+17) << "responseRandom = " << setprecision(indent) << m_responseRandom << '\n';
1230   if (HasOptionalField(e_requestRandom))
1231     strm << setw(indent+16) << "requestRandom = " << setprecision(indent) << m_requestRandom << '\n';
1232   if (HasOptionalField(e_certificate))
1233     strm << setw(indent+14) << "certificate = " << setprecision(indent) << m_certificate << '\n';
1234   strm << setw(indent-1) << setprecision(indent-2) << "}";
1235 }
1236 #endif
1237
1238
1239 PObject::Comparison H235_ReturnSig::Compare(const PObject & obj) const
1240 {
1241 #ifndef PASN_LEANANDMEAN
1242   PAssert(PIsDescendant(&obj, H235_ReturnSig), PInvalidCast);
1243 #endif
1244   const H235_ReturnSig & other = (const H235_ReturnSig &)obj;
1245
1246   Comparison result;
1247
1248   if ((result = m_generalId.Compare(other.m_generalId)) != EqualTo)
1249     return result;
1250   if ((result = m_responseRandom.Compare(other.m_responseRandom)) != EqualTo)
1251     return result;
1252   if ((result = m_requestRandom.Compare(other.m_requestRandom)) != EqualTo)
1253     return result;
1254   if ((result = m_certificate.Compare(other.m_certificate)) != EqualTo)
1255     return result;
1256
1257   return PASN_Sequence::Compare(other);
1258 }
1259
1260
1261 PINDEX H235_ReturnSig::GetDataLength() const
1262 {
1263   PINDEX length = 0;
1264   length += m_generalId.GetObjectLength();
1265   length += m_responseRandom.GetObjectLength();
1266   if (HasOptionalField(e_requestRandom))
1267     length += m_requestRandom.GetObjectLength();
1268   if (HasOptionalField(e_certificate))
1269     length += m_certificate.GetObjectLength();
1270   return length;
1271 }
1272
1273
1274 BOOL H235_ReturnSig::Decode(PASN_Stream & strm)
1275 {
1276   if (!PreambleDecode(strm))
1277     return FALSE;
1278
1279   if (!m_generalId.Decode(strm))
1280     return FALSE;
1281   if (!m_responseRandom.Decode(strm))
1282     return FALSE;
1283   if (HasOptionalField(e_requestRandom) && !m_requestRandom.Decode(strm))
1284     return FALSE;
1285   if (HasOptionalField(e_certificate) && !m_certificate.Decode(strm))
1286     return FALSE;
1287
1288   return UnknownExtensionsDecode(strm);
1289 }
1290
1291
1292 void H235_ReturnSig::Encode(PASN_Stream & strm) const
1293 {
1294   PreambleEncode(strm);
1295
1296   m_generalId.Encode(strm);
1297   m_responseRandom.Encode(strm);
1298   if (HasOptionalField(e_requestRandom))
1299     m_requestRandom.Encode(strm);
1300   if (HasOptionalField(e_certificate))
1301     m_certificate.Encode(strm);
1302
1303   UnknownExtensionsEncode(strm);
1304 }
1305
1306
1307 PObject * H235_ReturnSig::Clone() const
1308 {
1309 #ifndef PASN_LEANANDMEAN
1310   PAssert(IsClass(H235_ReturnSig::Class()), PInvalidCast);
1311 #endif
1312   return new H235_ReturnSig(*this);
1313 }
1314
1315
1316 //
1317 // EncodedReturnSig
1318 //
1319
1320 H235_EncodedReturnSig::H235_EncodedReturnSig(unsigned tag, PASN_Object::TagClass tagClass)
1321   : PASN_OctetString(tag, tagClass)
1322 {
1323 }
1324
1325
1326 PObject * H235_EncodedReturnSig::Clone() const
1327 {
1328 #ifndef PASN_LEANANDMEAN
1329   PAssert(IsClass(H235_EncodedReturnSig::Class()), PInvalidCast);
1330 #endif
1331   return new H235_EncodedReturnSig(*this);
1332 }
1333
1334
1335 //
1336 // KeySyncMaterial
1337 //
1338
1339 H235_KeySyncMaterial::H235_KeySyncMaterial(unsigned tag, PASN_Object::TagClass tagClass)
1340   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
1341 {
1342 }
1343
1344
1345 #ifndef PASN_NOPRINTON
1346 void H235_KeySyncMaterial::PrintOn(ostream & strm) const
1347 {
1348   int indent = strm.precision() + 2;
1349   strm << "{\n";
1350   strm << setw(indent+12) << "generalID = " << setprecision(indent) << m_generalID << '\n';
1351   strm << setw(indent+14) << "keyMaterial = " << setprecision(indent) << m_keyMaterial << '\n';
1352   strm << setw(indent-1) << setprecision(indent-2) << "}";
1353 }
1354 #endif
1355
1356
1357 PObject::Comparison H235_KeySyncMaterial::Compare(const PObject & obj) const
1358 {
1359 #ifndef PASN_LEANANDMEAN
1360   PAssert(PIsDescendant(&obj, H235_KeySyncMaterial), PInvalidCast);
1361 #endif
1362   const H235_KeySyncMaterial & other = (const H235_KeySyncMaterial &)obj;
1363
1364   Comparison result;
1365
1366   if ((result = m_generalID.Compare(other.m_generalID)) != EqualTo)
1367     return result;
1368   if ((result = m_keyMaterial.Compare(other.m_keyMaterial)) != EqualTo)
1369     return result;
1370
1371   return PASN_Sequence::Compare(other);
1372 }
1373
1374
1375 PINDEX H235_KeySyncMaterial::GetDataLength() const
1376 {
1377   PINDEX length = 0;
1378   length += m_generalID.GetObjectLength();
1379   length += m_keyMaterial.GetObjectLength();
1380   return length;
1381 }
1382
1383
1384 BOOL H235_KeySyncMaterial::Decode(PASN_Stream & strm)
1385 {
1386   if (!PreambleDecode(strm))
1387     return FALSE;
1388
1389   if (!m_generalID.Decode(strm))
1390     return FALSE;
1391   if (!m_keyMaterial.Decode(strm))
1392     return FALSE;
1393
1394   return UnknownExtensionsDecode(strm);
1395 }
1396
1397
1398 void H235_KeySyncMaterial::Encode(PASN_Stream & strm) const
1399 {
1400   PreambleEncode(strm);
1401
1402   m_generalID.Encode(strm);
1403   m_keyMaterial.Encode(strm);
1404
1405   UnknownExtensionsEncode(strm);
1406 }
1407
1408
1409 PObject * H235_KeySyncMaterial::Clone() const
1410 {
1411 #ifndef PASN_LEANANDMEAN
1412   PAssert(IsClass(H235_KeySyncMaterial::Class()), PInvalidCast);
1413 #endif
1414   return new H235_KeySyncMaterial(*this);
1415 }
1416
1417
1418 //
1419 // EncodedKeySyncMaterial
1420 //
1421
1422 H235_EncodedKeySyncMaterial::H235_EncodedKeySyncMaterial(unsigned tag, PASN_Object::TagClass tagClass)
1423   : PASN_OctetString(tag, tagClass)
1424 {
1425 }
1426
1427
1428 PObject * H235_EncodedKeySyncMaterial::Clone() const
1429 {
1430 #ifndef PASN_LEANANDMEAN
1431   PAssert(IsClass(H235_EncodedKeySyncMaterial::Class()), PInvalidCast);
1432 #endif
1433   return new H235_EncodedKeySyncMaterial(*this);
1434 }
1435
1436
1437 //
1438 // V3KeySyncMaterial
1439 //
1440
1441 H235_V3KeySyncMaterial::H235_V3KeySyncMaterial(unsigned tag, PASN_Object::TagClass tagClass)
1442   : PASN_Sequence(tag, tagClass, 7, TRUE, 1)
1443 {
1444 }
1445
1446
1447 #ifndef PASN_NOPRINTON
1448 void H235_V3KeySyncMaterial::PrintOn(ostream & strm) const
1449 {
1450   int indent = strm.precision() + 2;
1451   strm << "{\n";
1452   if (HasOptionalField(e_generalID))
1453     strm << setw(indent+12) << "generalID = " << setprecision(indent) << m_generalID << '\n';
1454   if (HasOptionalField(e_algorithmOID))
1455     strm << setw(indent+15) << "algorithmOID = " << setprecision(indent) << m_algorithmOID << '\n';
1456   strm << setw(indent+9) << "paramS = " << setprecision(indent) << m_paramS << '\n';
1457   if (HasOptionalField(e_encryptedSessionKey))
1458     strm << setw(indent+22) << "encryptedSessionKey = " << setprecision(indent) << m_encryptedSessionKey << '\n';
1459   if (HasOptionalField(e_encryptedSaltingKey))
1460     strm << setw(indent+22) << "encryptedSaltingKey = " << setprecision(indent) << m_encryptedSaltingKey << '\n';
1461   if (HasOptionalField(e_clearSaltingKey))
1462     strm << setw(indent+18) << "clearSaltingKey = " << setprecision(indent) << m_clearSaltingKey << '\n';
1463   if (HasOptionalField(e_paramSsalt))
1464     strm << setw(indent+13) << "paramSsalt = " << setprecision(indent) << m_paramSsalt << '\n';
1465   if (HasOptionalField(e_keyDerivationOID))
1466     strm << setw(indent+19) << "keyDerivationOID = " << setprecision(indent) << m_keyDerivationOID << '\n';
1467   if (HasOptionalField(e_genericKeyMaterial))
1468     strm << setw(indent+21) << "genericKeyMaterial = " << setprecision(indent) << m_genericKeyMaterial << '\n';
1469   strm << setw(indent-1) << setprecision(indent-2) << "}";
1470 }
1471 #endif
1472
1473
1474 PObject::Comparison H235_V3KeySyncMaterial::Compare(const PObject & obj) const
1475 {
1476 #ifndef PASN_LEANANDMEAN
1477   PAssert(PIsDescendant(&obj, H235_V3KeySyncMaterial), PInvalidCast);
1478 #endif
1479   const H235_V3KeySyncMaterial & other = (const H235_V3KeySyncMaterial &)obj;
1480
1481   Comparison result;
1482
1483   if ((result = m_generalID.Compare(other.m_generalID)) != EqualTo)
1484     return result;
1485   if ((result = m_algorithmOID.Compare(other.m_algorithmOID)) != EqualTo)
1486     return result;
1487   if ((result = m_paramS.Compare(other.m_paramS)) != EqualTo)
1488     return result;
1489   if ((result = m_encryptedSessionKey.Compare(other.m_encryptedSessionKey)) != EqualTo)
1490     return result;
1491   if ((result = m_encryptedSaltingKey.Compare(other.m_encryptedSaltingKey)) != EqualTo)
1492     return result;
1493   if ((result = m_clearSaltingKey.Compare(other.m_clearSaltingKey)) != EqualTo)
1494     return result;
1495   if ((result = m_paramSsalt.Compare(other.m_paramSsalt)) != EqualTo)
1496     return result;
1497   if ((result = m_keyDerivationOID.Compare(other.m_keyDerivationOID)) != EqualTo)
1498     return result;
1499
1500   return PASN_Sequence::Compare(other);
1501 }
1502
1503
1504 PINDEX H235_V3KeySyncMaterial::GetDataLength() const
1505 {
1506   PINDEX length = 0;
1507   if (HasOptionalField(e_generalID))
1508     length += m_generalID.GetObjectLength();
1509   if (HasOptionalField(e_algorithmOID))
1510     length += m_algorithmOID.GetObjectLength();
1511   length += m_paramS.GetObjectLength();
1512   if (HasOptionalField(e_encryptedSessionKey))
1513     length += m_encryptedSessionKey.GetObjectLength();
1514   if (HasOptionalField(e_encryptedSaltingKey))
1515     length += m_encryptedSaltingKey.GetObjectLength();
1516   if (HasOptionalField(e_clearSaltingKey))
1517     length += m_clearSaltingKey.GetObjectLength();
1518   if (HasOptionalField(e_paramSsalt))
1519     length += m_paramSsalt.GetObjectLength();
1520   if (HasOptionalField(e_keyDerivationOID))
1521     length += m_keyDerivationOID.GetObjectLength();
1522   return length;
1523 }
1524
1525
1526 BOOL H235_V3KeySyncMaterial::Decode(PASN_Stream & strm)
1527 {
1528   if (!PreambleDecode(strm))
1529     return FALSE;
1530
1531   if (HasOptionalField(e_generalID) && !m_generalID.Decode(strm))
1532     return FALSE;
1533   if (HasOptionalField(e_algorithmOID) && !m_algorithmOID.Decode(strm))
1534     return FALSE;
1535   if (!m_paramS.Decode(strm))
1536     return FALSE;
1537   if (HasOptionalField(e_encryptedSessionKey) && !m_encryptedSessionKey.Decode(strm))
1538     return FALSE;
1539   if (HasOptionalField(e_encryptedSaltingKey) && !m_encryptedSaltingKey.Decode(strm))
1540     return FALSE;
1541   if (HasOptionalField(e_clearSaltingKey) && !m_clearSaltingKey.Decode(strm))
1542     return FALSE;
1543   if (HasOptionalField(e_paramSsalt) && !m_paramSsalt.Decode(strm))
1544     return FALSE;
1545   if (HasOptionalField(e_keyDerivationOID) && !m_keyDerivationOID.Decode(strm))
1546     return FALSE;
1547   if (!KnownExtensionDecode(strm, e_genericKeyMaterial, m_genericKeyMaterial))
1548     return FALSE;
1549
1550   return UnknownExtensionsDecode(strm);
1551 }
1552
1553
1554 void H235_V3KeySyncMaterial::Encode(PASN_Stream & strm) const
1555 {
1556   PreambleEncode(strm);
1557
1558   if (HasOptionalField(e_generalID))
1559     m_generalID.Encode(strm);
1560   if (HasOptionalField(e_algorithmOID))
1561     m_algorithmOID.Encode(strm);
1562   m_paramS.Encode(strm);
1563   if (HasOptionalField(e_encryptedSessionKey))
1564     m_encryptedSessionKey.Encode(strm);
1565   if (HasOptionalField(e_encryptedSaltingKey))
1566     m_encryptedSaltingKey.Encode(strm);
1567   if (HasOptionalField(e_clearSaltingKey))
1568     m_clearSaltingKey.Encode(strm);
1569   if (HasOptionalField(e_paramSsalt))
1570     m_paramSsalt.Encode(strm);
1571   if (HasOptionalField(e_keyDerivationOID))
1572     m_keyDerivationOID.Encode(strm);
1573   KnownExtensionEncode(strm, e_genericKeyMaterial, m_genericKeyMaterial);
1574
1575   UnknownExtensionsEncode(strm);
1576 }
1577
1578
1579 PObject * H235_V3KeySyncMaterial::Clone() const
1580 {
1581 #ifndef PASN_LEANANDMEAN
1582   PAssert(IsClass(H235_V3KeySyncMaterial::Class()), PInvalidCast);
1583 #endif
1584   return new H235_V3KeySyncMaterial(*this);
1585 }
1586
1587
1588 //
1589 // ECKASDH_eckasdhp
1590 //
1591
1592 H235_ECKASDH_eckasdhp::H235_ECKASDH_eckasdhp(unsigned tag, PASN_Object::TagClass tagClass)
1593   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
1594 {
1595   m_modulus.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
1596   m_weierstrassA.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
1597   m_weierstrassB.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
1598 }
1599
1600
1601 #ifndef PASN_NOPRINTON
1602 void H235_ECKASDH_eckasdhp::PrintOn(ostream & strm) const
1603 {
1604   int indent = strm.precision() + 2;
1605   strm << "{\n";
1606   strm << setw(indent+13) << "public_key = " << setprecision(indent) << m_public_key << '\n';
1607   strm << setw(indent+10) << "modulus = " << setprecision(indent) << m_modulus << '\n';
1608   strm << setw(indent+7) << "base = " << setprecision(indent) << m_base << '\n';
1609   strm << setw(indent+15) << "weierstrassA = " << setprecision(indent) << m_weierstrassA << '\n';
1610   strm << setw(indent+15) << "weierstrassB = " << setprecision(indent) << m_weierstrassB << '\n';
1611   strm << setw(indent-1) << setprecision(indent-2) << "}";
1612 }
1613 #endif
1614
1615
1616 PObject::Comparison H235_ECKASDH_eckasdhp::Compare(const PObject & obj) const
1617 {
1618 #ifndef PASN_LEANANDMEAN
1619   PAssert(PIsDescendant(&obj, H235_ECKASDH_eckasdhp), PInvalidCast);
1620 #endif
1621   const H235_ECKASDH_eckasdhp & other = (const H235_ECKASDH_eckasdhp &)obj;
1622
1623   Comparison result;
1624
1625   if ((result = m_public_key.Compare(other.m_public_key)) != EqualTo)
1626     return result;
1627   if ((result = m_modulus.Compare(other.m_modulus)) != EqualTo)
1628     return result;
1629   if ((result = m_base.Compare(other.m_base)) != EqualTo)
1630     return result;
1631   if ((result = m_weierstrassA.Compare(other.m_weierstrassA)) != EqualTo)
1632     return result;
1633   if ((result = m_weierstrassB.Compare(other.m_weierstrassB)) != EqualTo)
1634     return result;
1635
1636   return PASN_Sequence::Compare(other);
1637 }
1638
1639
1640 PINDEX H235_ECKASDH_eckasdhp::GetDataLength() const
1641 {
1642   PINDEX length = 0;
1643   length += m_public_key.GetObjectLength();
1644   length += m_modulus.GetObjectLength();
1645   length += m_base.GetObjectLength();
1646   length += m_weierstrassA.GetObjectLength();
1647   length += m_weierstrassB.GetObjectLength();
1648   return length;
1649 }
1650
1651
1652 BOOL H235_ECKASDH_eckasdhp::Decode(PASN_Stream & strm)
1653 {
1654   if (!PreambleDecode(strm))
1655     return FALSE;
1656
1657   if (!m_public_key.Decode(strm))
1658     return FALSE;
1659   if (!m_modulus.Decode(strm))
1660     return FALSE;
1661   if (!m_base.Decode(strm))
1662     return FALSE;
1663   if (!m_weierstrassA.Decode(strm))
1664     return FALSE;
1665   if (!m_weierstrassB.Decode(strm))
1666     return FALSE;
1667
1668   return UnknownExtensionsDecode(strm);
1669 }
1670
1671
1672 void H235_ECKASDH_eckasdhp::Encode(PASN_Stream & strm) const
1673 {
1674   PreambleEncode(strm);
1675
1676   m_public_key.Encode(strm);
1677   m_modulus.Encode(strm);
1678   m_base.Encode(strm);
1679   m_weierstrassA.Encode(strm);
1680   m_weierstrassB.Encode(strm);
1681
1682   UnknownExtensionsEncode(strm);
1683 }
1684
1685
1686 PObject * H235_ECKASDH_eckasdhp::Clone() const
1687 {
1688 #ifndef PASN_LEANANDMEAN
1689   PAssert(IsClass(H235_ECKASDH_eckasdhp::Class()), PInvalidCast);
1690 #endif
1691   return new H235_ECKASDH_eckasdhp(*this);
1692 }
1693
1694
1695 //
1696 // ECKASDH_eckasdh2
1697 //
1698
1699 H235_ECKASDH_eckasdh2::H235_ECKASDH_eckasdh2(unsigned tag, PASN_Object::TagClass tagClass)
1700   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
1701 {
1702   m_fieldSize.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
1703   m_weierstrassA.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
1704   m_weierstrassB.SetConstraints(PASN_Object::FixedConstraint, 0, 511);
1705 }
1706
1707
1708 #ifndef PASN_NOPRINTON
1709 void H235_ECKASDH_eckasdh2::PrintOn(ostream & strm) const
1710 {
1711   int indent = strm.precision() + 2;
1712   strm << "{\n";
1713   strm << setw(indent+13) << "public_key = " << setprecision(indent) << m_public_key << '\n';
1714   strm << setw(indent+12) << "fieldSize = " << setprecision(indent) << m_fieldSize << '\n';
1715   strm << setw(indent+7) << "base = " << setprecision(indent) << m_base << '\n';
1716   strm << setw(indent+15) << "weierstrassA = " << setprecision(indent) << m_weierstrassA << '\n';
1717   strm << setw(indent+15) << "weierstrassB = " << setprecision(indent) << m_weierstrassB << '\n';
1718   strm << setw(indent-1) << setprecision(indent-2) << "}";
1719 }
1720 #endif
1721
1722
1723 PObject::Comparison H235_ECKASDH_eckasdh2::Compare(const PObject & obj) const
1724 {
1725 #ifndef PASN_LEANANDMEAN
1726   PAssert(PIsDescendant(&obj, H235_ECKASDH_eckasdh2), PInvalidCast);
1727 #endif
1728   const H235_ECKASDH_eckasdh2 & other = (const H235_ECKASDH_eckasdh2 &)obj;
1729
1730   Comparison result;
1731
1732   if ((result = m_public_key.Compare(other.m_public_key)) != EqualTo)
1733     return result;
1734   if ((result = m_fieldSize.Compare(other.m_fieldSize)) != EqualTo)
1735     return result;
1736   if ((result = m_base.Compare(other.m_base)) != EqualTo)
1737     return result;
1738   if ((result = m_weierstrassA.Compare(other.m_weierstrassA)) != EqualTo)
1739     return result;
1740   if ((result = m_weierstrassB.Compare(other.m_weierstrassB)) != EqualTo)
1741     return result;
1742
1743   return PASN_Sequence::Compare(other);
1744 }
1745
1746
1747 PINDEX H235_ECKASDH_eckasdh2::GetDataLength() const
1748 {
1749   PINDEX length = 0;
1750   length += m_public_key.GetObjectLength();
1751   length += m_fieldSize.GetObjectLength();
1752   length += m_base.GetObjectLength();
1753   length += m_weierstrassA.GetObjectLength();
1754   length += m_weierstrassB.GetObjectLength();
1755   return length;
1756 }
1757
1758
1759 BOOL H235_ECKASDH_eckasdh2::Decode(PASN_Stream & strm)
1760 {
1761   if (!PreambleDecode(strm))
1762     return FALSE;
1763
1764   if (!m_public_key.Decode(strm))
1765     return FALSE;
1766   if (!m_fieldSize.Decode(strm))
1767     return FALSE;
1768   if (!m_base.Decode(strm))
1769     return FALSE;
1770   if (!m_weierstrassA.Decode(strm))
1771     return FALSE;
1772   if (!m_weierstrassB.Decode(strm))
1773     return FALSE;
1774
1775   return UnknownExtensionsDecode(strm);
1776 }
1777
1778
1779 void H235_ECKASDH_eckasdh2::Encode(PASN_Stream & strm) const
1780 {
1781   PreambleEncode(strm);
1782
1783   m_public_key.Encode(strm);
1784   m_fieldSize.Encode(strm);
1785   m_base.Encode(strm);
1786   m_weierstrassA.Encode(strm);
1787   m_weierstrassB.Encode(strm);
1788
1789   UnknownExtensionsEncode(strm);
1790 }
1791
1792
1793 PObject * H235_ECKASDH_eckasdh2::Clone() const
1794 {
1795 #ifndef PASN_LEANANDMEAN
1796   PAssert(IsClass(H235_ECKASDH_eckasdh2::Class()), PInvalidCast);
1797 #endif
1798   return new H235_ECKASDH_eckasdh2(*this);
1799 }
1800
1801
1802 //
1803 // ArrayOf_ProfileElement
1804 //
1805
1806 H235_ArrayOf_ProfileElement::H235_ArrayOf_ProfileElement(unsigned tag, PASN_Object::TagClass tagClass)
1807   : PASN_Array(tag, tagClass)
1808 {
1809 }
1810
1811
1812 PASN_Object * H235_ArrayOf_ProfileElement::CreateObject() const
1813 {
1814   return new H235_ProfileElement;
1815 }
1816
1817
1818 H235_ProfileElement & H235_ArrayOf_ProfileElement::operator[](PINDEX i) const
1819 {
1820   return (H235_ProfileElement &)array[i];
1821 }
1822
1823
1824 PObject * H235_ArrayOf_ProfileElement::Clone() const
1825 {
1826 #ifndef PASN_LEANANDMEAN
1827   PAssert(IsClass(H235_ArrayOf_ProfileElement::Class()), PInvalidCast);
1828 #endif
1829   return new H235_ArrayOf_ProfileElement(*this);
1830 }
1831
1832
1833 //
1834 // ProfileElement
1835 //
1836
1837 H235_ProfileElement::H235_ProfileElement(unsigned tag, PASN_Object::TagClass tagClass)
1838   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
1839 {
1840   m_elementID.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
1841 }
1842
1843
1844 #ifndef PASN_NOPRINTON
1845 void H235_ProfileElement::PrintOn(ostream & strm) const
1846 {
1847   int indent = strm.precision() + 2;
1848   strm << "{\n";
1849   strm << setw(indent+12) << "elementID = " << setprecision(indent) << m_elementID << '\n';
1850   if (HasOptionalField(e_paramS))
1851     strm << setw(indent+9) << "paramS = " << setprecision(indent) << m_paramS << '\n';
1852   if (HasOptionalField(e_element))
1853     strm << setw(indent+10) << "element = " << setprecision(indent) << m_element << '\n';
1854   strm << setw(indent-1) << setprecision(indent-2) << "}";
1855 }
1856 #endif
1857
1858
1859 PObject::Comparison H235_ProfileElement::Compare(const PObject & obj) const
1860 {
1861 #ifndef PASN_LEANANDMEAN
1862   PAssert(PIsDescendant(&obj, H235_ProfileElement), PInvalidCast);
1863 #endif
1864   const H235_ProfileElement & other = (const H235_ProfileElement &)obj;
1865
1866   Comparison result;
1867
1868   if ((result = m_elementID.Compare(other.m_elementID)) != EqualTo)
1869     return result;
1870   if ((result = m_paramS.Compare(other.m_paramS)) != EqualTo)
1871     return result;
1872   if ((result = m_element.Compare(other.m_element)) != EqualTo)
1873     return result;
1874
1875   return PASN_Sequence::Compare(other);
1876 }
1877
1878
1879 PINDEX H235_ProfileElement::GetDataLength() const
1880 {
1881   PINDEX length = 0;
1882   length += m_elementID.GetObjectLength();
1883   if (HasOptionalField(e_paramS))
1884     length += m_paramS.GetObjectLength();
1885   if (HasOptionalField(e_element))
1886     length += m_element.GetObjectLength();
1887   return length;
1888 }
1889
1890
1891 BOOL H235_ProfileElement::Decode(PASN_Stream & strm)
1892 {
1893   if (!PreambleDecode(strm))
1894     return FALSE;
1895
1896   if (!m_elementID.Decode(strm))
1897     return FALSE;
1898   if (HasOptionalField(e_paramS) && !m_paramS.Decode(strm))
1899     return FALSE;
1900   if (HasOptionalField(e_element) && !m_element.Decode(strm))
1901     return FALSE;
1902
1903   return UnknownExtensionsDecode(strm);
1904 }
1905
1906
1907 void H235_ProfileElement::Encode(PASN_Stream & strm) const
1908 {
1909   PreambleEncode(strm);
1910
1911   m_elementID.Encode(strm);
1912   if (HasOptionalField(e_paramS))
1913     m_paramS.Encode(strm);
1914   if (HasOptionalField(e_element))
1915     m_element.Encode(strm);
1916
1917   UnknownExtensionsEncode(strm);
1918 }
1919
1920
1921 PObject * H235_ProfileElement::Clone() const
1922 {
1923 #ifndef PASN_LEANANDMEAN
1924   PAssert(IsClass(H235_ProfileElement::Class()), PInvalidCast);
1925 #endif
1926   return new H235_ProfileElement(*this);
1927 }
1928
1929
1930 //
1931 // KeySignedMaterial
1932 //
1933
1934 H235_KeySignedMaterial::H235_KeySignedMaterial(unsigned tag, PASN_Object::TagClass tagClass)
1935   : PASN_Sequence(tag, tagClass, 2, FALSE, 0)
1936 {
1937 }
1938
1939
1940 #ifndef PASN_NOPRINTON
1941 void H235_KeySignedMaterial::PrintOn(ostream & strm) const
1942 {
1943   int indent = strm.precision() + 2;
1944   strm << "{\n";
1945   strm << setw(indent+12) << "generalId = " << setprecision(indent) << m_generalId << '\n';
1946   strm << setw(indent+10) << "mrandom = " << setprecision(indent) << m_mrandom << '\n';
1947   if (HasOptionalField(e_srandom))
1948     strm << setw(indent+10) << "srandom = " << setprecision(indent) << m_srandom << '\n';
1949   if (HasOptionalField(e_timeStamp))
1950     strm << setw(indent+12) << "timeStamp = " << setprecision(indent) << m_timeStamp << '\n';
1951   strm << setw(indent+12) << "encrptval = " << setprecision(indent) << m_encrptval << '\n';
1952   strm << setw(indent-1) << setprecision(indent-2) << "}";
1953 }
1954 #endif
1955
1956
1957 PObject::Comparison H235_KeySignedMaterial::Compare(const PObject & obj) const
1958 {
1959 #ifndef PASN_LEANANDMEAN
1960   PAssert(PIsDescendant(&obj, H235_KeySignedMaterial), PInvalidCast);
1961 #endif
1962   const H235_KeySignedMaterial & other = (const H235_KeySignedMaterial &)obj;
1963
1964   Comparison result;
1965
1966   if ((result = m_generalId.Compare(other.m_generalId)) != EqualTo)
1967     return result;
1968   if ((result = m_mrandom.Compare(other.m_mrandom)) != EqualTo)
1969     return result;
1970   if ((result = m_srandom.Compare(other.m_srandom)) != EqualTo)
1971     return result;
1972   if ((result = m_timeStamp.Compare(other.m_timeStamp)) != EqualTo)
1973     return result;
1974   if ((result = m_encrptval.Compare(other.m_encrptval)) != EqualTo)
1975     return result;
1976
1977   return PASN_Sequence::Compare(other);
1978 }
1979
1980
1981 PINDEX H235_KeySignedMaterial::GetDataLength() const
1982 {
1983   PINDEX length = 0;
1984   length += m_generalId.GetObjectLength();
1985   length += m_mrandom.GetObjectLength();
1986   if (HasOptionalField(e_srandom))
1987     length += m_srandom.GetObjectLength();
1988   if (HasOptionalField(e_timeStamp))
1989     length += m_timeStamp.GetObjectLength();
1990   length += m_encrptval.GetObjectLength();
1991   return length;
1992 }
1993
1994
1995 BOOL H235_KeySignedMaterial::Decode(PASN_Stream & strm)
1996 {
1997   if (!PreambleDecode(strm))
1998     return FALSE;
1999
2000   if (!m_generalId.Decode(strm))
2001     return FALSE;
2002   if (!m_mrandom.Decode(strm))
2003     return FALSE;
2004   if (HasOptionalField(e_srandom) && !m_srandom.Decode(strm))
2005     return FALSE;
2006   if (HasOptionalField(e_timeStamp) && !m_timeStamp.Decode(strm))
2007     return FALSE;
2008   if (!m_encrptval.Decode(strm))
2009     return FALSE;
2010
2011   return UnknownExtensionsDecode(strm);
2012 }
2013
2014
2015 void H235_KeySignedMaterial::Encode(PASN_Stream & strm) const
2016 {
2017   PreambleEncode(strm);
2018
2019   m_generalId.Encode(strm);
2020   m_mrandom.Encode(strm);
2021   if (HasOptionalField(e_srandom))
2022     m_srandom.Encode(strm);
2023   if (HasOptionalField(e_timeStamp))
2024     m_timeStamp.Encode(strm);
2025   m_encrptval.Encode(strm);
2026
2027   UnknownExtensionsEncode(strm);
2028 }
2029
2030
2031 PObject * H235_KeySignedMaterial::Clone() const
2032 {
2033 #ifndef PASN_LEANANDMEAN
2034   PAssert(IsClass(H235_KeySignedMaterial::Class()), PInvalidCast);
2035 #endif
2036   return new H235_KeySignedMaterial(*this);
2037 }
2038
2039
2040 //
2041 // EncodedKeySignedMaterial
2042 //
2043
2044 H235_EncodedKeySignedMaterial::H235_EncodedKeySignedMaterial(unsigned tag, PASN_Object::TagClass tagClass)
2045   : PASN_OctetString(tag, tagClass)
2046 {
2047 }
2048
2049
2050 PObject * H235_EncodedKeySignedMaterial::Clone() const
2051 {
2052 #ifndef PASN_LEANANDMEAN
2053   PAssert(IsClass(H235_EncodedKeySignedMaterial::Class()), PInvalidCast);
2054 #endif
2055   return new H235_EncodedKeySignedMaterial(*this);
2056 }
2057
2058
2059 //
2060 // H235CertificateSignature
2061 //
2062
2063 H235_H235CertificateSignature::H235_H235CertificateSignature(unsigned tag, PASN_Object::TagClass tagClass)
2064   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
2065 {
2066 }
2067
2068
2069 #ifndef PASN_NOPRINTON
2070 void H235_H235CertificateSignature::PrintOn(ostream & strm) const
2071 {
2072   int indent = strm.precision() + 2;
2073   strm << "{\n";
2074   strm << setw(indent+14) << "certificate = " << setprecision(indent) << m_certificate << '\n';
2075   strm << setw(indent+17) << "responseRandom = " << setprecision(indent) << m_responseRandom << '\n';
2076   if (HasOptionalField(e_requesterRandom))
2077     strm << setw(indent+18) << "requesterRandom = " << setprecision(indent) << m_requesterRandom << '\n';
2078   strm << setw(indent+12) << "signature = " << setprecision(indent) << m_signature << '\n';
2079   strm << setw(indent-1) << setprecision(indent-2) << "}";
2080 }
2081 #endif
2082
2083
2084 PObject::Comparison H235_H235CertificateSignature::Compare(const PObject & obj) const
2085 {
2086 #ifndef PASN_LEANANDMEAN
2087   PAssert(PIsDescendant(&obj, H235_H235CertificateSignature), PInvalidCast);
2088 #endif
2089   const H235_H235CertificateSignature & other = (const H235_H235CertificateSignature &)obj;
2090
2091   Comparison result;
2092
2093   if ((result = m_certificate.Compare(other.m_certificate)) != EqualTo)
2094     return result;
2095   if ((result = m_responseRandom.Compare(other.m_responseRandom)) != EqualTo)
2096     return result;
2097   if ((result = m_requesterRandom.Compare(other.m_requesterRandom)) != EqualTo)
2098     return result;
2099   if ((result = m_signature.Compare(other.m_signature)) != EqualTo)
2100     return result;
2101
2102   return PASN_Sequence::Compare(other);
2103 }
2104
2105
2106 PINDEX H235_H235CertificateSignature::GetDataLength() const
2107 {
2108   PINDEX length = 0;
2109   length += m_certificate.GetObjectLength();
2110   length += m_responseRandom.GetObjectLength();
2111   if (HasOptionalField(e_requesterRandom))
2112     length += m_requesterRandom.GetObjectLength();
2113   length += m_signature.GetObjectLength();
2114   return length;
2115 }
2116
2117
2118 BOOL H235_H235CertificateSignature::Decode(PASN_Stream & strm)
2119 {
2120   if (!PreambleDecode(strm))
2121     return FALSE;
2122
2123   if (!m_certificate.Decode(strm))
2124     return FALSE;
2125   if (!m_responseRandom.Decode(strm))
2126     return FALSE;
2127   if (HasOptionalField(e_requesterRandom) && !m_requesterRandom.Decode(strm))
2128     return FALSE;
2129   if (!m_signature.Decode(strm))
2130     return FALSE;
2131
2132   return UnknownExtensionsDecode(strm);
2133 }
2134
2135
2136 void H235_H235CertificateSignature::Encode(PASN_Stream & strm) const
2137 {
2138   PreambleEncode(strm);
2139
2140   m_certificate.Encode(strm);
2141   m_responseRandom.Encode(strm);
2142   if (HasOptionalField(e_requesterRandom))
2143     m_requesterRandom.Encode(strm);
2144   m_signature.Encode(strm);
2145
2146   UnknownExtensionsEncode(strm);
2147 }
2148
2149
2150 PObject * H235_H235CertificateSignature::Clone() const
2151 {
2152 #ifndef PASN_LEANANDMEAN
2153   PAssert(IsClass(H235_H235CertificateSignature::Class()), PInvalidCast);
2154 #endif
2155   return new H235_H235CertificateSignature(*this);
2156 }
2157
2158
2159
2160 #ifndef PASN_NOPRINTON
2161 const static PASN_Names Names_H235_H235Key[]={
2162       {"secureChannel",0}
2163      ,{"sharedSecret",1}
2164      ,{"certProtectedKey",2}
2165      ,{"secureSharedSecret",3}
2166 };
2167 #endif
2168 //
2169 // H235Key
2170 //
2171
2172 H235_H235Key::H235_H235Key(unsigned tag, PASN_Object::TagClass tagClass)
2173   : PASN_Choice(tag, tagClass, 3, TRUE
2174 #ifndef PASN_NOPRINTON
2175     ,(const PASN_Names *)Names_H235_H235Key,4
2176 #endif
2177 )
2178 {
2179 }
2180
2181
2182 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2183 H235_H235Key::operator H235_KeyMaterial &() const
2184 #else
2185 H235_H235Key::operator H235_KeyMaterial &()
2186 {
2187 #ifndef PASN_LEANANDMEAN
2188   PAssert(PIsDescendant(PAssertNULL(choice), H235_KeyMaterial), PInvalidCast);
2189 #endif
2190   return *(H235_KeyMaterial *)choice;
2191 }
2192
2193
2194 H235_H235Key::operator const H235_KeyMaterial &() const
2195 #endif
2196 {
2197 #ifndef PASN_LEANANDMEAN
2198   PAssert(PIsDescendant(PAssertNULL(choice), H235_KeyMaterial), PInvalidCast);
2199 #endif
2200   return *(H235_KeyMaterial *)choice;
2201 }
2202
2203
2204 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2205 H235_H235Key::operator H235_ENCRYPTED<H235_EncodedKeySyncMaterial> &() const
2206 #else
2207 H235_H235Key::operator H235_ENCRYPTED<H235_EncodedKeySyncMaterial> &()
2208 {
2209 #ifndef PASN_LEANANDMEAN
2210   PAssert(PIsDescendant(PAssertNULL(choice), H235_ENCRYPTED<H235_EncodedKeySyncMaterial>), PInvalidCast);
2211 #endif
2212   return *(H235_ENCRYPTED<H235_EncodedKeySyncMaterial> *)choice;
2213 }
2214
2215
2216 H235_H235Key::operator const H235_ENCRYPTED<H235_EncodedKeySyncMaterial> &() const
2217 #endif
2218 {
2219 #ifndef PASN_LEANANDMEAN
2220   PAssert(PIsDescendant(PAssertNULL(choice), H235_ENCRYPTED<H235_EncodedKeySyncMaterial>), PInvalidCast);
2221 #endif
2222   return *(H235_ENCRYPTED<H235_EncodedKeySyncMaterial> *)choice;
2223 }
2224
2225
2226 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2227 H235_H235Key::operator H235_SIGNED<H235_EncodedKeySignedMaterial> &() const
2228 #else
2229 H235_H235Key::operator H235_SIGNED<H235_EncodedKeySignedMaterial> &()
2230 {
2231 #ifndef PASN_LEANANDMEAN
2232   PAssert(PIsDescendant(PAssertNULL(choice), H235_SIGNED<H235_EncodedKeySignedMaterial>), PInvalidCast);
2233 #endif
2234   return *(H235_SIGNED<H235_EncodedKeySignedMaterial> *)choice;
2235 }
2236
2237
2238 H235_H235Key::operator const H235_SIGNED<H235_EncodedKeySignedMaterial> &() const
2239 #endif
2240 {
2241 #ifndef PASN_LEANANDMEAN
2242   PAssert(PIsDescendant(PAssertNULL(choice), H235_SIGNED<H235_EncodedKeySignedMaterial>), PInvalidCast);
2243 #endif
2244   return *(H235_SIGNED<H235_EncodedKeySignedMaterial> *)choice;
2245 }
2246
2247
2248 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2249 H235_H235Key::operator H235_V3KeySyncMaterial &() const
2250 #else
2251 H235_H235Key::operator H235_V3KeySyncMaterial &()
2252 {
2253 #ifndef PASN_LEANANDMEAN
2254   PAssert(PIsDescendant(PAssertNULL(choice), H235_V3KeySyncMaterial), PInvalidCast);
2255 #endif
2256   return *(H235_V3KeySyncMaterial *)choice;
2257 }
2258
2259
2260 H235_H235Key::operator const H235_V3KeySyncMaterial &() const
2261 #endif
2262 {
2263 #ifndef PASN_LEANANDMEAN
2264   PAssert(PIsDescendant(PAssertNULL(choice), H235_V3KeySyncMaterial), PInvalidCast);
2265 #endif
2266   return *(H235_V3KeySyncMaterial *)choice;
2267 }
2268
2269
2270 BOOL H235_H235Key::CreateObject()
2271 {
2272   switch (tag) {
2273     case e_secureChannel :
2274       choice = new H235_KeyMaterial();
2275       return TRUE;
2276     case e_sharedSecret :
2277       choice = new H235_ENCRYPTED<H235_EncodedKeySyncMaterial>();
2278       return TRUE;
2279     case e_certProtectedKey :
2280       choice = new H235_SIGNED<H235_EncodedKeySignedMaterial>();
2281       return TRUE;
2282     case e_secureSharedSecret :
2283       choice = new H235_V3KeySyncMaterial();
2284       return TRUE;
2285   }
2286
2287   choice = NULL;
2288   return FALSE;
2289 }
2290
2291
2292 PObject * H235_H235Key::Clone() const
2293 {
2294 #ifndef PASN_LEANANDMEAN
2295   PAssert(IsClass(H235_H235Key::Class()), PInvalidCast);
2296 #endif
2297   return new H235_H235Key(*this);
2298 }
2299
2300
2301 //
2302 // ClearToken
2303 //
2304
2305 H235_ClearToken::H235_ClearToken(unsigned tag, PASN_Object::TagClass tagClass)
2306   : PASN_Sequence(tag, tagClass, 8, TRUE, 4)
2307 {
2308 }
2309
2310
2311 #ifndef PASN_NOPRINTON
2312 void H235_ClearToken::PrintOn(ostream & strm) const
2313 {
2314   int indent = strm.precision() + 2;
2315   strm << "{\n";
2316   strm << setw(indent+11) << "tokenOID = " << setprecision(indent) << m_tokenOID << '\n';
2317   if (HasOptionalField(e_timeStamp))
2318     strm << setw(indent+12) << "timeStamp = " << setprecision(indent) << m_timeStamp << '\n';
2319   if (HasOptionalField(e_password))
2320     strm << setw(indent+11) << "password = " << setprecision(indent) << m_password << '\n';
2321   if (HasOptionalField(e_dhkey))
2322     strm << setw(indent+8) << "dhkey = " << setprecision(indent) << m_dhkey << '\n';
2323   if (HasOptionalField(e_challenge))
2324     strm << setw(indent+12) << "challenge = " << setprecision(indent) << m_challenge << '\n';
2325   if (HasOptionalField(e_random))
2326     strm << setw(indent+9) << "random = " << setprecision(indent) << m_random << '\n';
2327   if (HasOptionalField(e_certificate))
2328     strm << setw(indent+14) << "certificate = " << setprecision(indent) << m_certificate << '\n';
2329   if (HasOptionalField(e_generalID))
2330     strm << setw(indent+12) << "generalID = " << setprecision(indent) << m_generalID << '\n';
2331   if (HasOptionalField(e_nonStandard))
2332     strm << setw(indent+14) << "nonStandard = " << setprecision(indent) << m_nonStandard << '\n';
2333   if (HasOptionalField(e_eckasdhkey))
2334     strm << setw(indent+13) << "eckasdhkey = " << setprecision(indent) << m_eckasdhkey << '\n';
2335   if (HasOptionalField(e_sendersID))
2336     strm << setw(indent+12) << "sendersID = " << setprecision(indent) << m_sendersID << '\n';
2337   if (HasOptionalField(e_h235Key))
2338     strm << setw(indent+10) << "h235Key = " << setprecision(indent) << m_h235Key << '\n';
2339   if (HasOptionalField(e_profileInfo))
2340     strm << setw(indent+14) << "profileInfo = " << setprecision(indent) << m_profileInfo << '\n';
2341   strm << setw(indent-1) << setprecision(indent-2) << "}";
2342 }
2343 #endif
2344
2345
2346 PObject::Comparison H235_ClearToken::Compare(const PObject & obj) const
2347 {
2348 #ifndef PASN_LEANANDMEAN
2349   PAssert(PIsDescendant(&obj, H235_ClearToken), PInvalidCast);
2350 #endif
2351   const H235_ClearToken & other = (const H235_ClearToken &)obj;
2352
2353   Comparison result;
2354
2355   if ((result = m_tokenOID.Compare(other.m_tokenOID)) != EqualTo)
2356     return result;
2357   if ((result = m_timeStamp.Compare(other.m_timeStamp)) != EqualTo)
2358     return result;
2359   if ((result = m_password.Compare(other.m_password)) != EqualTo)
2360     return result;
2361   if ((result = m_dhkey.Compare(other.m_dhkey)) != EqualTo)
2362     return result;
2363   if ((result = m_challenge.Compare(other.m_challenge)) != EqualTo)
2364     return result;
2365   if ((result = m_random.Compare(other.m_random)) != EqualTo)
2366     return result;
2367   if ((result = m_certificate.Compare(other.m_certificate)) != EqualTo)
2368     return result;
2369   if ((result = m_generalID.Compare(other.m_generalID)) != EqualTo)
2370     return result;
2371   if ((result = m_nonStandard.Compare(other.m_nonStandard)) != EqualTo)
2372     return result;
2373
2374   return PASN_Sequence::Compare(other);
2375 }
2376
2377
2378 PINDEX H235_ClearToken::GetDataLength() const
2379 {
2380   PINDEX length = 0;
2381   length += m_tokenOID.GetObjectLength();
2382   if (HasOptionalField(e_timeStamp))
2383     length += m_timeStamp.GetObjectLength();
2384   if (HasOptionalField(e_password))
2385     length += m_password.GetObjectLength();
2386   if (HasOptionalField(e_dhkey))
2387     length += m_dhkey.GetObjectLength();
2388   if (HasOptionalField(e_challenge))
2389     length += m_challenge.GetObjectLength();
2390   if (HasOptionalField(e_random))
2391     length += m_random.GetObjectLength();
2392   if (HasOptionalField(e_certificate))
2393     length += m_certificate.GetObjectLength();
2394   if (HasOptionalField(e_generalID))
2395     length += m_generalID.GetObjectLength();
2396   if (HasOptionalField(e_nonStandard))
2397     length += m_nonStandard.GetObjectLength();
2398   return length;
2399 }
2400
2401
2402 BOOL H235_ClearToken::Decode(PASN_Stream & strm)
2403 {
2404   if (!PreambleDecode(strm))
2405     return FALSE;
2406
2407   if (!m_tokenOID.Decode(strm))
2408     return FALSE;
2409   if (HasOptionalField(e_timeStamp) && !m_timeStamp.Decode(strm))
2410     return FALSE;
2411   if (HasOptionalField(e_password) && !m_password.Decode(strm))
2412     return FALSE;
2413   if (HasOptionalField(e_dhkey) && !m_dhkey.Decode(strm))
2414     return FALSE;
2415   if (HasOptionalField(e_challenge) && !m_challenge.Decode(strm))
2416     return FALSE;
2417   if (HasOptionalField(e_random) && !m_random.Decode(strm))
2418     return FALSE;
2419   if (HasOptionalField(e_certificate) && !m_certificate.Decode(strm))
2420     return FALSE;
2421   if (HasOptionalField(e_generalID) && !m_generalID.Decode(strm))
2422     return FALSE;
2423   if (HasOptionalField(e_nonStandard) && !m_nonStandard.Decode(strm))
2424     return FALSE;
2425   if (!KnownExtensionDecode(strm, e_eckasdhkey, m_eckasdhkey))
2426     return FALSE;
2427   if (!KnownExtensionDecode(strm, e_sendersID, m_sendersID))
2428     return FALSE;
2429   if (!KnownExtensionDecode(strm, e_h235Key, m_h235Key))
2430     return FALSE;
2431   if (!KnownExtensionDecode(strm, e_profileInfo, m_profileInfo))
2432     return FALSE;
2433
2434   return UnknownExtensionsDecode(strm);
2435 }
2436
2437
2438 void H235_ClearToken::Encode(PASN_Stream & strm) const
2439 {
2440   PreambleEncode(strm);
2441
2442   m_tokenOID.Encode(strm);
2443   if (HasOptionalField(e_timeStamp))
2444     m_timeStamp.Encode(strm);
2445   if (HasOptionalField(e_password))
2446     m_password.Encode(strm);
2447   if (HasOptionalField(e_dhkey))
2448     m_dhkey.Encode(strm);
2449   if (HasOptionalField(e_challenge))
2450     m_challenge.Encode(strm);
2451   if (HasOptionalField(e_random))
2452     m_random.Encode(strm);
2453   if (HasOptionalField(e_certificate))
2454     m_certificate.Encode(strm);
2455   if (HasOptionalField(e_generalID))
2456     m_generalID.Encode(strm);
2457   if (HasOptionalField(e_nonStandard))
2458     m_nonStandard.Encode(strm);
2459   KnownExtensionEncode(strm, e_eckasdhkey, m_eckasdhkey);
2460   KnownExtensionEncode(strm, e_sendersID, m_sendersID);
2461   KnownExtensionEncode(strm, e_h235Key, m_h235Key);
2462   KnownExtensionEncode(strm, e_profileInfo, m_profileInfo);
2463
2464   UnknownExtensionsEncode(strm);
2465 }
2466
2467
2468 PObject * H235_ClearToken::Clone() const
2469 {
2470 #ifndef PASN_LEANANDMEAN
2471   PAssert(IsClass(H235_ClearToken::Class()), PInvalidCast);
2472 #endif
2473   return new H235_ClearToken(*this);
2474 }
2475
2476
2477 //
2478 // EncodedGeneralToken
2479 //
2480
2481 H235_EncodedGeneralToken::H235_EncodedGeneralToken(unsigned tag, PASN_Object::TagClass tagClass)
2482   : PASN_OctetString(tag, tagClass)
2483 {
2484 }
2485
2486
2487 PObject * H235_EncodedGeneralToken::Clone() const
2488 {
2489 #ifndef PASN_LEANANDMEAN
2490   PAssert(IsClass(H235_EncodedGeneralToken::Class()), PInvalidCast);
2491 #endif
2492   return new H235_EncodedGeneralToken(*this);
2493 }
2494
2495
2496 //
2497 // PwdCertToken
2498 //
2499
2500 H235_PwdCertToken::H235_PwdCertToken(unsigned tag, PASN_Object::TagClass tagClass)
2501   : H235_ClearToken(tag, tagClass)
2502 {
2503   IncludeOptionalField(e_generalID);
2504   IncludeOptionalField(e_timeStamp);
2505 }
2506
2507
2508 PObject * H235_PwdCertToken::Clone() const
2509 {
2510 #ifndef PASN_LEANANDMEAN
2511   PAssert(IsClass(H235_PwdCertToken::Class()), PInvalidCast);
2512 #endif
2513   return new H235_PwdCertToken(*this);
2514 }
2515
2516
2517 //
2518 // EncodedPwdCertToken
2519 //
2520
2521 H235_EncodedPwdCertToken::H235_EncodedPwdCertToken(unsigned tag, PASN_Object::TagClass tagClass)
2522   : PASN_OctetString(tag, tagClass)
2523 {
2524 }
2525
2526
2527 PObject * H235_EncodedPwdCertToken::Clone() const
2528 {
2529 #ifndef PASN_LEANANDMEAN
2530   PAssert(IsClass(H235_EncodedPwdCertToken::Class()), PInvalidCast);
2531 #endif
2532   return new H235_EncodedPwdCertToken(*this);
2533 }
2534
2535
2536
2537 #ifndef PASN_NOPRINTON
2538 const static PASN_Names Names_H235_CryptoToken[]={
2539       {"cryptoEncryptedToken",0}
2540      ,{"cryptoSignedToken",1}
2541      ,{"cryptoHashedToken",2}
2542      ,{"cryptoPwdEncr",3}
2543 };
2544 #endif
2545 //
2546 // CryptoToken
2547 //
2548
2549 H235_CryptoToken::H235_CryptoToken(unsigned tag, PASN_Object::TagClass tagClass)
2550   : PASN_Choice(tag, tagClass, 4, TRUE
2551 #ifndef PASN_NOPRINTON
2552     ,(const PASN_Names *)Names_H235_CryptoToken,4
2553 #endif
2554 )
2555 {
2556 }
2557
2558
2559 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2560 H235_CryptoToken::operator H235_CryptoToken_cryptoEncryptedToken &() const
2561 #else
2562 H235_CryptoToken::operator H235_CryptoToken_cryptoEncryptedToken &()
2563 {
2564 #ifndef PASN_LEANANDMEAN
2565   PAssert(PIsDescendant(PAssertNULL(choice), H235_CryptoToken_cryptoEncryptedToken), PInvalidCast);
2566 #endif
2567   return *(H235_CryptoToken_cryptoEncryptedToken *)choice;
2568 }
2569
2570
2571 H235_CryptoToken::operator const H235_CryptoToken_cryptoEncryptedToken &() const
2572 #endif
2573 {
2574 #ifndef PASN_LEANANDMEAN
2575   PAssert(PIsDescendant(PAssertNULL(choice), H235_CryptoToken_cryptoEncryptedToken), PInvalidCast);
2576 #endif
2577   return *(H235_CryptoToken_cryptoEncryptedToken *)choice;
2578 }
2579
2580
2581 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2582 H235_CryptoToken::operator H235_CryptoToken_cryptoSignedToken &() const
2583 #else
2584 H235_CryptoToken::operator H235_CryptoToken_cryptoSignedToken &()
2585 {
2586 #ifndef PASN_LEANANDMEAN
2587   PAssert(PIsDescendant(PAssertNULL(choice), H235_CryptoToken_cryptoSignedToken), PInvalidCast);
2588 #endif
2589   return *(H235_CryptoToken_cryptoSignedToken *)choice;
2590 }
2591
2592
2593 H235_CryptoToken::operator const H235_CryptoToken_cryptoSignedToken &() const
2594 #endif
2595 {
2596 #ifndef PASN_LEANANDMEAN
2597   PAssert(PIsDescendant(PAssertNULL(choice), H235_CryptoToken_cryptoSignedToken), PInvalidCast);
2598 #endif
2599   return *(H235_CryptoToken_cryptoSignedToken *)choice;
2600 }
2601
2602
2603 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2604 H235_CryptoToken::operator H235_CryptoToken_cryptoHashedToken &() const
2605 #else
2606 H235_CryptoToken::operator H235_CryptoToken_cryptoHashedToken &()
2607 {
2608 #ifndef PASN_LEANANDMEAN
2609   PAssert(PIsDescendant(PAssertNULL(choice), H235_CryptoToken_cryptoHashedToken), PInvalidCast);
2610 #endif
2611   return *(H235_CryptoToken_cryptoHashedToken *)choice;
2612 }
2613
2614
2615 H235_CryptoToken::operator const H235_CryptoToken_cryptoHashedToken &() const
2616 #endif
2617 {
2618 #ifndef PASN_LEANANDMEAN
2619   PAssert(PIsDescendant(PAssertNULL(choice), H235_CryptoToken_cryptoHashedToken), PInvalidCast);
2620 #endif
2621   return *(H235_CryptoToken_cryptoHashedToken *)choice;
2622 }
2623
2624
2625 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2626 H235_CryptoToken::operator H235_ENCRYPTED<H235_EncodedPwdCertToken> &() const
2627 #else
2628 H235_CryptoToken::operator H235_ENCRYPTED<H235_EncodedPwdCertToken> &()
2629 {
2630 #ifndef PASN_LEANANDMEAN
2631   PAssert(PIsDescendant(PAssertNULL(choice), H235_ENCRYPTED<H235_EncodedPwdCertToken>), PInvalidCast);
2632 #endif
2633   return *(H235_ENCRYPTED<H235_EncodedPwdCertToken> *)choice;
2634 }
2635
2636
2637 H235_CryptoToken::operator const H235_ENCRYPTED<H235_EncodedPwdCertToken> &() const
2638 #endif
2639 {
2640 #ifndef PASN_LEANANDMEAN
2641   PAssert(PIsDescendant(PAssertNULL(choice), H235_ENCRYPTED<H235_EncodedPwdCertToken>), PInvalidCast);
2642 #endif
2643   return *(H235_ENCRYPTED<H235_EncodedPwdCertToken> *)choice;
2644 }
2645
2646
2647 BOOL H235_CryptoToken::CreateObject()
2648 {
2649   switch (tag) {
2650     case e_cryptoEncryptedToken :
2651       choice = new H235_CryptoToken_cryptoEncryptedToken();
2652       return TRUE;
2653     case e_cryptoSignedToken :
2654       choice = new H235_CryptoToken_cryptoSignedToken();
2655       return TRUE;
2656     case e_cryptoHashedToken :
2657       choice = new H235_CryptoToken_cryptoHashedToken();
2658       return TRUE;
2659     case e_cryptoPwdEncr :
2660       choice = new H235_ENCRYPTED<H235_EncodedPwdCertToken>();
2661       return TRUE;
2662   }
2663
2664   choice = NULL;
2665   return FALSE;
2666 }
2667
2668
2669 PObject * H235_CryptoToken::Clone() const
2670 {
2671 #ifndef PASN_LEANANDMEAN
2672   PAssert(IsClass(H235_CryptoToken::Class()), PInvalidCast);
2673 #endif
2674   return new H235_CryptoToken(*this);
2675 }
2676
2677
2678 //
2679 // CryptoToken_cryptoEncryptedToken
2680 //
2681
2682 H235_CryptoToken_cryptoEncryptedToken::H235_CryptoToken_cryptoEncryptedToken(unsigned tag, PASN_Object::TagClass tagClass)
2683   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
2684 {
2685 }
2686
2687
2688 #ifndef PASN_NOPRINTON
2689 void H235_CryptoToken_cryptoEncryptedToken::PrintOn(ostream & strm) const
2690 {
2691   int indent = strm.precision() + 2;
2692   strm << "{\n";
2693   strm << setw(indent+11) << "tokenOID = " << setprecision(indent) << m_tokenOID << '\n';
2694   strm << setw(indent+8) << "token = " << setprecision(indent) << m_token << '\n';
2695   strm << setw(indent-1) << setprecision(indent-2) << "}";
2696 }
2697 #endif
2698
2699
2700 PObject::Comparison H235_CryptoToken_cryptoEncryptedToken::Compare(const PObject & obj) const
2701 {
2702 #ifndef PASN_LEANANDMEAN
2703   PAssert(PIsDescendant(&obj, H235_CryptoToken_cryptoEncryptedToken), PInvalidCast);
2704 #endif
2705   const H235_CryptoToken_cryptoEncryptedToken & other = (const H235_CryptoToken_cryptoEncryptedToken &)obj;
2706
2707   Comparison result;
2708
2709   if ((result = m_tokenOID.Compare(other.m_tokenOID)) != EqualTo)
2710     return result;
2711   if ((result = m_token.Compare(other.m_token)) != EqualTo)
2712     return result;
2713
2714   return PASN_Sequence::Compare(other);
2715 }
2716
2717
2718 PINDEX H235_CryptoToken_cryptoEncryptedToken::GetDataLength() const
2719 {
2720   PINDEX length = 0;
2721   length += m_tokenOID.GetObjectLength();
2722   length += m_token.GetObjectLength();
2723   return length;
2724 }
2725
2726
2727 BOOL H235_CryptoToken_cryptoEncryptedToken::Decode(PASN_Stream & strm)
2728 {
2729   if (!PreambleDecode(strm))
2730     return FALSE;
2731
2732   if (!m_tokenOID.Decode(strm))
2733     return FALSE;
2734   if (!m_token.Decode(strm))
2735     return FALSE;
2736
2737   return UnknownExtensionsDecode(strm);
2738 }
2739
2740
2741 void H235_CryptoToken_cryptoEncryptedToken::Encode(PASN_Stream & strm) const
2742 {
2743   PreambleEncode(strm);
2744
2745   m_tokenOID.Encode(strm);
2746   m_token.Encode(strm);
2747
2748   UnknownExtensionsEncode(strm);
2749 }
2750
2751
2752 PObject * H235_CryptoToken_cryptoEncryptedToken::Clone() const
2753 {
2754 #ifndef PASN_LEANANDMEAN
2755   PAssert(IsClass(H235_CryptoToken_cryptoEncryptedToken::Class()), PInvalidCast);
2756 #endif
2757   return new H235_CryptoToken_cryptoEncryptedToken(*this);
2758 }
2759
2760
2761 //
2762 // CryptoToken_cryptoSignedToken
2763 //
2764
2765 H235_CryptoToken_cryptoSignedToken::H235_CryptoToken_cryptoSignedToken(unsigned tag, PASN_Object::TagClass tagClass)
2766   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
2767 {
2768 }
2769
2770
2771 #ifndef PASN_NOPRINTON
2772 void H235_CryptoToken_cryptoSignedToken::PrintOn(ostream & strm) const
2773 {
2774   int indent = strm.precision() + 2;
2775   strm << "{\n";
2776   strm << setw(indent+11) << "tokenOID = " << setprecision(indent) << m_tokenOID << '\n';
2777   strm << setw(indent+8) << "token = " << setprecision(indent) << m_token << '\n';
2778   strm << setw(indent-1) << setprecision(indent-2) << "}";
2779 }
2780 #endif
2781
2782
2783 PObject::Comparison H235_CryptoToken_cryptoSignedToken::Compare(const PObject & obj) const
2784 {
2785 #ifndef PASN_LEANANDMEAN
2786   PAssert(PIsDescendant(&obj, H235_CryptoToken_cryptoSignedToken), PInvalidCast);
2787 #endif
2788   const H235_CryptoToken_cryptoSignedToken & other = (const H235_CryptoToken_cryptoSignedToken &)obj;
2789
2790   Comparison result;
2791
2792   if ((result = m_tokenOID.Compare(other.m_tokenOID)) != EqualTo)
2793     return result;
2794   if ((result = m_token.Compare(other.m_token)) != EqualTo)
2795     return result;
2796
2797   return PASN_Sequence::Compare(other);
2798 }
2799
2800
2801 PINDEX H235_CryptoToken_cryptoSignedToken::GetDataLength() const
2802 {
2803   PINDEX length = 0;
2804   length += m_tokenOID.GetObjectLength();
2805   length += m_token.GetObjectLength();
2806   return length;
2807 }
2808
2809
2810 BOOL H235_CryptoToken_cryptoSignedToken::Decode(PASN_Stream & strm)
2811 {
2812   if (!PreambleDecode(strm))
2813     return FALSE;
2814
2815   if (!m_tokenOID.Decode(strm))
2816     return FALSE;
2817   if (!m_token.Decode(strm))
2818     return FALSE;
2819
2820   return UnknownExtensionsDecode(strm);
2821 }
2822
2823
2824 void H235_CryptoToken_cryptoSignedToken::Encode(PASN_Stream & strm) const
2825 {
2826   PreambleEncode(strm);
2827
2828   m_tokenOID.Encode(strm);
2829   m_token.Encode(strm);
2830
2831   UnknownExtensionsEncode(strm);
2832 }
2833
2834
2835 PObject * H235_CryptoToken_cryptoSignedToken::Clone() const
2836 {
2837 #ifndef PASN_LEANANDMEAN
2838   PAssert(IsClass(H235_CryptoToken_cryptoSignedToken::Class()), PInvalidCast);
2839 #endif
2840   return new H235_CryptoToken_cryptoSignedToken(*this);
2841 }
2842
2843
2844 //
2845 // CryptoToken_cryptoHashedToken
2846 //
2847
2848 H235_CryptoToken_cryptoHashedToken::H235_CryptoToken_cryptoHashedToken(unsigned tag, PASN_Object::TagClass tagClass)
2849   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
2850 {
2851 }
2852
2853
2854 #ifndef PASN_NOPRINTON
2855 void H235_CryptoToken_cryptoHashedToken::PrintOn(ostream & strm) const
2856 {
2857   int indent = strm.precision() + 2;
2858   strm << "{\n";
2859   strm << setw(indent+11) << "tokenOID = " << setprecision(indent) << m_tokenOID << '\n';
2860   strm << setw(indent+13) << "hashedVals = " << setprecision(indent) << m_hashedVals << '\n';
2861   strm << setw(indent+8) << "token = " << setprecision(indent) << m_token << '\n';
2862   strm << setw(indent-1) << setprecision(indent-2) << "}";
2863 }
2864 #endif
2865
2866
2867 PObject::Comparison H235_CryptoToken_cryptoHashedToken::Compare(const PObject & obj) const
2868 {
2869 #ifndef PASN_LEANANDMEAN
2870   PAssert(PIsDescendant(&obj, H235_CryptoToken_cryptoHashedToken), PInvalidCast);
2871 #endif
2872   const H235_CryptoToken_cryptoHashedToken & other = (const H235_CryptoToken_cryptoHashedToken &)obj;
2873
2874   Comparison result;
2875
2876   if ((result = m_tokenOID.Compare(other.m_tokenOID)) != EqualTo)
2877     return result;
2878   if ((result = m_hashedVals.Compare(other.m_hashedVals)) != EqualTo)
2879     return result;
2880   if ((result = m_token.Compare(other.m_token)) != EqualTo)
2881     return result;
2882
2883   return PASN_Sequence::Compare(other);
2884 }
2885
2886
2887 PINDEX H235_CryptoToken_cryptoHashedToken::GetDataLength() const
2888 {
2889   PINDEX length = 0;
2890   length += m_tokenOID.GetObjectLength();
2891   length += m_hashedVals.GetObjectLength();
2892   length += m_token.GetObjectLength();
2893   return length;
2894 }
2895
2896
2897 BOOL H235_CryptoToken_cryptoHashedToken::Decode(PASN_Stream & strm)
2898 {
2899   if (!PreambleDecode(strm))
2900     return FALSE;
2901
2902   if (!m_tokenOID.Decode(strm))
2903     return FALSE;
2904   if (!m_hashedVals.Decode(strm))
2905     return FALSE;
2906   if (!m_token.Decode(strm))
2907     return FALSE;
2908
2909   return UnknownExtensionsDecode(strm);
2910 }
2911
2912
2913 void H235_CryptoToken_cryptoHashedToken::Encode(PASN_Stream & strm) const
2914 {
2915   PreambleEncode(strm);
2916
2917   m_tokenOID.Encode(strm);
2918   m_hashedVals.Encode(strm);
2919   m_token.Encode(strm);
2920
2921   UnknownExtensionsEncode(strm);
2922 }
2923
2924
2925 PObject * H235_CryptoToken_cryptoHashedToken::Clone() const
2926 {
2927 #ifndef PASN_LEANANDMEAN
2928   PAssert(IsClass(H235_CryptoToken_cryptoHashedToken::Class()), PInvalidCast);
2929 #endif
2930   return new H235_CryptoToken_cryptoHashedToken(*this);
2931 }
2932
2933
2934 #endif // if ! H323_DISABLE_H235
2935
2936
2937 // End of h235.cxx