Fix warning of Coverity Static analysis, change H225ProtocolIdentifier
[asterisk/asterisk.git] / addons / ooh323c / src / h323 / H235-SECURITY-MESSAGESDec.c
1 /*
2  * Copyright (C) 2004-2005 by Objective Systems, Inc.
3  *
4  * This software is furnished under an open source license and may be 
5  * used and copied only in accordance with the terms of this license. 
6  * The text of the license may generally be found in the root 
7  * directory of this installation in the COPYING file.  It 
8  * can also be viewed online at the following URL:
9  *
10  *   http://www.obj-sys.com/open/license.html
11  *
12  * Any redistributions of this file including modified versions must 
13  * maintain this copyright notice.
14  *
15  *****************************************************************************/
16 /**
17  * This file was generated by the Objective Systems ASN1C Compiler
18  * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
19  */
20 #include "ooasn1.h"
21 #include "H235-SECURITY-MESSAGES.h"
22 #include "eventHandler.h"
23
24 /**************************************************************/
25 /*                                                            */
26 /*  ChallengeString                                           */
27 /*                                                            */
28 /**************************************************************/
29
30 EXTERN int asn1PD_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue)
31 {
32    static Asn1SizeCnst lsize1 = { 0, 8, 128, 0 };
33    int stat = ASN_OK;
34
35    addSizeConstraint (pctxt, &lsize1);
36
37    stat = decodeOctetString (pctxt,
38                           &pvalue->numocts,
39                           pvalue->data,
40                           sizeof(pvalue->data));
41    if (stat != ASN_OK) return stat;
42    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
43
44    return (stat);
45 }
46
47 /**************************************************************/
48 /*                                                            */
49 /*  TimeStamp                                                 */
50 /*                                                            */
51 /**************************************************************/
52
53 EXTERN int asn1PD_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp* pvalue)
54 {
55    int stat = ASN_OK;
56
57    stat = decodeConsUnsigned (pctxt, pvalue, 1U, ASN1UINT_MAX);
58    if (stat != ASN_OK) return stat;
59    invokeUIntValue (pctxt, *pvalue);
60
61    return (stat);
62 }
63
64 /**************************************************************/
65 /*                                                            */
66 /*  RandomVal                                                 */
67 /*                                                            */
68 /**************************************************************/
69
70 EXTERN int asn1PD_H235RandomVal (OOCTXT* pctxt, H235RandomVal* pvalue)
71 {
72    int stat = ASN_OK;
73
74    stat = decodeUnconsInteger (pctxt, pvalue);
75    if (stat != ASN_OK) return stat;
76    invokeIntValue (pctxt, *pvalue);
77
78    return (stat);
79 }
80
81 /**************************************************************/
82 /*                                                            */
83 /*  Password                                                  */
84 /*                                                            */
85 /**************************************************************/
86
87 EXTERN int asn1PD_H235Password (OOCTXT* pctxt, H235Password* pvalue)
88 {
89    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
90    int stat = ASN_OK;
91
92    addSizeConstraint (pctxt, &lsize1);
93
94    stat = decodeBMPString (pctxt, pvalue, 0);
95    if (stat != ASN_OK) return stat;
96    invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
97
98    return (stat);
99 }
100
101 /**************************************************************/
102 /*                                                            */
103 /*  EncodedPwdCertToken                                       */
104 /*                                                            */
105 /**************************************************************/
106
107 EXTERN int asn1PD_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken* pvalue)
108 {
109    int stat = ASN_OK;
110
111    stat = decodeOpenType (pctxt, &pvalue->data, &pvalue->numocts);
112    if (stat != ASN_OK) return stat;
113    invokeOpenTypeValue
114       (pctxt, pvalue->numocts, pvalue->data);
115
116    return (stat);
117 }
118
119 /**************************************************************/
120 /*                                                            */
121 /*  NonStandardParameter                                      */
122 /*                                                            */
123 /**************************************************************/
124
125 EXTERN int asn1PD_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue)
126 {
127    int stat = ASN_OK;
128
129    /* decode nonStandardIdentifier */
130
131    invokeStartElement (pctxt, "nonStandardIdentifier", -1);
132
133    stat = decodeObjectIdentifier (pctxt, &pvalue->nonStandardIdentifier);
134    if (stat != ASN_OK) return stat;
135    invokeOidValue (pctxt, pvalue->nonStandardIdentifier.numids, pvalue->nonStandardIdentifier.subid);
136
137    invokeEndElement (pctxt, "nonStandardIdentifier", -1);
138
139    /* decode data */
140
141    invokeStartElement (pctxt, "data", -1);
142
143    stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->data);
144    if (stat != ASN_OK) return stat;
145    invokeOctStrValue (pctxt, pvalue->data.numocts, pvalue->data.data);
146
147    invokeEndElement (pctxt, "data", -1);
148
149    return (stat);
150 }
151
152 /**************************************************************/
153 /*                                                            */
154 /*  AuthenticationBES                                         */
155 /*                                                            */
156 /**************************************************************/
157
158 EXTERN int asn1PD_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue)
159 {
160    int stat = ASN_OK;
161    ASN1UINT ui;
162    ASN1OpenType openType;
163    ASN1BOOL extbit;
164
165    extbit = 0;
166
167    /* extension bit */
168
169    DECODEBIT (pctxt, &extbit);
170
171    if (!extbit) {
172       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
173       if (stat != ASN_OK) return stat;
174       else pvalue->t = ui + 1;
175
176       switch (ui) {
177          /* default_ */
178          case 0:
179             invokeStartElement (pctxt, "default_", -1);
180
181             /* NULL */
182             invokeNullValue (pctxt);
183
184             invokeEndElement (pctxt, "default_", -1);
185
186             break;
187
188          /* radius */
189          case 1:
190             invokeStartElement (pctxt, "radius", -1);
191
192             /* NULL */
193             invokeNullValue (pctxt);
194
195             invokeEndElement (pctxt, "radius", -1);
196
197             break;
198
199          default:
200             return ASN_E_INVOPT;
201       }
202    }
203    else {
204       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
205       if (stat != ASN_OK) return stat;
206       else pvalue->t = ui + 3;
207
208       stat = decodeByteAlign (pctxt);
209       if (stat != ASN_OK) return stat;
210
211       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
212       if (stat != ASN_OK) return stat;
213
214    }
215
216    return (stat);
217 }
218
219 /**************************************************************/
220 /*                                                            */
221 /*  AuthenticationMechanism                                   */
222 /*                                                            */
223 /**************************************************************/
224
225 EXTERN int asn1PD_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue)
226 {
227    int stat = ASN_OK;
228    ASN1UINT ui;
229    ASN1OpenType openType;
230    ASN1BOOL extbit;
231    OOCTXT lctxt;
232
233    extbit = 0;
234
235    /* extension bit */
236
237    DECODEBIT (pctxt, &extbit);
238
239    if (!extbit) {
240       stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
241       if (stat != ASN_OK) return stat;
242       else pvalue->t = ui + 1;
243
244       switch (ui) {
245          /* dhExch */
246          case 0:
247             invokeStartElement (pctxt, "dhExch", -1);
248
249             /* NULL */
250             invokeNullValue (pctxt);
251
252             invokeEndElement (pctxt, "dhExch", -1);
253
254             break;
255
256          /* pwdSymEnc */
257          case 1:
258             invokeStartElement (pctxt, "pwdSymEnc", -1);
259
260             /* NULL */
261             invokeNullValue (pctxt);
262
263             invokeEndElement (pctxt, "pwdSymEnc", -1);
264
265             break;
266
267          /* pwdHash */
268          case 2:
269             invokeStartElement (pctxt, "pwdHash", -1);
270
271             /* NULL */
272             invokeNullValue (pctxt);
273
274             invokeEndElement (pctxt, "pwdHash", -1);
275
276             break;
277
278          /* certSign */
279          case 3:
280             invokeStartElement (pctxt, "certSign", -1);
281
282             /* NULL */
283             invokeNullValue (pctxt);
284
285             invokeEndElement (pctxt, "certSign", -1);
286
287             break;
288
289          /* ipsec */
290          case 4:
291             invokeStartElement (pctxt, "ipsec", -1);
292
293             /* NULL */
294             invokeNullValue (pctxt);
295
296             invokeEndElement (pctxt, "ipsec", -1);
297
298             break;
299
300          /* tls */
301          case 5:
302             invokeStartElement (pctxt, "tls", -1);
303
304             /* NULL */
305             invokeNullValue (pctxt);
306
307             invokeEndElement (pctxt, "tls", -1);
308
309             break;
310
311          /* nonStandard */
312          case 6:
313             invokeStartElement (pctxt, "nonStandard", -1);
314
315             pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H235NonStandardParameter);
316
317             stat = asn1PD_H235NonStandardParameter (pctxt, pvalue->u.nonStandard);
318             if (stat != ASN_OK) return stat;
319
320             invokeEndElement (pctxt, "nonStandard", -1);
321
322             break;
323
324          default:
325             return ASN_E_INVOPT;
326       }
327    }
328    else {
329       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
330       if (stat != ASN_OK) return stat;
331       else pvalue->t = ui + 8;
332
333       stat = decodeByteAlign (pctxt);
334       if (stat != ASN_OK) return stat;
335
336       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
337       if (stat != ASN_OK) return stat;
338
339       copyContext (&lctxt, pctxt);
340       initContextBuffer (pctxt, openType.data, openType.numocts);
341
342       switch (pvalue->t) {
343          /* authenticationBES */
344          case 8:
345             invokeStartElement (pctxt, "authenticationBES", -1);
346
347             pvalue->u.authenticationBES = ALLOC_ASN1ELEM (pctxt, H235AuthenticationBES);
348
349             stat = asn1PD_H235AuthenticationBES (pctxt, pvalue->u.authenticationBES);
350             if (stat != ASN_OK) return stat;
351
352             invokeEndElement (pctxt, "authenticationBES", -1);
353
354             break;
355
356          default:;
357       }
358
359       copyContext (pctxt, &lctxt);
360    }
361
362    return (stat);
363 }
364
365 /**************************************************************/
366 /*                                                            */
367 /*  DHset_halfkey                                             */
368 /*                                                            */
369 /**************************************************************/
370
371 EXTERN int asn1PD_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue)
372 {
373    static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
374    int stat = ASN_OK;
375
376    addSizeConstraint (pctxt, &lsize1);
377
378    stat = decodeBitString (pctxt,
379                         &pvalue->numbits,
380                         pvalue->data,
381                         sizeof(pvalue->data));
382    if (stat != ASN_OK) return stat;
383
384    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
385
386    return (stat);
387 }
388
389 /**************************************************************/
390 /*                                                            */
391 /*  DHset_modSize                                             */
392 /*                                                            */
393 /**************************************************************/
394
395 EXTERN int asn1PD_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue)
396 {
397    static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
398    int stat = ASN_OK;
399
400    addSizeConstraint (pctxt, &lsize1);
401
402    stat = decodeBitString (pctxt,
403                         &pvalue->numbits,
404                         pvalue->data,
405                         sizeof(pvalue->data));
406    if (stat != ASN_OK) return stat;
407
408    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
409
410    return (stat);
411 }
412
413 /**************************************************************/
414 /*                                                            */
415 /*  DHset_generator                                           */
416 /*                                                            */
417 /**************************************************************/
418
419 EXTERN int asn1PD_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue)
420 {
421    static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
422    int stat = ASN_OK;
423
424    addSizeConstraint (pctxt, &lsize1);
425
426    stat = decodeBitString (pctxt,
427                         &pvalue->numbits,
428                         pvalue->data,
429                         sizeof(pvalue->data));
430    if (stat != ASN_OK) return stat;
431
432    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
433
434    return (stat);
435 }
436
437 /**************************************************************/
438 /*                                                            */
439 /*  DHset                                                     */
440 /*                                                            */
441 /**************************************************************/
442
443 EXTERN int asn1PD_H235DHset (OOCTXT* pctxt, H235DHset* pvalue)
444 {
445    int stat = ASN_OK;
446    OOCTXT lctxt;
447    ASN1OpenType openType;
448    ASN1UINT bitcnt;
449    ASN1UINT i;
450    ASN1BOOL optbit;
451    ASN1BOOL extbit;
452
453    optbit = extbit = 0;
454
455    /* extension bit */
456
457    DECODEBIT (pctxt, &extbit);
458
459    /* decode halfkey */
460
461    invokeStartElement (pctxt, "halfkey", -1);
462
463    stat = asn1PD_H235DHset_halfkey (pctxt, &pvalue->halfkey);
464    if (stat != ASN_OK) return stat;
465
466    invokeEndElement (pctxt, "halfkey", -1);
467
468    /* decode modSize */
469
470    invokeStartElement (pctxt, "modSize", -1);
471
472    stat = asn1PD_H235DHset_modSize (pctxt, &pvalue->modSize);
473    if (stat != ASN_OK) return stat;
474
475    invokeEndElement (pctxt, "modSize", -1);
476
477    /* decode generator */
478
479    invokeStartElement (pctxt, "generator", -1);
480
481    stat = asn1PD_H235DHset_generator (pctxt, &pvalue->generator);
482    if (stat != ASN_OK) return stat;
483
484    invokeEndElement (pctxt, "generator", -1);
485
486    if (extbit) {
487
488       /* decode extension optional bits length */
489
490       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
491       if (stat != ASN_OK) return stat;
492
493       bitcnt += 1;
494
495       ZEROCONTEXT (&lctxt);
496       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
497       if (stat != ASN_OK) return stat;
498
499       stat = moveBitCursor (pctxt, bitcnt);
500       if (stat != ASN_OK) return stat;
501
502       for (i = 0; i < bitcnt; i++) {
503          DECODEBIT (&lctxt, &optbit);
504
505          if (optbit) {
506             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
507             if (stat != ASN_OK) return stat;
508
509             pctxt->buffer.byteIndex += openType.numocts;
510          }
511       }
512    }
513
514    return (stat);
515 }
516
517 /**************************************************************/
518 /*                                                            */
519 /*  TypedCertificate                                          */
520 /*                                                            */
521 /**************************************************************/
522
523 EXTERN int asn1PD_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue)
524 {
525    int stat = ASN_OK;
526    OOCTXT lctxt;
527    ASN1OpenType openType;
528    ASN1UINT bitcnt;
529    ASN1UINT i;
530    ASN1BOOL optbit;
531    ASN1BOOL extbit;
532
533    optbit = extbit = 0;
534
535    /* extension bit */
536
537    DECODEBIT (pctxt, &extbit);
538
539    /* decode type */
540
541    invokeStartElement (pctxt, "type", -1);
542
543    stat = decodeObjectIdentifier (pctxt, &pvalue->type);
544    if (stat != ASN_OK) return stat;
545    invokeOidValue (pctxt, pvalue->type.numids, pvalue->type.subid);
546
547    invokeEndElement (pctxt, "type", -1);
548
549    /* decode certificate */
550
551    invokeStartElement (pctxt, "certificate", -1);
552
553    stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->certificate);
554    if (stat != ASN_OK) return stat;
555    invokeOctStrValue (pctxt, pvalue->certificate.numocts, pvalue->certificate.data);
556
557    invokeEndElement (pctxt, "certificate", -1);
558
559    if (extbit) {
560
561       /* decode extension optional bits length */
562
563       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
564       if (stat != ASN_OK) return stat;
565
566       bitcnt += 1;
567
568       ZEROCONTEXT (&lctxt);
569       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
570       if (stat != ASN_OK) return stat;
571
572       stat = moveBitCursor (pctxt, bitcnt);
573       if (stat != ASN_OK) return stat;
574
575       for (i = 0; i < bitcnt; i++) {
576          DECODEBIT (&lctxt, &optbit);
577
578          if (optbit) {
579             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
580             if (stat != ASN_OK) return stat;
581
582             pctxt->buffer.byteIndex += openType.numocts;
583          }
584       }
585    }
586
587    return (stat);
588 }
589
590 /**************************************************************/
591 /*                                                            */
592 /*  Identifier                                                */
593 /*                                                            */
594 /**************************************************************/
595
596 EXTERN int asn1PD_H235Identifier (OOCTXT* pctxt, H235Identifier* pvalue)
597 {
598    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
599    int stat = ASN_OK;
600
601    addSizeConstraint (pctxt, &lsize1);
602
603    stat = decodeBMPString (pctxt, pvalue, 0);
604    if (stat != ASN_OK) return stat;
605    invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
606
607    return (stat);
608 }
609
610 /**************************************************************/
611 /*                                                            */
612 /*  ECpoint_x                                                 */
613 /*                                                            */
614 /**************************************************************/
615
616 EXTERN int asn1PD_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue)
617 {
618    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
619    int stat = ASN_OK;
620
621    addSizeConstraint (pctxt, &lsize1);
622
623    stat = decodeBitString (pctxt,
624                         &pvalue->numbits,
625                         pvalue->data,
626                         sizeof(pvalue->data));
627    if (stat != ASN_OK) return stat;
628
629    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
630
631    return (stat);
632 }
633
634 /**************************************************************/
635 /*                                                            */
636 /*  ECpoint_y                                                 */
637 /*                                                            */
638 /**************************************************************/
639
640 EXTERN int asn1PD_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue)
641 {
642    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
643    int stat = ASN_OK;
644
645    addSizeConstraint (pctxt, &lsize1);
646
647    stat = decodeBitString (pctxt,
648                         &pvalue->numbits,
649                         pvalue->data,
650                         sizeof(pvalue->data));
651    if (stat != ASN_OK) return stat;
652
653    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
654
655    return (stat);
656 }
657
658 /**************************************************************/
659 /*                                                            */
660 /*  ECpoint                                                   */
661 /*                                                            */
662 /**************************************************************/
663
664 EXTERN int asn1PD_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue)
665 {
666    int stat = ASN_OK;
667    OOCTXT lctxt;
668    ASN1OpenType openType;
669    ASN1UINT bitcnt;
670    ASN1UINT i;
671    ASN1BOOL optbit;
672    ASN1BOOL extbit;
673
674    optbit = extbit = 0;
675
676    /* extension bit */
677
678    DECODEBIT (pctxt, &extbit);
679
680    /* optional bits */
681
682    memset (&pvalue->m, 0, sizeof(pvalue->m));
683
684    DECODEBIT (pctxt, &optbit);
685    pvalue->m.xPresent = optbit;
686
687    DECODEBIT (pctxt, &optbit);
688    pvalue->m.yPresent = optbit;
689
690    /* decode x */
691
692    if (pvalue->m.xPresent) {
693       invokeStartElement (pctxt, "x", -1);
694
695       stat = asn1PD_H235ECpoint_x (pctxt, &pvalue->x);
696       if (stat != ASN_OK) return stat;
697
698       invokeEndElement (pctxt, "x", -1);
699    }
700
701    /* decode y */
702
703    if (pvalue->m.yPresent) {
704       invokeStartElement (pctxt, "y", -1);
705
706       stat = asn1PD_H235ECpoint_y (pctxt, &pvalue->y);
707       if (stat != ASN_OK) return stat;
708
709       invokeEndElement (pctxt, "y", -1);
710    }
711
712    if (extbit) {
713
714       /* decode extension optional bits length */
715
716       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
717       if (stat != ASN_OK) return stat;
718
719       bitcnt += 1;
720
721       ZEROCONTEXT (&lctxt);
722       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
723       if (stat != ASN_OK) return stat;
724
725       stat = moveBitCursor (pctxt, bitcnt);
726       if (stat != ASN_OK) return stat;
727
728       for (i = 0; i < bitcnt; i++) {
729          DECODEBIT (&lctxt, &optbit);
730
731          if (optbit) {
732             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
733             if (stat != ASN_OK) return stat;
734
735             pctxt->buffer.byteIndex += openType.numocts;
736          }
737       }
738    }
739
740    return (stat);
741 }
742
743 /**************************************************************/
744 /*                                                            */
745 /*  ECKASDH_eckasdhp_modulus                                  */
746 /*                                                            */
747 /**************************************************************/
748
749 EXTERN int asn1PD_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue)
750 {
751    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
752    int stat = ASN_OK;
753
754    addSizeConstraint (pctxt, &lsize1);
755
756    stat = decodeBitString (pctxt,
757                         &pvalue->numbits,
758                         pvalue->data,
759                         sizeof(pvalue->data));
760    if (stat != ASN_OK) return stat;
761
762    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
763
764    return (stat);
765 }
766
767 /**************************************************************/
768 /*                                                            */
769 /*  ECKASDH_eckasdhp_weierstrassA                             */
770 /*                                                            */
771 /**************************************************************/
772
773 EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue)
774 {
775    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
776    int stat = ASN_OK;
777
778    addSizeConstraint (pctxt, &lsize1);
779
780    stat = decodeBitString (pctxt,
781                         &pvalue->numbits,
782                         pvalue->data,
783                         sizeof(pvalue->data));
784    if (stat != ASN_OK) return stat;
785
786    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
787
788    return (stat);
789 }
790
791 /**************************************************************/
792 /*                                                            */
793 /*  ECKASDH_eckasdhp_weierstrassB                             */
794 /*                                                            */
795 /**************************************************************/
796
797 EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue)
798 {
799    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
800    int stat = ASN_OK;
801
802    addSizeConstraint (pctxt, &lsize1);
803
804    stat = decodeBitString (pctxt,
805                         &pvalue->numbits,
806                         pvalue->data,
807                         sizeof(pvalue->data));
808    if (stat != ASN_OK) return stat;
809
810    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
811
812    return (stat);
813 }
814
815 /**************************************************************/
816 /*                                                            */
817 /*  ECKASDH_eckasdhp                                          */
818 /*                                                            */
819 /**************************************************************/
820
821 EXTERN int asn1PD_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue)
822 {
823    int stat = ASN_OK;
824
825    /* decode public_key */
826
827    invokeStartElement (pctxt, "public_key", -1);
828
829    stat = asn1PD_H235ECpoint (pctxt, &pvalue->public_key);
830    if (stat != ASN_OK) return stat;
831
832    invokeEndElement (pctxt, "public_key", -1);
833
834    /* decode modulus */
835
836    invokeStartElement (pctxt, "modulus", -1);
837
838    stat = asn1PD_H235ECKASDH_eckasdhp_modulus (pctxt, &pvalue->modulus);
839    if (stat != ASN_OK) return stat;
840
841    invokeEndElement (pctxt, "modulus", -1);
842
843    /* decode base */
844
845    invokeStartElement (pctxt, "base", -1);
846
847    stat = asn1PD_H235ECpoint (pctxt, &pvalue->base);
848    if (stat != ASN_OK) return stat;
849
850    invokeEndElement (pctxt, "base", -1);
851
852    /* decode weierstrassA */
853
854    invokeStartElement (pctxt, "weierstrassA", -1);
855
856    stat = asn1PD_H235ECKASDH_eckasdhp_weierstrassA (pctxt, &pvalue->weierstrassA);
857    if (stat != ASN_OK) return stat;
858
859    invokeEndElement (pctxt, "weierstrassA", -1);
860
861    /* decode weierstrassB */
862
863    invokeStartElement (pctxt, "weierstrassB", -1);
864
865    stat = asn1PD_H235ECKASDH_eckasdhp_weierstrassB (pctxt, &pvalue->weierstrassB);
866    if (stat != ASN_OK) return stat;
867
868    invokeEndElement (pctxt, "weierstrassB", -1);
869
870    return (stat);
871 }
872
873 /**************************************************************/
874 /*                                                            */
875 /*  ECKASDH_eckasdh2_fieldSize                                */
876 /*                                                            */
877 /**************************************************************/
878
879 EXTERN int asn1PD_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue)
880 {
881    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
882    int stat = ASN_OK;
883
884    addSizeConstraint (pctxt, &lsize1);
885
886    stat = decodeBitString (pctxt,
887                         &pvalue->numbits,
888                         pvalue->data,
889                         sizeof(pvalue->data));
890    if (stat != ASN_OK) return stat;
891
892    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
893
894    return (stat);
895 }
896
897 /**************************************************************/
898 /*                                                            */
899 /*  ECKASDH_eckasdh2_weierstrassA                             */
900 /*                                                            */
901 /**************************************************************/
902
903 EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue)
904 {
905    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
906    int stat = ASN_OK;
907
908    addSizeConstraint (pctxt, &lsize1);
909
910    stat = decodeBitString (pctxt,
911                         &pvalue->numbits,
912                         pvalue->data,
913                         sizeof(pvalue->data));
914    if (stat != ASN_OK) return stat;
915
916    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
917
918    return (stat);
919 }
920
921 /**************************************************************/
922 /*                                                            */
923 /*  ECKASDH_eckasdh2_weierstrassB                             */
924 /*                                                            */
925 /**************************************************************/
926
927 EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue)
928 {
929    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
930    int stat = ASN_OK;
931
932    addSizeConstraint (pctxt, &lsize1);
933
934    stat = decodeBitString (pctxt,
935                         &pvalue->numbits,
936                         pvalue->data,
937                         sizeof(pvalue->data));
938    if (stat != ASN_OK) return stat;
939
940    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
941
942    return (stat);
943 }
944
945 /**************************************************************/
946 /*                                                            */
947 /*  ECKASDH_eckasdh2                                          */
948 /*                                                            */
949 /**************************************************************/
950
951 EXTERN int asn1PD_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue)
952 {
953    int stat = ASN_OK;
954
955    /* decode public_key */
956
957    invokeStartElement (pctxt, "public_key", -1);
958
959    stat = asn1PD_H235ECpoint (pctxt, &pvalue->public_key);
960    if (stat != ASN_OK) return stat;
961
962    invokeEndElement (pctxt, "public_key", -1);
963
964    /* decode fieldSize */
965
966    invokeStartElement (pctxt, "fieldSize", -1);
967
968    stat = asn1PD_H235ECKASDH_eckasdh2_fieldSize (pctxt, &pvalue->fieldSize);
969    if (stat != ASN_OK) return stat;
970
971    invokeEndElement (pctxt, "fieldSize", -1);
972
973    /* decode base */
974
975    invokeStartElement (pctxt, "base", -1);
976
977    stat = asn1PD_H235ECpoint (pctxt, &pvalue->base);
978    if (stat != ASN_OK) return stat;
979
980    invokeEndElement (pctxt, "base", -1);
981
982    /* decode weierstrassA */
983
984    invokeStartElement (pctxt, "weierstrassA", -1);
985
986    stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassA (pctxt, &pvalue->weierstrassA);
987    if (stat != ASN_OK) return stat;
988
989    invokeEndElement (pctxt, "weierstrassA", -1);
990
991    /* decode weierstrassB */
992
993    invokeStartElement (pctxt, "weierstrassB", -1);
994
995    stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassB (pctxt, &pvalue->weierstrassB);
996    if (stat != ASN_OK) return stat;
997
998    invokeEndElement (pctxt, "weierstrassB", -1);
999
1000    return (stat);
1001 }
1002
1003 /**************************************************************/
1004 /*                                                            */
1005 /*  ECKASDH                                                   */
1006 /*                                                            */
1007 /**************************************************************/
1008
1009 EXTERN int asn1PD_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue)
1010 {
1011    int stat = ASN_OK;
1012    ASN1UINT ui;
1013    ASN1OpenType openType;
1014    ASN1BOOL extbit;
1015
1016    extbit = 0;
1017
1018    /* extension bit */
1019
1020    DECODEBIT (pctxt, &extbit);
1021
1022    if (!extbit) {
1023       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
1024       if (stat != ASN_OK) return stat;
1025       else pvalue->t = ui + 1;
1026
1027       switch (ui) {
1028          /* eckasdhp */
1029          case 0:
1030             invokeStartElement (pctxt, "eckasdhp", -1);
1031
1032             pvalue->u.eckasdhp = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdhp);
1033
1034             stat = asn1PD_H235ECKASDH_eckasdhp (pctxt, pvalue->u.eckasdhp);
1035             if (stat != ASN_OK) return stat;
1036
1037             invokeEndElement (pctxt, "eckasdhp", -1);
1038
1039             break;
1040
1041          /* eckasdh2 */
1042          case 1:
1043             invokeStartElement (pctxt, "eckasdh2", -1);
1044
1045             pvalue->u.eckasdh2 = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdh2);
1046
1047             stat = asn1PD_H235ECKASDH_eckasdh2 (pctxt, pvalue->u.eckasdh2);
1048             if (stat != ASN_OK) return stat;
1049
1050             invokeEndElement (pctxt, "eckasdh2", -1);
1051
1052             break;
1053
1054          default:
1055             return ASN_E_INVOPT;
1056       }
1057    }
1058    else {
1059       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1060       if (stat != ASN_OK) return stat;
1061       else pvalue->t = ui + 3;
1062
1063       stat = decodeByteAlign (pctxt);
1064       if (stat != ASN_OK) return stat;
1065
1066       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1067       if (stat != ASN_OK) return stat;
1068
1069    }
1070
1071    return (stat);
1072 }
1073
1074 /**************************************************************/
1075 /*                                                            */
1076 /*  ClearToken                                                */
1077 /*                                                            */
1078 /**************************************************************/
1079
1080 EXTERN int asn1PD_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue)
1081 {
1082    int stat = ASN_OK;
1083    OOCTXT lctxt;
1084    OOCTXT lctxt2;
1085    ASN1OpenType openType;
1086    ASN1UINT bitcnt;
1087    ASN1UINT i;
1088    ASN1BOOL optbit;
1089    ASN1BOOL extbit;
1090
1091    optbit = extbit = 0;
1092
1093    /* extension bit */
1094
1095    DECODEBIT (pctxt, &extbit);
1096
1097    /* optional bits */
1098
1099    memset (&pvalue->m, 0, sizeof(pvalue->m));
1100
1101    DECODEBIT (pctxt, &optbit);
1102    pvalue->m.timeStampPresent = optbit;
1103
1104    DECODEBIT (pctxt, &optbit);
1105    pvalue->m.passwordPresent = optbit;
1106
1107    DECODEBIT (pctxt, &optbit);
1108    pvalue->m.dhkeyPresent = optbit;
1109
1110    DECODEBIT (pctxt, &optbit);
1111    pvalue->m.challengePresent = optbit;
1112
1113    DECODEBIT (pctxt, &optbit);
1114    pvalue->m.randomPresent = optbit;
1115
1116    DECODEBIT (pctxt, &optbit);
1117    pvalue->m.certificatePresent = optbit;
1118
1119    DECODEBIT (pctxt, &optbit);
1120    pvalue->m.generalIDPresent = optbit;
1121
1122    DECODEBIT (pctxt, &optbit);
1123    pvalue->m.nonStandardPresent = optbit;
1124
1125    /* decode tokenOID */
1126
1127    invokeStartElement (pctxt, "tokenOID", -1);
1128
1129    stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
1130    if (stat != ASN_OK) return stat;
1131    invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
1132
1133    invokeEndElement (pctxt, "tokenOID", -1);
1134
1135    /* decode timeStamp */
1136
1137    if (pvalue->m.timeStampPresent) {
1138       invokeStartElement (pctxt, "timeStamp", -1);
1139
1140       stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp);
1141       if (stat != ASN_OK) return stat;
1142
1143       invokeEndElement (pctxt, "timeStamp", -1);
1144    }
1145
1146    /* decode password */
1147
1148    if (pvalue->m.passwordPresent) {
1149       invokeStartElement (pctxt, "password", -1);
1150
1151       stat = asn1PD_H235Password (pctxt, &pvalue->password);
1152       if (stat != ASN_OK) return stat;
1153
1154       invokeEndElement (pctxt, "password", -1);
1155    }
1156
1157    /* decode dhkey */
1158
1159    if (pvalue->m.dhkeyPresent) {
1160       invokeStartElement (pctxt, "dhkey", -1);
1161
1162       stat = asn1PD_H235DHset (pctxt, &pvalue->dhkey);
1163       if (stat != ASN_OK) return stat;
1164
1165       invokeEndElement (pctxt, "dhkey", -1);
1166    }
1167
1168    /* decode challenge */
1169
1170    if (pvalue->m.challengePresent) {
1171       invokeStartElement (pctxt, "challenge", -1);
1172
1173       stat = asn1PD_H235ChallengeString (pctxt, &pvalue->challenge);
1174       if (stat != ASN_OK) return stat;
1175
1176       invokeEndElement (pctxt, "challenge", -1);
1177    }
1178
1179    /* decode random */
1180
1181    if (pvalue->m.randomPresent) {
1182       invokeStartElement (pctxt, "random", -1);
1183
1184       stat = asn1PD_H235RandomVal (pctxt, &pvalue->random);
1185       if (stat != ASN_OK) return stat;
1186
1187       invokeEndElement (pctxt, "random", -1);
1188    }
1189
1190    /* decode certificate */
1191
1192    if (pvalue->m.certificatePresent) {
1193       invokeStartElement (pctxt, "certificate", -1);
1194
1195       stat = asn1PD_H235TypedCertificate (pctxt, &pvalue->certificate);
1196       if (stat != ASN_OK) return stat;
1197
1198       invokeEndElement (pctxt, "certificate", -1);
1199    }
1200
1201    /* decode generalID */
1202
1203    if (pvalue->m.generalIDPresent) {
1204       invokeStartElement (pctxt, "generalID", -1);
1205
1206       stat = asn1PD_H235Identifier (pctxt, &pvalue->generalID);
1207       if (stat != ASN_OK) return stat;
1208
1209       invokeEndElement (pctxt, "generalID", -1);
1210    }
1211
1212    /* decode nonStandard */
1213
1214    if (pvalue->m.nonStandardPresent) {
1215       invokeStartElement (pctxt, "nonStandard", -1);
1216
1217       stat = asn1PD_H235NonStandardParameter (pctxt, &pvalue->nonStandard);
1218       if (stat != ASN_OK) return stat;
1219
1220       invokeEndElement (pctxt, "nonStandard", -1);
1221    }
1222
1223    if (extbit) {
1224
1225       /* decode extension optional bits length */
1226
1227       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1228       if (stat != ASN_OK) return stat;
1229
1230       bitcnt += 1;
1231
1232       ZEROCONTEXT (&lctxt);
1233       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1234       if (stat != ASN_OK) return stat;
1235
1236       stat = moveBitCursor (pctxt, bitcnt);
1237       if (stat != ASN_OK) return stat;
1238
1239       for (i = 0; i < bitcnt; i++) {
1240          DECODEBIT (&lctxt, &optbit);
1241
1242          if (optbit) {
1243             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1244             if (stat != ASN_OK) return stat;
1245
1246             if (i < 2 && openType.numocts > 0) {  /* known element */
1247                copyContext (&lctxt2, pctxt);
1248                initContextBuffer (pctxt, openType.data, openType.numocts);
1249
1250                switch (i) {
1251                   case 0:
1252                      pvalue->m.eckasdhkeyPresent = 1;
1253
1254                      invokeStartElement (pctxt, "eckasdhkey", -1);
1255
1256                      stat = asn1PD_H235ECKASDH (pctxt, &pvalue->eckasdhkey);
1257                      if (stat != ASN_OK) return stat;
1258
1259                      invokeEndElement (pctxt, "eckasdhkey", -1);
1260                      break;
1261
1262                   case 1:
1263                      pvalue->m.sendersIDPresent = 1;
1264
1265                      invokeStartElement (pctxt, "sendersID", -1);
1266
1267                      stat = asn1PD_H235Identifier (pctxt, &pvalue->sendersID);
1268                      if (stat != ASN_OK) return stat;
1269
1270                      invokeEndElement (pctxt, "sendersID", -1);
1271                      break;
1272
1273                   default:
1274                      pctxt->buffer.byteIndex += openType.numocts;
1275                }
1276                copyContext (pctxt, &lctxt2);
1277             }
1278             else {  /* unknown element */
1279                pctxt->buffer.byteIndex += openType.numocts;
1280             }
1281          }
1282       }
1283    }
1284
1285    return (stat);
1286 }
1287
1288 /**************************************************************/
1289 /*                                                            */
1290 /*  IV8                                                       */
1291 /*                                                            */
1292 /**************************************************************/
1293
1294 EXTERN int asn1PD_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue)
1295 {
1296    static Asn1SizeCnst lsize1 = { 0, 8, 8, 0 };
1297    int stat = ASN_OK;
1298
1299    addSizeConstraint (pctxt, &lsize1);
1300
1301    stat = decodeOctetString (pctxt,
1302                           &pvalue->numocts,
1303                           pvalue->data,
1304                           sizeof(pvalue->data));
1305    if (stat != ASN_OK) return stat;
1306    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
1307
1308    return (stat);
1309 }
1310
1311 /**************************************************************/
1312 /*                                                            */
1313 /*  IV16                                                      */
1314 /*                                                            */
1315 /**************************************************************/
1316
1317 EXTERN int asn1PD_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue)
1318 {
1319    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
1320    int stat = ASN_OK;
1321
1322    addSizeConstraint (pctxt, &lsize1);
1323
1324    stat = decodeOctetString (pctxt,
1325                           &pvalue->numocts,
1326                           pvalue->data,
1327                           sizeof(pvalue->data));
1328    if (stat != ASN_OK) return stat;
1329    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
1330
1331    return (stat);
1332 }
1333
1334 /**************************************************************/
1335 /*                                                            */
1336 /*  Params                                                    */
1337 /*                                                            */
1338 /**************************************************************/
1339
1340 EXTERN int asn1PD_H235Params (OOCTXT* pctxt, H235Params* pvalue)
1341 {
1342    int stat = ASN_OK;
1343    OOCTXT lctxt;
1344    OOCTXT lctxt2;
1345    ASN1OpenType openType;
1346    ASN1UINT bitcnt;
1347    ASN1UINT i;
1348    ASN1BOOL optbit;
1349    ASN1BOOL extbit;
1350
1351    optbit = extbit = 0;
1352
1353    /* extension bit */
1354
1355    DECODEBIT (pctxt, &extbit);
1356
1357    /* optional bits */
1358
1359    memset (&pvalue->m, 0, sizeof(pvalue->m));
1360
1361    DECODEBIT (pctxt, &optbit);
1362    pvalue->m.ranIntPresent = optbit;
1363
1364    DECODEBIT (pctxt, &optbit);
1365    pvalue->m.iv8Present = optbit;
1366
1367    /* decode ranInt */
1368
1369    if (pvalue->m.ranIntPresent) {
1370       invokeStartElement (pctxt, "ranInt", -1);
1371
1372       stat = decodeUnconsInteger (pctxt, &pvalue->ranInt);
1373       if (stat != ASN_OK) return stat;
1374       invokeIntValue (pctxt, pvalue->ranInt);
1375
1376       invokeEndElement (pctxt, "ranInt", -1);
1377    }
1378
1379    /* decode iv8 */
1380
1381    if (pvalue->m.iv8Present) {
1382       invokeStartElement (pctxt, "iv8", -1);
1383
1384       stat = asn1PD_H235IV8 (pctxt, &pvalue->iv8);
1385       if (stat != ASN_OK) return stat;
1386
1387       invokeEndElement (pctxt, "iv8", -1);
1388    }
1389
1390    if (extbit) {
1391
1392       /* decode extension optional bits length */
1393
1394       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1395       if (stat != ASN_OK) return stat;
1396
1397       bitcnt += 1;
1398
1399       ZEROCONTEXT (&lctxt);
1400       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1401       if (stat != ASN_OK) return stat;
1402
1403       stat = moveBitCursor (pctxt, bitcnt);
1404       if (stat != ASN_OK) return stat;
1405
1406       for (i = 0; i < bitcnt; i++) {
1407          DECODEBIT (&lctxt, &optbit);
1408
1409          if (optbit) {
1410             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1411             if (stat != ASN_OK) return stat;
1412
1413             if (i < 1 && openType.numocts > 0) {  /* known element */
1414                copyContext (&lctxt2, pctxt);
1415                initContextBuffer (pctxt, openType.data, openType.numocts);
1416
1417                switch (i) {
1418                   case 0:
1419                      pvalue->m.iv16Present = 1;
1420
1421                      invokeStartElement (pctxt, "iv16", -1);
1422
1423                      stat = asn1PD_H235IV16 (pctxt, &pvalue->iv16);
1424                      if (stat != ASN_OK) return stat;
1425
1426                      invokeEndElement (pctxt, "iv16", -1);
1427                      break;
1428
1429                   default:
1430                      pctxt->buffer.byteIndex += openType.numocts;
1431                }
1432                copyContext (pctxt, &lctxt2);
1433             }
1434             else {  /* unknown element */
1435                pctxt->buffer.byteIndex += openType.numocts;
1436             }
1437          }
1438       }
1439    }
1440
1441    return (stat);
1442 }
1443
1444 /**************************************************************/
1445 /*                                                            */
1446 /*  ENCRYPTED                                                 */
1447 /*                                                            */
1448 /**************************************************************/
1449
1450 EXTERN int asn1PD_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue)
1451 {
1452    int stat = ASN_OK;
1453
1454    /* decode algorithmOID */
1455
1456    invokeStartElement (pctxt, "algorithmOID", -1);
1457
1458    stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
1459    if (stat != ASN_OK) return stat;
1460    invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
1461
1462    invokeEndElement (pctxt, "algorithmOID", -1);
1463
1464    /* decode paramS */
1465
1466    invokeStartElement (pctxt, "paramS", -1);
1467
1468    stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
1469    if (stat != ASN_OK) return stat;
1470
1471    invokeEndElement (pctxt, "paramS", -1);
1472
1473    /* decode encryptedData */
1474
1475    invokeStartElement (pctxt, "encryptedData", -1);
1476
1477    stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->encryptedData);
1478    if (stat != ASN_OK) return stat;
1479    invokeOctStrValue (pctxt, pvalue->encryptedData.numocts, pvalue->encryptedData.data);
1480
1481    invokeEndElement (pctxt, "encryptedData", -1);
1482
1483    return (stat);
1484 }
1485
1486 /**************************************************************/
1487 /*                                                            */
1488 /*  CryptoToken_cryptoEncryptedToken                          */
1489 /*                                                            */
1490 /**************************************************************/
1491
1492 EXTERN int asn1PD_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue)
1493 {
1494    int stat = ASN_OK;
1495
1496    /* decode tokenOID */
1497
1498    invokeStartElement (pctxt, "tokenOID", -1);
1499
1500    stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
1501    if (stat != ASN_OK) return stat;
1502    invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
1503
1504    invokeEndElement (pctxt, "tokenOID", -1);
1505
1506    /* decode token */
1507
1508    invokeStartElement (pctxt, "token", -1);
1509
1510    stat = asn1PD_H235ENCRYPTED (pctxt, &pvalue->token);
1511    if (stat != ASN_OK) return stat;
1512
1513    invokeEndElement (pctxt, "token", -1);
1514
1515    return (stat);
1516 }
1517
1518 /**************************************************************/
1519 /*                                                            */
1520 /*  EncodedGeneralToken                                       */
1521 /*                                                            */
1522 /**************************************************************/
1523
1524 EXTERN int asn1PD_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken* pvalue)
1525 {
1526    int stat = ASN_OK;
1527
1528    stat = decodeOpenType (pctxt, &pvalue->data, &pvalue->numocts);
1529    if (stat != ASN_OK) return stat;
1530    invokeOpenTypeValue
1531       (pctxt, pvalue->numocts, pvalue->data);
1532
1533    return (stat);
1534 }
1535
1536 /**************************************************************/
1537 /*                                                            */
1538 /*  CryptoToken_cryptoSignedToken_token                       */
1539 /*                                                            */
1540 /**************************************************************/
1541
1542 EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue)
1543 {
1544    int stat = ASN_OK;
1545
1546    /* decode toBeSigned */
1547
1548    invokeStartElement (pctxt, "toBeSigned", -1);
1549
1550    stat = asn1PD_H235EncodedGeneralToken (pctxt, &pvalue->toBeSigned);
1551    if (stat != ASN_OK) return stat;
1552
1553    invokeEndElement (pctxt, "toBeSigned", -1);
1554
1555    /* decode algorithmOID */
1556
1557    invokeStartElement (pctxt, "algorithmOID", -1);
1558
1559    stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
1560    if (stat != ASN_OK) return stat;
1561    invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
1562
1563    invokeEndElement (pctxt, "algorithmOID", -1);
1564
1565    /* decode paramS */
1566
1567    invokeStartElement (pctxt, "paramS", -1);
1568
1569    stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
1570    if (stat != ASN_OK) return stat;
1571
1572    invokeEndElement (pctxt, "paramS", -1);
1573
1574    /* decode signature */
1575
1576    invokeStartElement (pctxt, "signature", -1);
1577
1578    stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
1579    if (stat != ASN_OK) return stat;
1580
1581    invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
1582
1583    invokeEndElement (pctxt, "signature", -1);
1584
1585    return (stat);
1586 }
1587
1588 /**************************************************************/
1589 /*                                                            */
1590 /*  CryptoToken_cryptoSignedToken                             */
1591 /*                                                            */
1592 /**************************************************************/
1593
1594 EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue)
1595 {
1596    int stat = ASN_OK;
1597
1598    /* decode tokenOID */
1599
1600    invokeStartElement (pctxt, "tokenOID", -1);
1601
1602    stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
1603    if (stat != ASN_OK) return stat;
1604    invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
1605
1606    invokeEndElement (pctxt, "tokenOID", -1);
1607
1608    /* decode token */
1609
1610    invokeStartElement (pctxt, "token", -1);
1611
1612    stat = asn1PD_H235CryptoToken_cryptoSignedToken_token (pctxt, &pvalue->token);
1613    if (stat != ASN_OK) return stat;
1614
1615    invokeEndElement (pctxt, "token", -1);
1616
1617    return (stat);
1618 }
1619
1620 /**************************************************************/
1621 /*                                                            */
1622 /*  HASHED                                                    */
1623 /*                                                            */
1624 /**************************************************************/
1625
1626 EXTERN int asn1PD_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue)
1627 {
1628    int stat = ASN_OK;
1629
1630    /* decode algorithmOID */
1631
1632    invokeStartElement (pctxt, "algorithmOID", -1);
1633
1634    stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
1635    if (stat != ASN_OK) return stat;
1636    invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
1637
1638    invokeEndElement (pctxt, "algorithmOID", -1);
1639
1640    /* decode paramS */
1641
1642    invokeStartElement (pctxt, "paramS", -1);
1643
1644    stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
1645    if (stat != ASN_OK) return stat;
1646
1647    invokeEndElement (pctxt, "paramS", -1);
1648
1649    /* decode hash */
1650
1651    invokeStartElement (pctxt, "hash", -1);
1652
1653    stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->hash);
1654    if (stat != ASN_OK) return stat;
1655
1656    invokeBitStrValue (pctxt, pvalue->hash.numbits, pvalue->hash.data);
1657
1658    invokeEndElement (pctxt, "hash", -1);
1659
1660    return (stat);
1661 }
1662
1663 /**************************************************************/
1664 /*                                                            */
1665 /*  CryptoToken_cryptoHashedToken                             */
1666 /*                                                            */
1667 /**************************************************************/
1668
1669 EXTERN int asn1PD_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue)
1670 {
1671    int stat = ASN_OK;
1672
1673    /* decode tokenOID */
1674
1675    invokeStartElement (pctxt, "tokenOID", -1);
1676
1677    stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
1678    if (stat != ASN_OK) return stat;
1679    invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);
1680
1681    invokeEndElement (pctxt, "tokenOID", -1);
1682
1683    /* decode hashedVals */
1684
1685    invokeStartElement (pctxt, "hashedVals", -1);
1686
1687    stat = asn1PD_H235ClearToken (pctxt, &pvalue->hashedVals);
1688    if (stat != ASN_OK) return stat;
1689
1690    invokeEndElement (pctxt, "hashedVals", -1);
1691
1692    /* decode token */
1693
1694    invokeStartElement (pctxt, "token", -1);
1695
1696    stat = asn1PD_H235HASHED (pctxt, &pvalue->token);
1697    if (stat != ASN_OK) return stat;
1698
1699    invokeEndElement (pctxt, "token", -1);
1700
1701    return (stat);
1702 }
1703
1704 /**************************************************************/
1705 /*                                                            */
1706 /*  CryptoToken                                               */
1707 /*                                                            */
1708 /**************************************************************/
1709
1710 EXTERN int asn1PD_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue)
1711 {
1712    int stat = ASN_OK;
1713    ASN1UINT ui;
1714    ASN1OpenType openType;
1715    ASN1BOOL extbit;
1716
1717    extbit = 0;
1718
1719    /* extension bit */
1720
1721    DECODEBIT (pctxt, &extbit);
1722
1723    if (!extbit) {
1724       stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
1725       if (stat != ASN_OK) return stat;
1726       else pvalue->t = ui + 1;
1727
1728       switch (ui) {
1729          /* cryptoEncryptedToken */
1730          case 0:
1731             invokeStartElement (pctxt, "cryptoEncryptedToken", -1);
1732
1733             pvalue->u.cryptoEncryptedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoEncryptedToken);
1734
1735             stat = asn1PD_H235CryptoToken_cryptoEncryptedToken (pctxt, pvalue->u.cryptoEncryptedToken);
1736             if (stat != ASN_OK) return stat;
1737
1738             invokeEndElement (pctxt, "cryptoEncryptedToken", -1);
1739
1740             break;
1741
1742          /* cryptoSignedToken */
1743          case 1:
1744             invokeStartElement (pctxt, "cryptoSignedToken", -1);
1745
1746             pvalue->u.cryptoSignedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoSignedToken);
1747
1748             stat = asn1PD_H235CryptoToken_cryptoSignedToken (pctxt, pvalue->u.cryptoSignedToken);
1749             if (stat != ASN_OK) return stat;
1750
1751             invokeEndElement (pctxt, "cryptoSignedToken", -1);
1752
1753             break;
1754
1755          /* cryptoHashedToken */
1756          case 2:
1757             invokeStartElement (pctxt, "cryptoHashedToken", -1);
1758
1759             pvalue->u.cryptoHashedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoHashedToken);
1760
1761             stat = asn1PD_H235CryptoToken_cryptoHashedToken (pctxt, pvalue->u.cryptoHashedToken);
1762             if (stat != ASN_OK) return stat;
1763
1764             invokeEndElement (pctxt, "cryptoHashedToken", -1);
1765
1766             break;
1767
1768          /* cryptoPwdEncr */
1769          case 3:
1770             invokeStartElement (pctxt, "cryptoPwdEncr", -1);
1771
1772             pvalue->u.cryptoPwdEncr = ALLOC_ASN1ELEM (pctxt, H235ENCRYPTED);
1773
1774             stat = asn1PD_H235ENCRYPTED (pctxt, pvalue->u.cryptoPwdEncr);
1775             if (stat != ASN_OK) return stat;
1776
1777             invokeEndElement (pctxt, "cryptoPwdEncr", -1);
1778
1779             break;
1780
1781          default:
1782             return ASN_E_INVOPT;
1783       }
1784    }
1785    else {
1786       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1787       if (stat != ASN_OK) return stat;
1788       else pvalue->t = ui + 5;
1789
1790       stat = decodeByteAlign (pctxt);
1791       if (stat != ASN_OK) return stat;
1792
1793       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1794       if (stat != ASN_OK) return stat;
1795
1796    }
1797
1798    return (stat);
1799 }
1800