62a2cd006871e98277307aa5e8eef8b55c02e7aa
[asterisk/asterisk.git] / addons / ooh323c / src / h323 / H323-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 "H323-MESSAGES.h"
22
23 /**************************************************************/
24 /*                                                            */
25 /*  ScreeningIndicator                                        */
26 /*                                                            */
27 /**************************************************************/
28
29 EXTERN int asn1PE_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator value)
30 {
31    int stat = ASN_OK;
32    ASN1UINT ui;
33    ASN1BOOL extbit;
34
35    extbit = 0;
36
37    switch (value) {
38       case userProvidedNotScreened: ui = 0; break;
39       case userProvidedVerifiedAndPassed: ui = 1; break;
40       case userProvidedVerifiedAndFailed: ui = 2; break;
41       case networkProvided: ui = 3; break;
42       default: ui = value; extbit = 1;
43    }
44
45    /* extension bit */
46
47    encodeBit (pctxt, extbit);
48
49    if (extbit) {
50       stat = encodeSmallNonNegWholeNumber (pctxt, ui);
51    }
52    else {
53       stat = encodeConsUnsigned (pctxt, ui, 0, 3);
54       if (stat != ASN_OK) return stat;
55    }
56
57    return (stat);
58 }
59
60 /**************************************************************/
61 /*                                                            */
62 /*  NumberDigits                                              */
63 /*                                                            */
64 /**************************************************************/
65
66 extern EXTERN const char* gs_H323_MESSAGES_NumberDigits_CharSet;
67
68 EXTERN int asn1PE_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits value)
69 {
70    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
71    int stat = ASN_OK;
72
73    addSizeConstraint (pctxt, &lsize1);
74
75    stat = encodeConstrainedStringEx (pctxt, value, gs_H323_MESSAGES_NumberDigits_CharSet, 4, 4, 7);
76    if (stat != ASN_OK) return stat;
77
78    return (stat);
79 }
80
81 /**************************************************************/
82 /*                                                            */
83 /*  TBCD_STRING                                               */
84 /*                                                            */
85 /**************************************************************/
86
87 extern EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet;
88
89 EXTERN int asn1PE_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING value)
90 {
91    int stat = ASN_OK;
92
93    stat = encodeConstrainedStringEx (pctxt, value, gs_H323_MESSAGES_TBCD_STRING_CharSet, 4, 4, 7);
94    if (stat != ASN_OK) return stat;
95
96    return (stat);
97 }
98
99 /**************************************************************/
100 /*                                                            */
101 /*  GloballyUniqueID                                          */
102 /*                                                            */
103 /**************************************************************/
104
105 EXTERN int asn1PE_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue)
106 {
107    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
108    int stat = ASN_OK;
109
110    addSizeConstraint (pctxt, &lsize1);
111
112    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
113    if (stat != ASN_OK) return stat;
114
115    return (stat);
116 }
117
118 /**************************************************************/
119 /*                                                            */
120 /*  ConferenceIdentifier                                      */
121 /*                                                            */
122 /**************************************************************/
123
124 EXTERN int asn1PE_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue)
125 {
126    int stat = ASN_OK;
127
128    stat = asn1PE_H225GloballyUniqueID (pctxt, pvalue);
129    if (stat != ASN_OK) return stat;
130
131    return (stat);
132 }
133
134 /**************************************************************/
135 /*                                                            */
136 /*  RequestSeqNum                                             */
137 /*                                                            */
138 /**************************************************************/
139
140 EXTERN int asn1PE_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum value)
141 {
142    int stat = ASN_OK;
143
144    stat = encodeConsUnsigned (pctxt, value, 1U, 65535U);
145    if (stat != ASN_OK) return stat;
146
147    return (stat);
148 }
149
150 /**************************************************************/
151 /*                                                            */
152 /*  GatekeeperIdentifier                                      */
153 /*                                                            */
154 /**************************************************************/
155
156 EXTERN int asn1PE_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier value)
157 {
158    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
159    int stat = ASN_OK;
160
161    addSizeConstraint (pctxt, &lsize1);
162
163    stat = encodeBMPString (pctxt, value, 0);
164    if (stat != ASN_OK) return stat;
165
166    return (stat);
167 }
168
169 /**************************************************************/
170 /*                                                            */
171 /*  BandWidth                                                 */
172 /*                                                            */
173 /**************************************************************/
174
175 EXTERN int asn1PE_H225BandWidth (OOCTXT* pctxt, H225BandWidth value)
176 {
177    int stat = ASN_OK;
178
179    stat = encodeConsUnsigned (pctxt, value, 0U, ASN1UINT_MAX);
180    if (stat != ASN_OK) return stat;
181
182    return (stat);
183 }
184
185 /**************************************************************/
186 /*                                                            */
187 /*  CallReferenceValue                                        */
188 /*                                                            */
189 /**************************************************************/
190
191 EXTERN int asn1PE_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue value)
192 {
193    int stat = ASN_OK;
194
195    stat = encodeConsUnsigned (pctxt, value, 0U, 65535U);
196    if (stat != ASN_OK) return stat;
197
198    return (stat);
199 }
200
201 /**************************************************************/
202 /*                                                            */
203 /*  EndpointIdentifier                                        */
204 /*                                                            */
205 /**************************************************************/
206
207 EXTERN int asn1PE_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier value)
208 {
209    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
210    int stat = ASN_OK;
211
212    addSizeConstraint (pctxt, &lsize1);
213
214    stat = encodeBMPString (pctxt, value, 0);
215    if (stat != ASN_OK) return stat;
216
217    return (stat);
218 }
219
220 /**************************************************************/
221 /*                                                            */
222 /*  ProtocolIdentifier                                        */
223 /*                                                            */
224 /**************************************************************/
225
226 EXTERN int asn1PE_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier value)
227 {
228    int stat = ASN_OK;
229
230    stat = encodeObjectIdentifier (pctxt, &value);
231    if (stat != ASN_OK) return stat;
232
233    return (stat);
234 }
235
236 /**************************************************************/
237 /*                                                            */
238 /*  TimeToLive                                                */
239 /*                                                            */
240 /**************************************************************/
241
242 EXTERN int asn1PE_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive value)
243 {
244    int stat = ASN_OK;
245
246    stat = encodeConsUnsigned (pctxt, value, 1U, ASN1UINT_MAX);
247    if (stat != ASN_OK) return stat;
248
249    return (stat);
250 }
251
252 /**************************************************************/
253 /*                                                            */
254 /*  H248PackagesDescriptor                                    */
255 /*                                                            */
256 /**************************************************************/
257
258 EXTERN int asn1PE_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor value)
259 {
260    int stat = ASN_OK;
261
262    stat = encodeOctetString (pctxt, value.numocts, value.data);
263    if (stat != ASN_OK) return stat;
264
265    return (stat);
266 }
267
268 /**************************************************************/
269 /*                                                            */
270 /*  H248SignalsDescriptor                                     */
271 /*                                                            */
272 /**************************************************************/
273
274 EXTERN int asn1PE_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor value)
275 {
276    int stat = ASN_OK;
277
278    stat = encodeOctetString (pctxt, value.numocts, value.data);
279    if (stat != ASN_OK) return stat;
280
281    return (stat);
282 }
283
284 /**************************************************************/
285 /*                                                            */
286 /*  GenericIdentifier                                         */
287 /*                                                            */
288 /**************************************************************/
289
290 EXTERN int asn1PE_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue)
291 {
292    int stat = ASN_OK;
293    ASN1BOOL extbit;
294
295    /* extension bit */
296
297    extbit = (ASN1BOOL)(pvalue->t > 3);
298
299    encodeBit (pctxt, extbit);
300
301    if (!extbit) {
302
303       /* Encode choice index value */
304
305       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2);
306       if (stat != ASN_OK) return stat;
307
308       /* Encode root element data value */
309
310       switch (pvalue->t)
311       {
312          /* standard */
313          case 1:
314             if ( (pvalue->u.standard >= 0 && pvalue->u.standard <= 16383) ) {
315                extbit = 0;
316             }
317             else extbit = 1;
318
319             /* extension bit */
320
321             encodeBit (pctxt, extbit);
322
323             if (extbit) {
324                stat = encodeUnconsInteger (pctxt, pvalue->u.standard);
325                if (stat != ASN_OK) return stat;
326             }
327             else {
328                stat = encodeConsInteger (pctxt, pvalue->u.standard, 0, 16383);
329                if (stat != ASN_OK) return stat;
330             }
331             break;
332
333          /* oid */
334          case 2:
335             stat = encodeObjectIdentifier (pctxt, pvalue->u.oid);
336             if (stat != ASN_OK) return stat;
337             break;
338
339          /* nonStandard */
340          case 3:
341             stat = asn1PE_H225GloballyUniqueID (pctxt, pvalue->u.nonStandard);
342             if (stat != ASN_OK) return stat;
343             break;
344
345          default:
346             return ASN_E_INVOPT;
347       }
348    }
349    else {
350       /* Encode extension choice index value */
351
352       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4);
353       if (stat != ASN_OK) return stat;
354
355       /* Encode extension element data value */
356
357    }
358
359    return (stat);
360 }
361
362 /**************************************************************/
363 /*                                                            */
364 /*  TransportAddress_ipAddress_ip                             */
365 /*                                                            */
366 /**************************************************************/
367
368 EXTERN int asn1PE_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue)
369 {
370    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
371    int stat = ASN_OK;
372
373    addSizeConstraint (pctxt, &lsize1);
374
375    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
376    if (stat != ASN_OK) return stat;
377
378    return (stat);
379 }
380
381 /**************************************************************/
382 /*                                                            */
383 /*  TransportAddress_ipAddress                                */
384 /*                                                            */
385 /**************************************************************/
386
387 EXTERN int asn1PE_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue)
388 {
389    int stat = ASN_OK;
390
391    /* encode ip */
392
393    stat = asn1PE_H225TransportAddress_ipAddress_ip (pctxt, &pvalue->ip);
394    if (stat != ASN_OK) return stat;
395
396    /* encode port */
397
398    stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U);
399    if (stat != ASN_OK) return stat;
400
401    return (stat);
402 }
403
404 /**************************************************************/
405 /*                                                            */
406 /*  TransportAddress_ipSourceRoute_ip                         */
407 /*                                                            */
408 /**************************************************************/
409
410 EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue)
411 {
412    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
413    int stat = ASN_OK;
414
415    addSizeConstraint (pctxt, &lsize1);
416
417    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
418    if (stat != ASN_OK) return stat;
419
420    return (stat);
421 }
422
423 /**************************************************************/
424 /*                                                            */
425 /*  TransportAddress_ipSourceRoute_route_element              */
426 /*                                                            */
427 /**************************************************************/
428
429 EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue)
430 {
431    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
432    int stat = ASN_OK;
433
434    addSizeConstraint (pctxt, &lsize1);
435
436    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
437    if (stat != ASN_OK) return stat;
438
439    return (stat);
440 }
441
442 /**************************************************************/
443 /*                                                            */
444 /*  _SeqOfH225TransportAddress_ipSourceRoute_route_element    */
445 /*                                                            */
446 /**************************************************************/
447
448 EXTERN int asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue)
449 {
450    int stat = ASN_OK;
451    ASN1UINT xx1;
452
453    /* encode length determinant */
454
455    stat = encodeLength (pctxt, pvalue->n);
456    if (stat < 0) return stat;
457
458    /* encode elements */
459
460    for (xx1 = 0; xx1 < pvalue->n; xx1++) {
461       stat = asn1PE_H225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->elem[xx1]);
462       if (stat != ASN_OK) return stat;
463    }
464
465    return (stat);
466 }
467
468 /**************************************************************/
469 /*                                                            */
470 /*  TransportAddress_ipSourceRoute_routing                    */
471 /*                                                            */
472 /**************************************************************/
473
474 EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue)
475 {
476    int stat = ASN_OK;
477    ASN1BOOL extbit;
478
479    /* extension bit */
480
481    extbit = (ASN1BOOL)(pvalue->t > 2);
482
483    encodeBit (pctxt, extbit);
484
485    if (!extbit) {
486
487       /* Encode choice index value */
488
489       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
490       if (stat != ASN_OK) return stat;
491
492       /* Encode root element data value */
493
494       switch (pvalue->t)
495       {
496          /* strict */
497          case 1:
498             /* NULL */
499             break;
500
501          /* loose */
502          case 2:
503             /* NULL */
504             break;
505
506          default:
507             return ASN_E_INVOPT;
508       }
509    }
510    else {
511       /* Encode extension choice index value */
512
513       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
514       if (stat != ASN_OK) return stat;
515
516       /* Encode extension element data value */
517
518    }
519
520    return (stat);
521 }
522
523 /**************************************************************/
524 /*                                                            */
525 /*  TransportAddress_ipSourceRoute                            */
526 /*                                                            */
527 /**************************************************************/
528
529 EXTERN int asn1PE_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue)
530 {
531    int stat = ASN_OK;
532    ASN1BOOL extbit;
533
534    /* extension bit */
535
536    extbit = 0;
537
538    encodeBit (pctxt, extbit);
539
540    /* encode ip */
541
542    stat = asn1PE_H225TransportAddress_ipSourceRoute_ip (pctxt, &pvalue->ip);
543    if (stat != ASN_OK) return stat;
544
545    /* encode port */
546
547    stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U);
548    if (stat != ASN_OK) return stat;
549
550    /* encode route */
551
552    stat = asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->route);
553    if (stat != ASN_OK) return stat;
554
555    /* encode routing */
556
557    stat = asn1PE_H225TransportAddress_ipSourceRoute_routing (pctxt, &pvalue->routing);
558    if (stat != ASN_OK) return stat;
559
560    return (stat);
561 }
562
563 /**************************************************************/
564 /*                                                            */
565 /*  TransportAddress_ipxAddress_node                          */
566 /*                                                            */
567 /**************************************************************/
568
569 EXTERN int asn1PE_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue)
570 {
571    static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 };
572    int stat = ASN_OK;
573
574    addSizeConstraint (pctxt, &lsize1);
575
576    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
577    if (stat != ASN_OK) return stat;
578
579    return (stat);
580 }
581
582 /**************************************************************/
583 /*                                                            */
584 /*  TransportAddress_ipxAddress_netnum                        */
585 /*                                                            */
586 /**************************************************************/
587
588 EXTERN int asn1PE_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue)
589 {
590    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
591    int stat = ASN_OK;
592
593    addSizeConstraint (pctxt, &lsize1);
594
595    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
596    if (stat != ASN_OK) return stat;
597
598    return (stat);
599 }
600
601 /**************************************************************/
602 /*                                                            */
603 /*  TransportAddress_ipxAddress_port                          */
604 /*                                                            */
605 /**************************************************************/
606
607 EXTERN int asn1PE_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue)
608 {
609    static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 };
610    int stat = ASN_OK;
611
612    addSizeConstraint (pctxt, &lsize1);
613
614    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
615    if (stat != ASN_OK) return stat;
616
617    return (stat);
618 }
619
620 /**************************************************************/
621 /*                                                            */
622 /*  TransportAddress_ipxAddress                               */
623 /*                                                            */
624 /**************************************************************/
625
626 EXTERN int asn1PE_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue)
627 {
628    int stat = ASN_OK;
629
630    /* encode node */
631
632    stat = asn1PE_H225TransportAddress_ipxAddress_node (pctxt, &pvalue->node);
633    if (stat != ASN_OK) return stat;
634
635    /* encode netnum */
636
637    stat = asn1PE_H225TransportAddress_ipxAddress_netnum (pctxt, &pvalue->netnum);
638    if (stat != ASN_OK) return stat;
639
640    /* encode port */
641
642    stat = asn1PE_H225TransportAddress_ipxAddress_port (pctxt, &pvalue->port);
643    if (stat != ASN_OK) return stat;
644
645    return (stat);
646 }
647
648 /**************************************************************/
649 /*                                                            */
650 /*  TransportAddress_ip6Address_ip                            */
651 /*                                                            */
652 /**************************************************************/
653
654 EXTERN int asn1PE_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue)
655 {
656    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
657    int stat = ASN_OK;
658
659    addSizeConstraint (pctxt, &lsize1);
660
661    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
662    if (stat != ASN_OK) return stat;
663
664    return (stat);
665 }
666
667 /**************************************************************/
668 /*                                                            */
669 /*  TransportAddress_ip6Address                               */
670 /*                                                            */
671 /**************************************************************/
672
673 EXTERN int asn1PE_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue)
674 {
675    int stat = ASN_OK;
676    ASN1BOOL extbit;
677
678    /* extension bit */
679
680    extbit = 0;
681
682    encodeBit (pctxt, extbit);
683
684    /* encode ip */
685
686    stat = asn1PE_H225TransportAddress_ip6Address_ip (pctxt, &pvalue->ip);
687    if (stat != ASN_OK) return stat;
688
689    /* encode port */
690
691    stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U);
692    if (stat != ASN_OK) return stat;
693
694    return (stat);
695 }
696
697 /**************************************************************/
698 /*                                                            */
699 /*  TransportAddress_netBios                                  */
700 /*                                                            */
701 /**************************************************************/
702
703 EXTERN int asn1PE_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue)
704 {
705    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
706    int stat = ASN_OK;
707
708    addSizeConstraint (pctxt, &lsize1);
709
710    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
711    if (stat != ASN_OK) return stat;
712
713    return (stat);
714 }
715
716 /**************************************************************/
717 /*                                                            */
718 /*  TransportAddress_nsap                                     */
719 /*                                                            */
720 /**************************************************************/
721
722 EXTERN int asn1PE_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue)
723 {
724    static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
725    int stat = ASN_OK;
726
727    addSizeConstraint (pctxt, &lsize1);
728
729    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
730    if (stat != ASN_OK) return stat;
731
732    return (stat);
733 }
734
735 /**************************************************************/
736 /*                                                            */
737 /*  H221NonStandard                                           */
738 /*                                                            */
739 /**************************************************************/
740
741 EXTERN int asn1PE_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue)
742 {
743    int stat = ASN_OK;
744    ASN1BOOL extbit;
745
746    /* extension bit */
747
748    extbit = 0;
749
750    encodeBit (pctxt, extbit);
751
752    /* encode t35CountryCode */
753
754    stat = encodeConsUnsigned (pctxt, pvalue->t35CountryCode, 0U, 255U);
755    if (stat != ASN_OK) return stat;
756
757    /* encode t35Extension */
758
759    stat = encodeConsUnsigned (pctxt, pvalue->t35Extension, 0U, 255U);
760    if (stat != ASN_OK) return stat;
761
762    /* encode manufacturerCode */
763
764    stat = encodeConsUnsigned (pctxt, pvalue->manufacturerCode, 0U, 65535U);
765    if (stat != ASN_OK) return stat;
766
767    return (stat);
768 }
769
770 /**************************************************************/
771 /*                                                            */
772 /*  NonStandardIdentifier                                     */
773 /*                                                            */
774 /**************************************************************/
775
776 EXTERN int asn1PE_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue)
777 {
778    int stat = ASN_OK;
779    ASN1BOOL extbit;
780
781    /* extension bit */
782
783    extbit = (ASN1BOOL)(pvalue->t > 2);
784
785    encodeBit (pctxt, extbit);
786
787    if (!extbit) {
788
789       /* Encode choice index value */
790
791       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
792       if (stat != ASN_OK) return stat;
793
794       /* Encode root element data value */
795
796       switch (pvalue->t)
797       {
798          /* object */
799          case 1:
800             stat = encodeObjectIdentifier (pctxt, pvalue->u.object);
801             if (stat != ASN_OK) return stat;
802             break;
803
804          /* h221NonStandard */
805          case 2:
806             stat = asn1PE_H225H221NonStandard (pctxt, pvalue->u.h221NonStandard);
807             if (stat != ASN_OK) return stat;
808             break;
809
810          default:
811             return ASN_E_INVOPT;
812       }
813    }
814    else {
815       /* Encode extension choice index value */
816
817       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
818       if (stat != ASN_OK) return stat;
819
820       /* Encode extension element data value */
821
822    }
823
824    return (stat);
825 }
826
827 /**************************************************************/
828 /*                                                            */
829 /*  NonStandardParameter                                      */
830 /*                                                            */
831 /**************************************************************/
832
833 EXTERN int asn1PE_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue)
834 {
835    int stat = ASN_OK;
836
837    /* encode nonStandardIdentifier */
838
839    stat = asn1PE_H225NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
840    if (stat != ASN_OK) return stat;
841
842    /* encode data */
843
844    stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data);
845    if (stat != ASN_OK) return stat;
846
847    return (stat);
848 }
849
850 /**************************************************************/
851 /*                                                            */
852 /*  TransportAddress                                          */
853 /*                                                            */
854 /**************************************************************/
855
856 EXTERN int asn1PE_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue)
857 {
858    int stat = ASN_OK;
859    ASN1BOOL extbit;
860
861    /* extension bit */
862
863    extbit = (ASN1BOOL)(pvalue->t > 7);
864
865    encodeBit (pctxt, extbit);
866
867    if (!extbit) {
868
869       /* Encode choice index value */
870
871       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6);
872       if (stat != ASN_OK) return stat;
873
874       /* Encode root element data value */
875
876       switch (pvalue->t)
877       {
878          /* ipAddress */
879          case 1:
880             stat = asn1PE_H225TransportAddress_ipAddress (pctxt, pvalue->u.ipAddress);
881             if (stat != ASN_OK) return stat;
882             break;
883
884          /* ipSourceRoute */
885          case 2:
886             stat = asn1PE_H225TransportAddress_ipSourceRoute (pctxt, pvalue->u.ipSourceRoute);
887             if (stat != ASN_OK) return stat;
888             break;
889
890          /* ipxAddress */
891          case 3:
892             stat = asn1PE_H225TransportAddress_ipxAddress (pctxt, pvalue->u.ipxAddress);
893             if (stat != ASN_OK) return stat;
894             break;
895
896          /* ip6Address */
897          case 4:
898             stat = asn1PE_H225TransportAddress_ip6Address (pctxt, pvalue->u.ip6Address);
899             if (stat != ASN_OK) return stat;
900             break;
901
902          /* netBios */
903          case 5:
904             stat = asn1PE_H225TransportAddress_netBios (pctxt, pvalue->u.netBios);
905             if (stat != ASN_OK) return stat;
906             break;
907
908          /* nsap */
909          case 6:
910             stat = asn1PE_H225TransportAddress_nsap (pctxt, pvalue->u.nsap);
911             if (stat != ASN_OK) return stat;
912             break;
913
914          /* nonStandardAddress */
915          case 7:
916             stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandardAddress);
917             if (stat != ASN_OK) return stat;
918             break;
919
920          default:
921             return ASN_E_INVOPT;
922       }
923    }
924    else {
925       /* Encode extension choice index value */
926
927       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8);
928       if (stat != ASN_OK) return stat;
929
930       /* Encode extension element data value */
931
932    }
933
934    return (stat);
935 }
936
937 /**************************************************************/
938 /*                                                            */
939 /*  PublicTypeOfNumber                                        */
940 /*                                                            */
941 /**************************************************************/
942
943 EXTERN int asn1PE_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue)
944 {
945    int stat = ASN_OK;
946    ASN1BOOL extbit;
947
948    /* extension bit */
949
950    extbit = (ASN1BOOL)(pvalue->t > 6);
951
952    encodeBit (pctxt, extbit);
953
954    if (!extbit) {
955
956       /* Encode choice index value */
957
958       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
959       if (stat != ASN_OK) return stat;
960
961       /* Encode root element data value */
962
963       switch (pvalue->t)
964       {
965          /* unknown */
966          case 1:
967             /* NULL */
968             break;
969
970          /* internationalNumber */
971          case 2:
972             /* NULL */
973             break;
974
975          /* nationalNumber */
976          case 3:
977             /* NULL */
978             break;
979
980          /* networkSpecificNumber */
981          case 4:
982             /* NULL */
983             break;
984
985          /* subscriberNumber */
986          case 5:
987             /* NULL */
988             break;
989
990          /* abbreviatedNumber */
991          case 6:
992             /* NULL */
993             break;
994
995          default:
996             return ASN_E_INVOPT;
997       }
998    }
999    else {
1000       /* Encode extension choice index value */
1001
1002       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
1003       if (stat != ASN_OK) return stat;
1004
1005       /* Encode extension element data value */
1006
1007    }
1008
1009    return (stat);
1010 }
1011
1012 /**************************************************************/
1013 /*                                                            */
1014 /*  PublicPartyNumber                                         */
1015 /*                                                            */
1016 /**************************************************************/
1017
1018 EXTERN int asn1PE_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue)
1019 {
1020    int stat = ASN_OK;
1021
1022    /* encode publicTypeOfNumber */
1023
1024    stat = asn1PE_H225PublicTypeOfNumber (pctxt, &pvalue->publicTypeOfNumber);
1025    if (stat != ASN_OK) return stat;
1026
1027    /* encode publicNumberDigits */
1028
1029    stat = asn1PE_H225NumberDigits (pctxt, pvalue->publicNumberDigits);
1030    if (stat != ASN_OK) return stat;
1031
1032    return (stat);
1033 }
1034
1035 /**************************************************************/
1036 /*                                                            */
1037 /*  PrivateTypeOfNumber                                       */
1038 /*                                                            */
1039 /**************************************************************/
1040
1041 EXTERN int asn1PE_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue)
1042 {
1043    int stat = ASN_OK;
1044    ASN1BOOL extbit;
1045
1046    /* extension bit */
1047
1048    extbit = (ASN1BOOL)(pvalue->t > 6);
1049
1050    encodeBit (pctxt, extbit);
1051
1052    if (!extbit) {
1053
1054       /* Encode choice index value */
1055
1056       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5);
1057       if (stat != ASN_OK) return stat;
1058
1059       /* Encode root element data value */
1060
1061       switch (pvalue->t)
1062       {
1063          /* unknown */
1064          case 1:
1065             /* NULL */
1066             break;
1067
1068          /* level2RegionalNumber */
1069          case 2:
1070             /* NULL */
1071             break;
1072
1073          /* level1RegionalNumber */
1074          case 3:
1075             /* NULL */
1076             break;
1077
1078          /* pISNSpecificNumber */
1079          case 4:
1080             /* NULL */
1081             break;
1082
1083          /* localNumber */
1084          case 5:
1085             /* NULL */
1086             break;
1087
1088          /* abbreviatedNumber */
1089          case 6:
1090             /* NULL */
1091             break;
1092
1093          default:
1094             return ASN_E_INVOPT;
1095       }
1096    }
1097    else {
1098       /* Encode extension choice index value */
1099
1100       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7);
1101       if (stat != ASN_OK) return stat;
1102
1103       /* Encode extension element data value */
1104
1105    }
1106
1107    return (stat);
1108 }
1109
1110 /**************************************************************/
1111 /*                                                            */
1112 /*  PrivatePartyNumber                                        */
1113 /*                                                            */
1114 /**************************************************************/
1115
1116 EXTERN int asn1PE_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue)
1117 {
1118    int stat = ASN_OK;
1119
1120    /* encode privateTypeOfNumber */
1121
1122    stat = asn1PE_H225PrivateTypeOfNumber (pctxt, &pvalue->privateTypeOfNumber);
1123    if (stat != ASN_OK) return stat;
1124
1125    /* encode privateNumberDigits */
1126
1127    stat = asn1PE_H225NumberDigits (pctxt, pvalue->privateNumberDigits);
1128    if (stat != ASN_OK) return stat;
1129
1130    return (stat);
1131 }
1132
1133 /**************************************************************/
1134 /*                                                            */
1135 /*  PartyNumber                                               */
1136 /*                                                            */
1137 /**************************************************************/
1138
1139 EXTERN int asn1PE_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue)
1140 {
1141    int stat = ASN_OK;
1142    ASN1BOOL extbit;
1143
1144    /* extension bit */
1145
1146    extbit = (ASN1BOOL)(pvalue->t > 5);
1147
1148    encodeBit (pctxt, extbit);
1149
1150    if (!extbit) {
1151
1152       /* Encode choice index value */
1153
1154       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4);
1155       if (stat != ASN_OK) return stat;
1156
1157       /* Encode root element data value */
1158
1159       switch (pvalue->t)
1160       {
1161          /* e164Number */
1162          case 1:
1163             stat = asn1PE_H225PublicPartyNumber (pctxt, pvalue->u.e164Number);
1164             if (stat != ASN_OK) return stat;
1165             break;
1166
1167          /* dataPartyNumber */
1168          case 2:
1169             stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.dataPartyNumber);
1170             if (stat != ASN_OK) return stat;
1171             break;
1172
1173          /* telexPartyNumber */
1174          case 3:
1175             stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.telexPartyNumber);
1176             if (stat != ASN_OK) return stat;
1177             break;
1178
1179          /* privateNumber */
1180          case 4:
1181             stat = asn1PE_H225PrivatePartyNumber (pctxt, pvalue->u.privateNumber);
1182             if (stat != ASN_OK) return stat;
1183             break;
1184
1185          /* nationalStandardPartyNumber */
1186          case 5:
1187             stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.nationalStandardPartyNumber);
1188             if (stat != ASN_OK) return stat;
1189             break;
1190
1191          default:
1192             return ASN_E_INVOPT;
1193       }
1194    }
1195    else {
1196       /* Encode extension choice index value */
1197
1198       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6);
1199       if (stat != ASN_OK) return stat;
1200
1201       /* Encode extension element data value */
1202
1203    }
1204
1205    return (stat);
1206 }
1207
1208 /**************************************************************/
1209 /*                                                            */
1210 /*  ANSI_41_UIM_system_id                                     */
1211 /*                                                            */
1212 /**************************************************************/
1213
1214 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet;
1215
1216 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet;
1217
1218 EXTERN int asn1PE_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue)
1219 {
1220    static Asn1SizeCnst sid_lsize1 = { 0, 1, 4, 0 };
1221    static Asn1SizeCnst mid_lsize1 = { 0, 1, 4, 0 };
1222    int stat = ASN_OK;
1223    ASN1BOOL extbit;
1224
1225    /* extension bit */
1226
1227    extbit = (ASN1BOOL)(pvalue->t > 2);
1228
1229    encodeBit (pctxt, extbit);
1230
1231    if (!extbit) {
1232
1233       /* Encode choice index value */
1234
1235       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
1236       if (stat != ASN_OK) return stat;
1237
1238       /* Encode root element data value */
1239
1240       switch (pvalue->t)
1241       {
1242          /* sid */
1243          case 1:
1244             addSizeConstraint (pctxt, &sid_lsize1);
1245
1246             stat = encodeConstrainedStringEx (pctxt, pvalue->u.sid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet, 4, 4, 7);
1247             if (stat != ASN_OK) return stat;
1248             break;
1249
1250          /* mid */
1251          case 2:
1252             addSizeConstraint (pctxt, &mid_lsize1);
1253
1254             stat = encodeConstrainedStringEx (pctxt, pvalue->u.mid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet, 4, 4, 7);
1255             if (stat != ASN_OK) return stat;
1256             break;
1257
1258          default:
1259             return ASN_E_INVOPT;
1260       }
1261    }
1262    else {
1263       /* Encode extension choice index value */
1264
1265       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
1266       if (stat != ASN_OK) return stat;
1267
1268       /* Encode extension element data value */
1269
1270    }
1271
1272    return (stat);
1273 }
1274
1275 /**************************************************************/
1276 /*                                                            */
1277 /*  ANSI_41_UIM_systemMyTypeCode                              */
1278 /*                                                            */
1279 /**************************************************************/
1280
1281 EXTERN int asn1PE_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue)
1282 {
1283    static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
1284    int stat = ASN_OK;
1285
1286    addSizeConstraint (pctxt, &lsize1);
1287
1288    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
1289    if (stat != ASN_OK) return stat;
1290
1291    return (stat);
1292 }
1293
1294 /**************************************************************/
1295 /*                                                            */
1296 /*  ANSI_41_UIM_systemAccessType                              */
1297 /*                                                            */
1298 /**************************************************************/
1299
1300 EXTERN int asn1PE_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue)
1301 {
1302    static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
1303    int stat = ASN_OK;
1304
1305    addSizeConstraint (pctxt, &lsize1);
1306
1307    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
1308    if (stat != ASN_OK) return stat;
1309
1310    return (stat);
1311 }
1312
1313 /**************************************************************/
1314 /*                                                            */
1315 /*  ANSI_41_UIM_qualificationInformationCode                  */
1316 /*                                                            */
1317 /**************************************************************/
1318
1319 EXTERN int asn1PE_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue)
1320 {
1321    static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
1322    int stat = ASN_OK;
1323
1324    addSizeConstraint (pctxt, &lsize1);
1325
1326    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
1327    if (stat != ASN_OK) return stat;
1328
1329    return (stat);
1330 }
1331
1332 /**************************************************************/
1333 /*                                                            */
1334 /*  ANSI_41_UIM                                               */
1335 /*                                                            */
1336 /**************************************************************/
1337
1338 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet;
1339
1340 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet;
1341
1342 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet;
1343
1344 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet;
1345
1346 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet;
1347
1348 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet;
1349
1350 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet;
1351
1352 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet;
1353
1354 EXTERN int asn1PE_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue)
1355 {
1356    static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
1357    static Asn1SizeCnst min_lsize1 = { 0, 3, 16, 0 };
1358    static Asn1SizeCnst mdn_lsize1 = { 0, 3, 16, 0 };
1359    static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
1360    static Asn1SizeCnst esn_lsize1 = { 0, 16, 16, 0 };
1361    static Asn1SizeCnst mscid_lsize1 = { 0, 3, 16, 0 };
1362    static Asn1SizeCnst sesn_lsize1 = { 0, 16, 16, 0 };
1363    static Asn1SizeCnst soc_lsize1 = { 0, 3, 16, 0 };
1364    int stat = ASN_OK;
1365    ASN1BOOL extbit;
1366
1367    /* extension bit */
1368
1369    extbit = 0;
1370
1371    encodeBit (pctxt, extbit);
1372
1373    encodeBit (pctxt, (ASN1BOOL)pvalue->m.imsiPresent);
1374
1375    encodeBit (pctxt, (ASN1BOOL)pvalue->m.minPresent);
1376
1377    encodeBit (pctxt, (ASN1BOOL)pvalue->m.mdnPresent);
1378
1379    encodeBit (pctxt, (ASN1BOOL)pvalue->m.msisdnPresent);
1380
1381    encodeBit (pctxt, (ASN1BOOL)pvalue->m.esnPresent);
1382
1383    encodeBit (pctxt, (ASN1BOOL)pvalue->m.mscidPresent);
1384
1385    encodeBit (pctxt, (ASN1BOOL)pvalue->m.systemMyTypeCodePresent);
1386
1387    encodeBit (pctxt, (ASN1BOOL)pvalue->m.systemAccessTypePresent);
1388
1389    encodeBit (pctxt, (ASN1BOOL)pvalue->m.qualificationInformationCodePresent);
1390
1391    encodeBit (pctxt, (ASN1BOOL)pvalue->m.sesnPresent);
1392
1393    encodeBit (pctxt, (ASN1BOOL)pvalue->m.socPresent);
1394
1395    /* encode imsi */
1396
1397    if (pvalue->m.imsiPresent) {
1398       addSizeConstraint (pctxt, &imsi_lsize1);
1399
1400       stat = encodeConstrainedStringEx (pctxt, pvalue->imsi, gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet, 4, 4, 7);
1401       if (stat != ASN_OK) return stat;
1402    }
1403
1404    /* encode min */
1405
1406    if (pvalue->m.minPresent) {
1407       addSizeConstraint (pctxt, &min_lsize1);
1408
1409       stat = encodeConstrainedStringEx (pctxt, pvalue->min, gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet, 4, 4, 7);
1410       if (stat != ASN_OK) return stat;
1411    }
1412
1413    /* encode mdn */
1414
1415    if (pvalue->m.mdnPresent) {
1416       addSizeConstraint (pctxt, &mdn_lsize1);
1417
1418       stat = encodeConstrainedStringEx (pctxt, pvalue->mdn, gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet, 4, 4, 7);
1419       if (stat != ASN_OK) return stat;
1420    }
1421
1422    /* encode msisdn */
1423
1424    if (pvalue->m.msisdnPresent) {
1425       addSizeConstraint (pctxt, &msisdn_lsize1);
1426
1427       stat = encodeConstrainedStringEx (pctxt, pvalue->msisdn, gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet, 4, 4, 7);
1428       if (stat != ASN_OK) return stat;
1429    }
1430
1431    /* encode esn */
1432
1433    if (pvalue->m.esnPresent) {
1434       addSizeConstraint (pctxt, &esn_lsize1);
1435
1436       stat = encodeConstrainedStringEx (pctxt, pvalue->esn, gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet, 4, 4, 7);
1437       if (stat != ASN_OK) return stat;
1438    }
1439
1440    /* encode mscid */
1441
1442    if (pvalue->m.mscidPresent) {
1443       addSizeConstraint (pctxt, &mscid_lsize1);
1444
1445       stat = encodeConstrainedStringEx (pctxt, pvalue->mscid, gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet, 4, 4, 7);
1446       if (stat != ASN_OK) return stat;
1447    }
1448
1449    /* encode system_id */
1450
1451    stat = asn1PE_H225ANSI_41_UIM_system_id (pctxt, &pvalue->system_id);
1452    if (stat != ASN_OK) return stat;
1453
1454    /* encode systemMyTypeCode */
1455
1456    if (pvalue->m.systemMyTypeCodePresent) {
1457       stat = asn1PE_H225ANSI_41_UIM_systemMyTypeCode (pctxt, &pvalue->systemMyTypeCode);
1458       if (stat != ASN_OK) return stat;
1459    }
1460
1461    /* encode systemAccessType */
1462
1463    if (pvalue->m.systemAccessTypePresent) {
1464       stat = asn1PE_H225ANSI_41_UIM_systemAccessType (pctxt, &pvalue->systemAccessType);
1465       if (stat != ASN_OK) return stat;
1466    }
1467
1468    /* encode qualificationInformationCode */
1469
1470    if (pvalue->m.qualificationInformationCodePresent) {
1471       stat = asn1PE_H225ANSI_41_UIM_qualificationInformationCode (pctxt, &pvalue->qualificationInformationCode);
1472       if (stat != ASN_OK) return stat;
1473    }
1474
1475    /* encode sesn */
1476
1477    if (pvalue->m.sesnPresent) {
1478       addSizeConstraint (pctxt, &sesn_lsize1);
1479
1480       stat = encodeConstrainedStringEx (pctxt, pvalue->sesn, gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet, 4, 4, 7);
1481       if (stat != ASN_OK) return stat;
1482    }
1483
1484    /* encode soc */
1485
1486    if (pvalue->m.socPresent) {
1487       addSizeConstraint (pctxt, &soc_lsize1);
1488
1489       stat = encodeConstrainedStringEx (pctxt, pvalue->soc, gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet, 4, 4, 7);
1490       if (stat != ASN_OK) return stat;
1491    }
1492
1493    return (stat);
1494 }
1495
1496 /**************************************************************/
1497 /*                                                            */
1498 /*  GSM_UIM_tmsi                                              */
1499 /*                                                            */
1500 /**************************************************************/
1501
1502 EXTERN int asn1PE_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue)
1503 {
1504    static Asn1SizeCnst lsize1 = { 0, 1, 4, 0 };
1505    int stat = ASN_OK;
1506
1507    addSizeConstraint (pctxt, &lsize1);
1508
1509    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
1510    if (stat != ASN_OK) return stat;
1511
1512    return (stat);
1513 }
1514
1515 /**************************************************************/
1516 /*                                                            */
1517 /*  GSM_UIM                                                   */
1518 /*                                                            */
1519 /**************************************************************/
1520
1521 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet;
1522
1523 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet;
1524
1525 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet;
1526
1527 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet;
1528
1529 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet;
1530
1531 EXTERN int asn1PE_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue)
1532 {
1533    static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
1534    static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
1535    static Asn1SizeCnst imei_lsize1 = { 0, 15, 16, 0 };
1536    static Asn1SizeCnst hplmn_lsize1 = { 0, 1, 4, 0 };
1537    static Asn1SizeCnst vplmn_lsize1 = { 0, 1, 4, 0 };
1538    int stat = ASN_OK;
1539    ASN1BOOL extbit;
1540
1541    /* extension bit */
1542
1543    extbit = 0;
1544
1545    encodeBit (pctxt, extbit);
1546
1547    encodeBit (pctxt, (ASN1BOOL)pvalue->m.imsiPresent);
1548
1549    encodeBit (pctxt, (ASN1BOOL)pvalue->m.tmsiPresent);
1550
1551    encodeBit (pctxt, (ASN1BOOL)pvalue->m.msisdnPresent);
1552
1553    encodeBit (pctxt, (ASN1BOOL)pvalue->m.imeiPresent);
1554
1555    encodeBit (pctxt, (ASN1BOOL)pvalue->m.hplmnPresent);
1556
1557    encodeBit (pctxt, (ASN1BOOL)pvalue->m.vplmnPresent);
1558
1559    /* encode imsi */
1560
1561    if (pvalue->m.imsiPresent) {
1562       addSizeConstraint (pctxt, &imsi_lsize1);
1563
1564       stat = encodeConstrainedStringEx (pctxt, pvalue->imsi, gs_H323_MESSAGES_GSM_UIM_imsi_CharSet, 4, 4, 7);
1565       if (stat != ASN_OK) return stat;
1566    }
1567
1568    /* encode tmsi */
1569
1570    if (pvalue->m.tmsiPresent) {
1571       stat = asn1PE_H225GSM_UIM_tmsi (pctxt, &pvalue->tmsi);
1572       if (stat != ASN_OK) return stat;
1573    }
1574
1575    /* encode msisdn */
1576
1577    if (pvalue->m.msisdnPresent) {
1578       addSizeConstraint (pctxt, &msisdn_lsize1);
1579
1580       stat = encodeConstrainedStringEx (pctxt, pvalue->msisdn, gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet, 4, 4, 7);
1581       if (stat != ASN_OK) return stat;
1582    }
1583
1584    /* encode imei */
1585
1586    if (pvalue->m.imeiPresent) {
1587       addSizeConstraint (pctxt, &imei_lsize1);
1588
1589       stat = encodeConstrainedStringEx (pctxt, pvalue->imei, gs_H323_MESSAGES_GSM_UIM_imei_CharSet, 4, 4, 7);
1590       if (stat != ASN_OK) return stat;
1591    }
1592
1593    /* encode hplmn */
1594
1595    if (pvalue->m.hplmnPresent) {
1596       addSizeConstraint (pctxt, &hplmn_lsize1);
1597
1598       stat = encodeConstrainedStringEx (pctxt, pvalue->hplmn, gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet, 4, 4, 7);
1599       if (stat != ASN_OK) return stat;
1600    }
1601
1602    /* encode vplmn */
1603
1604    if (pvalue->m.vplmnPresent) {
1605       addSizeConstraint (pctxt, &vplmn_lsize1);
1606
1607       stat = encodeConstrainedStringEx (pctxt, pvalue->vplmn, gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet, 4, 4, 7);
1608       if (stat != ASN_OK) return stat;
1609    }
1610
1611    return (stat);
1612 }
1613
1614 /**************************************************************/
1615 /*                                                            */
1616 /*  MobileUIM                                                 */
1617 /*                                                            */
1618 /**************************************************************/
1619
1620 EXTERN int asn1PE_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue)
1621 {
1622    int stat = ASN_OK;
1623    ASN1BOOL extbit;
1624
1625    /* extension bit */
1626
1627    extbit = (ASN1BOOL)(pvalue->t > 2);
1628
1629    encodeBit (pctxt, extbit);
1630
1631    if (!extbit) {
1632
1633       /* Encode choice index value */
1634
1635       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
1636       if (stat != ASN_OK) return stat;
1637
1638       /* Encode root element data value */
1639
1640       switch (pvalue->t)
1641       {
1642          /* ansi_41_uim */
1643          case 1:
1644             stat = asn1PE_H225ANSI_41_UIM (pctxt, pvalue->u.ansi_41_uim);
1645             if (stat != ASN_OK) return stat;
1646             break;
1647
1648          /* gsm_uim */
1649          case 2:
1650             stat = asn1PE_H225GSM_UIM (pctxt, pvalue->u.gsm_uim);
1651             if (stat != ASN_OK) return stat;
1652             break;
1653
1654          default:
1655             return ASN_E_INVOPT;
1656       }
1657    }
1658    else {
1659       /* Encode extension choice index value */
1660
1661       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
1662       if (stat != ASN_OK) return stat;
1663
1664       /* Encode extension element data value */
1665
1666    }
1667
1668    return (stat);
1669 }
1670
1671 /**************************************************************/
1672 /*                                                            */
1673 /*  AliasAddress                                              */
1674 /*                                                            */
1675 /**************************************************************/
1676
1677 extern EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet;
1678
1679 EXTERN int asn1PE_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue)
1680 {
1681    static Asn1SizeCnst dialedDigits_lsize1 = { 0, 1, 128, 0 };
1682    static Asn1SizeCnst h323_ID_lsize1 = { 0, 1, 256, 0 };
1683    static Asn1SizeCnst url_ID_lsize1 = { 0, 1, 512, 0 };
1684    static Asn1SizeCnst email_ID_lsize1 = { 0, 1, 512, 0 };
1685    int stat = ASN_OK;
1686    OOCTXT lctxt;
1687    ASN1OpenType openType;
1688    ASN1BOOL extbit;
1689
1690    /* extension bit */
1691
1692    extbit = (ASN1BOOL)(pvalue->t > 2);
1693
1694    encodeBit (pctxt, extbit);
1695
1696    if (!extbit) {
1697
1698       /* Encode choice index value */
1699
1700       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
1701       if (stat != ASN_OK) return stat;
1702
1703       /* Encode root element data value */
1704
1705       switch (pvalue->t)
1706       {
1707          /* dialedDigits */
1708          case 1:
1709             addSizeConstraint (pctxt, &dialedDigits_lsize1);
1710
1711             stat = encodeConstrainedStringEx (pctxt, pvalue->u.dialedDigits, gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet, 4, 4, 7);
1712             if (stat != ASN_OK) return stat;
1713             break;
1714
1715          /* h323_ID */
1716          case 2:
1717             addSizeConstraint (pctxt, &h323_ID_lsize1);
1718
1719             stat = encodeBMPString (pctxt, pvalue->u.h323_ID, 0);
1720             if (stat != ASN_OK) return stat;
1721             break;
1722
1723          default:
1724             return ASN_E_INVOPT;
1725       }
1726    }
1727    else {
1728       /* Encode extension choice index value */
1729
1730       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3);
1731       if (stat != ASN_OK) return stat;
1732
1733       /* Encode extension element data value */
1734
1735       initContext (&lctxt);
1736       stat = setPERBuffer (&lctxt, 0, 0, TRUE);
1737       if (stat != ASN_OK) return freeContext (&lctxt), stat;
1738
1739       switch (pvalue->t)
1740       {
1741          /* url_ID */
1742          case 3:
1743             addSizeConstraint (&lctxt, &url_ID_lsize1);
1744
1745             stat = encodeConstrainedStringEx (&lctxt, pvalue->u.url_ID, 0, 8, 7, 7);
1746             if (stat != ASN_OK) return freeContext (&lctxt), stat;
1747             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
1748             break;
1749
1750          /* transportID */
1751          case 4:
1752             stat = asn1PE_H225TransportAddress (&lctxt, pvalue->u.transportID);
1753             if (stat != ASN_OK) return freeContext (&lctxt), stat;
1754             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
1755             break;
1756
1757          /* email_ID */
1758          case 5:
1759             addSizeConstraint (&lctxt, &email_ID_lsize1);
1760
1761             stat = encodeConstrainedStringEx (&lctxt, pvalue->u.email_ID, 0, 8, 7, 7);
1762             if (stat != ASN_OK) return freeContext (&lctxt), stat;
1763             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
1764             break;
1765
1766          /* partyNumber */
1767          case 6:
1768             stat = asn1PE_H225PartyNumber (&lctxt, pvalue->u.partyNumber);
1769             if (stat != ASN_OK) return freeContext (&lctxt), stat;
1770             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
1771             break;
1772
1773          /* mobileUIM */
1774          case 7:
1775             stat = asn1PE_H225MobileUIM (&lctxt, pvalue->u.mobileUIM);
1776             if (stat != ASN_OK) return freeContext (&lctxt), stat;
1777             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
1778             break;
1779
1780          default:
1781             ;
1782       }
1783
1784       stat = encodeByteAlign (pctxt);
1785       if (stat != ASN_OK) return freeContext (&lctxt), stat;
1786
1787       stat = encodeOpenType (pctxt, openType.numocts, openType.data);
1788       if (stat != ASN_OK) return freeContext (&lctxt), stat;
1789
1790       freeContext (&lctxt);
1791    }
1792
1793    return (stat);
1794 }
1795
1796 /**************************************************************/
1797 /*                                                            */
1798 /*  Content_compound                                          */
1799 /*                                                            */
1800 /**************************************************************/
1801
1802 EXTERN int asn1PE_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue)
1803 {
1804    static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
1805    int stat = ASN_OK;
1806    DListNode* pnode;
1807    ASN1UINT xx1;
1808
1809    /* encode length determinant */
1810
1811    addSizeConstraint (pctxt, &lsize1);
1812
1813    stat = encodeLength (pctxt, pvalue->count);
1814    if (stat < 0) return stat;
1815
1816    /* encode elements */
1817    pnode = pvalue->head;
1818
1819    for (xx1 = 0; xx1 < pvalue->count; xx1++) {
1820       stat = asn1PE_H225EnumeratedParameter (pctxt, (H225EnumeratedParameter*)((H225EnumeratedParameter*)pnode->data));
1821       if (stat != ASN_OK) return stat;
1822       pnode = pnode->next;
1823    }
1824
1825    return (stat);
1826 }
1827
1828 /**************************************************************/
1829 /*                                                            */
1830 /*  Content_nested                                            */
1831 /*                                                            */
1832 /**************************************************************/
1833
1834 EXTERN int asn1PE_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue)
1835 {
1836    static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
1837    int stat = ASN_OK;
1838    DListNode* pnode;
1839    ASN1UINT xx1;
1840
1841    /* encode length determinant */
1842
1843    addSizeConstraint (pctxt, &lsize1);
1844
1845    stat = encodeLength (pctxt, pvalue->count);
1846    if (stat < 0) return stat;
1847
1848    /* encode elements */
1849    pnode = pvalue->head;
1850
1851    for (xx1 = 0; xx1 < pvalue->count; xx1++) {
1852       stat = asn1PE_H225GenericData (pctxt, (H225GenericData*)((H225GenericData*)pnode->data));
1853       if (stat != ASN_OK) return stat;
1854       pnode = pnode->next;
1855    }
1856
1857    return (stat);
1858 }
1859
1860 /**************************************************************/
1861 /*                                                            */
1862 /*  Content                                                   */
1863 /*                                                            */
1864 /**************************************************************/
1865
1866 EXTERN int asn1PE_H225Content (OOCTXT* pctxt, H225Content* pvalue)
1867 {
1868    int stat = ASN_OK;
1869    ASN1BOOL extbit;
1870
1871    /* extension bit */
1872
1873    extbit = (ASN1BOOL)(pvalue->t > 12);
1874
1875    encodeBit (pctxt, extbit);
1876
1877    if (!extbit) {
1878
1879       /* Encode choice index value */
1880
1881       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 11);
1882       if (stat != ASN_OK) return stat;
1883
1884       /* Encode root element data value */
1885
1886       switch (pvalue->t)
1887       {
1888          /* raw */
1889          case 1:
1890             stat = encodeOctetString (pctxt, pvalue->u.raw->numocts, pvalue->u.raw->data);
1891             if (stat != ASN_OK) return stat;
1892             break;
1893
1894          /* text */
1895          case 2:
1896             stat = encodeConstrainedStringEx (pctxt, pvalue->u.text, 0, 8, 7, 7);
1897             if (stat != ASN_OK) return stat;
1898             break;
1899
1900          /* unicode */
1901          case 3:
1902             stat = encodeBMPString (pctxt, pvalue->u.unicode, 0);
1903             if (stat != ASN_OK) return stat;
1904             break;
1905
1906          /* bool_ */
1907          case 4:
1908             stat = encodeBit (pctxt, (ASN1BOOL)pvalue->u.bool_);
1909             if (stat != ASN_OK) return stat;
1910             break;
1911
1912          /* number8 */
1913          case 5:
1914             stat = encodeConsUnsigned (pctxt, pvalue->u.number8, 0U, 255U);
1915             if (stat != ASN_OK) return stat;
1916
1917             break;
1918
1919          /* number16 */
1920          case 6:
1921             stat = encodeConsUnsigned (pctxt, pvalue->u.number16, 0U, 65535U);
1922             if (stat != ASN_OK) return stat;
1923
1924             break;
1925
1926          /* number32 */
1927          case 7:
1928             stat = encodeConsUnsigned (pctxt, pvalue->u.number32, 0U, ASN1UINT_MAX);
1929             if (stat != ASN_OK) return stat;
1930
1931             break;
1932
1933          /* id */
1934          case 8:
1935             stat = asn1PE_H225GenericIdentifier (pctxt, pvalue->u.id);
1936             if (stat != ASN_OK) return stat;
1937             break;
1938
1939          /* alias */
1940          case 9:
1941             stat = asn1PE_H225AliasAddress (pctxt, pvalue->u.alias);
1942             if (stat != ASN_OK) return stat;
1943             break;
1944
1945          /* transport */
1946          case 10:
1947             stat = asn1PE_H225TransportAddress (pctxt, pvalue->u.transport);
1948             if (stat != ASN_OK) return stat;
1949             break;
1950
1951          /* compound */
1952          case 11:
1953             stat = asn1PE_H225Content_compound (pctxt, pvalue->u.compound);
1954             if (stat != ASN_OK) return stat;
1955             break;
1956
1957          /* nested */
1958          case 12:
1959             stat = asn1PE_H225Content_nested (pctxt, pvalue->u.nested);
1960             if (stat != ASN_OK) return stat;
1961             break;
1962
1963          default:
1964             return ASN_E_INVOPT;
1965       }
1966    }
1967    else {
1968       /* Encode extension choice index value */
1969
1970       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 13);
1971       if (stat != ASN_OK) return stat;
1972
1973       /* Encode extension element data value */
1974
1975    }
1976
1977    return (stat);
1978 }
1979
1980 /**************************************************************/
1981 /*                                                            */
1982 /*  EnumeratedParameter                                       */
1983 /*                                                            */
1984 /**************************************************************/
1985
1986 EXTERN int asn1PE_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue)
1987 {
1988    int stat = ASN_OK;
1989    ASN1BOOL extbit;
1990
1991    /* extension bit */
1992
1993    extbit = 0;
1994
1995    encodeBit (pctxt, extbit);
1996
1997    encodeBit (pctxt, (ASN1BOOL)pvalue->m.contentPresent);
1998
1999    /* encode id */
2000
2001    stat = asn1PE_H225GenericIdentifier (pctxt, &pvalue->id);
2002    if (stat != ASN_OK) return stat;
2003
2004    /* encode content */
2005
2006    if (pvalue->m.contentPresent) {
2007       stat = asn1PE_H225Content (pctxt, &pvalue->content);
2008       if (stat != ASN_OK) return stat;
2009    }
2010
2011    return (stat);
2012 }
2013
2014 /**************************************************************/
2015 /*                                                            */
2016 /*  GenericData_parameters                                    */
2017 /*                                                            */
2018 /**************************************************************/
2019
2020 EXTERN int asn1PE_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue)
2021 {
2022    static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
2023    int stat = ASN_OK;
2024    DListNode* pnode;
2025    ASN1UINT xx1;
2026
2027    /* encode length determinant */
2028
2029    addSizeConstraint (pctxt, &lsize1);
2030
2031    stat = encodeLength (pctxt, pvalue->count);
2032    if (stat < 0) return stat;
2033
2034    /* encode elements */
2035    pnode = pvalue->head;
2036
2037    for (xx1 = 0; xx1 < pvalue->count; xx1++) {
2038       stat = asn1PE_H225EnumeratedParameter (pctxt, ((H225EnumeratedParameter*)pnode->data));
2039       if (stat != ASN_OK) return stat;
2040       pnode = pnode->next;
2041    }
2042
2043    return (stat);
2044 }
2045
2046 /**************************************************************/
2047 /*                                                            */
2048 /*  GenericData                                               */
2049 /*                                                            */
2050 /**************************************************************/
2051
2052 EXTERN int asn1PE_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue)
2053 {
2054    int stat = ASN_OK;
2055    ASN1BOOL extbit;
2056
2057    /* extension bit */
2058
2059    extbit = 0;
2060
2061    encodeBit (pctxt, extbit);
2062
2063    encodeBit (pctxt, (ASN1BOOL)pvalue->m.parametersPresent);
2064
2065    /* encode id */
2066
2067    stat = asn1PE_H225GenericIdentifier (pctxt, &pvalue->id);
2068    if (stat != ASN_OK) return stat;
2069
2070    /* encode parameters */
2071
2072    if (pvalue->m.parametersPresent) {
2073       stat = asn1PE_H225GenericData_parameters (pctxt, &pvalue->parameters);
2074       if (stat != ASN_OK) return stat;
2075    }
2076
2077    return (stat);
2078 }
2079
2080 /**************************************************************/
2081 /*                                                            */
2082 /*  FeatureDescriptor                                         */
2083 /*                                                            */
2084 /**************************************************************/
2085
2086 EXTERN int asn1PE_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue)
2087 {
2088    int stat = ASN_OK;
2089
2090    stat = asn1PE_H225GenericData (pctxt, pvalue);
2091    if (stat != ASN_OK) return stat;
2092
2093    return (stat);
2094 }
2095
2096 /**************************************************************/
2097 /*                                                            */
2098 /*  FastStartToken                                            */
2099 /*                                                            */
2100 /**************************************************************/
2101
2102 EXTERN int asn1PE_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue)
2103 {
2104    int stat = ASN_OK;
2105
2106    stat = asn1PE_H235ClearToken (pctxt, pvalue);
2107    if (stat != ASN_OK) return stat;
2108
2109    return (stat);
2110 }
2111
2112 /**************************************************************/
2113 /*                                                            */
2114 /*  EncodedFastStartToken                                     */
2115 /*                                                            */
2116 /**************************************************************/
2117
2118 EXTERN int asn1PE_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken value)
2119 {
2120    int stat = ASN_OK;
2121
2122    stat = encodeOpenType (pctxt, value.numocts, value.data);
2123    if (stat != ASN_OK) return stat;
2124
2125    return (stat);
2126 }
2127
2128 /**************************************************************/
2129 /*                                                            */
2130 /*  H323_UserInformation_user_data_user_information           */
2131 /*                                                            */
2132 /**************************************************************/
2133
2134 EXTERN int asn1PE_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue)
2135 {
2136    static Asn1SizeCnst lsize1 = { 0, 1, 131, 0 };
2137    int stat = ASN_OK;
2138
2139    addSizeConstraint (pctxt, &lsize1);
2140
2141    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
2142    if (stat != ASN_OK) return stat;
2143
2144    return (stat);
2145 }
2146
2147 /**************************************************************/
2148 /*                                                            */
2149 /*  EndpointType_set                                          */
2150 /*                                                            */
2151 /**************************************************************/
2152
2153 EXTERN int asn1PE_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue)
2154 {
2155    static Asn1SizeCnst lsize1 = { 0, 32, 32, 0 };
2156    int stat = ASN_OK;
2157
2158    addSizeConstraint (pctxt, &lsize1);
2159
2160    stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data);
2161    if (stat != ASN_OK) return stat;
2162
2163    return (stat);
2164 }
2165
2166 /**************************************************************/
2167 /*                                                            */
2168 /*  VendorIdentifier_productId                                */
2169 /*                                                            */
2170 /**************************************************************/
2171
2172 EXTERN int asn1PE_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue)
2173 {
2174    static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
2175    int stat = ASN_OK;
2176
2177    addSizeConstraint (pctxt, &lsize1);
2178
2179    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
2180    if (stat != ASN_OK) return stat;
2181
2182    return (stat);
2183 }
2184
2185 /**************************************************************/
2186 /*                                                            */
2187 /*  VendorIdentifier_versionId                                */
2188 /*                                                            */
2189 /**************************************************************/
2190
2191 EXTERN int asn1PE_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue)
2192 {
2193    static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
2194    int stat = ASN_OK;
2195
2196    addSizeConstraint (pctxt, &lsize1);
2197
2198    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
2199    if (stat != ASN_OK) return stat;
2200
2201    return (stat);
2202 }
2203
2204 /**************************************************************/
2205 /*                                                            */
2206 /*  CicInfo_cic_element                                       */
2207 /*                                                            */
2208 /**************************************************************/
2209
2210 EXTERN int asn1PE_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue)
2211 {
2212    static Asn1SizeCnst lsize1 = { 0, 2, 4, 0 };
2213    int stat = ASN_OK;
2214
2215    addSizeConstraint (pctxt, &lsize1);
2216
2217    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
2218    if (stat != ASN_OK) return stat;
2219
2220    return (stat);
2221 }
2222
2223 /**************************************************************/
2224 /*                                                            */
2225 /*  CicInfo_pointCode                                         */
2226 /*                                                            */
2227 /**************************************************************/
2228
2229 EXTERN int asn1PE_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue)
2230 {
2231    static Asn1SizeCnst lsize1 = { 0, 2, 5, 0 };
2232    int stat = ASN_OK;
2233
2234    addSizeConstraint (pctxt, &lsize1);
2235
2236    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
2237    if (stat != ASN_OK) return stat;
2238
2239    return (stat);
2240 }
2241
2242 /**************************************************************/
2243 /*                                                            */
2244 /*  CarrierInfo_carrierIdentificationCode                     */
2245 /*                                                            */
2246 /**************************************************************/
2247
2248 EXTERN int asn1PE_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue)
2249 {
2250    static Asn1SizeCnst lsize1 = { 0, 3, 4, 0 };
2251    int stat = ASN_OK;
2252
2253    addSizeConstraint (pctxt, &lsize1);
2254
2255    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
2256    if (stat != ASN_OK) return stat;
2257
2258    return (stat);
2259 }
2260
2261 /**************************************************************/
2262 /*                                                            */
2263 /*  CallTerminationCause_releaseCompleteCauseIE               */
2264 /*                                                            */
2265 /**************************************************************/
2266
2267 EXTERN int asn1PE_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue)
2268 {
2269    static Asn1SizeCnst lsize1 = { 0, 2, 32, 0 };
2270    int stat = ASN_OK;
2271
2272    addSizeConstraint (pctxt, &lsize1);
2273
2274    stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data);
2275    if (stat != ASN_OK) return stat;
2276
2277    return (stat);
2278 }
2279
2280 /**************************************************************/
2281 /*                                                            */
2282 /*  _SeqOfH225AliasAddress                                    */
2283 /*                                                            */
2284 /**************************************************************/
2285
2286 EXTERN int asn1PE_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue)
2287 {
2288    int stat = ASN_OK;
2289    DListNode* pnode;
2290    ASN1UINT xx1;
2291    ASN1UINT enclen, fraglen;
2292
2293    enclen = fraglen = xx1 = 0;
2294    pnode = pvalue->head;
2295    for (;;) {
2296       /* encode length determinant */
2297
2298       stat = encodeLength (pctxt, (pvalue->count - enclen));
2299       if (stat < 0) return stat;
2300
2301       fraglen = stat;
2302       enclen += fraglen;
2303       /* encode elements */
2304
2305       for (; xx1 < enclen; xx1++) {
2306          stat = asn1PE_H225AliasAddress (pctxt, ((H225AliasAddress*)pnode->data));
2307          if (stat != ASN_OK) return stat;
2308          pnode = pnode->next;
2309       }
2310       if ( pvalue->count == enclen && fraglen < 16384) {
2311          break;
2312       }
2313    }
2314
2315    return (stat);
2316 }
2317
2318 /**************************************************************/
2319 /*                                                            */
2320 /*  VendorIdentifier                                          */
2321 /*                                                            */
2322 /**************************************************************/
2323
2324 EXTERN int asn1PE_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue)
2325 {
2326    int stat = ASN_OK;
2327    ASN1BOOL extbit;
2328    ASN1OpenType openType;
2329    OOCTXT lctxt;
2330
2331    /* extension bit */
2332
2333    extbit = (ASN1BOOL)(pvalue->m.enterpriseNumberPresent);
2334
2335    encodeBit (pctxt, extbit);
2336
2337    encodeBit (pctxt, (ASN1BOOL)pvalue->m.productIdPresent);
2338
2339    encodeBit (pctxt, (ASN1BOOL)pvalue->m.versionIdPresent);
2340
2341    /* encode vendor */
2342
2343    stat = asn1PE_H225H221NonStandard (pctxt, &pvalue->vendor);
2344    if (stat != ASN_OK) return stat;
2345
2346    /* encode productId */
2347
2348    if (pvalue->m.productIdPresent) {
2349       stat = asn1PE_H225VendorIdentifier_productId (pctxt, &pvalue->productId);
2350       if (stat != ASN_OK) return stat;
2351    }
2352
2353    /* encode versionId */
2354
2355    if (pvalue->m.versionIdPresent) {
2356       stat = asn1PE_H225VendorIdentifier_versionId (pctxt, &pvalue->versionId);
2357       if (stat != ASN_OK) return stat;
2358    }
2359
2360    if (extbit) {
2361
2362       /* encode extension optional bits length */
2363
2364       stat = encodeSmallNonNegWholeNumber (pctxt, 0);
2365       if (stat != ASN_OK) return stat;
2366
2367       /* encode optional bits */
2368
2369       encodeBit (pctxt, (ASN1BOOL)pvalue->m.enterpriseNumberPresent);
2370       /* encode extension elements */
2371
2372       if (pvalue->m.enterpriseNumberPresent) {
2373          initContext (&lctxt);
2374          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2375          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2376
2377          stat = encodeObjectIdentifier (&lctxt, &pvalue->enterpriseNumber);
2378          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2379
2380          stat = encodeByteAlign (&lctxt);
2381          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2382
2383          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2384
2385          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2386          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2387
2388          freeContext (&lctxt);
2389       }
2390
2391    }
2392
2393    return (stat);
2394 }
2395
2396 /**************************************************************/
2397 /*                                                            */
2398 /*  GatekeeperInfo                                            */
2399 /*                                                            */
2400 /**************************************************************/
2401
2402 EXTERN int asn1PE_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue)
2403 {
2404    int stat = ASN_OK;
2405    ASN1BOOL extbit;
2406
2407    /* extension bit */
2408
2409    extbit = 0;
2410
2411    encodeBit (pctxt, extbit);
2412
2413    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2414
2415    /* encode nonStandardData */
2416
2417    if (pvalue->m.nonStandardDataPresent) {
2418       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2419       if (stat != ASN_OK) return stat;
2420    }
2421
2422    return (stat);
2423 }
2424
2425 /**************************************************************/
2426 /*                                                            */
2427 /*  DataRate                                                  */
2428 /*                                                            */
2429 /**************************************************************/
2430
2431 EXTERN int asn1PE_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue)
2432 {
2433    int stat = ASN_OK;
2434    ASN1BOOL extbit;
2435
2436    /* extension bit */
2437
2438    extbit = 0;
2439
2440    encodeBit (pctxt, extbit);
2441
2442    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2443
2444    encodeBit (pctxt, (ASN1BOOL)pvalue->m.channelMultiplierPresent);
2445
2446    /* encode nonStandardData */
2447
2448    if (pvalue->m.nonStandardDataPresent) {
2449       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2450       if (stat != ASN_OK) return stat;
2451    }
2452
2453    /* encode channelRate */
2454
2455    stat = asn1PE_H225BandWidth (pctxt, pvalue->channelRate);
2456    if (stat != ASN_OK) return stat;
2457
2458    /* encode channelMultiplier */
2459
2460    if (pvalue->m.channelMultiplierPresent) {
2461       stat = encodeConsUnsigned (pctxt, pvalue->channelMultiplier, 1U, 256U);
2462       if (stat != ASN_OK) return stat;
2463
2464    }
2465
2466    return (stat);
2467 }
2468
2469 /**************************************************************/
2470 /*                                                            */
2471 /*  _SeqOfH225DataRate                                        */
2472 /*                                                            */
2473 /**************************************************************/
2474
2475 EXTERN int asn1PE_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue)
2476 {
2477    int stat = ASN_OK;
2478    DListNode* pnode;
2479    ASN1UINT xx1;
2480    ASN1UINT enclen, fraglen;
2481
2482    enclen = fraglen = xx1 = 0;
2483    pnode = pvalue->head;
2484    for (;;) {
2485       /* encode length determinant */
2486
2487       stat = encodeLength (pctxt, (pvalue->count - enclen));
2488       if (stat < 0) return stat;
2489
2490       fraglen = stat;
2491       enclen += fraglen;
2492       /* encode elements */
2493
2494       for (; xx1 < enclen; xx1++) {
2495          stat = asn1PE_H225DataRate (pctxt, ((H225DataRate*)pnode->data));
2496          if (stat != ASN_OK) return stat;
2497          pnode = pnode->next;
2498       }
2499       if ( pvalue->count == enclen && fraglen < 16384) {
2500          break;
2501       }
2502    }
2503
2504    return (stat);
2505 }
2506
2507 /**************************************************************/
2508 /*                                                            */
2509 /*  SupportedPrefix                                           */
2510 /*                                                            */
2511 /**************************************************************/
2512
2513 EXTERN int asn1PE_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue)
2514 {
2515    int stat = ASN_OK;
2516    ASN1BOOL extbit;
2517
2518    /* extension bit */
2519
2520    extbit = 0;
2521
2522    encodeBit (pctxt, extbit);
2523
2524    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2525
2526    /* encode nonStandardData */
2527
2528    if (pvalue->m.nonStandardDataPresent) {
2529       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2530       if (stat != ASN_OK) return stat;
2531    }
2532
2533    /* encode prefix */
2534
2535    stat = asn1PE_H225AliasAddress (pctxt, &pvalue->prefix);
2536    if (stat != ASN_OK) return stat;
2537
2538    return (stat);
2539 }
2540
2541 /**************************************************************/
2542 /*                                                            */
2543 /*  _SeqOfH225SupportedPrefix                                 */
2544 /*                                                            */
2545 /**************************************************************/
2546
2547 EXTERN int asn1PE_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue)
2548 {
2549    int stat = ASN_OK;
2550    DListNode* pnode;
2551    ASN1UINT xx1;
2552    ASN1UINT enclen, fraglen;
2553
2554    enclen = fraglen = xx1 = 0;
2555    pnode = pvalue->head;
2556    for (;;) {
2557       /* encode length determinant */
2558
2559       stat = encodeLength (pctxt, (pvalue->count - enclen));
2560       if (stat < 0) return stat;
2561
2562       fraglen = stat;
2563       enclen += fraglen;
2564       /* encode elements */
2565
2566       for (; xx1 < enclen; xx1++) {
2567          stat = asn1PE_H225SupportedPrefix (pctxt, ((H225SupportedPrefix*)pnode->data));
2568          if (stat != ASN_OK) return stat;
2569          pnode = pnode->next;
2570       }
2571       if ( pvalue->count == enclen && fraglen < 16384) {
2572          break;
2573       }
2574    }
2575
2576    return (stat);
2577 }
2578
2579 /**************************************************************/
2580 /*                                                            */
2581 /*  H310Caps                                                  */
2582 /*                                                            */
2583 /**************************************************************/
2584
2585 EXTERN int asn1PE_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue)
2586 {
2587    int stat = ASN_OK;
2588    ASN1BOOL extbit;
2589    ASN1OpenType openType;
2590    OOCTXT lctxt;
2591
2592    /* extension bit */
2593
2594    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
2595    pvalue->m.supportedPrefixesPresent);
2596
2597    encodeBit (pctxt, extbit);
2598
2599    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2600
2601    /* encode nonStandardData */
2602
2603    if (pvalue->m.nonStandardDataPresent) {
2604       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2605       if (stat != ASN_OK) return stat;
2606    }
2607
2608    if (extbit) {
2609
2610       /* encode extension optional bits length */
2611
2612       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
2613       if (stat != ASN_OK) return stat;
2614
2615       /* encode optional bits */
2616
2617       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
2618       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
2619       /* encode extension elements */
2620
2621       if (pvalue->m.dataRatesSupportedPresent) {
2622          initContext (&lctxt);
2623          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2624          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2625
2626          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
2627          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2628
2629          stat = encodeByteAlign (&lctxt);
2630          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2631
2632          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2633
2634          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2635          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2636
2637          freeContext (&lctxt);
2638       }
2639
2640       if (pvalue->m.supportedPrefixesPresent) {
2641          initContext (&lctxt);
2642          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2643          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2644
2645          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
2646          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2647
2648          stat = encodeByteAlign (&lctxt);
2649          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2650
2651          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2652
2653          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2654          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2655
2656          freeContext (&lctxt);
2657       }
2658
2659    }
2660
2661    return (stat);
2662 }
2663
2664 /**************************************************************/
2665 /*                                                            */
2666 /*  H320Caps                                                  */
2667 /*                                                            */
2668 /**************************************************************/
2669
2670 EXTERN int asn1PE_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue)
2671 {
2672    int stat = ASN_OK;
2673    ASN1BOOL extbit;
2674    ASN1OpenType openType;
2675    OOCTXT lctxt;
2676
2677    /* extension bit */
2678
2679    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
2680    pvalue->m.supportedPrefixesPresent);
2681
2682    encodeBit (pctxt, extbit);
2683
2684    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2685
2686    /* encode nonStandardData */
2687
2688    if (pvalue->m.nonStandardDataPresent) {
2689       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2690       if (stat != ASN_OK) return stat;
2691    }
2692
2693    if (extbit) {
2694
2695       /* encode extension optional bits length */
2696
2697       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
2698       if (stat != ASN_OK) return stat;
2699
2700       /* encode optional bits */
2701
2702       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
2703       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
2704       /* encode extension elements */
2705
2706       if (pvalue->m.dataRatesSupportedPresent) {
2707          initContext (&lctxt);
2708          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2709          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2710
2711          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
2712          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2713
2714          stat = encodeByteAlign (&lctxt);
2715          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2716
2717          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2718
2719          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2720          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2721
2722          freeContext (&lctxt);
2723       }
2724
2725       if (pvalue->m.supportedPrefixesPresent) {
2726          initContext (&lctxt);
2727          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2728          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2729
2730          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
2731          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2732
2733          stat = encodeByteAlign (&lctxt);
2734          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2735
2736          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2737
2738          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2739          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2740
2741          freeContext (&lctxt);
2742       }
2743
2744    }
2745
2746    return (stat);
2747 }
2748
2749 /**************************************************************/
2750 /*                                                            */
2751 /*  H321Caps                                                  */
2752 /*                                                            */
2753 /**************************************************************/
2754
2755 EXTERN int asn1PE_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue)
2756 {
2757    int stat = ASN_OK;
2758    ASN1BOOL extbit;
2759    ASN1OpenType openType;
2760    OOCTXT lctxt;
2761
2762    /* extension bit */
2763
2764    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
2765    pvalue->m.supportedPrefixesPresent);
2766
2767    encodeBit (pctxt, extbit);
2768
2769    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2770
2771    /* encode nonStandardData */
2772
2773    if (pvalue->m.nonStandardDataPresent) {
2774       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2775       if (stat != ASN_OK) return stat;
2776    }
2777
2778    if (extbit) {
2779
2780       /* encode extension optional bits length */
2781
2782       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
2783       if (stat != ASN_OK) return stat;
2784
2785       /* encode optional bits */
2786
2787       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
2788       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
2789       /* encode extension elements */
2790
2791       if (pvalue->m.dataRatesSupportedPresent) {
2792          initContext (&lctxt);
2793          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2794          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2795
2796          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
2797          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2798
2799          stat = encodeByteAlign (&lctxt);
2800          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2801
2802          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2803
2804          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2805          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2806
2807          freeContext (&lctxt);
2808       }
2809
2810       if (pvalue->m.supportedPrefixesPresent) {
2811          initContext (&lctxt);
2812          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2813          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2814
2815          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
2816          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2817
2818          stat = encodeByteAlign (&lctxt);
2819          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2820
2821          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2822
2823          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2824          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2825
2826          freeContext (&lctxt);
2827       }
2828
2829    }
2830
2831    return (stat);
2832 }
2833
2834 /**************************************************************/
2835 /*                                                            */
2836 /*  H322Caps                                                  */
2837 /*                                                            */
2838 /**************************************************************/
2839
2840 EXTERN int asn1PE_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue)
2841 {
2842    int stat = ASN_OK;
2843    ASN1BOOL extbit;
2844    ASN1OpenType openType;
2845    OOCTXT lctxt;
2846
2847    /* extension bit */
2848
2849    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
2850    pvalue->m.supportedPrefixesPresent);
2851
2852    encodeBit (pctxt, extbit);
2853
2854    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2855
2856    /* encode nonStandardData */
2857
2858    if (pvalue->m.nonStandardDataPresent) {
2859       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2860       if (stat != ASN_OK) return stat;
2861    }
2862
2863    if (extbit) {
2864
2865       /* encode extension optional bits length */
2866
2867       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
2868       if (stat != ASN_OK) return stat;
2869
2870       /* encode optional bits */
2871
2872       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
2873       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
2874       /* encode extension elements */
2875
2876       if (pvalue->m.dataRatesSupportedPresent) {
2877          initContext (&lctxt);
2878          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2879          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2880
2881          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
2882          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2883
2884          stat = encodeByteAlign (&lctxt);
2885          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2886
2887          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2888
2889          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2890          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2891
2892          freeContext (&lctxt);
2893       }
2894
2895       if (pvalue->m.supportedPrefixesPresent) {
2896          initContext (&lctxt);
2897          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2898          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2899
2900          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
2901          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2902
2903          stat = encodeByteAlign (&lctxt);
2904          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2905
2906          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2907
2908          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2909          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2910
2911          freeContext (&lctxt);
2912       }
2913
2914    }
2915
2916    return (stat);
2917 }
2918
2919 /**************************************************************/
2920 /*                                                            */
2921 /*  H323Caps                                                  */
2922 /*                                                            */
2923 /**************************************************************/
2924
2925 EXTERN int asn1PE_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue)
2926 {
2927    int stat = ASN_OK;
2928    ASN1BOOL extbit;
2929    ASN1OpenType openType;
2930    OOCTXT lctxt;
2931
2932    /* extension bit */
2933
2934    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
2935    pvalue->m.supportedPrefixesPresent);
2936
2937    encodeBit (pctxt, extbit);
2938
2939    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
2940
2941    /* encode nonStandardData */
2942
2943    if (pvalue->m.nonStandardDataPresent) {
2944       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
2945       if (stat != ASN_OK) return stat;
2946    }
2947
2948    if (extbit) {
2949
2950       /* encode extension optional bits length */
2951
2952       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
2953       if (stat != ASN_OK) return stat;
2954
2955       /* encode optional bits */
2956
2957       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
2958       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
2959       /* encode extension elements */
2960
2961       if (pvalue->m.dataRatesSupportedPresent) {
2962          initContext (&lctxt);
2963          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2964          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2965
2966          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
2967          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2968
2969          stat = encodeByteAlign (&lctxt);
2970          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2971
2972          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2973
2974          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2975          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2976
2977          freeContext (&lctxt);
2978       }
2979
2980       if (pvalue->m.supportedPrefixesPresent) {
2981          initContext (&lctxt);
2982          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
2983          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2984
2985          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
2986          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2987
2988          stat = encodeByteAlign (&lctxt);
2989          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2990
2991          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
2992
2993          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
2994          if (stat != ASN_OK) return freeContext (&lctxt), stat;
2995
2996          freeContext (&lctxt);
2997       }
2998
2999    }
3000
3001    return (stat);
3002 }
3003
3004 /**************************************************************/
3005 /*                                                            */
3006 /*  H324Caps                                                  */
3007 /*                                                            */
3008 /**************************************************************/
3009
3010 EXTERN int asn1PE_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue)
3011 {
3012    int stat = ASN_OK;
3013    ASN1BOOL extbit;
3014    ASN1OpenType openType;
3015    OOCTXT lctxt;
3016
3017    /* extension bit */
3018
3019    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
3020    pvalue->m.supportedPrefixesPresent);
3021
3022    encodeBit (pctxt, extbit);
3023
3024    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3025
3026    /* encode nonStandardData */
3027
3028    if (pvalue->m.nonStandardDataPresent) {
3029       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3030       if (stat != ASN_OK) return stat;
3031    }
3032
3033    if (extbit) {
3034
3035       /* encode extension optional bits length */
3036
3037       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
3038       if (stat != ASN_OK) return stat;
3039
3040       /* encode optional bits */
3041
3042       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
3043       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
3044       /* encode extension elements */
3045
3046       if (pvalue->m.dataRatesSupportedPresent) {
3047          initContext (&lctxt);
3048          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3049          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3050
3051          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
3052          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3053
3054          stat = encodeByteAlign (&lctxt);
3055          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3056
3057          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3058
3059          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3060          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3061
3062          freeContext (&lctxt);
3063       }
3064
3065       if (pvalue->m.supportedPrefixesPresent) {
3066          initContext (&lctxt);
3067          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3068          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3069
3070          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
3071          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3072
3073          stat = encodeByteAlign (&lctxt);
3074          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3075
3076          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3077
3078          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3079          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3080
3081          freeContext (&lctxt);
3082       }
3083
3084    }
3085
3086    return (stat);
3087 }
3088
3089 /**************************************************************/
3090 /*                                                            */
3091 /*  VoiceCaps                                                 */
3092 /*                                                            */
3093 /**************************************************************/
3094
3095 EXTERN int asn1PE_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue)
3096 {
3097    int stat = ASN_OK;
3098    ASN1BOOL extbit;
3099    ASN1OpenType openType;
3100    OOCTXT lctxt;
3101
3102    /* extension bit */
3103
3104    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
3105    pvalue->m.supportedPrefixesPresent);
3106
3107    encodeBit (pctxt, extbit);
3108
3109    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3110
3111    /* encode nonStandardData */
3112
3113    if (pvalue->m.nonStandardDataPresent) {
3114       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3115       if (stat != ASN_OK) return stat;
3116    }
3117
3118    if (extbit) {
3119
3120       /* encode extension optional bits length */
3121
3122       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
3123       if (stat != ASN_OK) return stat;
3124
3125       /* encode optional bits */
3126
3127       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
3128       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
3129       /* encode extension elements */
3130
3131       if (pvalue->m.dataRatesSupportedPresent) {
3132          initContext (&lctxt);
3133          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3134          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3135
3136          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
3137          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3138
3139          stat = encodeByteAlign (&lctxt);
3140          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3141
3142          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3143
3144          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3145          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3146
3147          freeContext (&lctxt);
3148       }
3149
3150       if (pvalue->m.supportedPrefixesPresent) {
3151          initContext (&lctxt);
3152          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3153          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3154
3155          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
3156          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3157
3158          stat = encodeByteAlign (&lctxt);
3159          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3160
3161          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3162
3163          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3164          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3165
3166          freeContext (&lctxt);
3167       }
3168
3169    }
3170
3171    return (stat);
3172 }
3173
3174 /**************************************************************/
3175 /*                                                            */
3176 /*  T120OnlyCaps                                              */
3177 /*                                                            */
3178 /**************************************************************/
3179
3180 EXTERN int asn1PE_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue)
3181 {
3182    int stat = ASN_OK;
3183    ASN1BOOL extbit;
3184    ASN1OpenType openType;
3185    OOCTXT lctxt;
3186
3187    /* extension bit */
3188
3189    extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent ||
3190    pvalue->m.supportedPrefixesPresent);
3191
3192    encodeBit (pctxt, extbit);
3193
3194    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3195
3196    /* encode nonStandardData */
3197
3198    if (pvalue->m.nonStandardDataPresent) {
3199       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3200       if (stat != ASN_OK) return stat;
3201    }
3202
3203    if (extbit) {
3204
3205       /* encode extension optional bits length */
3206
3207       stat = encodeSmallNonNegWholeNumber (pctxt, 1);
3208       if (stat != ASN_OK) return stat;
3209
3210       /* encode optional bits */
3211
3212       encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
3213       encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
3214       /* encode extension elements */
3215
3216       if (pvalue->m.dataRatesSupportedPresent) {
3217          initContext (&lctxt);
3218          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3219          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3220
3221          stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported);
3222          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3223
3224          stat = encodeByteAlign (&lctxt);
3225          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3226
3227          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3228
3229          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3230          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3231
3232          freeContext (&lctxt);
3233       }
3234
3235       if (pvalue->m.supportedPrefixesPresent) {
3236          initContext (&lctxt);
3237          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3238          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3239
3240          stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes);
3241          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3242
3243          stat = encodeByteAlign (&lctxt);
3244          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3245
3246          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3247
3248          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3249          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3250
3251          freeContext (&lctxt);
3252       }
3253
3254    }
3255
3256    return (stat);
3257 }
3258
3259 /**************************************************************/
3260 /*                                                            */
3261 /*  NonStandardProtocol                                       */
3262 /*                                                            */
3263 /**************************************************************/
3264
3265 EXTERN int asn1PE_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue)
3266 {
3267    int stat = ASN_OK;
3268    ASN1BOOL extbit;
3269
3270    /* extension bit */
3271
3272    extbit = 0;
3273
3274    encodeBit (pctxt, extbit);
3275
3276    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3277
3278    encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
3279
3280    /* encode nonStandardData */
3281
3282    if (pvalue->m.nonStandardDataPresent) {
3283       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3284       if (stat != ASN_OK) return stat;
3285    }
3286
3287    /* encode dataRatesSupported */
3288
3289    if (pvalue->m.dataRatesSupportedPresent) {
3290       stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
3291       if (stat != ASN_OK) return stat;
3292    }
3293
3294    /* encode supportedPrefixes */
3295
3296    stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
3297    if (stat != ASN_OK) return stat;
3298
3299    return (stat);
3300 }
3301
3302 /**************************************************************/
3303 /*                                                            */
3304 /*  T38FaxAnnexbOnlyCaps                                      */
3305 /*                                                            */
3306 /**************************************************************/
3307
3308 EXTERN int asn1PE_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue)
3309 {
3310    int stat = ASN_OK;
3311    ASN1BOOL extbit;
3312
3313    /* extension bit */
3314
3315    extbit = 0;
3316
3317    encodeBit (pctxt, extbit);
3318
3319    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3320
3321    encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
3322
3323    /* encode nonStandardData */
3324
3325    if (pvalue->m.nonStandardDataPresent) {
3326       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3327       if (stat != ASN_OK) return stat;
3328    }
3329
3330    /* encode dataRatesSupported */
3331
3332    if (pvalue->m.dataRatesSupportedPresent) {
3333       stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
3334       if (stat != ASN_OK) return stat;
3335    }
3336
3337    /* encode supportedPrefixes */
3338
3339    stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
3340    if (stat != ASN_OK) return stat;
3341
3342    /* encode t38FaxProtocol */
3343
3344    stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
3345    if (stat != ASN_OK) return stat;
3346
3347    /* encode t38FaxProfile */
3348
3349    stat = asn1PE_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
3350    if (stat != ASN_OK) return stat;
3351
3352    return (stat);
3353 }
3354
3355 /**************************************************************/
3356 /*                                                            */
3357 /*  SIPCaps                                                   */
3358 /*                                                            */
3359 /**************************************************************/
3360
3361 EXTERN int asn1PE_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue)
3362 {
3363    int stat = ASN_OK;
3364    ASN1BOOL extbit;
3365
3366    /* extension bit */
3367
3368    extbit = 0;
3369
3370    encodeBit (pctxt, extbit);
3371
3372    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3373
3374    encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent);
3375
3376    encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent);
3377
3378    /* encode nonStandardData */
3379
3380    if (pvalue->m.nonStandardDataPresent) {
3381       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3382       if (stat != ASN_OK) return stat;
3383    }
3384
3385    /* encode dataRatesSupported */
3386
3387    if (pvalue->m.dataRatesSupportedPresent) {
3388       stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
3389       if (stat != ASN_OK) return stat;
3390    }
3391
3392    /* encode supportedPrefixes */
3393
3394    if (pvalue->m.supportedPrefixesPresent) {
3395       stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
3396       if (stat != ASN_OK) return stat;
3397    }
3398
3399    return (stat);
3400 }
3401
3402 /**************************************************************/
3403 /*                                                            */
3404 /*  SupportedProtocols                                        */
3405 /*                                                            */
3406 /**************************************************************/
3407
3408 EXTERN int asn1PE_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue)
3409 {
3410    int stat = ASN_OK;
3411    OOCTXT lctxt;
3412    ASN1OpenType openType;
3413    ASN1BOOL extbit;
3414
3415    /* extension bit */
3416
3417    extbit = (ASN1BOOL)(pvalue->t > 9);
3418
3419    encodeBit (pctxt, extbit);
3420
3421    if (!extbit) {
3422
3423       /* Encode choice index value */
3424
3425       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 8);
3426       if (stat != ASN_OK) return stat;
3427
3428       /* Encode root element data value */
3429
3430       switch (pvalue->t)
3431       {
3432          /* nonStandardData */
3433          case 1:
3434             stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandardData);
3435             if (stat != ASN_OK) return stat;
3436             break;
3437
3438          /* h310 */
3439          case 2:
3440             stat = asn1PE_H225H310Caps (pctxt, pvalue->u.h310);
3441             if (stat != ASN_OK) return stat;
3442             break;
3443
3444          /* h320 */
3445          case 3:
3446             stat = asn1PE_H225H320Caps (pctxt, pvalue->u.h320);
3447             if (stat != ASN_OK) return stat;
3448             break;
3449
3450          /* h321 */
3451          case 4:
3452             stat = asn1PE_H225H321Caps (pctxt, pvalue->u.h321);
3453             if (stat != ASN_OK) return stat;
3454             break;
3455
3456          /* h322 */
3457          case 5:
3458             stat = asn1PE_H225H322Caps (pctxt, pvalue->u.h322);
3459             if (stat != ASN_OK) return stat;
3460             break;
3461
3462          /* h323 */
3463          case 6:
3464             stat = asn1PE_H225H323Caps (pctxt, pvalue->u.h323);
3465             if (stat != ASN_OK) return stat;
3466             break;
3467
3468          /* h324 */
3469          case 7:
3470             stat = asn1PE_H225H324Caps (pctxt, pvalue->u.h324);
3471             if (stat != ASN_OK) return stat;
3472             break;
3473
3474          /* voice */
3475          case 8:
3476             stat = asn1PE_H225VoiceCaps (pctxt, pvalue->u.voice);
3477             if (stat != ASN_OK) return stat;
3478             break;
3479
3480          /* t120_only */
3481          case 9:
3482             stat = asn1PE_H225T120OnlyCaps (pctxt, pvalue->u.t120_only);
3483             if (stat != ASN_OK) return stat;
3484             break;
3485
3486          default:
3487             return ASN_E_INVOPT;
3488       }
3489    }
3490    else {
3491       /* Encode extension choice index value */
3492
3493       stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 10);
3494       if (stat != ASN_OK) return stat;
3495
3496       /* Encode extension element data value */
3497
3498       initContext (&lctxt);
3499       stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3500       if (stat != ASN_OK) return freeContext (&lctxt), stat;
3501
3502       switch (pvalue->t)
3503       {
3504          /* nonStandardProtocol */
3505          case 10:
3506             stat = asn1PE_H225NonStandardProtocol (&lctxt, pvalue->u.nonStandardProtocol);
3507             if (stat != ASN_OK) return freeContext (&lctxt), stat;
3508             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3509             break;
3510
3511          /* t38FaxAnnexbOnly */
3512          case 11:
3513             stat = asn1PE_H225T38FaxAnnexbOnlyCaps (&lctxt, pvalue->u.t38FaxAnnexbOnly);
3514             if (stat != ASN_OK) return freeContext (&lctxt), stat;
3515             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3516             break;
3517
3518          /* sip */
3519          case 12:
3520             stat = asn1PE_H225SIPCaps (&lctxt, pvalue->u.sip);
3521             if (stat != ASN_OK) return freeContext (&lctxt), stat;
3522             openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3523             break;
3524
3525          default:
3526             ;
3527       }
3528
3529       stat = encodeByteAlign (pctxt);
3530       if (stat != ASN_OK) return freeContext (&lctxt), stat;
3531
3532       stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3533       if (stat != ASN_OK) return freeContext (&lctxt), stat;
3534
3535       freeContext (&lctxt);
3536    }
3537
3538    return (stat);
3539 }
3540
3541 /**************************************************************/
3542 /*                                                            */
3543 /*  _SeqOfH225SupportedProtocols                              */
3544 /*                                                            */
3545 /**************************************************************/
3546
3547 EXTERN int asn1PE_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue)
3548 {
3549    int stat = ASN_OK;
3550    DListNode* pnode;
3551    ASN1UINT xx1;
3552    ASN1UINT enclen, fraglen;
3553
3554    enclen = fraglen = xx1 = 0;
3555    pnode = pvalue->head;
3556    for (;;) {
3557       /* encode length determinant */
3558
3559       stat = encodeLength (pctxt, (pvalue->count - enclen));
3560       if (stat < 0) return stat;
3561
3562       fraglen = stat;
3563       enclen += fraglen;
3564       /* encode elements */
3565
3566       for (; xx1 < enclen; xx1++) {
3567          stat = asn1PE_H225SupportedProtocols (pctxt, ((H225SupportedProtocols*)pnode->data));
3568          if (stat != ASN_OK) return stat;
3569          pnode = pnode->next;
3570       }
3571       if ( pvalue->count == enclen && fraglen < 16384) {
3572          break;
3573       }
3574    }
3575
3576    return (stat);
3577 }
3578
3579 /**************************************************************/
3580 /*                                                            */
3581 /*  GatewayInfo                                               */
3582 /*                                                            */
3583 /**************************************************************/
3584
3585 EXTERN int asn1PE_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue)
3586 {
3587    int stat = ASN_OK;
3588    ASN1BOOL extbit;
3589
3590    /* extension bit */
3591
3592    extbit = 0;
3593
3594    encodeBit (pctxt, extbit);
3595
3596    encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolPresent);
3597
3598    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3599
3600    /* encode protocol */
3601
3602    if (pvalue->m.protocolPresent) {
3603       stat = asn1PE_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocol);
3604       if (stat != ASN_OK) return stat;
3605    }
3606
3607    /* encode nonStandardData */
3608
3609    if (pvalue->m.nonStandardDataPresent) {
3610       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3611       if (stat != ASN_OK) return stat;
3612    }
3613
3614    return (stat);
3615 }
3616
3617 /**************************************************************/
3618 /*                                                            */
3619 /*  McuInfo                                                   */
3620 /*                                                            */
3621 /**************************************************************/
3622
3623 EXTERN int asn1PE_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue)
3624 {
3625    int stat = ASN_OK;
3626    ASN1BOOL extbit;
3627    ASN1OpenType openType;
3628    OOCTXT lctxt;
3629
3630    /* extension bit */
3631
3632    extbit = (ASN1BOOL)(pvalue->m.protocolPresent);
3633
3634    encodeBit (pctxt, extbit);
3635
3636    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3637
3638    /* encode nonStandardData */
3639
3640    if (pvalue->m.nonStandardDataPresent) {
3641       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3642       if (stat != ASN_OK) return stat;
3643    }
3644
3645    if (extbit) {
3646
3647       /* encode extension optional bits length */
3648
3649       stat = encodeSmallNonNegWholeNumber (pctxt, 0);
3650       if (stat != ASN_OK) return stat;
3651
3652       /* encode optional bits */
3653
3654       encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolPresent);
3655       /* encode extension elements */
3656
3657       if (pvalue->m.protocolPresent) {
3658          initContext (&lctxt);
3659          stat = setPERBuffer (&lctxt, 0, 0, TRUE);
3660          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3661
3662          stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->protocol);
3663          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3664
3665          stat = encodeByteAlign (&lctxt);
3666          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3667
3668          openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);
3669
3670          stat = encodeOpenType (pctxt, openType.numocts, openType.data);
3671          if (stat != ASN_OK) return freeContext (&lctxt), stat;
3672
3673          freeContext (&lctxt);
3674       }
3675
3676    }
3677
3678    return (stat);
3679 }
3680
3681 /**************************************************************/
3682 /*                                                            */
3683 /*  TerminalInfo                                              */
3684 /*                                                            */
3685 /**************************************************************/
3686
3687 EXTERN int asn1PE_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue)
3688 {
3689    int stat = ASN_OK;
3690    ASN1BOOL extbit;
3691
3692    /* extension bit */
3693
3694    extbit = 0;
3695
3696    encodeBit (pctxt, extbit);
3697
3698    encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent);
3699
3700    /* encode nonStandardData */
3701
3702    if (pvalue->m.nonStandardDataPresent) {
3703       stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
3704       if (stat != ASN_OK) return stat;
3705    }
3706
3707    return (stat);
3708 }
3709
3710 /**************************************************************/
3711 /*                                                            */
3712 /*  TunnelledProtocolAlternateIdentifier                      */
3713 /*                                                            */
3714 /**************************************************************/
3715
3716 EXTERN int asn1PE_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue)
3717 {
3718    static Asn1SizeCnst protocolType_lsize1 = { 0, 1, 64, 0 };
3719    static Asn1SizeCnst protocolVariant_lsize1 = { 0, 1, 64, 0 };
3720    int stat = ASN_OK;
3721    ASN1BOOL extbit;
3722
3723    /* extension bit */
3724
3725    extbit = 0;
3726
3727    encodeBit (pctxt, extbit);
3728
3729    encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolVariantPresent);
3730
3731    /* encode protocolType */
3732
3733    addSizeConstraint (pctxt, &protocolType_lsize1);
3734
3735    stat = encodeConstrainedStringEx (pctxt, pvalue->protocolType, 0, 8, 7, 7);
3736    if (stat != ASN_OK) return stat;
3737
3738    /* encode protocolVariant */
3739
3740    if (pvalue->m.protocolVariantPresent) {
3741       addSizeConstraint (pctxt, &protocolVariant_lsize1);
3742
3743       stat = encodeConstrainedStringEx (pctxt, pvalue->protocolVariant, 0, 8, 7, 7);
3744       if (stat != ASN_OK) return stat;
3745    }
3746
3747    return (stat);
3748 }
3749
3750 /**************************************************************/
3751 /*                                                            */
3752 /*  TunnelledProtocol_id                                      */
3753 /*                                                            */
3754 /**************************************************************/
3755
3756 EXTERN int asn1PE_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue)
3757 {
3758    int stat = ASN_OK;
3759    ASN1BOOL extbit;
3760
3761    /* extension bit */
3762
3763    extbit = (ASN1BOOL)(pvalue->t > 2);
3764
3765    encodeBit (pctxt, extbit);
3766
3767    if (!extbit) {
3768
3769       /* Encode choice index value */
3770
3771       stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
3772       if (stat != ASN_OK) return stat;
3773
3774       /* Encode root element data value */
3775
3776       switch (pvalue->t)
3777       {
3778          /* tunnelledProtocolObjectID */
3779          case 1:
3780             stat = encodeObjectIdentifier (pctxt, pvalue->u.tunnelledProtocolObjectID);
3781             if (stat != ASN_OK) return stat;
3782             break;
3783
3784          /* tunnelledProtocolAlternateID */
3785          case 2:
3786             stat = asn1PE_H225TunnelledProtocolAlternateIdentifier (pctxt, pvalue->u.tunnelledProtocolAlternateID);
3787             if (stat != ASN_OK) return stat;
3788             break;
3789
3790          default: