Fix warning of Coverity Static analysis, change H225ProtocolIdentifier
[asterisk/asterisk.git] / addons / ooh323c / src / h323 / H235-SECURITY-MESSAGESEnc.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
23 /**************************************************************/
24 /*                                                            */
25 /*  ChallengeString                                           */
26 /*                                                            */
27 /**************************************************************/
28
29 EXTERN int asn1PE_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue)
30 {
31    static Asn1SizeCnst lsize1 = { 0, 8, 128, 0 };
32    int stat = ASN_OK;
33
34    addSizeConstraint (pctxt, &lsize1);
35
36    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
37    if (stat != ASN_OK) return stat;
38
39    return (stat);
40 }
41
42 /**************************************************************/
43 /*                                                            */
44 /*  TimeStamp                                                 */
45 /*                                                            */
46 /**************************************************************/
47
48 EXTERN int asn1PE_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp value)
49 {
50    int stat = ASN_OK;
51
52    stat = encodeConsUnsigned (pctxt, value, 1U, ASN1UINT_MAX);
53    if (stat != ASN_OK) return stat;
54
55    return (stat);
56 }
57
58 /**************************************************************/
59 /*                                                            */
60 /*  RandomVal                                                 */
61 /*                                                            */
62 /**************************************************************/
63
64 EXTERN int asn1PE_H235RandomVal (OOCTXT* pctxt, H235RandomVal value)
65 {
66    int stat = ASN_OK;
67
68    stat = encodeUnconsInteger (pctxt, value);
69    if (stat != ASN_OK) return stat;
70
71    return (stat);
72 }
73
74 /**************************************************************/
75 /*                                                            */
76 /*  Password                                                  */
77 /*                                                            */
78 /**************************************************************/
79
80 EXTERN int asn1PE_H235Password (OOCTXT* pctxt, H235Password value)
81 {
82    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
83    int stat = ASN_OK;
84
85    addSizeConstraint (pctxt, &lsize1);
86
87    stat = encodeBMPString (pctxt, value, 0);
88    if (stat != ASN_OK) return stat;
89
90    return (stat);
91 }
92
93 /**************************************************************/
94 /*                                                            */
95 /*  EncodedPwdCertToken                                       */
96 /*                                                            */
97 /**************************************************************/
98
99 EXTERN int asn1PE_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken value)
100 {
101    int stat = ASN_OK;
102
103    stat = encodeOpenType (pctxt, value.numocts, value.data);
104    if (stat != ASN_OK) return stat;
105
106    return (stat);
107 }
108
109 /**************************************************************/
110 /*                                                            */
111 /*  NonStandardParameter                                      */
112 /*                                                            */
113 /**************************************************************/
114
115 EXTERN int asn1PE_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue)
116 {
117    int stat = ASN_OK;
118
119    /* encode nonStandardIdentifier */
120
121    stat = encodeObjectIdentifier (pctxt, &pvalue->nonStandardIdentifier);
122    if (stat != ASN_OK) return stat;
123
124    /* encode data */
125
126    stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data);
127    if (stat != ASN_OK) return stat;
128
129    return (stat);
130 }
131
132 /**************************************************************/
133 /*                                                            */
134 /*  AuthenticationBES                                         */
135 /*                                                            */
136 /**************************************************************/
137
138 EXTERN int asn1PE_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue)
139 {
140    int stat = ASN_OK;
141    ASN1BOOL extbit;
142
143    /* extension bit */
144
145    extbit = (ASN1BOOL)(pvalue->t > 2);
146
147    encodeBit (pctxt, extbit);
148
149    if (!extbit) {
150
151       /* Encode choice index value */
152
153       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
154       if (stat != ASN_OK) return stat;
155
156       /* Encode root element data value */
157
158       switch (pvalue->t)
159       {
160          /* default_ */
161          case 1:
162             /* NULL */
163             break;
164
165          /* radius */
166          case 2:
167             /* NULL */
168             break;
169
170          default:
171             return ASN_E_INVOPT;
172       }
173    }
174    else {
175       /* Encode extension choice index value */
176
177       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
178       if (stat != ASN_OK) return stat;
179
180       /* Encode extension element data value */
181
182    }
183
184    return (stat);
185 }
186
187 /**************************************************************/
188 /*                                                            */
189 /*  AuthenticationMechanism                                   */
190 /*                                                            */
191 /**************************************************************/
192
193 EXTERN int asn1PE_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue)
194 {
195    int stat = ASN_OK;
196    OOCTXT lctxt;
197    ASN1OpenType openType;
198    ASN1BOOL extbit;
199
200    /* extension bit */
201
202    extbit = (ASN1BOOL)(pvalue->t > 7);
203
204    encodeBit (pctxt, extbit);
205
206    if (!extbit) {
207
208       /* Encode choice index value */
209
210       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
211       if (stat != ASN_OK) return stat;
212
213       /* Encode root element data value */
214
215       switch (pvalue->t)
216       {
217          /* dhExch */
218          case 1:
219             /* NULL */
220             break;
221
222          /* pwdSymEnc */
223          case 2:
224             /* NULL */
225             break;
226
227          /* pwdHash */
228          case 3:
229             /* NULL */
230             break;
231
232          /* certSign */
233          case 4:
234             /* NULL */
235             break;
236
237          /* ipsec */
238          case 5:
239             /* NULL */
240             break;
241
242          /* tls */
243          case 6:
244             /* NULL */
245             break;
246
247          /* nonStandard */
248          case 7:
249             stat = asn1PE_H235NonStandardParameter (pctxt, pvalue->u.nonStandard);
250             if (stat != ASN_OK) return stat;
251             break;
252
253          default:
254             return ASN_E_INVOPT;
255       }
256    }
257    else {
258       /* Encode extension choice index value */
259
260       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
261       if (stat != ASN_OK) return stat;
262
263       /* Encode extension element data value */
264
265       initContext (&lctxt);
266       stat = setPERBuffer (&lctxt, 0, 0, TRUE);
267       if (stat != ASN_OK) return freeContext (&lctxt), stat;
268
269       switch (pvalue->t)
270       {
271          /* authenticationBES */
272          case 8:
273             stat = asn1PE_H235AuthenticationBES (&lctxt, pvalue->u.authenticationBES);
274             if (stat != ASN_OK) return freeContext (&lctxt), stat;
275             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
276             break;
277
278          default:
279             ;
280       }
281
282       stat = encodeByteAlign (pctxt);
283       if (stat != ASN_OK) return freeContext (&lctxt), stat;
284
285       stat = encodeOpenType (pctxt, openType.numocts, openType.data);
286       if (stat != ASN_OK) return freeContext (&lctxt), stat;
287
288       freeContext (&lctxt);
289    }
290
291    return (stat);
292 }
293
294 /**************************************************************/
295 /*                                                            */
296 /*  DHset_halfkey                                             */
297 /*                                                            */
298 /**************************************************************/
299
300 EXTERN int asn1PE_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue)
301 {
302    static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
303    int stat = ASN_OK;
304
305    addSizeConstraint (pctxt, &lsize1);
306
307    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
308    if (stat != ASN_OK) return stat;
309
310    return (stat);
311 }
312
313 /**************************************************************/
314 /*                                                            */
315 /*  DHset_modSize                                             */
316 /*                                                            */
317 /**************************************************************/
318
319 EXTERN int asn1PE_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue)
320 {
321    static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
322    int stat = ASN_OK;
323
324    addSizeConstraint (pctxt, &lsize1);
325
326    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
327    if (stat != ASN_OK) return stat;
328
329    return (stat);
330 }
331
332 /**************************************************************/
333 /*                                                            */
334 /*  DHset_generator                                           */
335 /*                                                            */
336 /**************************************************************/
337
338 EXTERN int asn1PE_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue)
339 {
340    static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 };
341    int stat = ASN_OK;
342
343    addSizeConstraint (pctxt, &lsize1);
344
345    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
346    if (stat != ASN_OK) return stat;
347
348    return (stat);
349 }
350
351 /**************************************************************/
352 /*                                                            */
353 /*  DHset                                                     */
354 /*                                                            */
355 /**************************************************************/
356
357 EXTERN int asn1PE_H235DHset (OOCTXT* pctxt, H235DHset* pvalue)
358 {
359    int stat = ASN_OK;
360    ASN1BOOL extbit;
361
362    /* extension bit */
363
364    extbit = 0;
365
366    encodeBit (pctxt, extbit);
367
368    /* encode halfkey */
369
370    stat = asn1PE_H235DHset_halfkey (pctxt, &pvalue->halfkey);
371    if (stat != ASN_OK) return stat;
372
373    /* encode modSize */
374
375    stat = asn1PE_H235DHset_modSize (pctxt, &pvalue->modSize);
376    if (stat != ASN_OK) return stat;
377
378    /* encode generator */
379
380    stat = asn1PE_H235DHset_generator (pctxt, &pvalue->generator);
381    if (stat != ASN_OK) return stat;
382
383    return (stat);
384 }
385
386 /**************************************************************/
387 /*                                                            */
388 /*  TypedCertificate                                          */
389 /*                                                            */
390 /**************************************************************/
391
392 EXTERN int asn1PE_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue)
393 {
394    int stat = ASN_OK;
395    ASN1BOOL extbit;
396
397    /* extension bit */
398
399    extbit = 0;
400
401    encodeBit (pctxt, extbit);
402
403    /* encode type */
404
405    stat = encodeObjectIdentifier (pctxt, &pvalue->type);
406    if (stat != ASN_OK) return stat;
407
408    /* encode certificate */
409
410    stat = encodeOctetString (pctxt, pvalue->certificate.numocts, pvalue->certificate.data);
411    if (stat != ASN_OK) return stat;
412
413    return (stat);
414 }
415
416 /**************************************************************/
417 /*                                                            */
418 /*  Identifier                                                */
419 /*                                                            */
420 /**************************************************************/
421
422 EXTERN int asn1PE_H235Identifier (OOCTXT* pctxt, H235Identifier value)
423 {
424    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
425    int stat = ASN_OK;
426
427    addSizeConstraint (pctxt, &lsize1);
428
429    stat = encodeBMPString (pctxt, value, 0);
430    if (stat != ASN_OK) return stat;
431
432    return (stat);
433 }
434
435 /**************************************************************/
436 /*                                                            */
437 /*  ECpoint_x                                                 */
438 /*                                                            */
439 /**************************************************************/
440
441 EXTERN int asn1PE_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue)
442 {
443    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
444    int stat = ASN_OK;
445
446    addSizeConstraint (pctxt, &lsize1);
447
448    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
449    if (stat != ASN_OK) return stat;
450
451    return (stat);
452 }
453
454 /**************************************************************/
455 /*                                                            */
456 /*  ECpoint_y                                                 */
457 /*                                                            */
458 /**************************************************************/
459
460 EXTERN int asn1PE_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue)
461 {
462    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
463    int stat = ASN_OK;
464
465    addSizeConstraint (pctxt, &lsize1);
466
467    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
468    if (stat != ASN_OK) return stat;
469
470    return (stat);
471 }
472
473 /**************************************************************/
474 /*                                                            */
475 /*  ECpoint                                                   */
476 /*                                                            */
477 /**************************************************************/
478
479 EXTERN int asn1PE_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue)
480 {
481    int stat = ASN_OK;
482    ASN1BOOL extbit;
483
484    /* extension bit */
485
486    extbit = 0;
487
488    encodeBit (pctxt, extbit);
489
490    encodeBit (pctxt, (ASN1BOOL)pvalue->m.xPresent);
491
492    encodeBit (pctxt, (ASN1BOOL)pvalue->m.yPresent);
493
494    /* encode x */
495
496    if (pvalue->m.xPresent) {
497       stat = asn1PE_H235ECpoint_x (pctxt, &pvalue->x);
498       if (stat != ASN_OK) return stat;
499    }
500
501    /* encode y */
502
503    if (pvalue->m.yPresent) {
504       stat = asn1PE_H235ECpoint_y (pctxt, &pvalue->y);
505       if (stat != ASN_OK) return stat;
506    }
507
508    return (stat);
509 }
510
511 /**************************************************************/
512 /*                                                            */
513 /*  ECKASDH_eckasdhp_modulus                                  */
514 /*                                                            */
515 /**************************************************************/
516
517 EXTERN int asn1PE_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue)
518 {
519    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
520    int stat = ASN_OK;
521
522    addSizeConstraint (pctxt, &lsize1);
523
524    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
525    if (stat != ASN_OK) return stat;
526
527    return (stat);
528 }
529
530 /**************************************************************/
531 /*                                                            */
532 /*  ECKASDH_eckasdhp_weierstrassA                             */
533 /*                                                            */
534 /**************************************************************/
535
536 EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue)
537 {
538    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
539    int stat = ASN_OK;
540
541    addSizeConstraint (pctxt, &lsize1);
542
543    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
544    if (stat != ASN_OK) return stat;
545
546    return (stat);
547 }
548
549 /**************************************************************/
550 /*                                                            */
551 /*  ECKASDH_eckasdhp_weierstrassB                             */
552 /*                                                            */
553 /**************************************************************/
554
555 EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue)
556 {
557    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
558    int stat = ASN_OK;
559
560    addSizeConstraint (pctxt, &lsize1);
561
562    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
563    if (stat != ASN_OK) return stat;
564
565    return (stat);
566 }
567
568 /**************************************************************/
569 /*                                                            */
570 /*  ECKASDH_eckasdhp                                          */
571 /*                                                            */
572 /**************************************************************/
573
574 EXTERN int asn1PE_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue)
575 {
576    int stat = ASN_OK;
577
578    /* encode public_key */
579
580    stat = asn1PE_H235ECpoint (pctxt, &pvalue->public_key);
581    if (stat != ASN_OK) return stat;
582
583    /* encode modulus */
584
585    stat = asn1PE_H235ECKASDH_eckasdhp_modulus (pctxt, &pvalue->modulus);
586    if (stat != ASN_OK) return stat;
587
588    /* encode base */
589
590    stat = asn1PE_H235ECpoint (pctxt, &pvalue->base);
591    if (stat != ASN_OK) return stat;
592
593    /* encode weierstrassA */
594
595    stat = asn1PE_H235ECKASDH_eckasdhp_weierstrassA (pctxt, &pvalue->weierstrassA);
596    if (stat != ASN_OK) return stat;
597
598    /* encode weierstrassB */
599
600    stat = asn1PE_H235ECKASDH_eckasdhp_weierstrassB (pctxt, &pvalue->weierstrassB);
601    if (stat != ASN_OK) return stat;
602
603    return (stat);
604 }
605
606 /**************************************************************/
607 /*                                                            */
608 /*  ECKASDH_eckasdh2_fieldSize                                */
609 /*                                                            */
610 /**************************************************************/
611
612 EXTERN int asn1PE_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue)
613 {
614    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
615    int stat = ASN_OK;
616
617    addSizeConstraint (pctxt, &lsize1);
618
619    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
620    if (stat != ASN_OK) return stat;
621
622    return (stat);
623 }
624
625 /**************************************************************/
626 /*                                                            */
627 /*  ECKASDH_eckasdh2_weierstrassA                             */
628 /*                                                            */
629 /**************************************************************/
630
631 EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue)
632 {
633    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
634    int stat = ASN_OK;
635
636    addSizeConstraint (pctxt, &lsize1);
637
638    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
639    if (stat != ASN_OK) return stat;
640
641    return (stat);
642 }
643
644 /**************************************************************/
645 /*                                                            */
646 /*  ECKASDH_eckasdh2_weierstrassB                             */
647 /*                                                            */
648 /**************************************************************/
649
650 EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue)
651 {
652    static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
653    int stat = ASN_OK;
654
655    addSizeConstraint (pctxt, &lsize1);
656
657    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
658    if (stat != ASN_OK) return stat;
659
660    return (stat);
661 }
662
663 /**************************************************************/
664 /*                                                            */
665 /*  ECKASDH_eckasdh2                                          */
666 /*                                                            */
667 /**************************************************************/
668
669 EXTERN int asn1PE_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue)
670 {
671    int stat = ASN_OK;
672
673    /* encode public_key */
674
675    stat = asn1PE_H235ECpoint (pctxt, &pvalue->public_key);
676    if (stat != ASN_OK) return stat;
677
678    /* encode fieldSize */
679
680    stat = asn1PE_H235ECKASDH_eckasdh2_fieldSize (pctxt, &pvalue->fieldSize);
681    if (stat != ASN_OK) return stat;
682
683    /* encode base */
684
685    stat = asn1PE_H235ECpoint (pctxt, &pvalue->base);
686    if (stat != ASN_OK) return stat;
687
688    /* encode weierstrassA */
689
690    stat = asn1PE_H235ECKASDH_eckasdh2_weierstrassA (pctxt, &pvalue->weierstrassA);
691    if (stat != ASN_OK) return stat;
692
693    /* encode weierstrassB */
694
695    stat = asn1PE_H235ECKASDH_eckasdh2_weierstrassB (pctxt, &pvalue->weierstrassB);
696    if (stat != ASN_OK) return stat;
697
698    return (stat);
699 }
700
701 /**************************************************************/
702 /*                                                            */
703 /*  ECKASDH                                                   */
704 /*                                                            */
705 /**************************************************************/
706
707 EXTERN int asn1PE_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue)
708 {
709    int stat = ASN_OK;
710    ASN1BOOL extbit;
711
712    /* extension bit */
713
714    extbit = (ASN1BOOL)(pvalue->t > 2);
715
716    encodeBit (pctxt, extbit);
717
718    if (!extbit) {
719
720       /* Encode choice index value */
721
722       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
723       if (stat != ASN_OK) return stat;
724
725       /* Encode root element data value */
726
727       switch (pvalue->t)
728       {
729          /* eckasdhp */
730          case 1:
731             stat = asn1PE_H235ECKASDH_eckasdhp (pctxt, pvalue->u.eckasdhp);
732             if (stat != ASN_OK) return stat;
733             break;
734
735          /* eckasdh2 */
736          case 2:
737             stat = asn1PE_H235ECKASDH_eckasdh2 (pctxt, pvalue->u.eckasdh2);
738             if (stat != ASN_OK) return stat;
739             break;
740
741          default:
742             return ASN_E_INVOPT;
743       }
744    }
745    else {
746       /* Encode extension choice index value */
747
748       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
749       if (stat != ASN_OK) return stat;
750
751       /* Encode extension element data value */
752
753    }
754
755    return (stat);
756 }
757
758 /**************************************************************/
759 /*                                                            */
760 /*  ClearToken                                                */
761 /*                                                            */
762 /**************************************************************/
763
764 EXTERN int asn1PE_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue)
765 {
766    int stat = ASN_OK;
767    ASN1BOOL extbit;
768    ASN1OpenType openType;
769    OOCTXT lctxt;
770
771    /* extension bit */
772
773    extbit = (ASN1BOOL)(pvalue->m.eckasdhkeyPresent ||
774    pvalue->m.sendersIDPresent);
775
776    encodeBit (pctxt, extbit);
777
778    encodeBit (pctxt, (ASN1BOOL)pvalue->m.timeStampPresent);
779
780    encodeBit (pctxt, (ASN1BOOL)pvalue->m.passwordPresent);
781
782    encodeBit (pctxt, (ASN1BOOL)pvalue->m.dhkeyPresent);
783
784    encodeBit (pctxt, (ASN1BOOL)pvalue->m.challengePresent);
785
786    encodeBit (pctxt, (ASN1BOOL)pvalue->m.randomPresent);
787
788    encodeBit (pctxt, (ASN1BOOL)pvalue->m.certificatePresent);
789
790    encodeBit (pctxt, (ASN1BOOL)pvalue->m.generalIDPresent);
791
792    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent);
793
794    /* encode tokenOID */
795
796    stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
797    if (stat != ASN_OK) return stat;
798
799    /* encode timeStamp */
800
801    if (pvalue->m.timeStampPresent) {
802       stat = asn1PE_H235TimeStamp (pctxt, pvalue->timeStamp);
803       if (stat != ASN_OK) return stat;
804    }
805
806    /* encode password */
807
808    if (pvalue->m.passwordPresent) {
809       stat = asn1PE_H235Password (pctxt, pvalue->password);
810       if (stat != ASN_OK) return stat;
811    }
812
813    /* encode dhkey */
814
815    if (pvalue->m.dhkeyPresent) {
816       stat = asn1PE_H235DHset (pctxt, &pvalue->dhkey);
817       if (stat != ASN_OK) return stat;
818    }
819
820    /* encode challenge */
821
822    if (pvalue->m.challengePresent) {
823       stat = asn1PE_H235ChallengeString (pctxt, &pvalue->challenge);
824       if (stat != ASN_OK) return stat;
825    }
826
827    /* encode random */
828
829    if (pvalue->m.randomPresent) {
830       stat = asn1PE_H235RandomVal (pctxt, pvalue->random);
831       if (stat != ASN_OK) return stat;
832    }
833
834    /* encode certificate */
835
836    if (pvalue->m.certificatePresent) {
837       stat = asn1PE_H235TypedCertificate (pctxt, &pvalue->certificate);
838       if (stat != ASN_OK) return stat;
839    }
840
841    /* encode generalID */
842
843    if (pvalue->m.generalIDPresent) {
844       stat = asn1PE_H235Identifier (pctxt, pvalue->generalID);
845       if (stat != ASN_OK) return stat;
846    }
847
848    /* encode nonStandard */
849
850    if (pvalue->m.nonStandardPresent) {
851       stat = asn1PE_H235NonStandardParameter (pctxt, &pvalue->nonStandard);
852       if (stat != ASN_OK) return stat;
853    }
854
855    if (extbit) {
856
857       /* encode extension optional bits length */
858
859       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
860       if (stat != ASN_OK) return stat;
861
862       /* encode optional bits */
863
864       encodeBit (pctxt, (ASN1BOOL)pvalue->m.eckasdhkeyPresent);
865       encodeBit (pctxt, (ASN1BOOL)pvalue->m.sendersIDPresent);
866       /* encode extension elements */
867
868       if (pvalue->m.eckasdhkeyPresent) {
869          initContext (&lctxt);
870          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
871          if (stat != ASN_OK) return freeContext (&lctxt), stat;
872
873          stat = asn1PE_H235ECKASDH (&lctxt, &pvalue->eckasdhkey);
874          if (stat != ASN_OK) return freeContext (&lctxt), stat;
875
876          stat = encodeByteAlign (&lctxt);
877          if (stat != ASN_OK) return freeContext (&lctxt), stat;
878
879          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
880
881          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
882          if (stat != ASN_OK) return freeContext (&lctxt), stat;
883
884          freeContext (&lctxt);
885       }
886
887       if (pvalue->m.sendersIDPresent) {
888          initContext (&lctxt);
889          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
890          if (stat != ASN_OK) return freeContext (&lctxt), stat;
891
892          stat = asn1PE_H235Identifier (&lctxt, pvalue->sendersID);
893          if (stat != ASN_OK) return freeContext (&lctxt), stat;
894
895          stat = encodeByteAlign (&lctxt);
896          if (stat != ASN_OK) return freeContext (&lctxt), stat;
897
898          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
899
900          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
901          if (stat != ASN_OK) return freeContext (&lctxt), stat;
902
903          freeContext (&lctxt);
904       }
905
906    }
907
908    return (stat);
909 }
910
911 /**************************************************************/
912 /*                                                            */
913 /*  IV8                                                       */
914 /*                                                            */
915 /**************************************************************/
916
917 EXTERN int asn1PE_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue)
918 {
919    static Asn1SizeCnst lsize1 = { 0, 8, 8, 0 };
920    int stat = ASN_OK;
921
922    addSizeConstraint (pctxt, &lsize1);
923
924    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
925    if (stat != ASN_OK) return stat;
926
927    return (stat);
928 }
929
930 /**************************************************************/
931 /*                                                            */
932 /*  IV16                                                      */
933 /*                                                            */
934 /**************************************************************/
935
936 EXTERN int asn1PE_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue)
937 {
938    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
939    int stat = ASN_OK;
940
941    addSizeConstraint (pctxt, &lsize1);
942
943    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
944    if (stat != ASN_OK) return stat;
945
946    return (stat);
947 }
948
949 /**************************************************************/
950 /*                                                            */
951 /*  Params                                                    */
952 /*                                                            */
953 /**************************************************************/
954
955 EXTERN int asn1PE_H235Params (OOCTXT* pctxt, H235Params* pvalue)
956 {
957    int stat = ASN_OK;
958    ASN1BOOL extbit;
959    ASN1OpenType openType;
960    OOCTXT lctxt;
961
962    /* extension bit */
963
964    extbit = (ASN1BOOL)(pvalue->m.iv16Present);
965
966    encodeBit (pctxt, extbit);
967
968    encodeBit (pctxt, (ASN1BOOL)pvalue->m.ranIntPresent);
969
970    encodeBit (pctxt, (ASN1BOOL)pvalue->m.iv8Present);
971
972    /* encode ranInt */
973
974    if (pvalue->m.ranIntPresent) {
975       stat = encodeUnconsInteger (pctxt, pvalue->ranInt);
976       if (stat != ASN_OK) return stat;
977    }
978
979    /* encode iv8 */
980
981    if (pvalue->m.iv8Present) {
982       stat = asn1PE_H235IV8 (pctxt, &pvalue->iv8);
983       if (stat != ASN_OK) return stat;
984    }
985
986    if (extbit) {
987
988       /* encode extension optional bits length */
989
990       stat = encodeSmallNonNegWholeNumber (pctxt, 0);
991       if (stat != ASN_OK) return stat;
992
993       /* encode optional bits */
994
995       encodeBit (pctxt, (ASN1BOOL)pvalue->m.iv16Present);
996       /* encode extension elements */
997
998       if (pvalue->m.iv16Present) {
999          initContext (&lctxt);
1000          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
1001          if (stat != ASN_OK) return freeContext (&lctxt), stat;
1002
1003          stat = asn1PE_H235IV16 (&lctxt, &pvalue->iv16);
1004          if (stat != ASN_OK) return freeContext (&lctxt), stat;
1005
1006          stat = encodeByteAlign (&lctxt);
1007          if (stat != ASN_OK) return freeContext (&lctxt), stat;
1008
1009          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
1010
1011          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
1012          if (stat != ASN_OK) return freeContext (&lctxt), stat;
1013
1014          freeContext (&lctxt);
1015       }
1016
1017    }
1018
1019    return (stat);
1020 }
1021
1022 /**************************************************************/
1023 /*                                                            */
1024 /*  ENCRYPTED                                                 */
1025 /*                                                            */
1026 /**************************************************************/
1027
1028 EXTERN int asn1PE_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue)
1029 {
1030    int stat = ASN_OK;
1031
1032    /* encode algorithmOID */
1033
1034    stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
1035    if (stat != ASN_OK) return stat;
1036
1037    /* encode paramS */
1038
1039    stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
1040    if (stat != ASN_OK) return stat;
1041
1042    /* encode encryptedData */
1043
1044    stat = encodeOctetString (pctxt, pvalue->encryptedData.numocts, pvalue->encryptedData.data);
1045    if (stat != ASN_OK) return stat;
1046
1047    return (stat);
1048 }
1049
1050 /**************************************************************/
1051 /*                                                            */
1052 /*  CryptoToken_cryptoEncryptedToken                          */
1053 /*                                                            */
1054 /**************************************************************/
1055
1056 EXTERN int asn1PE_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue)
1057 {
1058    int stat = ASN_OK;
1059
1060    /* encode tokenOID */
1061
1062    stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
1063    if (stat != ASN_OK) return stat;
1064
1065    /* encode token */
1066
1067    stat = asn1PE_H235ENCRYPTED (pctxt, &pvalue->token);
1068    if (stat != ASN_OK) return stat;
1069
1070    return (stat);
1071 }
1072
1073 /**************************************************************/
1074 /*                                                            */
1075 /*  EncodedGeneralToken                                       */
1076 /*                                                            */
1077 /**************************************************************/
1078
1079 EXTERN int asn1PE_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken value)
1080 {
1081    int stat = ASN_OK;
1082
1083    stat = encodeOpenType (pctxt, value.numocts, value.data);
1084    if (stat != ASN_OK) return stat;
1085
1086    return (stat);
1087 }
1088
1089 /**************************************************************/
1090 /*                                                            */
1091 /*  CryptoToken_cryptoSignedToken_token                       */
1092 /*                                                            */
1093 /**************************************************************/
1094
1095 EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue)
1096 {
1097    int stat = ASN_OK;
1098
1099    /* encode toBeSigned */
1100
1101    stat = asn1PE_H235EncodedGeneralToken (pctxt, pvalue->toBeSigned);
1102    if (stat != ASN_OK) return stat;
1103
1104    /* encode algorithmOID */
1105
1106    stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
1107    if (stat != ASN_OK) return stat;
1108
1109    /* encode paramS */
1110
1111    stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
1112    if (stat != ASN_OK) return stat;
1113
1114    /* encode signature */
1115
1116    stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data);
1117    if (stat != ASN_OK) return stat;
1118
1119    return (stat);
1120 }
1121
1122 /**************************************************************/
1123 /*                                                            */
1124 /*  CryptoToken_cryptoSignedToken                             */
1125 /*                                                            */
1126 /**************************************************************/
1127
1128 EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue)
1129 {
1130    int stat = ASN_OK;
1131
1132    /* encode tokenOID */
1133
1134    stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
1135    if (stat != ASN_OK) return stat;
1136
1137    /* encode token */
1138
1139    stat = asn1PE_H235CryptoToken_cryptoSignedToken_token (pctxt, &pvalue->token);
1140    if (stat != ASN_OK) return stat;
1141
1142    return (stat);
1143 }
1144
1145 /**************************************************************/
1146 /*                                                            */
1147 /*  HASHED                                                    */
1148 /*                                                            */
1149 /**************************************************************/
1150
1151 EXTERN int asn1PE_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue)
1152 {
1153    int stat = ASN_OK;
1154
1155    /* encode algorithmOID */
1156
1157    stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
1158    if (stat != ASN_OK) return stat;
1159
1160    /* encode paramS */
1161
1162    stat = asn1PE_H235Params (pctxt, &pvalue->paramS);
1163    if (stat != ASN_OK) return stat;
1164
1165    /* encode hash */
1166
1167    stat = encodeBitString (pctxt, pvalue->hash.numbits, pvalue->hash.data);
1168    if (stat != ASN_OK) return stat;
1169
1170    return (stat);
1171 }
1172
1173 /**************************************************************/
1174 /*                                                            */
1175 /*  CryptoToken_cryptoHashedToken                             */
1176 /*                                                            */
1177 /**************************************************************/
1178
1179 EXTERN int asn1PE_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue)
1180 {
1181    int stat = ASN_OK;
1182
1183    /* encode tokenOID */
1184
1185    stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID);
1186    if (stat != ASN_OK) return stat;
1187
1188    /* encode hashedVals */
1189
1190    stat = asn1PE_H235ClearToken (pctxt, &pvalue->hashedVals);
1191    if (stat != ASN_OK) return stat;
1192
1193    /* encode token */
1194
1195    stat = asn1PE_H235HASHED (pctxt, &pvalue->token);
1196    if (stat != ASN_OK) return stat;
1197
1198    return (stat);
1199 }
1200
1201 /**************************************************************/
1202 /*                                                            */
1203 /*  CryptoToken                                               */
1204 /*                                                            */
1205 /**************************************************************/
1206
1207 EXTERN int asn1PE_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue)
1208 {
1209    int stat = ASN_OK;
1210    ASN1BOOL extbit;
1211
1212    /* extension bit */
1213
1214    extbit = (ASN1BOOL)(pvalue->t > 4);
1215
1216    encodeBit (pctxt, extbit);
1217
1218    if (!extbit) {
1219
1220       /* Encode choice index value */
1221
1222       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3);
1223       if (stat != ASN_OK) return stat;
1224
1225       /* Encode root element data value */
1226
1227       switch (pvalue->t)
1228       {
1229          /* cryptoEncryptedToken */
1230          case 1:
1231             stat = asn1PE_H235CryptoToken_cryptoEncryptedToken (pctxt, pvalue->u.cryptoEncryptedToken);
1232             if (stat != ASN_OK) return stat;
1233             break;
1234
1235          /* cryptoSignedToken */
1236          case 2:
1237             stat = asn1PE_H235CryptoToken_cryptoSignedToken (pctxt, pvalue->u.cryptoSignedToken);
1238             if (stat != ASN_OK) return stat;
1239             break;
1240
1241          /* cryptoHashedToken */
1242          case 3:
1243             stat = asn1PE_H235CryptoToken_cryptoHashedToken (pctxt, pvalue->u.cryptoHashedToken);
1244             if (stat != ASN_OK) return stat;
1245             break;
1246
1247          /* cryptoPwdEncr */
1248          case 4:
1249             stat = asn1PE_H235ENCRYPTED (pctxt, pvalue->u.cryptoPwdEncr);
1250             if (stat != ASN_OK) return stat;
1251             break;
1252
1253          default:
1254             return ASN_E_INVOPT;
1255       }
1256    }
1257    else {
1258       /* Encode extension choice index value */
1259
1260       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5);
1261       if (stat != ASN_OK) return stat;
1262
1263       /* Encode extension element data value */
1264
1265    }
1266
1267    return (stat);
1268 }
1269