Fix warning of Coverity Static analysis, change H225ProtocolIdentifier
[asterisk/asterisk.git] / addons / ooh323c / src / h323 / H323-MESSAGESDec.c
1 /*
2  * Copyright (C) 2004-2005 by Objective Systems, Inc.
3  *
4  * This software is furnished under an open source license and may be 
5  * used and copied only in accordance with the terms of this license. 
6  * The text of the license may generally be found in the root 
7  * directory of this installation in the COPYING file.  It 
8  * can also be viewed online at the following URL:
9  *
10  *   http://www.obj-sys.com/open/license.html
11  *
12  * Any redistributions of this file including modified versions must 
13  * maintain this copyright notice.
14  *
15  *****************************************************************************/
16
17 #include "ooasn1.h"
18 #include "H323-MESSAGES.h"
19 #include "eventHandler.h"
20
21 /**************************************************************/
22 /*                                                            */
23 /*  ScreeningIndicator                                        */
24 /*                                                            */
25 /**************************************************************/
26
27 EXTERN int asn1PD_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator* pvalue)
28 {
29    int stat = ASN_OK;
30    ASN1UINT ui;
31    ASN1BOOL extbit = 0;
32
33    /* extension bit */
34
35    DECODEBIT (pctxt, &extbit);
36
37    if (extbit) {
38       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
39       if (stat != ASN_OK) return stat;
40
41       *pvalue = ui;
42    }
43    else {
44       stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
45       if (stat != ASN_OK) return stat;
46
47       switch (ui) {
48          case 0: *pvalue = userProvidedNotScreened; break;
49          case 1: *pvalue = userProvidedVerifiedAndPassed; break;
50          case 2: *pvalue = userProvidedVerifiedAndFailed; break;
51          case 3: *pvalue = networkProvided; break;
52          default: return ASN_E_INVENUM;
53       }
54    }
55    invokeUIntValue (pctxt, *pvalue);
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 asn1PD_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits* pvalue)
69 {
70    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
71    int stat = ASN_OK;
72
73    addSizeConstraint (pctxt, &lsize1);
74
75    stat = decodeConstrainedStringEx (pctxt, pvalue, gs_H323_MESSAGES_NumberDigits_CharSet, 4, 4, 7);
76    if (stat != ASN_OK) return stat;
77    invokeCharStrValue (pctxt, *pvalue);
78
79    return (stat);
80 }
81
82 /**************************************************************/
83 /*                                                            */
84 /*  TBCD_STRING                                               */
85 /*                                                            */
86 /**************************************************************/
87
88 extern EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet;
89
90 EXTERN int asn1PD_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING* pvalue)
91 {
92    int stat = ASN_OK;
93
94    stat = decodeConstrainedStringEx (pctxt, pvalue, gs_H323_MESSAGES_TBCD_STRING_CharSet, 4, 4, 7);
95    if (stat != ASN_OK) return stat;
96    invokeCharStrValue (pctxt, *pvalue);
97
98    return (stat);
99 }
100
101 /**************************************************************/
102 /*                                                            */
103 /*  GloballyUniqueID                                          */
104 /*                                                            */
105 /**************************************************************/
106
107 EXTERN int asn1PD_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue)
108 {
109    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
110    int stat = ASN_OK;
111
112    addSizeConstraint (pctxt, &lsize1);
113
114    stat = decodeOctetString (pctxt,
115                           &pvalue->numocts,
116                           pvalue->data,
117                           sizeof(pvalue->data));
118    if (stat != ASN_OK) return stat;
119    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
120
121    return (stat);
122 }
123
124 /**************************************************************/
125 /*                                                            */
126 /*  ConferenceIdentifier                                      */
127 /*                                                            */
128 /**************************************************************/
129
130 EXTERN int asn1PD_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue)
131 {
132    int stat = ASN_OK;
133
134    stat = asn1PD_H225GloballyUniqueID (pctxt, pvalue);
135    if (stat != ASN_OK) return stat;
136
137    return (stat);
138 }
139
140 /**************************************************************/
141 /*                                                            */
142 /*  RequestSeqNum                                             */
143 /*                                                            */
144 /**************************************************************/
145
146 EXTERN int asn1PD_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum* pvalue)
147 {
148    int stat = ASN_OK;
149
150    stat = decodeConsUInt16 (pctxt, pvalue, 1U, 65535U);
151    if (stat != ASN_OK) return stat;
152    invokeUIntValue (pctxt, *pvalue);
153
154    return (stat);
155 }
156
157 /**************************************************************/
158 /*                                                            */
159 /*  GatekeeperIdentifier                                      */
160 /*                                                            */
161 /**************************************************************/
162
163 EXTERN int asn1PD_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier* pvalue)
164 {
165    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
166    int stat = ASN_OK;
167
168    addSizeConstraint (pctxt, &lsize1);
169
170    stat = decodeBMPString (pctxt, pvalue, 0);
171    if (stat != ASN_OK) return stat;
172    invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
173
174    return (stat);
175 }
176
177 /**************************************************************/
178 /*                                                            */
179 /*  BandWidth                                                 */
180 /*                                                            */
181 /**************************************************************/
182
183 EXTERN int asn1PD_H225BandWidth (OOCTXT* pctxt, H225BandWidth* pvalue)
184 {
185    int stat = ASN_OK;
186
187    stat = decodeConsUnsigned (pctxt, pvalue, 0U, ASN1UINT_MAX);
188    if (stat != ASN_OK) return stat;
189    invokeUIntValue (pctxt, *pvalue);
190
191    return (stat);
192 }
193
194 /**************************************************************/
195 /*                                                            */
196 /*  CallReferenceValue                                        */
197 /*                                                            */
198 /**************************************************************/
199
200 EXTERN int asn1PD_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue* pvalue)
201 {
202    int stat = ASN_OK;
203
204    stat = decodeConsUInt16 (pctxt, pvalue, 0U, 65535U);
205    if (stat != ASN_OK) return stat;
206    invokeUIntValue (pctxt, *pvalue);
207
208    return (stat);
209 }
210
211 /**************************************************************/
212 /*                                                            */
213 /*  EndpointIdentifier                                        */
214 /*                                                            */
215 /**************************************************************/
216
217 EXTERN int asn1PD_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier* pvalue)
218 {
219    static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
220    int stat = ASN_OK;
221
222    addSizeConstraint (pctxt, &lsize1);
223
224    stat = decodeBMPString (pctxt, pvalue, 0);
225    if (stat != ASN_OK) return stat;
226    invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
227
228    return (stat);
229 }
230
231 /**************************************************************/
232 /*                                                            */
233 /*  ProtocolIdentifier                                        */
234 /*                                                            */
235 /**************************************************************/
236
237 EXTERN int asn1PD_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier* pvalue)
238 {
239    int stat = ASN_OK;
240
241    stat = decodeObjectIdentifier (pctxt, pvalue);
242    if (stat != ASN_OK) return stat;
243    invokeOidValue (pctxt, pvalue->numids, pvalue->subid);
244
245    return (stat);
246 }
247
248 /**************************************************************/
249 /*                                                            */
250 /*  TimeToLive                                                */
251 /*                                                            */
252 /**************************************************************/
253
254 EXTERN int asn1PD_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive* pvalue)
255 {
256    int stat = ASN_OK;
257
258    stat = decodeConsUnsigned (pctxt, pvalue, 1U, ASN1UINT_MAX);
259    if (stat != ASN_OK) return stat;
260    invokeUIntValue (pctxt, *pvalue);
261
262    return (stat);
263 }
264
265 /**************************************************************/
266 /*                                                            */
267 /*  H248PackagesDescriptor                                    */
268 /*                                                            */
269 /**************************************************************/
270
271 EXTERN int asn1PD_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor* pvalue)
272 {
273    int stat = ASN_OK;
274
275    stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue);
276    if (stat != ASN_OK) return stat;
277    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
278
279    return (stat);
280 }
281
282 /**************************************************************/
283 /*                                                            */
284 /*  H248SignalsDescriptor                                     */
285 /*                                                            */
286 /**************************************************************/
287
288 EXTERN int asn1PD_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor* pvalue)
289 {
290    int stat = ASN_OK;
291
292    stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue);
293    if (stat != ASN_OK) return stat;
294    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
295
296    return (stat);
297 }
298
299 /**************************************************************/
300 /*                                                            */
301 /*  GenericIdentifier                                         */
302 /*                                                            */
303 /**************************************************************/
304
305 EXTERN int asn1PD_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue)
306 {
307    int stat = ASN_OK;
308    ASN1UINT ui;
309    ASN1OpenType openType;
310    ASN1BOOL extbit = 0;
311
312    /* extension bit */
313
314    DECODEBIT (pctxt, &extbit);
315
316    if (!extbit) {
317       stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
318       if (stat != ASN_OK) return stat;
319       else pvalue->t = ui + 1;
320
321       switch (ui) {
322          /* standard */
323          case 0:
324             invokeStartElement (pctxt, "standard", -1);
325
326             /* extension bit */
327
328             DECODEBIT (pctxt, &extbit);
329
330             if (extbit == 0) {
331                stat = decodeConsInteger (pctxt, &pvalue->u.standard, 0, 16383);
332                if (stat != ASN_OK) return stat;
333             }
334             else {
335                stat = decodeUnconsInteger (pctxt, &pvalue->u.standard);
336                if (stat != ASN_OK) return stat;
337             }
338             invokeIntValue (pctxt, pvalue->u.standard);
339
340             invokeEndElement (pctxt, "standard", -1);
341
342             break;
343
344          /* oid */
345          case 1:
346             invokeStartElement (pctxt, "oid", -1);
347
348             pvalue->u.oid = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
349
350             stat = decodeObjectIdentifier (pctxt, pvalue->u.oid);
351             if (stat != ASN_OK) return stat;
352             invokeOidValue (pctxt, pvalue->u.oid->numids, pvalue->u.oid->subid);
353
354             invokeEndElement (pctxt, "oid", -1);
355
356             break;
357
358          /* nonStandard */
359          case 2:
360             invokeStartElement (pctxt, "nonStandard", -1);
361
362             pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225GloballyUniqueID);
363
364             stat = asn1PD_H225GloballyUniqueID (pctxt, pvalue->u.nonStandard);
365             if (stat != ASN_OK) return stat;
366
367             invokeEndElement (pctxt, "nonStandard", -1);
368
369             break;
370
371          default:
372             return ASN_E_INVOPT;
373       }
374    }
375    else {
376       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
377       if (stat != ASN_OK) return stat;
378       else pvalue->t = ui + 4;
379
380       stat = decodeByteAlign (pctxt);
381       if (stat != ASN_OK) return stat;
382
383       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
384       if (stat != ASN_OK) return stat;
385
386    }
387
388    return (stat);
389 }
390
391 /**************************************************************/
392 /*                                                            */
393 /*  TransportAddress_ipAddress_ip                             */
394 /*                                                            */
395 /**************************************************************/
396
397 EXTERN int asn1PD_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue)
398 {
399    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
400    int stat = ASN_OK;
401
402    addSizeConstraint (pctxt, &lsize1);
403
404    stat = decodeOctetString (pctxt,
405                           &pvalue->numocts,
406                           pvalue->data,
407                           sizeof(pvalue->data));
408    if (stat != ASN_OK) return stat;
409    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
410
411    return (stat);
412 }
413
414 /**************************************************************/
415 /*                                                            */
416 /*  TransportAddress_ipAddress                                */
417 /*                                                            */
418 /**************************************************************/
419
420 EXTERN int asn1PD_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue)
421 {
422    int stat = ASN_OK;
423
424    /* decode ip */
425
426    invokeStartElement (pctxt, "ip", -1);
427
428    stat = asn1PD_H225TransportAddress_ipAddress_ip (pctxt, &pvalue->ip);
429    if (stat != ASN_OK) return stat;
430
431    invokeEndElement (pctxt, "ip", -1);
432
433    /* decode port */
434
435    invokeStartElement (pctxt, "port", -1);
436
437    stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
438    if (stat != ASN_OK) return stat;
439    invokeUIntValue (pctxt, pvalue->port);
440
441    invokeEndElement (pctxt, "port", -1);
442
443    return (stat);
444 }
445
446 /**************************************************************/
447 /*                                                            */
448 /*  TransportAddress_ipSourceRoute_ip                         */
449 /*                                                            */
450 /**************************************************************/
451
452 EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue)
453 {
454    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
455    int stat = ASN_OK;
456
457    addSizeConstraint (pctxt, &lsize1);
458
459    stat = decodeOctetString (pctxt,
460                           &pvalue->numocts,
461                           pvalue->data,
462                           sizeof(pvalue->data));
463    if (stat != ASN_OK) return stat;
464    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
465
466    return (stat);
467 }
468
469 /**************************************************************/
470 /*                                                            */
471 /*  TransportAddress_ipSourceRoute_route_element              */
472 /*                                                            */
473 /**************************************************************/
474
475 EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue)
476 {
477    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
478    int stat = ASN_OK;
479
480    addSizeConstraint (pctxt, &lsize1);
481
482    stat = decodeOctetString (pctxt,
483                           &pvalue->numocts,
484                           pvalue->data,
485                           sizeof(pvalue->data));
486    if (stat != ASN_OK) return stat;
487    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
488
489    return (stat);
490 }
491
492 /**************************************************************/
493 /*                                                            */
494 /*  _SeqOfH225TransportAddress_ipSourceRoute_route_element    */
495 /*                                                            */
496 /**************************************************************/
497
498 EXTERN int asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue)
499 {
500    int stat = ASN_OK;
501    ASN1UINT xx1;
502
503    /* decode length determinant */
504
505    stat = decodeLength (pctxt, &pvalue->n);
506    if (stat != ASN_OK) return stat;
507
508    /* decode elements */
509
510    ALLOC_ASN1ARRAY (pctxt, pvalue, H225TransportAddress_ipSourceRoute_route_element);
511
512    for (xx1 = 0; xx1 < pvalue->n; xx1++) {
513       invokeStartElement (pctxt, "elem", xx1);
514
515       stat = asn1PD_H225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->elem[xx1]);
516       if (stat != ASN_OK) return stat;
517       invokeEndElement (pctxt, "elem", xx1);
518
519    }
520
521    return (stat);
522 }
523
524 /**************************************************************/
525 /*                                                            */
526 /*  TransportAddress_ipSourceRoute_routing                    */
527 /*                                                            */
528 /**************************************************************/
529
530 EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue)
531 {
532    int stat = ASN_OK;
533    ASN1UINT ui;
534    ASN1OpenType openType;
535    ASN1BOOL extbit = 0;
536
537    /* extension bit */
538
539    DECODEBIT (pctxt, &extbit);
540
541    if (!extbit) {
542       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
543       if (stat != ASN_OK) return stat;
544       else pvalue->t = ui + 1;
545
546       switch (ui) {
547          /* strict */
548          case 0:
549             invokeStartElement (pctxt, "strict", -1);
550
551             /* NULL */
552             invokeNullValue (pctxt);
553
554             invokeEndElement (pctxt, "strict", -1);
555
556             break;
557
558          /* loose */
559          case 1:
560             invokeStartElement (pctxt, "loose", -1);
561
562             /* NULL */
563             invokeNullValue (pctxt);
564
565             invokeEndElement (pctxt, "loose", -1);
566
567             break;
568
569          default:
570             return ASN_E_INVOPT;
571       }
572    }
573    else {
574       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
575       if (stat != ASN_OK) return stat;
576       else pvalue->t = ui + 3;
577
578       stat = decodeByteAlign (pctxt);
579       if (stat != ASN_OK) return stat;
580
581       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
582       if (stat != ASN_OK) return stat;
583
584    }
585
586    return (stat);
587 }
588
589 /**************************************************************/
590 /*                                                            */
591 /*  TransportAddress_ipSourceRoute                            */
592 /*                                                            */
593 /**************************************************************/
594
595 EXTERN int asn1PD_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue)
596 {
597    int stat = ASN_OK;
598    OOCTXT lctxt;
599    ASN1OpenType openType;
600    ASN1UINT bitcnt;
601    ASN1UINT i;
602    ASN1BOOL optbit = 0;
603    ASN1BOOL extbit = 0;
604
605    /* extension bit */
606
607    DECODEBIT (pctxt, &extbit);
608
609    /* decode ip */
610
611    invokeStartElement (pctxt, "ip", -1);
612
613    stat = asn1PD_H225TransportAddress_ipSourceRoute_ip (pctxt, &pvalue->ip);
614    if (stat != ASN_OK) return stat;
615
616    invokeEndElement (pctxt, "ip", -1);
617
618    /* decode port */
619
620    invokeStartElement (pctxt, "port", -1);
621
622    stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
623    if (stat != ASN_OK) return stat;
624    invokeUIntValue (pctxt, pvalue->port);
625
626    invokeEndElement (pctxt, "port", -1);
627
628    /* decode route */
629
630    invokeStartElement (pctxt, "route", -1);
631
632    stat = asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->route);
633    if (stat != ASN_OK) return stat;
634
635    invokeEndElement (pctxt, "route", -1);
636
637    /* decode routing */
638
639    invokeStartElement (pctxt, "routing", -1);
640
641    stat = asn1PD_H225TransportAddress_ipSourceRoute_routing (pctxt, &pvalue->routing);
642    if (stat != ASN_OK) return stat;
643
644    invokeEndElement (pctxt, "routing", -1);
645
646    if (extbit) {
647
648       /* decode extension optional bits length */
649
650       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
651       if (stat != ASN_OK) return stat;
652
653       bitcnt += 1;
654
655       ZEROCONTEXT (&lctxt);
656       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
657       if (stat != ASN_OK) return stat;
658
659       stat = moveBitCursor (pctxt, bitcnt);
660       if (stat != ASN_OK) return stat;
661
662       for (i = 0; i < bitcnt; i++) {
663          DECODEBIT (&lctxt, &optbit);
664
665          if (optbit) {
666             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
667             if (stat != ASN_OK) return stat;
668
669             pctxt->buffer.byteIndex += openType.numocts;
670          }
671       }
672    }
673
674    return (stat);
675 }
676
677 /**************************************************************/
678 /*                                                            */
679 /*  TransportAddress_ipxAddress_node                          */
680 /*                                                            */
681 /**************************************************************/
682
683 EXTERN int asn1PD_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue)
684 {
685    static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 };
686    int stat = ASN_OK;
687
688    addSizeConstraint (pctxt, &lsize1);
689
690    stat = decodeOctetString (pctxt,
691                           &pvalue->numocts,
692                           pvalue->data,
693                           sizeof(pvalue->data));
694    if (stat != ASN_OK) return stat;
695    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
696
697    return (stat);
698 }
699
700 /**************************************************************/
701 /*                                                            */
702 /*  TransportAddress_ipxAddress_netnum                        */
703 /*                                                            */
704 /**************************************************************/
705
706 EXTERN int asn1PD_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue)
707 {
708    static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
709    int stat = ASN_OK;
710
711    addSizeConstraint (pctxt, &lsize1);
712
713    stat = decodeOctetString (pctxt,
714                           &pvalue->numocts,
715                           pvalue->data,
716                           sizeof(pvalue->data));
717    if (stat != ASN_OK) return stat;
718    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
719
720    return (stat);
721 }
722
723 /**************************************************************/
724 /*                                                            */
725 /*  TransportAddress_ipxAddress_port                          */
726 /*                                                            */
727 /**************************************************************/
728
729 EXTERN int asn1PD_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue)
730 {
731    static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 };
732    int stat = ASN_OK;
733
734    addSizeConstraint (pctxt, &lsize1);
735
736    stat = decodeOctetString (pctxt,
737                           &pvalue->numocts,
738                           pvalue->data,
739                           sizeof(pvalue->data));
740    if (stat != ASN_OK) return stat;
741    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
742
743    return (stat);
744 }
745
746 /**************************************************************/
747 /*                                                            */
748 /*  TransportAddress_ipxAddress                               */
749 /*                                                            */
750 /**************************************************************/
751
752 EXTERN int asn1PD_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue)
753 {
754    int stat = ASN_OK;
755
756    /* decode node */
757
758    invokeStartElement (pctxt, "node", -1);
759
760    stat = asn1PD_H225TransportAddress_ipxAddress_node (pctxt, &pvalue->node);
761    if (stat != ASN_OK) return stat;
762
763    invokeEndElement (pctxt, "node", -1);
764
765    /* decode netnum */
766
767    invokeStartElement (pctxt, "netnum", -1);
768
769    stat = asn1PD_H225TransportAddress_ipxAddress_netnum (pctxt, &pvalue->netnum);
770    if (stat != ASN_OK) return stat;
771
772    invokeEndElement (pctxt, "netnum", -1);
773
774    /* decode port */
775
776    invokeStartElement (pctxt, "port", -1);
777
778    stat = asn1PD_H225TransportAddress_ipxAddress_port (pctxt, &pvalue->port);
779    if (stat != ASN_OK) return stat;
780
781    invokeEndElement (pctxt, "port", -1);
782
783    return (stat);
784 }
785
786 /**************************************************************/
787 /*                                                            */
788 /*  TransportAddress_ip6Address_ip                            */
789 /*                                                            */
790 /**************************************************************/
791
792 EXTERN int asn1PD_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue)
793 {
794    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
795    int stat = ASN_OK;
796
797    addSizeConstraint (pctxt, &lsize1);
798
799    stat = decodeOctetString (pctxt,
800                           &pvalue->numocts,
801                           pvalue->data,
802                           sizeof(pvalue->data));
803    if (stat != ASN_OK) return stat;
804    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
805
806    return (stat);
807 }
808
809 /**************************************************************/
810 /*                                                            */
811 /*  TransportAddress_ip6Address                               */
812 /*                                                            */
813 /**************************************************************/
814
815 EXTERN int asn1PD_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue)
816 {
817    int stat = ASN_OK;
818    OOCTXT lctxt;
819    ASN1OpenType openType;
820    ASN1UINT bitcnt;
821    ASN1UINT i;
822    ASN1BOOL optbit = 0;
823    ASN1BOOL extbit = 0;
824
825    /* extension bit */
826
827    DECODEBIT (pctxt, &extbit);
828
829    /* decode ip */
830
831    invokeStartElement (pctxt, "ip", -1);
832
833    stat = asn1PD_H225TransportAddress_ip6Address_ip (pctxt, &pvalue->ip);
834    if (stat != ASN_OK) return stat;
835
836    invokeEndElement (pctxt, "ip", -1);
837
838    /* decode port */
839
840    invokeStartElement (pctxt, "port", -1);
841
842    stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
843    if (stat != ASN_OK) return stat;
844    invokeUIntValue (pctxt, pvalue->port);
845
846    invokeEndElement (pctxt, "port", -1);
847
848    if (extbit) {
849
850       /* decode extension optional bits length */
851
852       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
853       if (stat != ASN_OK) return stat;
854
855       bitcnt += 1;
856
857       ZEROCONTEXT (&lctxt);
858       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
859       if (stat != ASN_OK) return stat;
860
861       stat = moveBitCursor (pctxt, bitcnt);
862       if (stat != ASN_OK) return stat;
863
864       for (i = 0; i < bitcnt; i++) {
865          DECODEBIT (&lctxt, &optbit);
866
867          if (optbit) {
868             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
869             if (stat != ASN_OK) return stat;
870
871             pctxt->buffer.byteIndex += openType.numocts;
872          }
873       }
874    }
875
876    return (stat);
877 }
878
879 /**************************************************************/
880 /*                                                            */
881 /*  TransportAddress_netBios                                  */
882 /*                                                            */
883 /**************************************************************/
884
885 EXTERN int asn1PD_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue)
886 {
887    static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
888    int stat = ASN_OK;
889
890    addSizeConstraint (pctxt, &lsize1);
891
892    stat = decodeOctetString (pctxt,
893                           &pvalue->numocts,
894                           pvalue->data,
895                           sizeof(pvalue->data));
896    if (stat != ASN_OK) return stat;
897    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
898
899    return (stat);
900 }
901
902 /**************************************************************/
903 /*                                                            */
904 /*  TransportAddress_nsap                                     */
905 /*                                                            */
906 /**************************************************************/
907
908 EXTERN int asn1PD_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue)
909 {
910    static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
911    int stat = ASN_OK;
912
913    addSizeConstraint (pctxt, &lsize1);
914
915    stat = decodeOctetString (pctxt,
916                           &pvalue->numocts,
917                           pvalue->data,
918                           sizeof(pvalue->data));
919    if (stat != ASN_OK) return stat;
920    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
921
922    return (stat);
923 }
924
925 /**************************************************************/
926 /*                                                            */
927 /*  H221NonStandard                                           */
928 /*                                                            */
929 /**************************************************************/
930
931 EXTERN int asn1PD_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue)
932 {
933    int stat = ASN_OK;
934    OOCTXT lctxt;
935    ASN1OpenType openType;
936    ASN1UINT bitcnt;
937    ASN1UINT i;
938    ASN1BOOL optbit = 0;
939    ASN1BOOL extbit = 0;
940
941    /* extension bit */
942
943    DECODEBIT (pctxt, &extbit);
944
945    /* decode t35CountryCode */
946
947    invokeStartElement (pctxt, "t35CountryCode", -1);
948
949    stat = decodeConsUInt8 (pctxt, &pvalue->t35CountryCode, 0U, 255U);
950    if (stat != ASN_OK) return stat;
951    invokeUIntValue (pctxt, pvalue->t35CountryCode);
952
953    invokeEndElement (pctxt, "t35CountryCode", -1);
954
955    /* decode t35Extension */
956
957    invokeStartElement (pctxt, "t35Extension", -1);
958
959    stat = decodeConsUInt8 (pctxt, &pvalue->t35Extension, 0U, 255U);
960    if (stat != ASN_OK) return stat;
961    invokeUIntValue (pctxt, pvalue->t35Extension);
962
963    invokeEndElement (pctxt, "t35Extension", -1);
964
965    /* decode manufacturerCode */
966
967    invokeStartElement (pctxt, "manufacturerCode", -1);
968
969    stat = decodeConsUInt16 (pctxt, &pvalue->manufacturerCode, 0U, 65535U);
970    if (stat != ASN_OK) return stat;
971    invokeUIntValue (pctxt, pvalue->manufacturerCode);
972
973    invokeEndElement (pctxt, "manufacturerCode", -1);
974
975    if (extbit) {
976
977       /* decode extension optional bits length */
978
979       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
980       if (stat != ASN_OK) return stat;
981
982       bitcnt += 1;
983
984       ZEROCONTEXT (&lctxt);
985       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
986       if (stat != ASN_OK) return stat;
987
988       stat = moveBitCursor (pctxt, bitcnt);
989       if (stat != ASN_OK) return stat;
990
991       for (i = 0; i < bitcnt; i++) {
992          DECODEBIT (&lctxt, &optbit);
993
994          if (optbit) {
995             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
996             if (stat != ASN_OK) return stat;
997
998             pctxt->buffer.byteIndex += openType.numocts;
999          }
1000       }
1001    }
1002
1003    return (stat);
1004 }
1005
1006 /**************************************************************/
1007 /*                                                            */
1008 /*  NonStandardIdentifier                                     */
1009 /*                                                            */
1010 /**************************************************************/
1011
1012 EXTERN int asn1PD_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue)
1013 {
1014    int stat = ASN_OK;
1015    ASN1UINT ui;
1016    ASN1OpenType openType;
1017    ASN1BOOL extbit = 0;
1018
1019    /* extension bit */
1020
1021    DECODEBIT (pctxt, &extbit);
1022
1023    if (!extbit) {
1024       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
1025       if (stat != ASN_OK) return stat;
1026       else pvalue->t = ui + 1;
1027
1028       switch (ui) {
1029          /* object */
1030          case 0:
1031             invokeStartElement (pctxt, "object", -1);
1032
1033             pvalue->u.object = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
1034
1035             stat = decodeObjectIdentifier (pctxt, pvalue->u.object);
1036             if (stat != ASN_OK) return stat;
1037             invokeOidValue (pctxt, pvalue->u.object->numids, pvalue->u.object->subid);
1038
1039             invokeEndElement (pctxt, "object", -1);
1040
1041             break;
1042
1043          /* h221NonStandard */
1044          case 1:
1045             invokeStartElement (pctxt, "h221NonStandard", -1);
1046
1047             pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H225H221NonStandard);
1048
1049             stat = asn1PD_H225H221NonStandard (pctxt, pvalue->u.h221NonStandard);
1050             if (stat != ASN_OK) return stat;
1051
1052             invokeEndElement (pctxt, "h221NonStandard", -1);
1053
1054             break;
1055
1056          default:
1057             return ASN_E_INVOPT;
1058       }
1059    }
1060    else {
1061       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1062       if (stat != ASN_OK) return stat;
1063       else pvalue->t = ui + 3;
1064
1065       stat = decodeByteAlign (pctxt);
1066       if (stat != ASN_OK) return stat;
1067
1068       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1069       if (stat != ASN_OK) return stat;
1070
1071    }
1072
1073    return (stat);
1074 }
1075
1076 /**************************************************************/
1077 /*                                                            */
1078 /*  NonStandardParameter                                      */
1079 /*                                                            */
1080 /**************************************************************/
1081
1082 EXTERN int asn1PD_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue)
1083 {
1084    int stat = ASN_OK;
1085
1086    /* decode nonStandardIdentifier */
1087
1088    invokeStartElement (pctxt, "nonStandardIdentifier", -1);
1089
1090    stat = asn1PD_H225NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
1091    if (stat != ASN_OK) return stat;
1092
1093    invokeEndElement (pctxt, "nonStandardIdentifier", -1);
1094
1095    /* decode data */
1096
1097    invokeStartElement (pctxt, "data", -1);
1098
1099    stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->data);
1100    if (stat != ASN_OK) return stat;
1101    invokeOctStrValue (pctxt, pvalue->data.numocts, pvalue->data.data);
1102
1103    invokeEndElement (pctxt, "data", -1);
1104
1105    return (stat);
1106 }
1107
1108 /**************************************************************/
1109 /*                                                            */
1110 /*  TransportAddress                                          */
1111 /*                                                            */
1112 /**************************************************************/
1113
1114 EXTERN int asn1PD_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue)
1115 {
1116    int stat = ASN_OK;
1117    ASN1UINT ui;
1118    ASN1OpenType openType;
1119    ASN1BOOL extbit = 0;
1120
1121    /* extension bit */
1122
1123    DECODEBIT (pctxt, &extbit);
1124
1125    if (!extbit) {
1126       stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
1127       if (stat != ASN_OK) return stat;
1128       else pvalue->t = ui + 1;
1129
1130       switch (ui) {
1131          /* ipAddress */
1132          case 0:
1133             invokeStartElement (pctxt, "ipAddress", -1);
1134
1135             pvalue->u.ipAddress = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipAddress);
1136
1137             stat = asn1PD_H225TransportAddress_ipAddress (pctxt, pvalue->u.ipAddress);
1138             if (stat != ASN_OK) return stat;
1139
1140             invokeEndElement (pctxt, "ipAddress", -1);
1141
1142             break;
1143
1144          /* ipSourceRoute */
1145          case 1:
1146             invokeStartElement (pctxt, "ipSourceRoute", -1);
1147
1148             pvalue->u.ipSourceRoute = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipSourceRoute);
1149
1150             stat = asn1PD_H225TransportAddress_ipSourceRoute (pctxt, pvalue->u.ipSourceRoute);
1151             if (stat != ASN_OK) return stat;
1152
1153             invokeEndElement (pctxt, "ipSourceRoute", -1);
1154
1155             break;
1156
1157          /* ipxAddress */
1158          case 2:
1159             invokeStartElement (pctxt, "ipxAddress", -1);
1160
1161             pvalue->u.ipxAddress = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipxAddress);
1162
1163             stat = asn1PD_H225TransportAddress_ipxAddress (pctxt, pvalue->u.ipxAddress);
1164             if (stat != ASN_OK) return stat;
1165
1166             invokeEndElement (pctxt, "ipxAddress", -1);
1167
1168             break;
1169
1170          /* ip6Address */
1171          case 3:
1172             invokeStartElement (pctxt, "ip6Address", -1);
1173
1174             pvalue->u.ip6Address = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ip6Address);
1175
1176             stat = asn1PD_H225TransportAddress_ip6Address (pctxt, pvalue->u.ip6Address);
1177             if (stat != ASN_OK) return stat;
1178
1179             invokeEndElement (pctxt, "ip6Address", -1);
1180
1181             break;
1182
1183          /* netBios */
1184          case 4:
1185             invokeStartElement (pctxt, "netBios", -1);
1186
1187             pvalue->u.netBios = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_netBios);
1188
1189             stat = asn1PD_H225TransportAddress_netBios (pctxt, pvalue->u.netBios);
1190             if (stat != ASN_OK) return stat;
1191
1192             invokeEndElement (pctxt, "netBios", -1);
1193
1194             break;
1195
1196          /* nsap */
1197          case 5:
1198             invokeStartElement (pctxt, "nsap", -1);
1199
1200             pvalue->u.nsap = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_nsap);
1201
1202             stat = asn1PD_H225TransportAddress_nsap (pctxt, pvalue->u.nsap);
1203             if (stat != ASN_OK) return stat;
1204
1205             invokeEndElement (pctxt, "nsap", -1);
1206
1207             break;
1208
1209          /* nonStandardAddress */
1210          case 6:
1211             invokeStartElement (pctxt, "nonStandardAddress", -1);
1212
1213             pvalue->u.nonStandardAddress = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
1214
1215             stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandardAddress);
1216             if (stat != ASN_OK) return stat;
1217
1218             invokeEndElement (pctxt, "nonStandardAddress", -1);
1219
1220             break;
1221
1222          default:
1223             return ASN_E_INVOPT;
1224       }
1225    }
1226    else {
1227       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1228       if (stat != ASN_OK) return stat;
1229       else pvalue->t = ui + 8;
1230
1231       stat = decodeByteAlign (pctxt);
1232       if (stat != ASN_OK) return stat;
1233
1234       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1235       if (stat != ASN_OK) return stat;
1236
1237    }
1238
1239    return (stat);
1240 }
1241
1242 /**************************************************************/
1243 /*                                                            */
1244 /*  PublicTypeOfNumber                                        */
1245 /*                                                            */
1246 /**************************************************************/
1247
1248 EXTERN int asn1PD_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue)
1249 {
1250    int stat = ASN_OK;
1251    ASN1UINT ui;
1252    ASN1OpenType openType;
1253    ASN1BOOL extbit = 0;
1254
1255    /* extension bit */
1256
1257    DECODEBIT (pctxt, &extbit);
1258
1259    if (!extbit) {
1260       stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
1261       if (stat != ASN_OK) return stat;
1262       else pvalue->t = ui + 1;
1263
1264       switch (ui) {
1265          /* unknown */
1266          case 0:
1267             invokeStartElement (pctxt, "unknown", -1);
1268
1269             /* NULL */
1270             invokeNullValue (pctxt);
1271
1272             invokeEndElement (pctxt, "unknown", -1);
1273
1274             break;
1275
1276          /* internationalNumber */
1277          case 1:
1278             invokeStartElement (pctxt, "internationalNumber", -1);
1279
1280             /* NULL */
1281             invokeNullValue (pctxt);
1282
1283             invokeEndElement (pctxt, "internationalNumber", -1);
1284
1285             break;
1286
1287          /* nationalNumber */
1288          case 2:
1289             invokeStartElement (pctxt, "nationalNumber", -1);
1290
1291             /* NULL */
1292             invokeNullValue (pctxt);
1293
1294             invokeEndElement (pctxt, "nationalNumber", -1);
1295
1296             break;
1297
1298          /* networkSpecificNumber */
1299          case 3:
1300             invokeStartElement (pctxt, "networkSpecificNumber", -1);
1301
1302             /* NULL */
1303             invokeNullValue (pctxt);
1304
1305             invokeEndElement (pctxt, "networkSpecificNumber", -1);
1306
1307             break;
1308
1309          /* subscriberNumber */
1310          case 4:
1311             invokeStartElement (pctxt, "subscriberNumber", -1);
1312
1313             /* NULL */
1314             invokeNullValue (pctxt);
1315
1316             invokeEndElement (pctxt, "subscriberNumber", -1);
1317
1318             break;
1319
1320          /* abbreviatedNumber */
1321          case 5:
1322             invokeStartElement (pctxt, "abbreviatedNumber", -1);
1323
1324             /* NULL */
1325             invokeNullValue (pctxt);
1326
1327             invokeEndElement (pctxt, "abbreviatedNumber", -1);
1328
1329             break;
1330
1331          default:
1332             return ASN_E_INVOPT;
1333       }
1334    }
1335    else {
1336       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1337       if (stat != ASN_OK) return stat;
1338       else pvalue->t = ui + 7;
1339
1340       stat = decodeByteAlign (pctxt);
1341       if (stat != ASN_OK) return stat;
1342
1343       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1344       if (stat != ASN_OK) return stat;
1345
1346    }
1347
1348    return (stat);
1349 }
1350
1351 /**************************************************************/
1352 /*                                                            */
1353 /*  PublicPartyNumber                                         */
1354 /*                                                            */
1355 /**************************************************************/
1356
1357 EXTERN int asn1PD_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue)
1358 {
1359    int stat = ASN_OK;
1360
1361    /* decode publicTypeOfNumber */
1362
1363    invokeStartElement (pctxt, "publicTypeOfNumber", -1);
1364
1365    stat = asn1PD_H225PublicTypeOfNumber (pctxt, &pvalue->publicTypeOfNumber);
1366    if (stat != ASN_OK) return stat;
1367
1368    invokeEndElement (pctxt, "publicTypeOfNumber", -1);
1369
1370    /* decode publicNumberDigits */
1371
1372    invokeStartElement (pctxt, "publicNumberDigits", -1);
1373
1374    stat = asn1PD_H225NumberDigits (pctxt, &pvalue->publicNumberDigits);
1375    if (stat != ASN_OK) return stat;
1376
1377    invokeEndElement (pctxt, "publicNumberDigits", -1);
1378
1379    return (stat);
1380 }
1381
1382 /**************************************************************/
1383 /*                                                            */
1384 /*  PrivateTypeOfNumber                                       */
1385 /*                                                            */
1386 /**************************************************************/
1387
1388 EXTERN int asn1PD_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue)
1389 {
1390    int stat = ASN_OK;
1391    ASN1UINT ui;
1392    ASN1OpenType openType;
1393    ASN1BOOL extbit = 0;
1394
1395    /* extension bit */
1396
1397    DECODEBIT (pctxt, &extbit);
1398
1399    if (!extbit) {
1400       stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
1401       if (stat != ASN_OK) return stat;
1402       else pvalue->t = ui + 1;
1403
1404       switch (ui) {
1405          /* unknown */
1406          case 0:
1407             invokeStartElement (pctxt, "unknown", -1);
1408
1409             /* NULL */
1410             invokeNullValue (pctxt);
1411
1412             invokeEndElement (pctxt, "unknown", -1);
1413
1414             break;
1415
1416          /* level2RegionalNumber */
1417          case 1:
1418             invokeStartElement (pctxt, "level2RegionalNumber", -1);
1419
1420             /* NULL */
1421             invokeNullValue (pctxt);
1422
1423             invokeEndElement (pctxt, "level2RegionalNumber", -1);
1424
1425             break;
1426
1427          /* level1RegionalNumber */
1428          case 2:
1429             invokeStartElement (pctxt, "level1RegionalNumber", -1);
1430
1431             /* NULL */
1432             invokeNullValue (pctxt);
1433
1434             invokeEndElement (pctxt, "level1RegionalNumber", -1);
1435
1436             break;
1437
1438          /* pISNSpecificNumber */
1439          case 3:
1440             invokeStartElement (pctxt, "pISNSpecificNumber", -1);
1441
1442             /* NULL */
1443             invokeNullValue (pctxt);
1444
1445             invokeEndElement (pctxt, "pISNSpecificNumber", -1);
1446
1447             break;
1448
1449          /* localNumber */
1450          case 4:
1451             invokeStartElement (pctxt, "localNumber", -1);
1452
1453             /* NULL */
1454             invokeNullValue (pctxt);
1455
1456             invokeEndElement (pctxt, "localNumber", -1);
1457
1458             break;
1459
1460          /* abbreviatedNumber */
1461          case 5:
1462             invokeStartElement (pctxt, "abbreviatedNumber", -1);
1463
1464             /* NULL */
1465             invokeNullValue (pctxt);
1466
1467             invokeEndElement (pctxt, "abbreviatedNumber", -1);
1468
1469             break;
1470
1471          default:
1472             return ASN_E_INVOPT;
1473       }
1474    }
1475    else {
1476       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1477       if (stat != ASN_OK) return stat;
1478       else pvalue->t = ui + 7;
1479
1480       stat = decodeByteAlign (pctxt);
1481       if (stat != ASN_OK) return stat;
1482
1483       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1484       if (stat != ASN_OK) return stat;
1485
1486    }
1487
1488    return (stat);
1489 }
1490
1491 /**************************************************************/
1492 /*                                                            */
1493 /*  PrivatePartyNumber                                        */
1494 /*                                                            */
1495 /**************************************************************/
1496
1497 EXTERN int asn1PD_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue)
1498 {
1499    int stat = ASN_OK;
1500
1501    /* decode privateTypeOfNumber */
1502
1503    invokeStartElement (pctxt, "privateTypeOfNumber", -1);
1504
1505    stat = asn1PD_H225PrivateTypeOfNumber (pctxt, &pvalue->privateTypeOfNumber);
1506    if (stat != ASN_OK) return stat;
1507
1508    invokeEndElement (pctxt, "privateTypeOfNumber", -1);
1509
1510    /* decode privateNumberDigits */
1511
1512    invokeStartElement (pctxt, "privateNumberDigits", -1);
1513
1514    stat = asn1PD_H225NumberDigits (pctxt, &pvalue->privateNumberDigits);
1515    if (stat != ASN_OK) return stat;
1516
1517    invokeEndElement (pctxt, "privateNumberDigits", -1);
1518
1519    return (stat);
1520 }
1521
1522 /**************************************************************/
1523 /*                                                            */
1524 /*  PartyNumber                                               */
1525 /*                                                            */
1526 /**************************************************************/
1527
1528 EXTERN int asn1PD_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue)
1529 {
1530    int stat = ASN_OK;
1531    ASN1UINT ui;
1532    ASN1OpenType openType;
1533    ASN1BOOL extbit = 0;
1534
1535    /* extension bit */
1536
1537    DECODEBIT (pctxt, &extbit);
1538
1539    if (!extbit) {
1540       stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
1541       if (stat != ASN_OK) return stat;
1542       else pvalue->t = ui + 1;
1543
1544       switch (ui) {
1545          /* e164Number */
1546          case 0:
1547             invokeStartElement (pctxt, "e164Number", -1);
1548
1549             pvalue->u.e164Number = ALLOC_ASN1ELEM (pctxt, H225PublicPartyNumber);
1550
1551             stat = asn1PD_H225PublicPartyNumber (pctxt, pvalue->u.e164Number);
1552             if (stat != ASN_OK) return stat;
1553
1554             invokeEndElement (pctxt, "e164Number", -1);
1555
1556             break;
1557
1558          /* dataPartyNumber */
1559          case 1:
1560             invokeStartElement (pctxt, "dataPartyNumber", -1);
1561
1562             stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.dataPartyNumber);
1563             if (stat != ASN_OK) return stat;
1564
1565             invokeEndElement (pctxt, "dataPartyNumber", -1);
1566
1567             break;
1568
1569          /* telexPartyNumber */
1570          case 2:
1571             invokeStartElement (pctxt, "telexPartyNumber", -1);
1572
1573             stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.telexPartyNumber);
1574             if (stat != ASN_OK) return stat;
1575
1576             invokeEndElement (pctxt, "telexPartyNumber", -1);
1577
1578             break;
1579
1580          /* privateNumber */
1581          case 3:
1582             invokeStartElement (pctxt, "privateNumber", -1);
1583
1584             pvalue->u.privateNumber = ALLOC_ASN1ELEM (pctxt, H225PrivatePartyNumber);
1585
1586             stat = asn1PD_H225PrivatePartyNumber (pctxt, pvalue->u.privateNumber);
1587             if (stat != ASN_OK) return stat;
1588
1589             invokeEndElement (pctxt, "privateNumber", -1);
1590
1591             break;
1592
1593          /* nationalStandardPartyNumber */
1594          case 4:
1595             invokeStartElement (pctxt, "nationalStandardPartyNumber", -1);
1596
1597             stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.nationalStandardPartyNumber);
1598             if (stat != ASN_OK) return stat;
1599
1600             invokeEndElement (pctxt, "nationalStandardPartyNumber", -1);
1601
1602             break;
1603
1604          default:
1605             return ASN_E_INVOPT;
1606       }
1607    }
1608    else {
1609       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1610       if (stat != ASN_OK) return stat;
1611       else pvalue->t = ui + 6;
1612
1613       stat = decodeByteAlign (pctxt);
1614       if (stat != ASN_OK) return stat;
1615
1616       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1617       if (stat != ASN_OK) return stat;
1618
1619    }
1620
1621    return (stat);
1622 }
1623
1624 /**************************************************************/
1625 /*                                                            */
1626 /*  ANSI_41_UIM_system_id                                     */
1627 /*                                                            */
1628 /**************************************************************/
1629
1630 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet;
1631
1632 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet;
1633
1634 EXTERN int asn1PD_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue)
1635 {
1636    static Asn1SizeCnst sid_lsize1 = { 0, 1, 4, 0 };
1637    static Asn1SizeCnst mid_lsize1 = { 0, 1, 4, 0 };
1638    int stat = ASN_OK;
1639    ASN1UINT ui;
1640    ASN1OpenType openType;
1641    ASN1BOOL extbit = 0;
1642
1643    /* extension bit */
1644
1645    DECODEBIT (pctxt, &extbit);
1646
1647    if (!extbit) {
1648       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
1649       if (stat != ASN_OK) return stat;
1650       else pvalue->t = ui + 1;
1651
1652       switch (ui) {
1653          /* sid */
1654          case 0:
1655             invokeStartElement (pctxt, "sid", -1);
1656
1657             addSizeConstraint (pctxt, &sid_lsize1);
1658
1659             stat = decodeConstrainedStringEx (pctxt, &pvalue->u.sid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet, 4, 4, 7);
1660             if (stat != ASN_OK) return stat;
1661             invokeCharStrValue (pctxt, pvalue->u.sid);
1662
1663             invokeEndElement (pctxt, "sid", -1);
1664
1665             break;
1666
1667          /* mid */
1668          case 1:
1669             invokeStartElement (pctxt, "mid", -1);
1670
1671             addSizeConstraint (pctxt, &mid_lsize1);
1672
1673             stat = decodeConstrainedStringEx (pctxt, &pvalue->u.mid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet, 4, 4, 7);
1674             if (stat != ASN_OK) return stat;
1675             invokeCharStrValue (pctxt, pvalue->u.mid);
1676
1677             invokeEndElement (pctxt, "mid", -1);
1678
1679             break;
1680
1681          default:
1682             return ASN_E_INVOPT;
1683       }
1684    }
1685    else {
1686       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1687       if (stat != ASN_OK) return stat;
1688       else pvalue->t = ui + 3;
1689
1690       stat = decodeByteAlign (pctxt);
1691       if (stat != ASN_OK) return stat;
1692
1693       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1694       if (stat != ASN_OK) return stat;
1695
1696    }
1697
1698    return (stat);
1699 }
1700
1701 /**************************************************************/
1702 /*                                                            */
1703 /*  ANSI_41_UIM_systemMyTypeCode                              */
1704 /*                                                            */
1705 /**************************************************************/
1706
1707 EXTERN int asn1PD_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue)
1708 {
1709    static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
1710    int stat = ASN_OK;
1711
1712    addSizeConstraint (pctxt, &lsize1);
1713
1714    stat = decodeOctetString (pctxt,
1715                           &pvalue->numocts,
1716                           pvalue->data,
1717                           sizeof(pvalue->data));
1718    if (stat != ASN_OK) return stat;
1719    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
1720
1721    return (stat);
1722 }
1723
1724 /**************************************************************/
1725 /*                                                            */
1726 /*  ANSI_41_UIM_systemAccessType                              */
1727 /*                                                            */
1728 /**************************************************************/
1729
1730 EXTERN int asn1PD_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue)
1731 {
1732    static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
1733    int stat = ASN_OK;
1734
1735    addSizeConstraint (pctxt, &lsize1);
1736
1737    stat = decodeOctetString (pctxt,
1738                           &pvalue->numocts,
1739                           pvalue->data,
1740                           sizeof(pvalue->data));
1741    if (stat != ASN_OK) return stat;
1742    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
1743
1744    return (stat);
1745 }
1746
1747 /**************************************************************/
1748 /*                                                            */
1749 /*  ANSI_41_UIM_qualificationInformationCode                  */
1750 /*                                                            */
1751 /**************************************************************/
1752
1753 EXTERN int asn1PD_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue)
1754 {
1755    static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
1756    int stat = ASN_OK;
1757
1758    addSizeConstraint (pctxt, &lsize1);
1759
1760    stat = decodeOctetString (pctxt,
1761                           &pvalue->numocts,
1762                           pvalue->data,
1763                           sizeof(pvalue->data));
1764    if (stat != ASN_OK) return stat;
1765    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
1766
1767    return (stat);
1768 }
1769
1770 /**************************************************************/
1771 /*                                                            */
1772 /*  ANSI_41_UIM                                               */
1773 /*                                                            */
1774 /**************************************************************/
1775
1776 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet;
1777
1778 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet;
1779
1780 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet;
1781
1782 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet;
1783
1784 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet;
1785
1786 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet;
1787
1788 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet;
1789
1790 extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet;
1791
1792 EXTERN int asn1PD_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue)
1793 {
1794    static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
1795    static Asn1SizeCnst min_lsize1 = { 0, 3, 16, 0 };
1796    static Asn1SizeCnst mdn_lsize1 = { 0, 3, 16, 0 };
1797    static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
1798    static Asn1SizeCnst esn_lsize1 = { 0, 16, 16, 0 };
1799    static Asn1SizeCnst mscid_lsize1 = { 0, 3, 16, 0 };
1800    static Asn1SizeCnst sesn_lsize1 = { 0, 16, 16, 0 };
1801    static Asn1SizeCnst soc_lsize1 = { 0, 3, 16, 0 };
1802    int stat = ASN_OK;
1803    OOCTXT lctxt;
1804    ASN1OpenType openType;
1805    ASN1UINT bitcnt;
1806    ASN1UINT i;
1807    ASN1BOOL optbit = 0;
1808    ASN1BOOL extbit = 0;
1809
1810    /* extension bit */
1811
1812    DECODEBIT (pctxt, &extbit);
1813
1814    /* optional bits */
1815
1816    memset (&pvalue->m, 0, sizeof(pvalue->m));
1817
1818    DECODEBIT (pctxt, &optbit);
1819    pvalue->m.imsiPresent = optbit;
1820
1821    DECODEBIT (pctxt, &optbit);
1822    pvalue->m.minPresent = optbit;
1823
1824    DECODEBIT (pctxt, &optbit);
1825    pvalue->m.mdnPresent = optbit;
1826
1827    DECODEBIT (pctxt, &optbit);
1828    pvalue->m.msisdnPresent = optbit;
1829
1830    DECODEBIT (pctxt, &optbit);
1831    pvalue->m.esnPresent = optbit;
1832
1833    DECODEBIT (pctxt, &optbit);
1834    pvalue->m.mscidPresent = optbit;
1835
1836    DECODEBIT (pctxt, &optbit);
1837    pvalue->m.systemMyTypeCodePresent = optbit;
1838
1839    DECODEBIT (pctxt, &optbit);
1840    pvalue->m.systemAccessTypePresent = optbit;
1841
1842    DECODEBIT (pctxt, &optbit);
1843    pvalue->m.qualificationInformationCodePresent = optbit;
1844
1845    DECODEBIT (pctxt, &optbit);
1846    pvalue->m.sesnPresent = optbit;
1847
1848    DECODEBIT (pctxt, &optbit);
1849    pvalue->m.socPresent = optbit;
1850
1851    /* decode imsi */
1852
1853    if (pvalue->m.imsiPresent) {
1854       invokeStartElement (pctxt, "imsi", -1);
1855
1856       addSizeConstraint (pctxt, &imsi_lsize1);
1857
1858       stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet, 4, 4, 7);
1859       if (stat != ASN_OK) return stat;
1860       invokeCharStrValue (pctxt, pvalue->imsi);
1861
1862       invokeEndElement (pctxt, "imsi", -1);
1863    }
1864
1865    /* decode min */
1866
1867    if (pvalue->m.minPresent) {
1868       invokeStartElement (pctxt, "min", -1);
1869
1870       addSizeConstraint (pctxt, &min_lsize1);
1871
1872       stat = decodeConstrainedStringEx (pctxt, &pvalue->min, gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet, 4, 4, 7);
1873       if (stat != ASN_OK) return stat;
1874       invokeCharStrValue (pctxt, pvalue->min);
1875
1876       invokeEndElement (pctxt, "min", -1);
1877    }
1878
1879    /* decode mdn */
1880
1881    if (pvalue->m.mdnPresent) {
1882       invokeStartElement (pctxt, "mdn", -1);
1883
1884       addSizeConstraint (pctxt, &mdn_lsize1);
1885
1886       stat = decodeConstrainedStringEx (pctxt, &pvalue->mdn, gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet, 4, 4, 7);
1887       if (stat != ASN_OK) return stat;
1888       invokeCharStrValue (pctxt, pvalue->mdn);
1889
1890       invokeEndElement (pctxt, "mdn", -1);
1891    }
1892
1893    /* decode msisdn */
1894
1895    if (pvalue->m.msisdnPresent) {
1896       invokeStartElement (pctxt, "msisdn", -1);
1897
1898       addSizeConstraint (pctxt, &msisdn_lsize1);
1899
1900       stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet, 4, 4, 7);
1901       if (stat != ASN_OK) return stat;
1902       invokeCharStrValue (pctxt, pvalue->msisdn);
1903
1904       invokeEndElement (pctxt, "msisdn", -1);
1905    }
1906
1907    /* decode esn */
1908
1909    if (pvalue->m.esnPresent) {
1910       invokeStartElement (pctxt, "esn", -1);
1911
1912       addSizeConstraint (pctxt, &esn_lsize1);
1913
1914       stat = decodeConstrainedStringEx (pctxt, &pvalue->esn, gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet, 4, 4, 7);
1915       if (stat != ASN_OK) return stat;
1916       invokeCharStrValue (pctxt, pvalue->esn);
1917
1918       invokeEndElement (pctxt, "esn", -1);
1919    }
1920
1921    /* decode mscid */
1922
1923    if (pvalue->m.mscidPresent) {
1924       invokeStartElement (pctxt, "mscid", -1);
1925
1926       addSizeConstraint (pctxt, &mscid_lsize1);
1927
1928       stat = decodeConstrainedStringEx (pctxt, &pvalue->mscid, gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet, 4, 4, 7);
1929       if (stat != ASN_OK) return stat;
1930       invokeCharStrValue (pctxt, pvalue->mscid);
1931
1932       invokeEndElement (pctxt, "mscid", -1);
1933    }
1934
1935    /* decode system_id */
1936
1937    invokeStartElement (pctxt, "system_id", -1);
1938
1939    stat = asn1PD_H225ANSI_41_UIM_system_id (pctxt, &pvalue->system_id);
1940    if (stat != ASN_OK) return stat;
1941
1942    invokeEndElement (pctxt, "system_id", -1);
1943
1944    /* decode systemMyTypeCode */
1945
1946    if (pvalue->m.systemMyTypeCodePresent) {
1947       invokeStartElement (pctxt, "systemMyTypeCode", -1);
1948
1949       stat = asn1PD_H225ANSI_41_UIM_systemMyTypeCode (pctxt, &pvalue->systemMyTypeCode);
1950       if (stat != ASN_OK) return stat;
1951
1952       invokeEndElement (pctxt, "systemMyTypeCode", -1);
1953    }
1954
1955    /* decode systemAccessType */
1956
1957    if (pvalue->m.systemAccessTypePresent) {
1958       invokeStartElement (pctxt, "systemAccessType", -1);
1959
1960       stat = asn1PD_H225ANSI_41_UIM_systemAccessType (pctxt, &pvalue->systemAccessType);
1961       if (stat != ASN_OK) return stat;
1962
1963       invokeEndElement (pctxt, "systemAccessType", -1);
1964    }
1965
1966    /* decode qualificationInformationCode */
1967
1968    if (pvalue->m.qualificationInformationCodePresent) {
1969       invokeStartElement (pctxt, "qualificationInformationCode", -1);
1970
1971       stat = asn1PD_H225ANSI_41_UIM_qualificationInformationCode (pctxt, &pvalue->qualificationInformationCode);
1972       if (stat != ASN_OK) return stat;
1973
1974       invokeEndElement (pctxt, "qualificationInformationCode", -1);
1975    }
1976
1977    /* decode sesn */
1978
1979    if (pvalue->m.sesnPresent) {
1980       invokeStartElement (pctxt, "sesn", -1);
1981
1982       addSizeConstraint (pctxt, &sesn_lsize1);
1983
1984       stat = decodeConstrainedStringEx (pctxt, &pvalue->sesn, gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet, 4, 4, 7);
1985       if (stat != ASN_OK) return stat;
1986       invokeCharStrValue (pctxt, pvalue->sesn);
1987
1988       invokeEndElement (pctxt, "sesn", -1);
1989    }
1990
1991    /* decode soc */
1992
1993    if (pvalue->m.socPresent) {
1994       invokeStartElement (pctxt, "soc", -1);
1995
1996       addSizeConstraint (pctxt, &soc_lsize1);
1997
1998       stat = decodeConstrainedStringEx (pctxt, &pvalue->soc, gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet, 4, 4, 7);
1999       if (stat != ASN_OK) return stat;
2000       invokeCharStrValue (pctxt, pvalue->soc);
2001
2002       invokeEndElement (pctxt, "soc", -1);
2003    }
2004
2005    if (extbit) {
2006
2007       /* decode extension optional bits length */
2008
2009       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2010       if (stat != ASN_OK) return stat;
2011
2012       bitcnt += 1;
2013
2014       ZEROCONTEXT (&lctxt);
2015       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2016       if (stat != ASN_OK) return stat;
2017
2018       stat = moveBitCursor (pctxt, bitcnt);
2019       if (stat != ASN_OK) return stat;
2020
2021       for (i = 0; i < bitcnt; i++) {
2022          DECODEBIT (&lctxt, &optbit);
2023
2024          if (optbit) {
2025             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2026             if (stat != ASN_OK) return stat;
2027
2028             pctxt->buffer.byteIndex += openType.numocts;
2029          }
2030       }
2031    }
2032
2033    return (stat);
2034 }
2035
2036 /**************************************************************/
2037 /*                                                            */
2038 /*  GSM_UIM_tmsi                                              */
2039 /*                                                            */
2040 /**************************************************************/
2041
2042 EXTERN int asn1PD_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue)
2043 {
2044    static Asn1SizeCnst lsize1 = { 0, 1, 4, 0 };
2045    int stat = ASN_OK;
2046
2047    addSizeConstraint (pctxt, &lsize1);
2048
2049    stat = decodeOctetString (pctxt,
2050                           &pvalue->numocts,
2051                           pvalue->data,
2052                           sizeof(pvalue->data));
2053    if (stat != ASN_OK) return stat;
2054    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
2055
2056    return (stat);
2057 }
2058
2059 /**************************************************************/
2060 /*                                                            */
2061 /*  GSM_UIM                                                   */
2062 /*                                                            */
2063 /**************************************************************/
2064
2065 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet;
2066
2067 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet;
2068
2069 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet;
2070
2071 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet;
2072
2073 extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet;
2074
2075 EXTERN int asn1PD_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue)
2076 {
2077    static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
2078    static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
2079    static Asn1SizeCnst imei_lsize1 = { 0, 15, 16, 0 };
2080    static Asn1SizeCnst hplmn_lsize1 = { 0, 1, 4, 0 };
2081    static Asn1SizeCnst vplmn_lsize1 = { 0, 1, 4, 0 };
2082    int stat = ASN_OK;
2083    OOCTXT lctxt;
2084    ASN1OpenType openType;
2085    ASN1UINT bitcnt;
2086    ASN1UINT i;
2087    ASN1BOOL optbit = 0;
2088    ASN1BOOL extbit = 0;
2089
2090    /* extension bit */
2091
2092    DECODEBIT (pctxt, &extbit);
2093
2094    /* optional bits */
2095
2096    memset (&pvalue->m, 0, sizeof(pvalue->m));
2097
2098    DECODEBIT (pctxt, &optbit);
2099    pvalue->m.imsiPresent = optbit;
2100
2101    DECODEBIT (pctxt, &optbit);
2102    pvalue->m.tmsiPresent = optbit;
2103
2104    DECODEBIT (pctxt, &optbit);
2105    pvalue->m.msisdnPresent = optbit;
2106
2107    DECODEBIT (pctxt, &optbit);
2108    pvalue->m.imeiPresent = optbit;
2109
2110    DECODEBIT (pctxt, &optbit);
2111    pvalue->m.hplmnPresent = optbit;
2112
2113    DECODEBIT (pctxt, &optbit);
2114    pvalue->m.vplmnPresent = optbit;
2115
2116    /* decode imsi */
2117
2118    if (pvalue->m.imsiPresent) {
2119       invokeStartElement (pctxt, "imsi", -1);
2120
2121       addSizeConstraint (pctxt, &imsi_lsize1);
2122
2123       stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_GSM_UIM_imsi_CharSet, 4, 4, 7);
2124       if (stat != ASN_OK) return stat;
2125       invokeCharStrValue (pctxt, pvalue->imsi);
2126
2127       invokeEndElement (pctxt, "imsi", -1);
2128    }
2129
2130    /* decode tmsi */
2131
2132    if (pvalue->m.tmsiPresent) {
2133       invokeStartElement (pctxt, "tmsi", -1);
2134
2135       stat = asn1PD_H225GSM_UIM_tmsi (pctxt, &pvalue->tmsi);
2136       if (stat != ASN_OK) return stat;
2137
2138       invokeEndElement (pctxt, "tmsi", -1);
2139    }
2140
2141    /* decode msisdn */
2142
2143    if (pvalue->m.msisdnPresent) {
2144       invokeStartElement (pctxt, "msisdn", -1);
2145
2146       addSizeConstraint (pctxt, &msisdn_lsize1);
2147
2148       stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet, 4, 4, 7);
2149       if (stat != ASN_OK) return stat;
2150       invokeCharStrValue (pctxt, pvalue->msisdn);
2151
2152       invokeEndElement (pctxt, "msisdn", -1);
2153    }
2154
2155    /* decode imei */
2156
2157    if (pvalue->m.imeiPresent) {
2158       invokeStartElement (pctxt, "imei", -1);
2159
2160       addSizeConstraint (pctxt, &imei_lsize1);
2161
2162       stat = decodeConstrainedStringEx (pctxt, &pvalue->imei, gs_H323_MESSAGES_GSM_UIM_imei_CharSet, 4, 4, 7);
2163       if (stat != ASN_OK) return stat;
2164       invokeCharStrValue (pctxt, pvalue->imei);
2165
2166       invokeEndElement (pctxt, "imei", -1);
2167    }
2168
2169    /* decode hplmn */
2170
2171    if (pvalue->m.hplmnPresent) {
2172       invokeStartElement (pctxt, "hplmn", -1);
2173
2174       addSizeConstraint (pctxt, &hplmn_lsize1);
2175
2176       stat = decodeConstrainedStringEx (pctxt, &pvalue->hplmn, gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet, 4, 4, 7);
2177       if (stat != ASN_OK) return stat;
2178       invokeCharStrValue (pctxt, pvalue->hplmn);
2179
2180       invokeEndElement (pctxt, "hplmn", -1);
2181    }
2182
2183    /* decode vplmn */
2184
2185    if (pvalue->m.vplmnPresent) {
2186       invokeStartElement (pctxt, "vplmn", -1);
2187
2188       addSizeConstraint (pctxt, &vplmn_lsize1);
2189
2190       stat = decodeConstrainedStringEx (pctxt, &pvalue->vplmn, gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet, 4, 4, 7);
2191       if (stat != ASN_OK) return stat;
2192       invokeCharStrValue (pctxt, pvalue->vplmn);
2193
2194       invokeEndElement (pctxt, "vplmn", -1);
2195    }
2196
2197    if (extbit) {
2198
2199       /* decode extension optional bits length */
2200
2201       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2202       if (stat != ASN_OK) return stat;
2203
2204       bitcnt += 1;
2205
2206       ZEROCONTEXT (&lctxt);
2207       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2208       if (stat != ASN_OK) return stat;
2209
2210       stat = moveBitCursor (pctxt, bitcnt);
2211       if (stat != ASN_OK) return stat;
2212
2213       for (i = 0; i < bitcnt; i++) {
2214          DECODEBIT (&lctxt, &optbit);
2215
2216          if (optbit) {
2217             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2218             if (stat != ASN_OK) return stat;
2219
2220             pctxt->buffer.byteIndex += openType.numocts;
2221          }
2222       }
2223    }
2224
2225    return (stat);
2226 }
2227
2228 /**************************************************************/
2229 /*                                                            */
2230 /*  MobileUIM                                                 */
2231 /*                                                            */
2232 /**************************************************************/
2233
2234 EXTERN int asn1PD_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue)
2235 {
2236    int stat = ASN_OK;
2237    ASN1UINT ui;
2238    ASN1OpenType openType;
2239    ASN1BOOL extbit = 0;
2240
2241    /* extension bit */
2242
2243    DECODEBIT (pctxt, &extbit);
2244
2245    if (!extbit) {
2246       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
2247       if (stat != ASN_OK) return stat;
2248       else pvalue->t = ui + 1;
2249
2250       switch (ui) {
2251          /* ansi_41_uim */
2252          case 0:
2253             invokeStartElement (pctxt, "ansi_41_uim", -1);
2254
2255             pvalue->u.ansi_41_uim = ALLOC_ASN1ELEM (pctxt, H225ANSI_41_UIM);
2256
2257             stat = asn1PD_H225ANSI_41_UIM (pctxt, pvalue->u.ansi_41_uim);
2258             if (stat != ASN_OK) return stat;
2259
2260             invokeEndElement (pctxt, "ansi_41_uim", -1);
2261
2262             break;
2263
2264          /* gsm_uim */
2265          case 1:
2266             invokeStartElement (pctxt, "gsm_uim", -1);
2267
2268             pvalue->u.gsm_uim = ALLOC_ASN1ELEM (pctxt, H225GSM_UIM);
2269
2270             stat = asn1PD_H225GSM_UIM (pctxt, pvalue->u.gsm_uim);
2271             if (stat != ASN_OK) return stat;
2272
2273             invokeEndElement (pctxt, "gsm_uim", -1);
2274
2275             break;
2276
2277          default:
2278             return ASN_E_INVOPT;
2279       }
2280    }
2281    else {
2282       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
2283       if (stat != ASN_OK) return stat;
2284       else pvalue->t = ui + 3;
2285
2286       stat = decodeByteAlign (pctxt);
2287       if (stat != ASN_OK) return stat;
2288
2289       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2290       if (stat != ASN_OK) return stat;
2291
2292    }
2293
2294    return (stat);
2295 }
2296
2297 /**************************************************************/
2298 /*                                                            */
2299 /*  AliasAddress                                              */
2300 /*                                                            */
2301 /**************************************************************/
2302
2303 extern EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet;
2304
2305 EXTERN int asn1PD_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue)
2306 {
2307    static Asn1SizeCnst dialedDigits_lsize1 = { 0, 1, 128, 0 };
2308    static Asn1SizeCnst h323_ID_lsize1 = { 0, 1, 256, 0 };
2309    static Asn1SizeCnst url_ID_lsize1 = { 0, 1, 512, 0 };
2310    static Asn1SizeCnst email_ID_lsize1 = { 0, 1, 512, 0 };
2311    int stat = ASN_OK;
2312    ASN1UINT ui;
2313    ASN1OpenType openType;
2314    ASN1BOOL extbit = 0;
2315    OOCTXT lctxt;
2316
2317    /* extension bit */
2318
2319    DECODEBIT (pctxt, &extbit);
2320
2321    if (!extbit) {
2322       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
2323       if (stat != ASN_OK) return stat;
2324       else pvalue->t = ui + 1;
2325
2326       switch (ui) {
2327          /* dialedDigits */
2328          case 0:
2329             invokeStartElement (pctxt, "dialedDigits", -1);
2330
2331             addSizeConstraint (pctxt, &dialedDigits_lsize1);
2332
2333             stat = decodeConstrainedStringEx (pctxt, &pvalue->u.dialedDigits, gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet, 4, 4, 7);
2334             if (stat != ASN_OK) return stat;
2335             invokeCharStrValue (pctxt, pvalue->u.dialedDigits);
2336
2337             invokeEndElement (pctxt, "dialedDigits", -1);
2338
2339             break;
2340
2341          /* h323_ID */
2342          case 1:
2343             invokeStartElement (pctxt, "h323_ID", -1);
2344
2345             addSizeConstraint (pctxt, &h323_ID_lsize1);
2346
2347             stat = decodeBMPString (pctxt, &pvalue->u.h323_ID, 0);
2348             if (stat != ASN_OK) return stat;
2349             invokeCharStr16BitValue (pctxt, pvalue->u.h323_ID.nchars, pvalue->u.h323_ID.data);
2350
2351             invokeEndElement (pctxt, "h323_ID", -1);
2352
2353             break;
2354
2355          default:
2356             return ASN_E_INVOPT;
2357       }
2358    }
2359    else {
2360       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
2361       if (stat != ASN_OK) return stat;
2362       else pvalue->t = ui + 3;
2363
2364       stat = decodeByteAlign (pctxt);
2365       if (stat != ASN_OK) return stat;
2366
2367       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2368       if (stat != ASN_OK) return stat;
2369
2370       copyContext (&lctxt, pctxt);
2371       initContextBuffer (pctxt, openType.data, openType.numocts);
2372
2373       switch (pvalue->t) {
2374          /* url_ID */
2375          case 3:
2376             invokeStartElement (pctxt, "url_ID", -1);
2377
2378             addSizeConstraint (pctxt, &url_ID_lsize1);
2379
2380             stat = decodeConstrainedStringEx (pctxt, &pvalue->u.url_ID, 0, 8, 7, 7);
2381             if (stat != ASN_OK) return stat;
2382             invokeCharStrValue (pctxt, pvalue->u.url_ID);
2383
2384             invokeEndElement (pctxt, "url_ID", -1);
2385
2386             break;
2387
2388          /* transportID */
2389          case 4:
2390             invokeStartElement (pctxt, "transportID", -1);
2391
2392             pvalue->u.transportID = ALLOC_ASN1ELEM (pctxt, H225TransportAddress);
2393
2394             stat = asn1PD_H225TransportAddress (pctxt, pvalue->u.transportID);
2395             if (stat != ASN_OK) return stat;
2396
2397             invokeEndElement (pctxt, "transportID", -1);
2398
2399             break;
2400
2401          /* email_ID */
2402          case 5:
2403             invokeStartElement (pctxt, "email_ID", -1);
2404
2405             addSizeConstraint (pctxt, &email_ID_lsize1);
2406
2407             stat = decodeConstrainedStringEx (pctxt, &pvalue->u.email_ID, 0, 8, 7, 7);
2408             if (stat != ASN_OK) return stat;
2409             invokeCharStrValue (pctxt, pvalue->u.email_ID);
2410
2411             invokeEndElement (pctxt, "email_ID", -1);
2412
2413             break;
2414
2415          /* partyNumber */
2416          case 6:
2417             invokeStartElement (pctxt, "partyNumber", -1);
2418
2419             pvalue->u.partyNumber = ALLOC_ASN1ELEM (pctxt, H225PartyNumber);
2420
2421             stat = asn1PD_H225PartyNumber (pctxt, pvalue->u.partyNumber);
2422             if (stat != ASN_OK) return stat;
2423
2424             invokeEndElement (pctxt, "partyNumber", -1);
2425
2426             break;
2427
2428          /* mobileUIM */
2429          case 7:
2430             invokeStartElement (pctxt, "mobileUIM", -1);
2431
2432             pvalue->u.mobileUIM = ALLOC_ASN1ELEM (pctxt, H225MobileUIM);
2433
2434             stat = asn1PD_H225MobileUIM (pctxt, pvalue->u.mobileUIM);
2435             if (stat != ASN_OK) return stat;
2436
2437             invokeEndElement (pctxt, "mobileUIM", -1);
2438
2439             break;
2440
2441          default:;
2442       }
2443
2444       copyContext (pctxt, &lctxt);
2445    }
2446
2447    return (stat);
2448 }
2449
2450 /**************************************************************/
2451 /*                                                            */
2452 /*  Content_compound                                          */
2453 /*                                                            */
2454 /**************************************************************/
2455
2456 EXTERN int asn1PD_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue)
2457 {
2458    static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
2459    int stat = ASN_OK;
2460    H225EnumeratedParameter* pdata;
2461    ASN1UINT count = 0;
2462    ASN1UINT xx1;
2463
2464    /* decode length determinant */
2465
2466    addSizeConstraint (pctxt, &lsize1);
2467
2468    stat = decodeLength (pctxt, &count);
2469    if (stat != ASN_OK) return stat;
2470
2471    /* decode elements */
2472
2473    dListInit (pvalue);
2474
2475    for (xx1 = 0; xx1 < count; xx1++) {
2476       invokeStartElement (pctxt, "elem", xx1);
2477
2478       pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225EnumeratedParameter);
2479
2480       stat = asn1PD_H225EnumeratedParameter (pctxt, (H225EnumeratedParameter*)pdata);
2481       if (stat != ASN_OK) return stat;
2482       invokeEndElement (pctxt, "elem", xx1);
2483
2484       dListAppendNode (pctxt, pvalue, pdata);
2485    }
2486
2487    return (stat);
2488 }
2489
2490 /**************************************************************/
2491 /*                                                            */
2492 /*  Content_nested                                            */
2493 /*                                                            */
2494 /**************************************************************/
2495
2496 EXTERN int asn1PD_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue)
2497 {
2498    static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
2499    int stat = ASN_OK;
2500    H225GenericData* pdata;
2501    ASN1UINT count = 0;
2502    ASN1UINT xx1;
2503
2504    /* decode length determinant */
2505
2506    addSizeConstraint (pctxt, &lsize1);
2507
2508    stat = decodeLength (pctxt, &count);
2509    if (stat != ASN_OK) return stat;
2510
2511    /* decode elements */
2512
2513    dListInit (pvalue);
2514
2515    for (xx1 = 0; xx1 < count; xx1++) {
2516       invokeStartElement (pctxt, "elem", xx1);
2517
2518       pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225GenericData);
2519
2520       stat = asn1PD_H225GenericData (pctxt, (H225GenericData*)pdata);
2521       if (stat != ASN_OK) return stat;
2522       invokeEndElement (pctxt, "elem", xx1);
2523
2524       dListAppendNode (pctxt, pvalue, pdata);
2525    }
2526
2527    return (stat);
2528 }
2529
2530 /**************************************************************/
2531 /*                                                            */
2532 /*  Content                                                   */
2533 /*                                                            */
2534 /**************************************************************/
2535
2536 EXTERN int asn1PD_H225Content (OOCTXT* pctxt, H225Content* pvalue)
2537 {
2538    int stat = ASN_OK;
2539    ASN1UINT ui;
2540    ASN1OpenType openType;
2541    ASN1BOOL extbit = 0;
2542
2543    /* extension bit */
2544
2545    DECODEBIT (pctxt, &extbit);
2546
2547    if (!extbit) {
2548       stat = decodeConsUnsigned (pctxt, &ui, 0, 11);
2549       if (stat != ASN_OK) return stat;
2550       else pvalue->t = ui + 1;
2551
2552       switch (ui) {
2553          /* raw */
2554          case 0:
2555             invokeStartElement (pctxt, "raw", -1);
2556
2557             pvalue->u.raw = ALLOC_ASN1ELEM (pctxt, ASN1DynOctStr);
2558
2559             stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue->u.raw);
2560             if (stat != ASN_OK) return stat;
2561             invokeOctStrValue (pctxt, pvalue->u.raw->numocts, pvalue->u.raw->data);
2562
2563             invokeEndElement (pctxt, "raw", -1);
2564
2565             break;
2566
2567          /* text */
2568          case 1:
2569             invokeStartElement (pctxt, "text", -1);
2570
2571             stat = decodeConstrainedStringEx (pctxt, &pvalue->u.text, 0, 8, 7, 7);
2572             if (stat != ASN_OK) return stat;
2573             invokeCharStrValue (pctxt, pvalue->u.text);
2574
2575             invokeEndElement (pctxt, "text", -1);
2576
2577             break;
2578
2579          /* unicode */
2580          case 2:
2581             invokeStartElement (pctxt, "unicode", -1);
2582
2583             stat = decodeBMPString (pctxt, &pvalue->u.unicode, 0);
2584             if (stat != ASN_OK) return stat;
2585             invokeCharStr16BitValue (pctxt, pvalue->u.unicode.nchars, pvalue->u.unicode.data);
2586
2587             invokeEndElement (pctxt, "unicode", -1);
2588
2589             break;
2590
2591          /* bool_ */
2592          case 3:
2593             invokeStartElement (pctxt, "bool_", -1);
2594
2595             stat = DECODEBIT (pctxt, &pvalue->u.bool_);
2596             if (stat != ASN_OK) return stat;
2597             invokeBoolValue (pctxt, pvalue->u.bool_);
2598
2599             invokeEndElement (pctxt, "bool_", -1);
2600
2601             break;
2602
2603          /* number8 */
2604          case 4:
2605             invokeStartElement (pctxt, "number8", -1);
2606
2607             stat = decodeConsUInt8 (pctxt, &pvalue->u.number8, 0U, 255U);
2608             if (stat != ASN_OK) return stat;
2609             invokeUIntValue (pctxt, pvalue->u.number8);
2610
2611             invokeEndElement (pctxt, "number8", -1);
2612
2613             break;
2614
2615          /* number16 */
2616          case 5:
2617             invokeStartElement (pctxt, "number16", -1);
2618
2619             stat = decodeConsUInt16 (pctxt, &pvalue->u.number16, 0U, 65535U);
2620             if (stat != ASN_OK) return stat;
2621             invokeUIntValue (pctxt, pvalue->u.number16);
2622
2623             invokeEndElement (pctxt, "number16", -1);
2624
2625             break;
2626
2627          /* number32 */
2628          case 6:
2629             invokeStartElement (pctxt, "number32", -1);
2630
2631             stat = decodeConsUnsigned (pctxt, &pvalue->u.number32, 0U, ASN1UINT_MAX);
2632             if (stat != ASN_OK) return stat;
2633             invokeUIntValue (pctxt, pvalue->u.number32);
2634
2635             invokeEndElement (pctxt, "number32", -1);
2636
2637             break;
2638
2639          /* id */
2640          case 7:
2641             invokeStartElement (pctxt, "id", -1);
2642
2643             pvalue->u.id = ALLOC_ASN1ELEM (pctxt, H225GenericIdentifier);
2644
2645             stat = asn1PD_H225GenericIdentifier (pctxt, pvalue->u.id);
2646             if (stat != ASN_OK) return stat;
2647
2648             invokeEndElement (pctxt, "id", -1);
2649
2650             break;
2651
2652          /* alias */
2653          case 8:
2654             invokeStartElement (pctxt, "alias", -1);
2655
2656             pvalue->u.alias = ALLOC_ASN1ELEM (pctxt, H225AliasAddress);
2657
2658             stat = asn1PD_H225AliasAddress (pctxt, pvalue->u.alias);
2659             if (stat != ASN_OK) return stat;
2660
2661             invokeEndElement (pctxt, "alias", -1);
2662
2663             break;
2664
2665          /* transport */
2666          case 9:
2667             invokeStartElement (pctxt, "transport", -1);
2668
2669             pvalue->u.transport = ALLOC_ASN1ELEM (pctxt, H225TransportAddress);
2670
2671             stat = asn1PD_H225TransportAddress (pctxt, pvalue->u.transport);
2672             if (stat != ASN_OK) return stat;
2673
2674             invokeEndElement (pctxt, "transport", -1);
2675
2676             break;
2677
2678          /* compound */
2679          case 10:
2680             invokeStartElement (pctxt, "compound", -1);
2681
2682             pvalue->u.compound = ALLOC_ASN1ELEM (pctxt, H225Content_compound);
2683
2684             stat = asn1PD_H225Content_compound (pctxt, pvalue->u.compound);
2685             if (stat != ASN_OK) return stat;
2686
2687             invokeEndElement (pctxt, "compound", -1);
2688
2689             break;
2690
2691          /* nested */
2692          case 11:
2693             invokeStartElement (pctxt, "nested", -1);
2694
2695             pvalue->u.nested = ALLOC_ASN1ELEM (pctxt, H225Content_nested);
2696
2697             stat = asn1PD_H225Content_nested (pctxt, pvalue->u.nested);
2698             if (stat != ASN_OK) return stat;
2699
2700             invokeEndElement (pctxt, "nested", -1);
2701
2702             break;
2703
2704          default:
2705             return ASN_E_INVOPT;
2706       }
2707    }
2708    else {
2709       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
2710       if (stat != ASN_OK) return stat;
2711       else pvalue->t = ui + 13;
2712
2713       stat = decodeByteAlign (pctxt);
2714       if (stat != ASN_OK) return stat;
2715
2716       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2717       if (stat != ASN_OK) return stat;
2718
2719    }
2720
2721    return (stat);
2722 }
2723
2724 /**************************************************************/
2725 /*                                                            */
2726 /*  EnumeratedParameter                                       */
2727 /*                                                            */
2728 /**************************************************************/
2729
2730 EXTERN int asn1PD_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue)
2731 {
2732    int stat = ASN_OK;
2733    OOCTXT lctxt;
2734    ASN1OpenType openType;
2735    ASN1UINT bitcnt;
2736    ASN1UINT i;
2737    ASN1BOOL optbit = 0;
2738    ASN1BOOL extbit = 0;
2739
2740    /* extension bit */
2741
2742    DECODEBIT (pctxt, &extbit);
2743
2744    /* optional bits */
2745
2746    memset (&pvalue->m, 0, sizeof(pvalue->m));
2747
2748    DECODEBIT (pctxt, &optbit);
2749    pvalue->m.contentPresent = optbit;
2750
2751    /* decode id */
2752
2753    invokeStartElement (pctxt, "id", -1);
2754
2755    stat = asn1PD_H225GenericIdentifier (pctxt, &pvalue->id);
2756    if (stat != ASN_OK) return stat;
2757
2758    invokeEndElement (pctxt, "id", -1);
2759
2760    /* decode content */
2761
2762    if (pvalue->m.contentPresent) {
2763       invokeStartElement (pctxt, "content", -1);
2764
2765       stat = asn1PD_H225Content (pctxt, &pvalue->content);
2766       if (stat != ASN_OK) return stat;
2767
2768       invokeEndElement (pctxt, "content", -1);
2769    }
2770
2771    if (extbit) {
2772
2773       /* decode extension optional bits length */
2774
2775       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2776       if (stat != ASN_OK) return stat;
2777
2778       bitcnt += 1;
2779
2780       ZEROCONTEXT (&lctxt);
2781       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2782       if (stat != ASN_OK) return stat;
2783
2784       stat = moveBitCursor (pctxt, bitcnt);
2785       if (stat != ASN_OK) return stat;
2786
2787       for (i = 0; i < bitcnt; i++) {
2788          DECODEBIT (&lctxt, &optbit);
2789
2790          if (optbit) {
2791             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2792             if (stat != ASN_OK) return stat;
2793
2794             pctxt->buffer.byteIndex += openType.numocts;
2795          }
2796       }
2797    }
2798
2799    return (stat);
2800 }
2801
2802 /**************************************************************/
2803 /*                                                            */
2804 /*  GenericData_parameters                                    */
2805 /*                                                            */
2806 /**************************************************************/
2807
2808 EXTERN int asn1PD_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue)
2809 {
2810    static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
2811    int stat = ASN_OK;
2812    H225EnumeratedParameter* pdata;
2813    ASN1UINT count = 0;
2814    ASN1UINT xx1;
2815
2816    /* decode length determinant */
2817
2818    addSizeConstraint (pctxt, &lsize1);
2819
2820    stat = decodeLength (pctxt, &count);
2821    if (stat != ASN_OK) return stat;
2822
2823    /* decode elements */
2824
2825    dListInit (pvalue);
2826
2827    for (xx1 = 0; xx1 < count; xx1++) {
2828       invokeStartElement (pctxt, "elem", xx1);
2829
2830       pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225EnumeratedParameter);
2831
2832       stat = asn1PD_H225EnumeratedParameter (pctxt, pdata);
2833       if (stat != ASN_OK) return stat;
2834       invokeEndElement (pctxt, "elem", xx1);
2835
2836       dListAppendNode (pctxt, pvalue, pdata);
2837    }
2838
2839    return (stat);
2840 }
2841
2842 /**************************************************************/
2843 /*                                                            */
2844 /*  GenericData                                               */
2845 /*                                                            */
2846 /**************************************************************/
2847
2848 EXTERN int asn1PD_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue)
2849 {
2850    int stat = ASN_OK;
2851    OOCTXT lctxt;
2852    ASN1OpenType openType;
2853    ASN1UINT bitcnt;
2854    ASN1UINT i;
2855    ASN1BOOL optbit = 0;
2856    ASN1BOOL extbit = 0;
2857
2858    /* extension bit */
2859
2860    DECODEBIT (pctxt, &extbit);
2861
2862    /* optional bits */
2863
2864    memset (&pvalue->m, 0, sizeof(pvalue->m));
2865
2866    DECODEBIT (pctxt, &optbit);
2867    pvalue->m.parametersPresent = optbit;
2868
2869    /* decode id */
2870
2871    invokeStartElement (pctxt, "id", -1);
2872
2873    stat = asn1PD_H225GenericIdentifier (pctxt, &pvalue->id);
2874    if (stat != ASN_OK) return stat;
2875
2876    invokeEndElement (pctxt, "id", -1);
2877
2878    /* decode parameters */
2879
2880    if (pvalue->m.parametersPresent) {
2881       invokeStartElement (pctxt, "parameters", -1);
2882
2883       stat = asn1PD_H225GenericData_parameters (pctxt, &pvalue->parameters);
2884       if (stat != ASN_OK) return stat;
2885
2886       invokeEndElement (pctxt, "parameters", -1);
2887    }
2888
2889    if (extbit) {
2890
2891       /* decode extension optional bits length */
2892
2893       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2894       if (stat != ASN_OK) return stat;
2895
2896       bitcnt += 1;
2897
2898       ZEROCONTEXT (&lctxt);
2899       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2900       if (stat != ASN_OK) return stat;
2901
2902       stat = moveBitCursor (pctxt, bitcnt);
2903       if (stat != ASN_OK) return stat;
2904
2905       for (i = 0; i < bitcnt; i++) {
2906          DECODEBIT (&lctxt, &optbit);
2907
2908          if (optbit) {
2909             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2910             if (stat != ASN_OK) return stat;
2911
2912             pctxt->buffer.byteIndex += openType.numocts;
2913          }
2914       }
2915    }
2916
2917    return (stat);
2918 }
2919
2920 /**************************************************************/
2921 /*                                                            */
2922 /*  FeatureDescriptor                                         */
2923 /*                                                            */
2924 /**************************************************************/
2925
2926 EXTERN int asn1PD_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue)
2927 {
2928    int stat = ASN_OK;
2929
2930    stat = asn1PD_H225GenericData (pctxt, pvalue);
2931    if (stat != ASN_OK) return stat;
2932
2933    return (stat);
2934 }
2935
2936 /**************************************************************/
2937 /*                                                            */
2938 /*  FastStartToken                                            */
2939 /*                                                            */
2940 /**************************************************************/
2941
2942 EXTERN int asn1PD_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue)
2943 {
2944    int stat = ASN_OK;
2945
2946    stat = asn1PD_H235ClearToken (pctxt, pvalue);
2947    if (stat != ASN_OK) return stat;
2948
2949    return (stat);
2950 }
2951
2952 /**************************************************************/
2953 /*                                                            */
2954 /*  EncodedFastStartToken                                     */
2955 /*                                                            */
2956 /**************************************************************/
2957
2958 EXTERN int asn1PD_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken* pvalue)
2959 {
2960    int stat = ASN_OK;
2961
2962    stat = decodeOpenType (pctxt, &pvalue->data, &pvalue->numocts);
2963    if (stat != ASN_OK) return stat;
2964    invokeOpenTypeValue
2965       (pctxt, pvalue->numocts, pvalue->data);
2966
2967    return (stat);
2968 }
2969
2970 /**************************************************************/
2971 /*                                                            */
2972 /*  H323_UserInformation_user_data_user_information           */
2973 /*                                                            */
2974 /**************************************************************/
2975
2976 EXTERN int asn1PD_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue)
2977 {
2978    static Asn1SizeCnst lsize1 = { 0, 1, 131, 0 };
2979    int stat = ASN_OK;
2980
2981    addSizeConstraint (pctxt, &lsize1);
2982
2983    stat = decodeOctetString (pctxt,
2984                           &pvalue->numocts,
2985                           pvalue->data,
2986                           sizeof(pvalue->data));
2987    if (stat != ASN_OK) return stat;
2988    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
2989
2990    return (stat);
2991 }
2992
2993 /**************************************************************/
2994 /*                                                            */
2995 /*  EndpointType_set                                          */
2996 /*                                                            */
2997 /**************************************************************/
2998
2999 EXTERN int asn1PD_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue)
3000 {
3001    static Asn1SizeCnst lsize1 = { 0, 32, 32, 0 };
3002    int stat = ASN_OK;
3003
3004    addSizeConstraint (pctxt, &lsize1);
3005
3006    stat = decodeBitString (pctxt,
3007                         &pvalue->numbits,
3008                         pvalue->data,
3009                         sizeof(pvalue->data));
3010    if (stat != ASN_OK) return stat;
3011
3012    invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
3013
3014    return (stat);
3015 }
3016
3017 /**************************************************************/
3018 /*                                                            */
3019 /*  VendorIdentifier_productId                                */
3020 /*                                                            */
3021 /**************************************************************/
3022
3023 EXTERN int asn1PD_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue)
3024 {
3025    static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
3026    int stat = ASN_OK;
3027
3028    addSizeConstraint (pctxt, &lsize1);
3029
3030    stat = decodeOctetString (pctxt,
3031                           &pvalue->numocts,
3032                           pvalue->data,
3033                           sizeof(pvalue->data));
3034    if (stat != ASN_OK) return stat;
3035    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
3036
3037    return (stat);
3038 }
3039
3040 /**************************************************************/
3041 /*                                                            */
3042 /*  VendorIdentifier_versionId                                */
3043 /*                                                            */
3044 /**************************************************************/
3045
3046 EXTERN int asn1PD_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue)
3047 {
3048    static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
3049    int stat = ASN_OK;
3050
3051    addSizeConstraint (pctxt, &lsize1);
3052
3053    stat = decodeOctetString (pctxt,
3054                           &pvalue->numocts,
3055                           pvalue->data,
3056                           sizeof(pvalue->data));
3057    if (stat != ASN_OK) return stat;
3058    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
3059
3060    return (stat);
3061 }
3062
3063 /**************************************************************/
3064 /*                                                            */
3065 /*  CicInfo_cic_element                                       */
3066 /*                                                            */
3067 /**************************************************************/
3068
3069 EXTERN int asn1PD_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue)
3070 {
3071    static Asn1SizeCnst lsize1 = { 0, 2, 4, 0 };
3072    int stat = ASN_OK;
3073
3074    addSizeConstraint (pctxt, &lsize1);
3075
3076    stat = decodeOctetString (pctxt,
3077                           &pvalue->numocts,
3078                           pvalue->data,
3079                           sizeof(pvalue->data));
3080    if (stat != ASN_OK) return stat;
3081    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
3082
3083    return (stat);
3084 }
3085
3086 /**************************************************************/
3087 /*                                                            */
3088 /*  CicInfo_pointCode                                         */
3089 /*                                                            */
3090 /**************************************************************/
3091
3092 EXTERN int asn1PD_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue)
3093 {
3094    static Asn1SizeCnst lsize1 = { 0, 2, 5, 0 };
3095    int stat = ASN_OK;
3096
3097    addSizeConstraint (pctxt, &lsize1);
3098
3099    stat = decodeOctetString (pctxt,
3100                           &pvalue->numocts,
3101                           pvalue->data,
3102                           sizeof(pvalue->data));
3103    if (stat != ASN_OK) return stat;
3104    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
3105
3106    return (stat);
3107 }
3108
3109 /**************************************************************/
3110 /*                                                            */
3111 /*  CarrierInfo_carrierIdentificationCode                     */
3112 /*                                                            */
3113 /**************************************************************/
3114
3115 EXTERN int asn1PD_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue)
3116 {
3117    static Asn1SizeCnst lsize1 = { 0, 3, 4, 0 };
3118    int stat = ASN_OK;
3119
3120    addSizeConstraint (pctxt, &lsize1);
3121
3122    stat = decodeOctetString (pctxt,
3123                           &pvalue->numocts,
3124                           pvalue->data,
3125                           sizeof(pvalue->data));
3126    if (stat != ASN_OK) return stat;
3127    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
3128
3129    return (stat);
3130 }
3131
3132 /**************************************************************/
3133 /*                                                            */
3134 /*  CallTerminationCause_releaseCompleteCauseIE               */
3135 /*                                                            */
3136 /**************************************************************/
3137
3138 EXTERN int asn1PD_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue)
3139 {
3140    static Asn1SizeCnst lsize1 = { 0, 2, 32, 0 };
3141    int stat = ASN_OK;
3142
3143    addSizeConstraint (pctxt, &lsize1);
3144
3145    stat = decodeOctetString (pctxt,
3146                           &pvalue->numocts,
3147                           pvalue->data,
3148                           sizeof(pvalue->data));
3149    if (stat != ASN_OK) return stat;
3150    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
3151
3152    return (stat);
3153 }
3154
3155 /**************************************************************/
3156 /*                                                            */
3157 /*  _SeqOfH225AliasAddress                                    */
3158 /*                                                            */
3159 /**************************************************************/
3160
3161 EXTERN int asn1PD_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue)
3162 {
3163    int stat = ASN_OK;
3164    H225AliasAddress* pdata;
3165    ASN1UINT count = 0;
3166    ASN1UINT xx1;
3167    int lstat;
3168
3169    dListInit (pvalue);
3170
3171    for (;;) {
3172       /* decode length determinant */
3173
3174       lstat = decodeLength (pctxt, &count);
3175       if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
3176          return lstat;
3177       }
3178
3179       /* decode elements */
3180
3181       for (xx1 = 0; xx1 < count; xx1++) {
3182          invokeStartElement (pctxt, "elem", xx1);
3183
3184          pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AliasAddress);
3185
3186          stat = asn1PD_H225AliasAddress (pctxt, pdata);
3187          if (stat != ASN_OK) return stat;
3188          invokeEndElement (pctxt, "elem", xx1);
3189
3190          dListAppendNode (pctxt, pvalue, pdata);
3191       }
3192
3193       if(lstat == ASN_OK) break;
3194    }
3195
3196    return (stat);
3197 }
3198
3199 /**************************************************************/
3200 /*                                                            */
3201 /*  VendorIdentifier                                          */
3202 /*                                                            */
3203 /**************************************************************/
3204
3205 EXTERN int asn1PD_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue)
3206 {
3207    int stat = ASN_OK;
3208    OOCTXT lctxt;
3209    OOCTXT lctxt2;
3210    ASN1OpenType openType;
3211    ASN1UINT bitcnt;
3212    ASN1UINT i;
3213    ASN1BOOL optbit = 0;
3214    ASN1BOOL extbit = 0;
3215
3216    /* extension bit */
3217
3218    DECODEBIT (pctxt, &extbit);
3219
3220    /* optional bits */
3221
3222    memset (&pvalue->m, 0, sizeof(pvalue->m));
3223
3224    DECODEBIT (pctxt, &optbit);
3225    pvalue->m.productIdPresent = optbit;
3226
3227    DECODEBIT (pctxt, &optbit);
3228    pvalue->m.versionIdPresent = optbit;
3229
3230    /* decode vendor */
3231
3232    invokeStartElement (pctxt, "vendor", -1);
3233
3234    stat = asn1PD_H225H221NonStandard (pctxt, &pvalue->vendor);
3235    if (stat != ASN_OK) return stat;
3236
3237    invokeEndElement (pctxt, "vendor", -1);
3238
3239    /* decode productId */
3240
3241    if (pvalue->m.productIdPresent) {
3242       invokeStartElement (pctxt, "productId", -1);
3243
3244       stat = asn1PD_H225VendorIdentifier_productId (pctxt, &pvalue->productId);
3245       if (stat != ASN_OK) return stat;
3246
3247       invokeEndElement (pctxt, "productId", -1);
3248    }
3249
3250    /* decode versionId */
3251
3252    if (pvalue->m.versionIdPresent) {
3253       invokeStartElement (pctxt, "versionId", -1);
3254
3255       stat = asn1PD_H225VendorIdentifier_versionId (pctxt, &pvalue->versionId);
3256       if (stat != ASN_OK) return stat;
3257
3258       invokeEndElement (pctxt, "versionId", -1);
3259    }
3260
3261    if (extbit) {
3262
3263       /* decode extension optional bits length */
3264
3265       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);