27200 lines
771 KiB
C
27200 lines
771 KiB
C
/*
|
|
* Copyright (C) 2004-2005 by Objective Systems, Inc.
|
|
*
|
|
* This software is furnished under an open source license and may be
|
|
* used and copied only in accordance with the terms of this license.
|
|
* The text of the license may generally be found in the root
|
|
* directory of this installation in the COPYING file. It
|
|
* can also be viewed online at the following URL:
|
|
*
|
|
* http://www.obj-sys.com/open/license.html
|
|
*
|
|
* Any redistributions of this file including modified versions must
|
|
* maintain this copyright notice.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "ooasn1.h"
|
|
#include "H323-MESSAGES.h"
|
|
#include "eventHandler.h"
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ScreeningIndicator */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (extbit) {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
*pvalue = ui;
|
|
}
|
|
else {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
switch (ui) {
|
|
case 0: *pvalue = userProvidedNotScreened; break;
|
|
case 1: *pvalue = userProvidedVerifiedAndPassed; break;
|
|
case 2: *pvalue = userProvidedVerifiedAndFailed; break;
|
|
case 3: *pvalue = networkProvided; break;
|
|
default: return ASN_E_INVENUM;
|
|
}
|
|
}
|
|
invokeUIntValue (pctxt, *pvalue);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* NumberDigits */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_NumberDigits_CharSet;
|
|
|
|
EXTERN int asn1PD_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, pvalue, gs_H323_MESSAGES_NumberDigits_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, *pvalue);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TBCD_STRING */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet;
|
|
|
|
EXTERN int asn1PD_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, pvalue, gs_H323_MESSAGES_TBCD_STRING_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, *pvalue);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GloballyUniqueID */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ConferenceIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = asn1PD_H225GloballyUniqueID (pctxt, pvalue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RequestSeqNum */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeConsUInt16 (pctxt, pvalue, 1U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, *pvalue);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatekeeperIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeBMPString (pctxt, pvalue, 0);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* BandWidth */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225BandWidth (OOCTXT* pctxt, H225BandWidth* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeConsUnsigned (pctxt, pvalue, 0U, ASN1UINT_MAX);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, *pvalue);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallReferenceValue */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeConsUInt16 (pctxt, pvalue, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, *pvalue);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* EndpointIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeBMPString (pctxt, pvalue, 0);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStr16BitValue (pctxt, pvalue->nchars, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ProtocolIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeObjectIdentifier (pctxt, pvalue);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->numids, pvalue->subid);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TimeToLive */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeConsUnsigned (pctxt, pvalue, 1U, ASN1UINT_MAX);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, *pvalue);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H248PackagesDescriptor */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H248SignalsDescriptor */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GenericIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* standard */
|
|
case 0:
|
|
invokeStartElement (pctxt, "standard", -1);
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (extbit == 0) {
|
|
stat = decodeConsInteger (pctxt, &pvalue->u.standard, 0, 16383);
|
|
if (stat != ASN_OK) return stat;
|
|
}
|
|
else {
|
|
stat = decodeUnconsInteger (pctxt, &pvalue->u.standard);
|
|
if (stat != ASN_OK) return stat;
|
|
}
|
|
invokeIntValue (pctxt, pvalue->u.standard);
|
|
|
|
invokeEndElement (pctxt, "standard", -1);
|
|
|
|
break;
|
|
|
|
/* oid */
|
|
case 1:
|
|
invokeStartElement (pctxt, "oid", -1);
|
|
|
|
pvalue->u.oid = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, pvalue->u.oid);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->u.oid->numids, pvalue->u.oid->subid);
|
|
|
|
invokeEndElement (pctxt, "oid", -1);
|
|
|
|
break;
|
|
|
|
/* nonStandard */
|
|
case 2:
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225GloballyUniqueID);
|
|
|
|
stat = asn1PD_H225GloballyUniqueID (pctxt, pvalue->u.nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipAddress_ip */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode ip */
|
|
|
|
invokeStartElement (pctxt, "ip", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipAddress_ip (pctxt, &pvalue->ip);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ip", -1);
|
|
|
|
/* decode port */
|
|
|
|
invokeStartElement (pctxt, "port", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->port);
|
|
|
|
invokeEndElement (pctxt, "port", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipSourceRoute_ip */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipSourceRoute_route_element */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225TransportAddress_ipSourceRoute_route_element */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, H225TransportAddress_ipSourceRoute_route_element);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipSourceRoute_routing */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* strict */
|
|
case 0:
|
|
invokeStartElement (pctxt, "strict", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "strict", -1);
|
|
|
|
break;
|
|
|
|
/* loose */
|
|
case 1:
|
|
invokeStartElement (pctxt, "loose", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "loose", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipSourceRoute */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode ip */
|
|
|
|
invokeStartElement (pctxt, "ip", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipSourceRoute_ip (pctxt, &pvalue->ip);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ip", -1);
|
|
|
|
/* decode port */
|
|
|
|
invokeStartElement (pctxt, "port", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->port);
|
|
|
|
invokeEndElement (pctxt, "port", -1);
|
|
|
|
/* decode route */
|
|
|
|
invokeStartElement (pctxt, "route", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->route);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "route", -1);
|
|
|
|
/* decode routing */
|
|
|
|
invokeStartElement (pctxt, "routing", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipSourceRoute_routing (pctxt, &pvalue->routing);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "routing", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipxAddress_node */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipxAddress_netnum */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipxAddress_port */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ipxAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode node */
|
|
|
|
invokeStartElement (pctxt, "node", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipxAddress_node (pctxt, &pvalue->node);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "node", -1);
|
|
|
|
/* decode netnum */
|
|
|
|
invokeStartElement (pctxt, "netnum", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipxAddress_netnum (pctxt, &pvalue->netnum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "netnum", -1);
|
|
|
|
/* decode port */
|
|
|
|
invokeStartElement (pctxt, "port", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipxAddress_port (pctxt, &pvalue->port);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "port", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ip6Address_ip */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_ip6Address */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode ip */
|
|
|
|
invokeStartElement (pctxt, "ip", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress_ip6Address_ip (pctxt, &pvalue->ip);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ip", -1);
|
|
|
|
/* decode port */
|
|
|
|
invokeStartElement (pctxt, "port", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->port, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->port);
|
|
|
|
invokeEndElement (pctxt, "port", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_netBios */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress_nsap */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H221NonStandard */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode t35CountryCode */
|
|
|
|
invokeStartElement (pctxt, "t35CountryCode", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->t35CountryCode, 0U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->t35CountryCode);
|
|
|
|
invokeEndElement (pctxt, "t35CountryCode", -1);
|
|
|
|
/* decode t35Extension */
|
|
|
|
invokeStartElement (pctxt, "t35Extension", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->t35Extension, 0U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->t35Extension);
|
|
|
|
invokeEndElement (pctxt, "t35Extension", -1);
|
|
|
|
/* decode manufacturerCode */
|
|
|
|
invokeStartElement (pctxt, "manufacturerCode", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->manufacturerCode, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->manufacturerCode);
|
|
|
|
invokeEndElement (pctxt, "manufacturerCode", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* NonStandardIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* object */
|
|
case 0:
|
|
invokeStartElement (pctxt, "object", -1);
|
|
|
|
pvalue->u.object = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, pvalue->u.object);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->u.object->numids, pvalue->u.object->subid);
|
|
|
|
invokeEndElement (pctxt, "object", -1);
|
|
|
|
break;
|
|
|
|
/* h221NonStandard */
|
|
case 1:
|
|
invokeStartElement (pctxt, "h221NonStandard", -1);
|
|
|
|
pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H225H221NonStandard);
|
|
|
|
stat = asn1PD_H225H221NonStandard (pctxt, pvalue->u.h221NonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h221NonStandard", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* NonStandardParameter */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode nonStandardIdentifier */
|
|
|
|
invokeStartElement (pctxt, "nonStandardIdentifier", -1);
|
|
|
|
stat = asn1PD_H225NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardIdentifier", -1);
|
|
|
|
/* decode data */
|
|
|
|
invokeStartElement (pctxt, "data", -1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->data);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->data.numocts, pvalue->data.data);
|
|
|
|
invokeEndElement (pctxt, "data", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* ipAddress */
|
|
case 0:
|
|
invokeStartElement (pctxt, "ipAddress", -1);
|
|
|
|
pvalue->u.ipAddress = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipAddress);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipAddress (pctxt, pvalue->u.ipAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ipAddress", -1);
|
|
|
|
break;
|
|
|
|
/* ipSourceRoute */
|
|
case 1:
|
|
invokeStartElement (pctxt, "ipSourceRoute", -1);
|
|
|
|
pvalue->u.ipSourceRoute = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipSourceRoute);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipSourceRoute (pctxt, pvalue->u.ipSourceRoute);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ipSourceRoute", -1);
|
|
|
|
break;
|
|
|
|
/* ipxAddress */
|
|
case 2:
|
|
invokeStartElement (pctxt, "ipxAddress", -1);
|
|
|
|
pvalue->u.ipxAddress = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ipxAddress);
|
|
|
|
stat = asn1PD_H225TransportAddress_ipxAddress (pctxt, pvalue->u.ipxAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ipxAddress", -1);
|
|
|
|
break;
|
|
|
|
/* ip6Address */
|
|
case 3:
|
|
invokeStartElement (pctxt, "ip6Address", -1);
|
|
|
|
pvalue->u.ip6Address = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_ip6Address);
|
|
|
|
stat = asn1PD_H225TransportAddress_ip6Address (pctxt, pvalue->u.ip6Address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ip6Address", -1);
|
|
|
|
break;
|
|
|
|
/* netBios */
|
|
case 4:
|
|
invokeStartElement (pctxt, "netBios", -1);
|
|
|
|
pvalue->u.netBios = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_netBios);
|
|
|
|
stat = asn1PD_H225TransportAddress_netBios (pctxt, pvalue->u.netBios);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "netBios", -1);
|
|
|
|
break;
|
|
|
|
/* nsap */
|
|
case 5:
|
|
invokeStartElement (pctxt, "nsap", -1);
|
|
|
|
pvalue->u.nsap = ALLOC_ASN1ELEM (pctxt, H225TransportAddress_nsap);
|
|
|
|
stat = asn1PD_H225TransportAddress_nsap (pctxt, pvalue->u.nsap);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nsap", -1);
|
|
|
|
break;
|
|
|
|
/* nonStandardAddress */
|
|
case 6:
|
|
invokeStartElement (pctxt, "nonStandardAddress", -1);
|
|
|
|
pvalue->u.nonStandardAddress = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandardAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardAddress", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 8;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* PublicTypeOfNumber */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* unknown */
|
|
case 0:
|
|
invokeStartElement (pctxt, "unknown", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "unknown", -1);
|
|
|
|
break;
|
|
|
|
/* internationalNumber */
|
|
case 1:
|
|
invokeStartElement (pctxt, "internationalNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "internationalNumber", -1);
|
|
|
|
break;
|
|
|
|
/* nationalNumber */
|
|
case 2:
|
|
invokeStartElement (pctxt, "nationalNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "nationalNumber", -1);
|
|
|
|
break;
|
|
|
|
/* networkSpecificNumber */
|
|
case 3:
|
|
invokeStartElement (pctxt, "networkSpecificNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "networkSpecificNumber", -1);
|
|
|
|
break;
|
|
|
|
/* subscriberNumber */
|
|
case 4:
|
|
invokeStartElement (pctxt, "subscriberNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "subscriberNumber", -1);
|
|
|
|
break;
|
|
|
|
/* abbreviatedNumber */
|
|
case 5:
|
|
invokeStartElement (pctxt, "abbreviatedNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "abbreviatedNumber", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 7;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* PublicPartyNumber */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode publicTypeOfNumber */
|
|
|
|
invokeStartElement (pctxt, "publicTypeOfNumber", -1);
|
|
|
|
stat = asn1PD_H225PublicTypeOfNumber (pctxt, &pvalue->publicTypeOfNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "publicTypeOfNumber", -1);
|
|
|
|
/* decode publicNumberDigits */
|
|
|
|
invokeStartElement (pctxt, "publicNumberDigits", -1);
|
|
|
|
stat = asn1PD_H225NumberDigits (pctxt, &pvalue->publicNumberDigits);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "publicNumberDigits", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* PrivateTypeOfNumber */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* unknown */
|
|
case 0:
|
|
invokeStartElement (pctxt, "unknown", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "unknown", -1);
|
|
|
|
break;
|
|
|
|
/* level2RegionalNumber */
|
|
case 1:
|
|
invokeStartElement (pctxt, "level2RegionalNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "level2RegionalNumber", -1);
|
|
|
|
break;
|
|
|
|
/* level1RegionalNumber */
|
|
case 2:
|
|
invokeStartElement (pctxt, "level1RegionalNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "level1RegionalNumber", -1);
|
|
|
|
break;
|
|
|
|
/* pISNSpecificNumber */
|
|
case 3:
|
|
invokeStartElement (pctxt, "pISNSpecificNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "pISNSpecificNumber", -1);
|
|
|
|
break;
|
|
|
|
/* localNumber */
|
|
case 4:
|
|
invokeStartElement (pctxt, "localNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "localNumber", -1);
|
|
|
|
break;
|
|
|
|
/* abbreviatedNumber */
|
|
case 5:
|
|
invokeStartElement (pctxt, "abbreviatedNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "abbreviatedNumber", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 7;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* PrivatePartyNumber */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode privateTypeOfNumber */
|
|
|
|
invokeStartElement (pctxt, "privateTypeOfNumber", -1);
|
|
|
|
stat = asn1PD_H225PrivateTypeOfNumber (pctxt, &pvalue->privateTypeOfNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "privateTypeOfNumber", -1);
|
|
|
|
/* decode privateNumberDigits */
|
|
|
|
invokeStartElement (pctxt, "privateNumberDigits", -1);
|
|
|
|
stat = asn1PD_H225NumberDigits (pctxt, &pvalue->privateNumberDigits);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "privateNumberDigits", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* PartyNumber */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* e164Number */
|
|
case 0:
|
|
invokeStartElement (pctxt, "e164Number", -1);
|
|
|
|
pvalue->u.e164Number = ALLOC_ASN1ELEM (pctxt, H225PublicPartyNumber);
|
|
|
|
stat = asn1PD_H225PublicPartyNumber (pctxt, pvalue->u.e164Number);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "e164Number", -1);
|
|
|
|
break;
|
|
|
|
/* dataPartyNumber */
|
|
case 1:
|
|
invokeStartElement (pctxt, "dataPartyNumber", -1);
|
|
|
|
stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.dataPartyNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataPartyNumber", -1);
|
|
|
|
break;
|
|
|
|
/* telexPartyNumber */
|
|
case 2:
|
|
invokeStartElement (pctxt, "telexPartyNumber", -1);
|
|
|
|
stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.telexPartyNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "telexPartyNumber", -1);
|
|
|
|
break;
|
|
|
|
/* privateNumber */
|
|
case 3:
|
|
invokeStartElement (pctxt, "privateNumber", -1);
|
|
|
|
pvalue->u.privateNumber = ALLOC_ASN1ELEM (pctxt, H225PrivatePartyNumber);
|
|
|
|
stat = asn1PD_H225PrivatePartyNumber (pctxt, pvalue->u.privateNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "privateNumber", -1);
|
|
|
|
break;
|
|
|
|
/* nationalStandardPartyNumber */
|
|
case 4:
|
|
invokeStartElement (pctxt, "nationalStandardPartyNumber", -1);
|
|
|
|
stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.nationalStandardPartyNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nationalStandardPartyNumber", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 6;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ANSI_41_UIM_system_id */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet;
|
|
|
|
EXTERN int asn1PD_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue)
|
|
{
|
|
static Asn1SizeCnst sid_lsize1 = { 0, 1, 4, 0 };
|
|
static Asn1SizeCnst mid_lsize1 = { 0, 1, 4, 0 };
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* sid */
|
|
case 0:
|
|
invokeStartElement (pctxt, "sid", -1);
|
|
|
|
addSizeConstraint (pctxt, &sid_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->u.sid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->u.sid);
|
|
|
|
invokeEndElement (pctxt, "sid", -1);
|
|
|
|
break;
|
|
|
|
/* mid */
|
|
case 1:
|
|
invokeStartElement (pctxt, "mid", -1);
|
|
|
|
addSizeConstraint (pctxt, &mid_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->u.mid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->u.mid);
|
|
|
|
invokeEndElement (pctxt, "mid", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ANSI_41_UIM_systemMyTypeCode */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ANSI_41_UIM_systemAccessType */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ANSI_41_UIM_qualificationInformationCode */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 1, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ANSI_41_UIM */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet;
|
|
|
|
EXTERN int asn1PD_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue)
|
|
{
|
|
static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
|
|
static Asn1SizeCnst min_lsize1 = { 0, 3, 16, 0 };
|
|
static Asn1SizeCnst mdn_lsize1 = { 0, 3, 16, 0 };
|
|
static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
|
|
static Asn1SizeCnst esn_lsize1 = { 0, 16, 16, 0 };
|
|
static Asn1SizeCnst mscid_lsize1 = { 0, 3, 16, 0 };
|
|
static Asn1SizeCnst sesn_lsize1 = { 0, 16, 16, 0 };
|
|
static Asn1SizeCnst soc_lsize1 = { 0, 3, 16, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.imsiPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.minPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.mdnPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.msisdnPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.esnPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.mscidPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.systemMyTypeCodePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.systemAccessTypePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.qualificationInformationCodePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.sesnPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.socPresent = optbit;
|
|
|
|
/* decode imsi */
|
|
|
|
if (pvalue->m.imsiPresent) {
|
|
invokeStartElement (pctxt, "imsi", -1);
|
|
|
|
addSizeConstraint (pctxt, &imsi_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->imsi);
|
|
|
|
invokeEndElement (pctxt, "imsi", -1);
|
|
}
|
|
|
|
/* decode min */
|
|
|
|
if (pvalue->m.minPresent) {
|
|
invokeStartElement (pctxt, "min", -1);
|
|
|
|
addSizeConstraint (pctxt, &min_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->min, gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->min);
|
|
|
|
invokeEndElement (pctxt, "min", -1);
|
|
}
|
|
|
|
/* decode mdn */
|
|
|
|
if (pvalue->m.mdnPresent) {
|
|
invokeStartElement (pctxt, "mdn", -1);
|
|
|
|
addSizeConstraint (pctxt, &mdn_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->mdn, gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->mdn);
|
|
|
|
invokeEndElement (pctxt, "mdn", -1);
|
|
}
|
|
|
|
/* decode msisdn */
|
|
|
|
if (pvalue->m.msisdnPresent) {
|
|
invokeStartElement (pctxt, "msisdn", -1);
|
|
|
|
addSizeConstraint (pctxt, &msisdn_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->msisdn);
|
|
|
|
invokeEndElement (pctxt, "msisdn", -1);
|
|
}
|
|
|
|
/* decode esn */
|
|
|
|
if (pvalue->m.esnPresent) {
|
|
invokeStartElement (pctxt, "esn", -1);
|
|
|
|
addSizeConstraint (pctxt, &esn_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->esn, gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->esn);
|
|
|
|
invokeEndElement (pctxt, "esn", -1);
|
|
}
|
|
|
|
/* decode mscid */
|
|
|
|
if (pvalue->m.mscidPresent) {
|
|
invokeStartElement (pctxt, "mscid", -1);
|
|
|
|
addSizeConstraint (pctxt, &mscid_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->mscid, gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->mscid);
|
|
|
|
invokeEndElement (pctxt, "mscid", -1);
|
|
}
|
|
|
|
/* decode system_id */
|
|
|
|
invokeStartElement (pctxt, "system_id", -1);
|
|
|
|
stat = asn1PD_H225ANSI_41_UIM_system_id (pctxt, &pvalue->system_id);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "system_id", -1);
|
|
|
|
/* decode systemMyTypeCode */
|
|
|
|
if (pvalue->m.systemMyTypeCodePresent) {
|
|
invokeStartElement (pctxt, "systemMyTypeCode", -1);
|
|
|
|
stat = asn1PD_H225ANSI_41_UIM_systemMyTypeCode (pctxt, &pvalue->systemMyTypeCode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "systemMyTypeCode", -1);
|
|
}
|
|
|
|
/* decode systemAccessType */
|
|
|
|
if (pvalue->m.systemAccessTypePresent) {
|
|
invokeStartElement (pctxt, "systemAccessType", -1);
|
|
|
|
stat = asn1PD_H225ANSI_41_UIM_systemAccessType (pctxt, &pvalue->systemAccessType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "systemAccessType", -1);
|
|
}
|
|
|
|
/* decode qualificationInformationCode */
|
|
|
|
if (pvalue->m.qualificationInformationCodePresent) {
|
|
invokeStartElement (pctxt, "qualificationInformationCode", -1);
|
|
|
|
stat = asn1PD_H225ANSI_41_UIM_qualificationInformationCode (pctxt, &pvalue->qualificationInformationCode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "qualificationInformationCode", -1);
|
|
}
|
|
|
|
/* decode sesn */
|
|
|
|
if (pvalue->m.sesnPresent) {
|
|
invokeStartElement (pctxt, "sesn", -1);
|
|
|
|
addSizeConstraint (pctxt, &sesn_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->sesn, gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->sesn);
|
|
|
|
invokeEndElement (pctxt, "sesn", -1);
|
|
}
|
|
|
|
/* decode soc */
|
|
|
|
if (pvalue->m.socPresent) {
|
|
invokeStartElement (pctxt, "soc", -1);
|
|
|
|
addSizeConstraint (pctxt, &soc_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->soc, gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->soc);
|
|
|
|
invokeEndElement (pctxt, "soc", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GSM_UIM_tmsi */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 4, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GSM_UIM */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet;
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet;
|
|
|
|
EXTERN int asn1PD_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue)
|
|
{
|
|
static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
|
|
static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
|
|
static Asn1SizeCnst imei_lsize1 = { 0, 15, 16, 0 };
|
|
static Asn1SizeCnst hplmn_lsize1 = { 0, 1, 4, 0 };
|
|
static Asn1SizeCnst vplmn_lsize1 = { 0, 1, 4, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.imsiPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tmsiPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.msisdnPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.imeiPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.hplmnPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.vplmnPresent = optbit;
|
|
|
|
/* decode imsi */
|
|
|
|
if (pvalue->m.imsiPresent) {
|
|
invokeStartElement (pctxt, "imsi", -1);
|
|
|
|
addSizeConstraint (pctxt, &imsi_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_GSM_UIM_imsi_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->imsi);
|
|
|
|
invokeEndElement (pctxt, "imsi", -1);
|
|
}
|
|
|
|
/* decode tmsi */
|
|
|
|
if (pvalue->m.tmsiPresent) {
|
|
invokeStartElement (pctxt, "tmsi", -1);
|
|
|
|
stat = asn1PD_H225GSM_UIM_tmsi (pctxt, &pvalue->tmsi);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tmsi", -1);
|
|
}
|
|
|
|
/* decode msisdn */
|
|
|
|
if (pvalue->m.msisdnPresent) {
|
|
invokeStartElement (pctxt, "msisdn", -1);
|
|
|
|
addSizeConstraint (pctxt, &msisdn_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->msisdn);
|
|
|
|
invokeEndElement (pctxt, "msisdn", -1);
|
|
}
|
|
|
|
/* decode imei */
|
|
|
|
if (pvalue->m.imeiPresent) {
|
|
invokeStartElement (pctxt, "imei", -1);
|
|
|
|
addSizeConstraint (pctxt, &imei_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->imei, gs_H323_MESSAGES_GSM_UIM_imei_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->imei);
|
|
|
|
invokeEndElement (pctxt, "imei", -1);
|
|
}
|
|
|
|
/* decode hplmn */
|
|
|
|
if (pvalue->m.hplmnPresent) {
|
|
invokeStartElement (pctxt, "hplmn", -1);
|
|
|
|
addSizeConstraint (pctxt, &hplmn_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->hplmn, gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->hplmn);
|
|
|
|
invokeEndElement (pctxt, "hplmn", -1);
|
|
}
|
|
|
|
/* decode vplmn */
|
|
|
|
if (pvalue->m.vplmnPresent) {
|
|
invokeStartElement (pctxt, "vplmn", -1);
|
|
|
|
addSizeConstraint (pctxt, &vplmn_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->vplmn, gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->vplmn);
|
|
|
|
invokeEndElement (pctxt, "vplmn", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* MobileUIM */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* ansi_41_uim */
|
|
case 0:
|
|
invokeStartElement (pctxt, "ansi_41_uim", -1);
|
|
|
|
pvalue->u.ansi_41_uim = ALLOC_ASN1ELEM (pctxt, H225ANSI_41_UIM);
|
|
|
|
stat = asn1PD_H225ANSI_41_UIM (pctxt, pvalue->u.ansi_41_uim);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ansi_41_uim", -1);
|
|
|
|
break;
|
|
|
|
/* gsm_uim */
|
|
case 1:
|
|
invokeStartElement (pctxt, "gsm_uim", -1);
|
|
|
|
pvalue->u.gsm_uim = ALLOC_ASN1ELEM (pctxt, H225GSM_UIM);
|
|
|
|
stat = asn1PD_H225GSM_UIM (pctxt, pvalue->u.gsm_uim);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gsm_uim", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AliasAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
extern EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet;
|
|
|
|
EXTERN int asn1PD_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue)
|
|
{
|
|
static Asn1SizeCnst dialedDigits_lsize1 = { 0, 1, 128, 0 };
|
|
static Asn1SizeCnst h323_ID_lsize1 = { 0, 1, 256, 0 };
|
|
static Asn1SizeCnst url_ID_lsize1 = { 0, 1, 512, 0 };
|
|
static Asn1SizeCnst email_ID_lsize1 = { 0, 1, 512, 0 };
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* dialedDigits */
|
|
case 0:
|
|
invokeStartElement (pctxt, "dialedDigits", -1);
|
|
|
|
addSizeConstraint (pctxt, &dialedDigits_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->u.dialedDigits, gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet, 4, 4, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->u.dialedDigits);
|
|
|
|
invokeEndElement (pctxt, "dialedDigits", -1);
|
|
|
|
break;
|
|
|
|
/* h323_ID */
|
|
case 1:
|
|
invokeStartElement (pctxt, "h323_ID", -1);
|
|
|
|
addSizeConstraint (pctxt, &h323_ID_lsize1);
|
|
|
|
stat = decodeBMPString (pctxt, &pvalue->u.h323_ID, 0);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStr16BitValue (pctxt, pvalue->u.h323_ID.nchars, pvalue->u.h323_ID.data);
|
|
|
|
invokeEndElement (pctxt, "h323_ID", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* url_ID */
|
|
case 3:
|
|
invokeStartElement (pctxt, "url_ID", -1);
|
|
|
|
addSizeConstraint (pctxt, &url_ID_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->u.url_ID, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->u.url_ID);
|
|
|
|
invokeEndElement (pctxt, "url_ID", -1);
|
|
|
|
break;
|
|
|
|
/* transportID */
|
|
case 4:
|
|
invokeStartElement (pctxt, "transportID", -1);
|
|
|
|
pvalue->u.transportID = ALLOC_ASN1ELEM (pctxt, H225TransportAddress);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, pvalue->u.transportID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "transportID", -1);
|
|
|
|
break;
|
|
|
|
/* email_ID */
|
|
case 5:
|
|
invokeStartElement (pctxt, "email_ID", -1);
|
|
|
|
addSizeConstraint (pctxt, &email_ID_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->u.email_ID, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->u.email_ID);
|
|
|
|
invokeEndElement (pctxt, "email_ID", -1);
|
|
|
|
break;
|
|
|
|
/* partyNumber */
|
|
case 6:
|
|
invokeStartElement (pctxt, "partyNumber", -1);
|
|
|
|
pvalue->u.partyNumber = ALLOC_ASN1ELEM (pctxt, H225PartyNumber);
|
|
|
|
stat = asn1PD_H225PartyNumber (pctxt, pvalue->u.partyNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "partyNumber", -1);
|
|
|
|
break;
|
|
|
|
/* mobileUIM */
|
|
case 7:
|
|
invokeStartElement (pctxt, "mobileUIM", -1);
|
|
|
|
pvalue->u.mobileUIM = ALLOC_ASN1ELEM (pctxt, H225MobileUIM);
|
|
|
|
stat = asn1PD_H225MobileUIM (pctxt, pvalue->u.mobileUIM);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "mobileUIM", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Content_compound */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
|
|
int stat = ASN_OK;
|
|
H225EnumeratedParameter* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeLength (pctxt, &count);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225EnumeratedParameter);
|
|
|
|
stat = asn1PD_H225EnumeratedParameter (pctxt, (H225EnumeratedParameter*)pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Content_nested */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 };
|
|
int stat = ASN_OK;
|
|
H225GenericData* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeLength (pctxt, &count);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225GenericData);
|
|
|
|
stat = asn1PD_H225GenericData (pctxt, (H225GenericData*)pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Content */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Content (OOCTXT* pctxt, H225Content* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 11);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* raw */
|
|
case 0:
|
|
invokeStartElement (pctxt, "raw", -1);
|
|
|
|
pvalue->u.raw = ALLOC_ASN1ELEM (pctxt, ASN1DynOctStr);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue->u.raw);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->u.raw->numocts, pvalue->u.raw->data);
|
|
|
|
invokeEndElement (pctxt, "raw", -1);
|
|
|
|
break;
|
|
|
|
/* text */
|
|
case 1:
|
|
invokeStartElement (pctxt, "text", -1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->u.text, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->u.text);
|
|
|
|
invokeEndElement (pctxt, "text", -1);
|
|
|
|
break;
|
|
|
|
/* unicode */
|
|
case 2:
|
|
invokeStartElement (pctxt, "unicode", -1);
|
|
|
|
stat = decodeBMPString (pctxt, &pvalue->u.unicode, 0);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStr16BitValue (pctxt, pvalue->u.unicode.nchars, pvalue->u.unicode.data);
|
|
|
|
invokeEndElement (pctxt, "unicode", -1);
|
|
|
|
break;
|
|
|
|
/* bool_ */
|
|
case 3:
|
|
invokeStartElement (pctxt, "bool_", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->u.bool_);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->u.bool_);
|
|
|
|
invokeEndElement (pctxt, "bool_", -1);
|
|
|
|
break;
|
|
|
|
/* number8 */
|
|
case 4:
|
|
invokeStartElement (pctxt, "number8", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->u.number8, 0U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->u.number8);
|
|
|
|
invokeEndElement (pctxt, "number8", -1);
|
|
|
|
break;
|
|
|
|
/* number16 */
|
|
case 5:
|
|
invokeStartElement (pctxt, "number16", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->u.number16, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->u.number16);
|
|
|
|
invokeEndElement (pctxt, "number16", -1);
|
|
|
|
break;
|
|
|
|
/* number32 */
|
|
case 6:
|
|
invokeStartElement (pctxt, "number32", -1);
|
|
|
|
stat = decodeConsUnsigned (pctxt, &pvalue->u.number32, 0U, ASN1UINT_MAX);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->u.number32);
|
|
|
|
invokeEndElement (pctxt, "number32", -1);
|
|
|
|
break;
|
|
|
|
/* id */
|
|
case 7:
|
|
invokeStartElement (pctxt, "id", -1);
|
|
|
|
pvalue->u.id = ALLOC_ASN1ELEM (pctxt, H225GenericIdentifier);
|
|
|
|
stat = asn1PD_H225GenericIdentifier (pctxt, pvalue->u.id);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "id", -1);
|
|
|
|
break;
|
|
|
|
/* alias */
|
|
case 8:
|
|
invokeStartElement (pctxt, "alias", -1);
|
|
|
|
pvalue->u.alias = ALLOC_ASN1ELEM (pctxt, H225AliasAddress);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, pvalue->u.alias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alias", -1);
|
|
|
|
break;
|
|
|
|
/* transport */
|
|
case 9:
|
|
invokeStartElement (pctxt, "transport", -1);
|
|
|
|
pvalue->u.transport = ALLOC_ASN1ELEM (pctxt, H225TransportAddress);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, pvalue->u.transport);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "transport", -1);
|
|
|
|
break;
|
|
|
|
/* compound */
|
|
case 10:
|
|
invokeStartElement (pctxt, "compound", -1);
|
|
|
|
pvalue->u.compound = ALLOC_ASN1ELEM (pctxt, H225Content_compound);
|
|
|
|
stat = asn1PD_H225Content_compound (pctxt, pvalue->u.compound);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "compound", -1);
|
|
|
|
break;
|
|
|
|
/* nested */
|
|
case 11:
|
|
invokeStartElement (pctxt, "nested", -1);
|
|
|
|
pvalue->u.nested = ALLOC_ASN1ELEM (pctxt, H225Content_nested);
|
|
|
|
stat = asn1PD_H225Content_nested (pctxt, pvalue->u.nested);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nested", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 13;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* EnumeratedParameter */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.contentPresent = optbit;
|
|
|
|
/* decode id */
|
|
|
|
invokeStartElement (pctxt, "id", -1);
|
|
|
|
stat = asn1PD_H225GenericIdentifier (pctxt, &pvalue->id);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "id", -1);
|
|
|
|
/* decode content */
|
|
|
|
if (pvalue->m.contentPresent) {
|
|
invokeStartElement (pctxt, "content", -1);
|
|
|
|
stat = asn1PD_H225Content (pctxt, &pvalue->content);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "content", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GenericData_parameters */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 };
|
|
int stat = ASN_OK;
|
|
H225EnumeratedParameter* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeLength (pctxt, &count);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225EnumeratedParameter);
|
|
|
|
stat = asn1PD_H225EnumeratedParameter (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GenericData */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.parametersPresent = optbit;
|
|
|
|
/* decode id */
|
|
|
|
invokeStartElement (pctxt, "id", -1);
|
|
|
|
stat = asn1PD_H225GenericIdentifier (pctxt, &pvalue->id);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "id", -1);
|
|
|
|
/* decode parameters */
|
|
|
|
if (pvalue->m.parametersPresent) {
|
|
invokeStartElement (pctxt, "parameters", -1);
|
|
|
|
stat = asn1PD_H225GenericData_parameters (pctxt, &pvalue->parameters);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "parameters", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* FeatureDescriptor */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = asn1PD_H225GenericData (pctxt, pvalue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* FastStartToken */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = asn1PD_H235ClearToken (pctxt, pvalue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* EncodedFastStartToken */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
stat = decodeOpenType (pctxt, &pvalue->data, &pvalue->numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOpenTypeValue
|
|
(pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UserInformation_user_data_user_information */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 131, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* EndpointType_set */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 32, 32, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeBitString (pctxt,
|
|
&pvalue->numbits,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* VendorIdentifier_productId */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* VendorIdentifier_versionId */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CicInfo_cic_element */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 2, 4, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CicInfo_pointCode */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 2, 5, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CarrierInfo_carrierIdentificationCode */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 3, 4, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallTerminationCause_releaseCompleteCauseIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue)
|
|
{
|
|
static Asn1SizeCnst lsize1 = { 0, 2, 32, 0 };
|
|
int stat = ASN_OK;
|
|
|
|
addSizeConstraint (pctxt, &lsize1);
|
|
|
|
stat = decodeOctetString (pctxt,
|
|
&pvalue->numocts,
|
|
pvalue->data,
|
|
sizeof(pvalue->data));
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225AliasAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225AliasAddress* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AliasAddress);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* VendorIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.productIdPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.versionIdPresent = optbit;
|
|
|
|
/* decode vendor */
|
|
|
|
invokeStartElement (pctxt, "vendor", -1);
|
|
|
|
stat = asn1PD_H225H221NonStandard (pctxt, &pvalue->vendor);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "vendor", -1);
|
|
|
|
/* decode productId */
|
|
|
|
if (pvalue->m.productIdPresent) {
|
|
invokeStartElement (pctxt, "productId", -1);
|
|
|
|
stat = asn1PD_H225VendorIdentifier_productId (pctxt, &pvalue->productId);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "productId", -1);
|
|
}
|
|
|
|
/* decode versionId */
|
|
|
|
if (pvalue->m.versionIdPresent) {
|
|
invokeStartElement (pctxt, "versionId", -1);
|
|
|
|
stat = asn1PD_H225VendorIdentifier_versionId (pctxt, &pvalue->versionId);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "versionId", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 1 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.enterpriseNumberPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "enterpriseNumber", -1);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, &pvalue->enterpriseNumber);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->enterpriseNumber.numids, pvalue->enterpriseNumber.subid);
|
|
|
|
invokeEndElement (pctxt, "enterpriseNumber", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatekeeperInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* DataRate */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.channelMultiplierPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode channelRate */
|
|
|
|
invokeStartElement (pctxt, "channelRate", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->channelRate);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "channelRate", -1);
|
|
|
|
/* decode channelMultiplier */
|
|
|
|
if (pvalue->m.channelMultiplierPresent) {
|
|
invokeStartElement (pctxt, "channelMultiplier", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->channelMultiplier, 1U, 256U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->channelMultiplier);
|
|
|
|
invokeEndElement (pctxt, "channelMultiplier", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225DataRate */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225DataRate* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225DataRate);
|
|
|
|
stat = asn1PD_H225DataRate (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SupportedPrefix */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode prefix */
|
|
|
|
invokeStartElement (pctxt, "prefix", -1);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, &pvalue->prefix);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "prefix", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225SupportedPrefix */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225SupportedPrefix* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225SupportedPrefix);
|
|
|
|
stat = asn1PD_H225SupportedPrefix (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H310Caps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H320Caps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H321Caps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H322Caps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323Caps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H324Caps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* VoiceCaps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* T120OnlyCaps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.dataRatesSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* NonStandardProtocol */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.dataRatesSupportedPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode dataRatesSupported */
|
|
|
|
if (pvalue->m.dataRatesSupportedPresent) {
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
}
|
|
|
|
/* decode supportedPrefixes */
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* T38FaxAnnexbOnlyCaps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.dataRatesSupportedPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode dataRatesSupported */
|
|
|
|
if (pvalue->m.dataRatesSupportedPresent) {
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
}
|
|
|
|
/* decode supportedPrefixes */
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
/* decode t38FaxProtocol */
|
|
|
|
invokeStartElement (pctxt, "t38FaxProtocol", -1);
|
|
|
|
stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "t38FaxProtocol", -1);
|
|
|
|
/* decode t38FaxProfile */
|
|
|
|
invokeStartElement (pctxt, "t38FaxProfile", -1);
|
|
|
|
stat = asn1PD_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "t38FaxProfile", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SIPCaps */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.dataRatesSupportedPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.supportedPrefixesPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode dataRatesSupported */
|
|
|
|
if (pvalue->m.dataRatesSupportedPresent) {
|
|
invokeStartElement (pctxt, "dataRatesSupported", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "dataRatesSupported", -1);
|
|
}
|
|
|
|
/* decode supportedPrefixes */
|
|
|
|
if (pvalue->m.supportedPrefixesPresent) {
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SupportedProtocols */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 8);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* nonStandardData */
|
|
case 0:
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
pvalue->u.nonStandardData = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
|
|
break;
|
|
|
|
/* h310 */
|
|
case 1:
|
|
invokeStartElement (pctxt, "h310", -1);
|
|
|
|
pvalue->u.h310 = ALLOC_ASN1ELEM (pctxt, H225H310Caps);
|
|
|
|
stat = asn1PD_H225H310Caps (pctxt, pvalue->u.h310);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h310", -1);
|
|
|
|
break;
|
|
|
|
/* h320 */
|
|
case 2:
|
|
invokeStartElement (pctxt, "h320", -1);
|
|
|
|
pvalue->u.h320 = ALLOC_ASN1ELEM (pctxt, H225H320Caps);
|
|
|
|
stat = asn1PD_H225H320Caps (pctxt, pvalue->u.h320);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h320", -1);
|
|
|
|
break;
|
|
|
|
/* h321 */
|
|
case 3:
|
|
invokeStartElement (pctxt, "h321", -1);
|
|
|
|
pvalue->u.h321 = ALLOC_ASN1ELEM (pctxt, H225H321Caps);
|
|
|
|
stat = asn1PD_H225H321Caps (pctxt, pvalue->u.h321);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h321", -1);
|
|
|
|
break;
|
|
|
|
/* h322 */
|
|
case 4:
|
|
invokeStartElement (pctxt, "h322", -1);
|
|
|
|
pvalue->u.h322 = ALLOC_ASN1ELEM (pctxt, H225H322Caps);
|
|
|
|
stat = asn1PD_H225H322Caps (pctxt, pvalue->u.h322);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h322", -1);
|
|
|
|
break;
|
|
|
|
/* h323 */
|
|
case 5:
|
|
invokeStartElement (pctxt, "h323", -1);
|
|
|
|
pvalue->u.h323 = ALLOC_ASN1ELEM (pctxt, H225H323Caps);
|
|
|
|
stat = asn1PD_H225H323Caps (pctxt, pvalue->u.h323);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h323", -1);
|
|
|
|
break;
|
|
|
|
/* h324 */
|
|
case 6:
|
|
invokeStartElement (pctxt, "h324", -1);
|
|
|
|
pvalue->u.h324 = ALLOC_ASN1ELEM (pctxt, H225H324Caps);
|
|
|
|
stat = asn1PD_H225H324Caps (pctxt, pvalue->u.h324);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h324", -1);
|
|
|
|
break;
|
|
|
|
/* voice */
|
|
case 7:
|
|
invokeStartElement (pctxt, "voice", -1);
|
|
|
|
pvalue->u.voice = ALLOC_ASN1ELEM (pctxt, H225VoiceCaps);
|
|
|
|
stat = asn1PD_H225VoiceCaps (pctxt, pvalue->u.voice);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "voice", -1);
|
|
|
|
break;
|
|
|
|
/* t120_only */
|
|
case 8:
|
|
invokeStartElement (pctxt, "t120_only", -1);
|
|
|
|
pvalue->u.t120_only = ALLOC_ASN1ELEM (pctxt, H225T120OnlyCaps);
|
|
|
|
stat = asn1PD_H225T120OnlyCaps (pctxt, pvalue->u.t120_only);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "t120_only", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 10;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* nonStandardProtocol */
|
|
case 10:
|
|
invokeStartElement (pctxt, "nonStandardProtocol", -1);
|
|
|
|
pvalue->u.nonStandardProtocol = ALLOC_ASN1ELEM (pctxt, H225NonStandardProtocol);
|
|
|
|
stat = asn1PD_H225NonStandardProtocol (pctxt, pvalue->u.nonStandardProtocol);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardProtocol", -1);
|
|
|
|
break;
|
|
|
|
/* t38FaxAnnexbOnly */
|
|
case 11:
|
|
invokeStartElement (pctxt, "t38FaxAnnexbOnly", -1);
|
|
|
|
pvalue->u.t38FaxAnnexbOnly = ALLOC_ASN1ELEM (pctxt, H225T38FaxAnnexbOnlyCaps);
|
|
|
|
stat = asn1PD_H225T38FaxAnnexbOnlyCaps (pctxt, pvalue->u.t38FaxAnnexbOnly);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "t38FaxAnnexbOnly", -1);
|
|
|
|
break;
|
|
|
|
/* sip */
|
|
case 12:
|
|
invokeStartElement (pctxt, "sip", -1);
|
|
|
|
pvalue->u.sip = ALLOC_ASN1ELEM (pctxt, H225SIPCaps);
|
|
|
|
stat = asn1PD_H225SIPCaps (pctxt, pvalue->u.sip);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sip", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225SupportedProtocols */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225SupportedProtocols* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225SupportedProtocols);
|
|
|
|
stat = asn1PD_H225SupportedProtocols (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatewayInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.protocolPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode protocol */
|
|
|
|
if (pvalue->m.protocolPresent) {
|
|
invokeStartElement (pctxt, "protocol", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocol);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocol", -1);
|
|
}
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* McuInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 1 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.protocolPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "protocol", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocol);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocol", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TerminalInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TunnelledProtocolAlternateIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue)
|
|
{
|
|
static Asn1SizeCnst protocolType_lsize1 = { 0, 1, 64, 0 };
|
|
static Asn1SizeCnst protocolVariant_lsize1 = { 0, 1, 64, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.protocolVariantPresent = optbit;
|
|
|
|
/* decode protocolType */
|
|
|
|
invokeStartElement (pctxt, "protocolType", -1);
|
|
|
|
addSizeConstraint (pctxt, &protocolType_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->protocolType, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->protocolType);
|
|
|
|
invokeEndElement (pctxt, "protocolType", -1);
|
|
|
|
/* decode protocolVariant */
|
|
|
|
if (pvalue->m.protocolVariantPresent) {
|
|
invokeStartElement (pctxt, "protocolVariant", -1);
|
|
|
|
addSizeConstraint (pctxt, &protocolVariant_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->protocolVariant, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->protocolVariant);
|
|
|
|
invokeEndElement (pctxt, "protocolVariant", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TunnelledProtocol_id */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* tunnelledProtocolObjectID */
|
|
case 0:
|
|
invokeStartElement (pctxt, "tunnelledProtocolObjectID", -1);
|
|
|
|
pvalue->u.tunnelledProtocolObjectID = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, pvalue->u.tunnelledProtocolObjectID);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->u.tunnelledProtocolObjectID->numids, pvalue->u.tunnelledProtocolObjectID->subid);
|
|
|
|
invokeEndElement (pctxt, "tunnelledProtocolObjectID", -1);
|
|
|
|
break;
|
|
|
|
/* tunnelledProtocolAlternateID */
|
|
case 1:
|
|
invokeStartElement (pctxt, "tunnelledProtocolAlternateID", -1);
|
|
|
|
pvalue->u.tunnelledProtocolAlternateID = ALLOC_ASN1ELEM (pctxt, H225TunnelledProtocolAlternateIdentifier);
|
|
|
|
stat = asn1PD_H225TunnelledProtocolAlternateIdentifier (pctxt, pvalue->u.tunnelledProtocolAlternateID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tunnelledProtocolAlternateID", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TunnelledProtocol */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue)
|
|
{
|
|
static Asn1SizeCnst subIdentifier_lsize1 = { 0, 1, 64, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.subIdentifierPresent = optbit;
|
|
|
|
/* decode id */
|
|
|
|
invokeStartElement (pctxt, "id", -1);
|
|
|
|
stat = asn1PD_H225TunnelledProtocol_id (pctxt, &pvalue->id);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "id", -1);
|
|
|
|
/* decode subIdentifier */
|
|
|
|
if (pvalue->m.subIdentifierPresent) {
|
|
invokeStartElement (pctxt, "subIdentifier", -1);
|
|
|
|
addSizeConstraint (pctxt, &subIdentifier_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->subIdentifier, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->subIdentifier);
|
|
|
|
invokeEndElement (pctxt, "subIdentifier", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225TunnelledProtocol */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225TunnelledProtocol* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225TunnelledProtocol);
|
|
|
|
stat = asn1PD_H225TunnelledProtocol (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* EndpointType */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.vendorPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatewayPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.mcuPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.terminalPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode vendor */
|
|
|
|
if (pvalue->m.vendorPresent) {
|
|
invokeStartElement (pctxt, "vendor", -1);
|
|
|
|
stat = asn1PD_H225VendorIdentifier (pctxt, &pvalue->vendor);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "vendor", -1);
|
|
}
|
|
|
|
/* decode gatekeeper */
|
|
|
|
if (pvalue->m.gatekeeperPresent) {
|
|
invokeStartElement (pctxt, "gatekeeper", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperInfo (pctxt, &pvalue->gatekeeper);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeper", -1);
|
|
}
|
|
|
|
/* decode gateway */
|
|
|
|
if (pvalue->m.gatewayPresent) {
|
|
invokeStartElement (pctxt, "gateway", -1);
|
|
|
|
stat = asn1PD_H225GatewayInfo (pctxt, &pvalue->gateway);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gateway", -1);
|
|
}
|
|
|
|
/* decode mcu */
|
|
|
|
if (pvalue->m.mcuPresent) {
|
|
invokeStartElement (pctxt, "mcu", -1);
|
|
|
|
stat = asn1PD_H225McuInfo (pctxt, &pvalue->mcu);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "mcu", -1);
|
|
}
|
|
|
|
/* decode terminal */
|
|
|
|
if (pvalue->m.terminalPresent) {
|
|
invokeStartElement (pctxt, "terminal", -1);
|
|
|
|
stat = asn1PD_H225TerminalInfo (pctxt, &pvalue->terminal);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminal", -1);
|
|
}
|
|
|
|
/* decode mc */
|
|
|
|
invokeStartElement (pctxt, "mc", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->mc);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->mc);
|
|
|
|
invokeEndElement (pctxt, "mc", -1);
|
|
|
|
/* decode undefinedNode */
|
|
|
|
invokeStartElement (pctxt, "undefinedNode", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->undefinedNode);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->undefinedNode);
|
|
|
|
invokeEndElement (pctxt, "undefinedNode", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.setPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "set", -1);
|
|
|
|
stat = asn1PD_H225EndpointType_set (pctxt, &pvalue->set);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "set", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.supportedTunnelledProtocolsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedTunnelledProtocols", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TunnelledProtocol (pctxt, &pvalue->supportedTunnelledProtocols);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedTunnelledProtocols", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225CallReferenceValue */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, H225CallReferenceValue);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Setup_UUIE_conferenceGoal */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* create */
|
|
case 0:
|
|
invokeStartElement (pctxt, "create", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "create", -1);
|
|
|
|
break;
|
|
|
|
/* join */
|
|
case 1:
|
|
invokeStartElement (pctxt, "join", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "join", -1);
|
|
|
|
break;
|
|
|
|
/* invite */
|
|
case 2:
|
|
invokeStartElement (pctxt, "invite", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invite", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* capability_negotiation */
|
|
case 4:
|
|
invokeStartElement (pctxt, "capability_negotiation", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "capability_negotiation", -1);
|
|
|
|
break;
|
|
|
|
/* callIndependentSupplementaryService */
|
|
case 5:
|
|
invokeStartElement (pctxt, "callIndependentSupplementaryService", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "callIndependentSupplementaryService", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Q954Details */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode conferenceCalling */
|
|
|
|
invokeStartElement (pctxt, "conferenceCalling", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->conferenceCalling);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->conferenceCalling);
|
|
|
|
invokeEndElement (pctxt, "conferenceCalling", -1);
|
|
|
|
/* decode threePartyService */
|
|
|
|
invokeStartElement (pctxt, "threePartyService", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->threePartyService);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->threePartyService);
|
|
|
|
invokeEndElement (pctxt, "threePartyService", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* QseriesOptions */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode q932Full */
|
|
|
|
invokeStartElement (pctxt, "q932Full", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->q932Full);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->q932Full);
|
|
|
|
invokeEndElement (pctxt, "q932Full", -1);
|
|
|
|
/* decode q951Full */
|
|
|
|
invokeStartElement (pctxt, "q951Full", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->q951Full);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->q951Full);
|
|
|
|
invokeEndElement (pctxt, "q951Full", -1);
|
|
|
|
/* decode q952Full */
|
|
|
|
invokeStartElement (pctxt, "q952Full", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->q952Full);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->q952Full);
|
|
|
|
invokeEndElement (pctxt, "q952Full", -1);
|
|
|
|
/* decode q953Full */
|
|
|
|
invokeStartElement (pctxt, "q953Full", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->q953Full);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->q953Full);
|
|
|
|
invokeEndElement (pctxt, "q953Full", -1);
|
|
|
|
/* decode q955Full */
|
|
|
|
invokeStartElement (pctxt, "q955Full", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->q955Full);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->q955Full);
|
|
|
|
invokeEndElement (pctxt, "q955Full", -1);
|
|
|
|
/* decode q956Full */
|
|
|
|
invokeStartElement (pctxt, "q956Full", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->q956Full);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->q956Full);
|
|
|
|
invokeEndElement (pctxt, "q956Full", -1);
|
|
|
|
/* decode q957Full */
|
|
|
|
invokeStartElement (pctxt, "q957Full", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->q957Full);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->q957Full);
|
|
|
|
invokeEndElement (pctxt, "q957Full", -1);
|
|
|
|
/* decode q954Info */
|
|
|
|
invokeStartElement (pctxt, "q954Info", -1);
|
|
|
|
stat = asn1PD_H225Q954Details (pctxt, &pvalue->q954Info);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "q954Info", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallType */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallType (OOCTXT* pctxt, H225CallType* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* pointToPoint */
|
|
case 0:
|
|
invokeStartElement (pctxt, "pointToPoint", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "pointToPoint", -1);
|
|
|
|
break;
|
|
|
|
/* oneToN */
|
|
case 1:
|
|
invokeStartElement (pctxt, "oneToN", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "oneToN", -1);
|
|
|
|
break;
|
|
|
|
/* nToOne */
|
|
case 2:
|
|
invokeStartElement (pctxt, "nToOne", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "nToOne", -1);
|
|
|
|
break;
|
|
|
|
/* nToN */
|
|
case 3:
|
|
invokeStartElement (pctxt, "nToN", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "nToN", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode guid */
|
|
|
|
invokeStartElement (pctxt, "guid", -1);
|
|
|
|
stat = asn1PD_H225GloballyUniqueID (pctxt, &pvalue->guid);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "guid", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SecurityServiceMode */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* nonStandard */
|
|
case 0:
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
|
|
break;
|
|
|
|
/* none */
|
|
case 1:
|
|
invokeStartElement (pctxt, "none", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "none", -1);
|
|
|
|
break;
|
|
|
|
/* default_ */
|
|
case 2:
|
|
invokeStartElement (pctxt, "default_", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "default_", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SecurityCapabilities */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardPresent = optbit;
|
|
|
|
/* decode nonStandard */
|
|
|
|
if (pvalue->m.nonStandardPresent) {
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
}
|
|
|
|
/* decode encryption */
|
|
|
|
invokeStartElement (pctxt, "encryption", -1);
|
|
|
|
stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->encryption);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "encryption", -1);
|
|
|
|
/* decode authenticaton */
|
|
|
|
invokeStartElement (pctxt, "authenticaton", -1);
|
|
|
|
stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->authenticaton);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "authenticaton", -1);
|
|
|
|
/* decode integrity */
|
|
|
|
invokeStartElement (pctxt, "integrity", -1);
|
|
|
|
stat = asn1PD_H225SecurityServiceMode (pctxt, &pvalue->integrity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrity", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H245Security */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* nonStandard */
|
|
case 0:
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
|
|
break;
|
|
|
|
/* noSecurity */
|
|
case 1:
|
|
invokeStartElement (pctxt, "noSecurity", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "noSecurity", -1);
|
|
|
|
break;
|
|
|
|
/* tls */
|
|
case 2:
|
|
invokeStartElement (pctxt, "tls", -1);
|
|
|
|
pvalue->u.tls = ALLOC_ASN1ELEM (pctxt, H225SecurityCapabilities);
|
|
|
|
stat = asn1PD_H225SecurityCapabilities (pctxt, pvalue->u.tls);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tls", -1);
|
|
|
|
break;
|
|
|
|
/* ipsec */
|
|
case 3:
|
|
invokeStartElement (pctxt, "ipsec", -1);
|
|
|
|
pvalue->u.ipsec = ALLOC_ASN1ELEM (pctxt, H225SecurityCapabilities);
|
|
|
|
stat = asn1PD_H225SecurityCapabilities (pctxt, pvalue->u.ipsec);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "ipsec", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225H245Security */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225H245Security* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225H245Security);
|
|
|
|
stat = asn1PD_H225H245Security (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225ClearToken */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H235ClearToken* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H235ClearToken);
|
|
|
|
stat = asn1PD_H235ClearToken (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CryptoH323Token_cryptoEPPwdHash */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode alias */
|
|
|
|
invokeStartElement (pctxt, "alias", -1);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, &pvalue->alias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alias", -1);
|
|
|
|
/* decode timeStamp */
|
|
|
|
invokeStartElement (pctxt, "timeStamp", -1);
|
|
|
|
stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "timeStamp", -1);
|
|
|
|
/* decode token */
|
|
|
|
invokeStartElement (pctxt, "token", -1);
|
|
|
|
stat = asn1PD_H235HASHED (pctxt, &pvalue->token);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "token", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CryptoH323Token_cryptoGKPwdHash */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode gatekeeperId */
|
|
|
|
invokeStartElement (pctxt, "gatekeeperId", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperId);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperId", -1);
|
|
|
|
/* decode timeStamp */
|
|
|
|
invokeStartElement (pctxt, "timeStamp", -1);
|
|
|
|
stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "timeStamp", -1);
|
|
|
|
/* decode token */
|
|
|
|
invokeStartElement (pctxt, "token", -1);
|
|
|
|
stat = asn1PD_H235HASHED (pctxt, &pvalue->token);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "token", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CryptoH323Token_cryptoEPCert */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode toBeSigned */
|
|
|
|
invokeStartElement (pctxt, "toBeSigned", -1);
|
|
|
|
stat = asn1PD_H235EncodedPwdCertToken (pctxt, &pvalue->toBeSigned);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "toBeSigned", -1);
|
|
|
|
/* decode algorithmOID */
|
|
|
|
invokeStartElement (pctxt, "algorithmOID", -1);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
|
|
|
|
invokeEndElement (pctxt, "algorithmOID", -1);
|
|
|
|
/* decode paramS */
|
|
|
|
invokeStartElement (pctxt, "paramS", -1);
|
|
|
|
stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "paramS", -1);
|
|
|
|
/* decode signature */
|
|
|
|
invokeStartElement (pctxt, "signature", -1);
|
|
|
|
stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
|
|
|
|
invokeEndElement (pctxt, "signature", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CryptoH323Token_cryptoGKCert */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode toBeSigned */
|
|
|
|
invokeStartElement (pctxt, "toBeSigned", -1);
|
|
|
|
stat = asn1PD_H235EncodedPwdCertToken (pctxt, &pvalue->toBeSigned);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "toBeSigned", -1);
|
|
|
|
/* decode algorithmOID */
|
|
|
|
invokeStartElement (pctxt, "algorithmOID", -1);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
|
|
|
|
invokeEndElement (pctxt, "algorithmOID", -1);
|
|
|
|
/* decode paramS */
|
|
|
|
invokeStartElement (pctxt, "paramS", -1);
|
|
|
|
stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "paramS", -1);
|
|
|
|
/* decode signature */
|
|
|
|
invokeStartElement (pctxt, "signature", -1);
|
|
|
|
stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
|
|
|
|
invokeEndElement (pctxt, "signature", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CryptoH323Token_cryptoFastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode toBeSigned */
|
|
|
|
invokeStartElement (pctxt, "toBeSigned", -1);
|
|
|
|
stat = asn1PD_H225EncodedFastStartToken (pctxt, &pvalue->toBeSigned);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "toBeSigned", -1);
|
|
|
|
/* decode algorithmOID */
|
|
|
|
invokeStartElement (pctxt, "algorithmOID", -1);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
|
|
|
|
invokeEndElement (pctxt, "algorithmOID", -1);
|
|
|
|
/* decode paramS */
|
|
|
|
invokeStartElement (pctxt, "paramS", -1);
|
|
|
|
stat = asn1PD_H235Params (pctxt, &pvalue->paramS);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "paramS", -1);
|
|
|
|
/* decode signature */
|
|
|
|
invokeStartElement (pctxt, "signature", -1);
|
|
|
|
stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->signature);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeBitStrValue (pctxt, pvalue->signature.numbits, pvalue->signature.data);
|
|
|
|
invokeEndElement (pctxt, "signature", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CryptoH323Token */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* cryptoEPPwdHash */
|
|
case 0:
|
|
invokeStartElement (pctxt, "cryptoEPPwdHash", -1);
|
|
|
|
pvalue->u.cryptoEPPwdHash = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoEPPwdHash);
|
|
|
|
stat = asn1PD_H225CryptoH323Token_cryptoEPPwdHash (pctxt, pvalue->u.cryptoEPPwdHash);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoEPPwdHash", -1);
|
|
|
|
break;
|
|
|
|
/* cryptoGKPwdHash */
|
|
case 1:
|
|
invokeStartElement (pctxt, "cryptoGKPwdHash", -1);
|
|
|
|
pvalue->u.cryptoGKPwdHash = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoGKPwdHash);
|
|
|
|
stat = asn1PD_H225CryptoH323Token_cryptoGKPwdHash (pctxt, pvalue->u.cryptoGKPwdHash);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoGKPwdHash", -1);
|
|
|
|
break;
|
|
|
|
/* cryptoEPPwdEncr */
|
|
case 2:
|
|
invokeStartElement (pctxt, "cryptoEPPwdEncr", -1);
|
|
|
|
pvalue->u.cryptoEPPwdEncr = ALLOC_ASN1ELEM (pctxt, H235ENCRYPTED);
|
|
|
|
stat = asn1PD_H235ENCRYPTED (pctxt, pvalue->u.cryptoEPPwdEncr);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoEPPwdEncr", -1);
|
|
|
|
break;
|
|
|
|
/* cryptoGKPwdEncr */
|
|
case 3:
|
|
invokeStartElement (pctxt, "cryptoGKPwdEncr", -1);
|
|
|
|
pvalue->u.cryptoGKPwdEncr = ALLOC_ASN1ELEM (pctxt, H235ENCRYPTED);
|
|
|
|
stat = asn1PD_H235ENCRYPTED (pctxt, pvalue->u.cryptoGKPwdEncr);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoGKPwdEncr", -1);
|
|
|
|
break;
|
|
|
|
/* cryptoEPCert */
|
|
case 4:
|
|
invokeStartElement (pctxt, "cryptoEPCert", -1);
|
|
|
|
pvalue->u.cryptoEPCert = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoEPCert);
|
|
|
|
stat = asn1PD_H225CryptoH323Token_cryptoEPCert (pctxt, pvalue->u.cryptoEPCert);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoEPCert", -1);
|
|
|
|
break;
|
|
|
|
/* cryptoGKCert */
|
|
case 5:
|
|
invokeStartElement (pctxt, "cryptoGKCert", -1);
|
|
|
|
pvalue->u.cryptoGKCert = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoGKCert);
|
|
|
|
stat = asn1PD_H225CryptoH323Token_cryptoGKCert (pctxt, pvalue->u.cryptoGKCert);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoGKCert", -1);
|
|
|
|
break;
|
|
|
|
/* cryptoFastStart */
|
|
case 6:
|
|
invokeStartElement (pctxt, "cryptoFastStart", -1);
|
|
|
|
pvalue->u.cryptoFastStart = ALLOC_ASN1ELEM (pctxt, H225CryptoH323Token_cryptoFastStart);
|
|
|
|
stat = asn1PD_H225CryptoH323Token_cryptoFastStart (pctxt, pvalue->u.cryptoFastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoFastStart", -1);
|
|
|
|
break;
|
|
|
|
/* nestedcryptoToken */
|
|
case 7:
|
|
invokeStartElement (pctxt, "nestedcryptoToken", -1);
|
|
|
|
pvalue->u.nestedcryptoToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken);
|
|
|
|
stat = asn1PD_H235CryptoToken (pctxt, pvalue->u.nestedcryptoToken);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nestedcryptoToken", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 9;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225CryptoH323Token */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225CryptoH323Token* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225CryptoH323Token);
|
|
|
|
stat = asn1PD_H225CryptoH323Token (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Setup_UUIE_fastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ScnConnectionType */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* unknown */
|
|
case 0:
|
|
invokeStartElement (pctxt, "unknown", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "unknown", -1);
|
|
|
|
break;
|
|
|
|
/* bChannel */
|
|
case 1:
|
|
invokeStartElement (pctxt, "bChannel", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "bChannel", -1);
|
|
|
|
break;
|
|
|
|
/* hybrid2x64 */
|
|
case 2:
|
|
invokeStartElement (pctxt, "hybrid2x64", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "hybrid2x64", -1);
|
|
|
|
break;
|
|
|
|
/* hybrid384 */
|
|
case 3:
|
|
invokeStartElement (pctxt, "hybrid384", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "hybrid384", -1);
|
|
|
|
break;
|
|
|
|
/* hybrid1536 */
|
|
case 4:
|
|
invokeStartElement (pctxt, "hybrid1536", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "hybrid1536", -1);
|
|
|
|
break;
|
|
|
|
/* hybrid1920 */
|
|
case 5:
|
|
invokeStartElement (pctxt, "hybrid1920", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "hybrid1920", -1);
|
|
|
|
break;
|
|
|
|
/* multirate */
|
|
case 6:
|
|
invokeStartElement (pctxt, "multirate", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "multirate", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 8;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ScnConnectionAggregation */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* auto_ */
|
|
case 0:
|
|
invokeStartElement (pctxt, "auto_", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "auto_", -1);
|
|
|
|
break;
|
|
|
|
/* none */
|
|
case 1:
|
|
invokeStartElement (pctxt, "none", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "none", -1);
|
|
|
|
break;
|
|
|
|
/* h221 */
|
|
case 2:
|
|
invokeStartElement (pctxt, "h221", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "h221", -1);
|
|
|
|
break;
|
|
|
|
/* bonded_mode1 */
|
|
case 3:
|
|
invokeStartElement (pctxt, "bonded_mode1", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "bonded_mode1", -1);
|
|
|
|
break;
|
|
|
|
/* bonded_mode2 */
|
|
case 4:
|
|
invokeStartElement (pctxt, "bonded_mode2", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "bonded_mode2", -1);
|
|
|
|
break;
|
|
|
|
/* bonded_mode3 */
|
|
case 5:
|
|
invokeStartElement (pctxt, "bonded_mode3", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "bonded_mode3", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 7;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Setup_UUIE_connectionParameters */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode connectionType */
|
|
|
|
invokeStartElement (pctxt, "connectionType", -1);
|
|
|
|
stat = asn1PD_H225ScnConnectionType (pctxt, &pvalue->connectionType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "connectionType", -1);
|
|
|
|
/* decode numberOfScnConnections */
|
|
|
|
invokeStartElement (pctxt, "numberOfScnConnections", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->numberOfScnConnections, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->numberOfScnConnections);
|
|
|
|
invokeEndElement (pctxt, "numberOfScnConnections", -1);
|
|
|
|
/* decode connectionAggregation */
|
|
|
|
invokeStartElement (pctxt, "connectionAggregation", -1);
|
|
|
|
stat = asn1PD_H225ScnConnectionAggregation (pctxt, &pvalue->connectionAggregation);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "connectionAggregation", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Setup_UUIE_language */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue)
|
|
{
|
|
static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1IA5String);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
addSizeConstraint (pctxt, &element_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->elem[xx1], 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->elem[xx1]);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* PresentationIndicator */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* presentationAllowed */
|
|
case 0:
|
|
invokeStartElement (pctxt, "presentationAllowed", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "presentationAllowed", -1);
|
|
|
|
break;
|
|
|
|
/* presentationRestricted */
|
|
case 1:
|
|
invokeStartElement (pctxt, "presentationRestricted", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "presentationRestricted", -1);
|
|
|
|
break;
|
|
|
|
/* addressNotAvailable */
|
|
case 2:
|
|
invokeStartElement (pctxt, "addressNotAvailable", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "addressNotAvailable", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallCreditServiceControl_billingMode */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* credit */
|
|
case 0:
|
|
invokeStartElement (pctxt, "credit", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "credit", -1);
|
|
|
|
break;
|
|
|
|
/* debit */
|
|
case 1:
|
|
invokeStartElement (pctxt, "debit", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "debit", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallCreditServiceControl_callStartingPoint */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* alerting */
|
|
case 0:
|
|
invokeStartElement (pctxt, "alerting", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "alerting", -1);
|
|
|
|
break;
|
|
|
|
/* connect */
|
|
case 1:
|
|
invokeStartElement (pctxt, "connect", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "connect", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallCreditServiceControl */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue)
|
|
{
|
|
static Asn1SizeCnst amountString_lsize1 = { 0, 1, 512, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.amountStringPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.billingModePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callDurationLimitPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.enforceCallDurationLimitPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callStartingPointPresent = optbit;
|
|
|
|
/* decode amountString */
|
|
|
|
if (pvalue->m.amountStringPresent) {
|
|
invokeStartElement (pctxt, "amountString", -1);
|
|
|
|
addSizeConstraint (pctxt, &amountString_lsize1);
|
|
|
|
stat = decodeBMPString (pctxt, &pvalue->amountString, 0);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStr16BitValue (pctxt, pvalue->amountString.nchars, pvalue->amountString.data);
|
|
|
|
invokeEndElement (pctxt, "amountString", -1);
|
|
}
|
|
|
|
/* decode billingMode */
|
|
|
|
if (pvalue->m.billingModePresent) {
|
|
invokeStartElement (pctxt, "billingMode", -1);
|
|
|
|
stat = asn1PD_H225CallCreditServiceControl_billingMode (pctxt, &pvalue->billingMode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "billingMode", -1);
|
|
}
|
|
|
|
/* decode callDurationLimit */
|
|
|
|
if (pvalue->m.callDurationLimitPresent) {
|
|
invokeStartElement (pctxt, "callDurationLimit", -1);
|
|
|
|
stat = decodeConsUnsigned (pctxt, &pvalue->callDurationLimit, 1U, ASN1UINT_MAX);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->callDurationLimit);
|
|
|
|
invokeEndElement (pctxt, "callDurationLimit", -1);
|
|
}
|
|
|
|
/* decode enforceCallDurationLimit */
|
|
|
|
if (pvalue->m.enforceCallDurationLimitPresent) {
|
|
invokeStartElement (pctxt, "enforceCallDurationLimit", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->enforceCallDurationLimit);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->enforceCallDurationLimit);
|
|
|
|
invokeEndElement (pctxt, "enforceCallDurationLimit", -1);
|
|
}
|
|
|
|
/* decode callStartingPoint */
|
|
|
|
if (pvalue->m.callStartingPointPresent) {
|
|
invokeStartElement (pctxt, "callStartingPoint", -1);
|
|
|
|
stat = asn1PD_H225CallCreditServiceControl_callStartingPoint (pctxt, &pvalue->callStartingPoint);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callStartingPoint", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ServiceControlDescriptor */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue)
|
|
{
|
|
static Asn1SizeCnst url_lsize1 = { 0, 0, 512, 0 };
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* url */
|
|
case 0:
|
|
invokeStartElement (pctxt, "url", -1);
|
|
|
|
addSizeConstraint (pctxt, &url_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->u.url, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->u.url);
|
|
|
|
invokeEndElement (pctxt, "url", -1);
|
|
|
|
break;
|
|
|
|
/* signal */
|
|
case 1:
|
|
invokeStartElement (pctxt, "signal", -1);
|
|
|
|
pvalue->u.signal = ALLOC_ASN1ELEM (pctxt, H225H248SignalsDescriptor);
|
|
|
|
stat = asn1PD_H225H248SignalsDescriptor (pctxt, pvalue->u.signal);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "signal", -1);
|
|
|
|
break;
|
|
|
|
/* nonStandard */
|
|
case 2:
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
|
|
break;
|
|
|
|
/* callCreditServiceControl */
|
|
case 3:
|
|
invokeStartElement (pctxt, "callCreditServiceControl", -1);
|
|
|
|
pvalue->u.callCreditServiceControl = ALLOC_ASN1ELEM (pctxt, H225CallCreditServiceControl);
|
|
|
|
stat = asn1PD_H225CallCreditServiceControl (pctxt, pvalue->u.callCreditServiceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callCreditServiceControl", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ServiceControlSession_reason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* open */
|
|
case 0:
|
|
invokeStartElement (pctxt, "open", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "open", -1);
|
|
|
|
break;
|
|
|
|
/* refresh */
|
|
case 1:
|
|
invokeStartElement (pctxt, "refresh", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "refresh", -1);
|
|
|
|
break;
|
|
|
|
/* close */
|
|
case 2:
|
|
invokeStartElement (pctxt, "close", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "close", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ServiceControlSession */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.contentsPresent = optbit;
|
|
|
|
/* decode sessionId */
|
|
|
|
invokeStartElement (pctxt, "sessionId", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->sessionId, 0U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->sessionId);
|
|
|
|
invokeEndElement (pctxt, "sessionId", -1);
|
|
|
|
/* decode contents */
|
|
|
|
if (pvalue->m.contentsPresent) {
|
|
invokeStartElement (pctxt, "contents", -1);
|
|
|
|
stat = asn1PD_H225ServiceControlDescriptor (pctxt, &pvalue->contents);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "contents", -1);
|
|
}
|
|
|
|
/* decode reason */
|
|
|
|
invokeStartElement (pctxt, "reason", -1);
|
|
|
|
stat = asn1PD_H225ServiceControlSession_reason (pctxt, &pvalue->reason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "reason", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225ServiceControlSession */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225ServiceControlSession* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225ServiceControlSession);
|
|
|
|
stat = asn1PD_H225ServiceControlSession (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CarrierInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue)
|
|
{
|
|
static Asn1SizeCnst carrierName_lsize1 = { 0, 1, 128, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.carrierIdentificationCodePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.carrierNamePresent = optbit;
|
|
|
|
/* decode carrierIdentificationCode */
|
|
|
|
if (pvalue->m.carrierIdentificationCodePresent) {
|
|
invokeStartElement (pctxt, "carrierIdentificationCode", -1);
|
|
|
|
stat = asn1PD_H225CarrierInfo_carrierIdentificationCode (pctxt, &pvalue->carrierIdentificationCode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "carrierIdentificationCode", -1);
|
|
}
|
|
|
|
/* decode carrierName */
|
|
|
|
if (pvalue->m.carrierNamePresent) {
|
|
invokeStartElement (pctxt, "carrierName", -1);
|
|
|
|
addSizeConstraint (pctxt, &carrierName_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->carrierName, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->carrierName);
|
|
|
|
invokeEndElement (pctxt, "carrierName", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallsAvailable */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue)
|
|
{
|
|
static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.groupPresent = optbit;
|
|
|
|
/* decode calls */
|
|
|
|
invokeStartElement (pctxt, "calls", -1);
|
|
|
|
stat = decodeConsUnsigned (pctxt, &pvalue->calls, 0U, ASN1UINT_MAX);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->calls);
|
|
|
|
invokeEndElement (pctxt, "calls", -1);
|
|
|
|
/* decode group */
|
|
|
|
if (pvalue->m.groupPresent) {
|
|
invokeStartElement (pctxt, "group", -1);
|
|
|
|
addSizeConstraint (pctxt, &group_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->group, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->group);
|
|
|
|
invokeEndElement (pctxt, "group", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 1 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.carrierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "carrier", -1);
|
|
|
|
stat = asn1PD_H225CarrierInfo (pctxt, &pvalue->carrier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "carrier", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225CallsAvailable */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225CallsAvailable* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225CallsAvailable);
|
|
|
|
stat = asn1PD_H225CallsAvailable (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallCapacityInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.voiceGwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h310GwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h320GwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h321GwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h322GwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h323GwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h324GwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.t120OnlyGwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.terminalCallsAvailablePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.mcuCallsAvailablePresent = optbit;
|
|
|
|
/* decode voiceGwCallsAvailable */
|
|
|
|
if (pvalue->m.voiceGwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "voiceGwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->voiceGwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "voiceGwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode h310GwCallsAvailable */
|
|
|
|
if (pvalue->m.h310GwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "h310GwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h310GwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h310GwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode h320GwCallsAvailable */
|
|
|
|
if (pvalue->m.h320GwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "h320GwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h320GwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h320GwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode h321GwCallsAvailable */
|
|
|
|
if (pvalue->m.h321GwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "h321GwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h321GwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h321GwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode h322GwCallsAvailable */
|
|
|
|
if (pvalue->m.h322GwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "h322GwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h322GwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h322GwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode h323GwCallsAvailable */
|
|
|
|
if (pvalue->m.h323GwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "h323GwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h323GwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h323GwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode h324GwCallsAvailable */
|
|
|
|
if (pvalue->m.h324GwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "h324GwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h324GwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h324GwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode t120OnlyGwCallsAvailable */
|
|
|
|
if (pvalue->m.t120OnlyGwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "t120OnlyGwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t120OnlyGwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "t120OnlyGwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode t38FaxAnnexbOnlyGwCallsAvailable */
|
|
|
|
if (pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "t38FaxAnnexbOnlyGwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t38FaxAnnexbOnlyGwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "t38FaxAnnexbOnlyGwCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode terminalCallsAvailable */
|
|
|
|
if (pvalue->m.terminalCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "terminalCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->terminalCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalCallsAvailable", -1);
|
|
}
|
|
|
|
/* decode mcuCallsAvailable */
|
|
|
|
if (pvalue->m.mcuCallsAvailablePresent) {
|
|
invokeStartElement (pctxt, "mcuCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->mcuCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "mcuCallsAvailable", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 1 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.sipGwCallsAvailablePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "sipGwCallsAvailable", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->sipGwCallsAvailable);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sipGwCallsAvailable", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallCapacity */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.maximumCallCapacityPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.currentCallCapacityPresent = optbit;
|
|
|
|
/* decode maximumCallCapacity */
|
|
|
|
if (pvalue->m.maximumCallCapacityPresent) {
|
|
invokeStartElement (pctxt, "maximumCallCapacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacityInfo (pctxt, &pvalue->maximumCallCapacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "maximumCallCapacity", -1);
|
|
}
|
|
|
|
/* decode currentCallCapacity */
|
|
|
|
if (pvalue->m.currentCallCapacityPresent) {
|
|
invokeStartElement (pctxt, "currentCallCapacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacityInfo (pctxt, &pvalue->currentCallCapacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "currentCallCapacity", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225CicInfo_cic_element */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, H225CicInfo_cic_element);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = asn1PD_H225CicInfo_cic_element (pctxt, &pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CicInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode cic */
|
|
|
|
invokeStartElement (pctxt, "cic", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CicInfo_cic_element (pctxt, &pvalue->cic);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cic", -1);
|
|
|
|
/* decode pointCode */
|
|
|
|
invokeStartElement (pctxt, "pointCode", -1);
|
|
|
|
stat = asn1PD_H225CicInfo_pointCode (pctxt, &pvalue->pointCode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "pointCode", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GroupID_member */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1USINT);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->elem[xx1], 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->elem[xx1]);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GroupID */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue)
|
|
{
|
|
static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 };
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.memberPresent = optbit;
|
|
|
|
/* decode member */
|
|
|
|
if (pvalue->m.memberPresent) {
|
|
invokeStartElement (pctxt, "member", -1);
|
|
|
|
stat = asn1PD_H225GroupID_member (pctxt, &pvalue->member);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "member", -1);
|
|
}
|
|
|
|
/* decode group */
|
|
|
|
invokeStartElement (pctxt, "group", -1);
|
|
|
|
addSizeConstraint (pctxt, &group_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->group, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->group);
|
|
|
|
invokeEndElement (pctxt, "group", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CircuitIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cicPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.groupPresent = optbit;
|
|
|
|
/* decode cic */
|
|
|
|
if (pvalue->m.cicPresent) {
|
|
invokeStartElement (pctxt, "cic", -1);
|
|
|
|
stat = asn1PD_H225CicInfo (pctxt, &pvalue->cic);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cic", -1);
|
|
}
|
|
|
|
/* decode group */
|
|
|
|
if (pvalue->m.groupPresent) {
|
|
invokeStartElement (pctxt, "group", -1);
|
|
|
|
stat = asn1PD_H225GroupID (pctxt, &pvalue->group);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "group", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 1 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.carrierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "carrier", -1);
|
|
|
|
stat = asn1PD_H225CarrierInfo (pctxt, &pvalue->carrier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "carrier", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225GenericData */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225GenericData* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225GenericData);
|
|
|
|
stat = asn1PD_H225GenericData (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CircuitInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.sourceCircuitIDPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destinationCircuitIDPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.genericDataPresent = optbit;
|
|
|
|
/* decode sourceCircuitID */
|
|
|
|
if (pvalue->m.sourceCircuitIDPresent) {
|
|
invokeStartElement (pctxt, "sourceCircuitID", -1);
|
|
|
|
stat = asn1PD_H225CircuitIdentifier (pctxt, &pvalue->sourceCircuitID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sourceCircuitID", -1);
|
|
}
|
|
|
|
/* decode destinationCircuitID */
|
|
|
|
if (pvalue->m.destinationCircuitIDPresent) {
|
|
invokeStartElement (pctxt, "destinationCircuitID", -1);
|
|
|
|
stat = asn1PD_H225CircuitIdentifier (pctxt, &pvalue->destinationCircuitID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationCircuitID", -1);
|
|
}
|
|
|
|
/* decode genericData */
|
|
|
|
if (pvalue->m.genericDataPresent) {
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225FeatureDescriptor */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225FeatureDescriptor* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225FeatureDescriptor);
|
|
|
|
stat = asn1PD_H225FeatureDescriptor (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Setup_UUIE_parallelH245Control */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ExtendedAliasAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.presentationIndicatorPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.screeningIndicatorPresent = optbit;
|
|
|
|
/* decode address */
|
|
|
|
invokeStartElement (pctxt, "address", -1);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, &pvalue->address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "address", -1);
|
|
|
|
/* decode presentationIndicator */
|
|
|
|
if (pvalue->m.presentationIndicatorPresent) {
|
|
invokeStartElement (pctxt, "presentationIndicator", -1);
|
|
|
|
stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "presentationIndicator", -1);
|
|
}
|
|
|
|
/* decode screeningIndicator */
|
|
|
|
if (pvalue->m.screeningIndicatorPresent) {
|
|
invokeStartElement (pctxt, "screeningIndicator", -1);
|
|
|
|
stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "screeningIndicator", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225ExtendedAliasAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225ExtendedAliasAddress* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225ExtendedAliasAddress);
|
|
|
|
stat = asn1PD_H225ExtendedAliasAddress (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Setup_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h245AddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.sourceAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destinationAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destCallSignalAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destExtraCallInfoPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destExtraCRVPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callServicesPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode h245Address */
|
|
|
|
if (pvalue->m.h245AddressPresent) {
|
|
invokeStartElement (pctxt, "h245Address", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245Address", -1);
|
|
}
|
|
|
|
/* decode sourceAddress */
|
|
|
|
if (pvalue->m.sourceAddressPresent) {
|
|
invokeStartElement (pctxt, "sourceAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sourceAddress", -1);
|
|
}
|
|
|
|
/* decode sourceInfo */
|
|
|
|
invokeStartElement (pctxt, "sourceInfo", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->sourceInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sourceInfo", -1);
|
|
|
|
/* decode destinationAddress */
|
|
|
|
if (pvalue->m.destinationAddressPresent) {
|
|
invokeStartElement (pctxt, "destinationAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationAddress", -1);
|
|
}
|
|
|
|
/* decode destCallSignalAddress */
|
|
|
|
if (pvalue->m.destCallSignalAddressPresent) {
|
|
invokeStartElement (pctxt, "destCallSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destCallSignalAddress", -1);
|
|
}
|
|
|
|
/* decode destExtraCallInfo */
|
|
|
|
if (pvalue->m.destExtraCallInfoPresent) {
|
|
invokeStartElement (pctxt, "destExtraCallInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destExtraCallInfo", -1);
|
|
}
|
|
|
|
/* decode destExtraCRV */
|
|
|
|
if (pvalue->m.destExtraCRVPresent) {
|
|
invokeStartElement (pctxt, "destExtraCRV", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CallReferenceValue (pctxt, &pvalue->destExtraCRV);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destExtraCRV", -1);
|
|
}
|
|
|
|
/* decode activeMC */
|
|
|
|
invokeStartElement (pctxt, "activeMC", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->activeMC);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->activeMC);
|
|
|
|
invokeEndElement (pctxt, "activeMC", -1);
|
|
|
|
/* decode conferenceID */
|
|
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
|
|
/* decode conferenceGoal */
|
|
|
|
invokeStartElement (pctxt, "conferenceGoal", -1);
|
|
|
|
stat = asn1PD_H225Setup_UUIE_conferenceGoal (pctxt, &pvalue->conferenceGoal);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceGoal", -1);
|
|
|
|
/* decode callServices */
|
|
|
|
if (pvalue->m.callServicesPresent) {
|
|
invokeStartElement (pctxt, "callServices", -1);
|
|
|
|
stat = asn1PD_H225QseriesOptions (pctxt, &pvalue->callServices);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callServices", -1);
|
|
}
|
|
|
|
/* decode callType */
|
|
|
|
invokeStartElement (pctxt, "callType", -1);
|
|
|
|
stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callType", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 27 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.sourceCallSignalAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "sourceCallSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->sourceCallSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sourceCallSignalAddress", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.remoteExtensionAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "remoteExtensionAddress", -1);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "remoteExtensionAddress", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.h245SecurityCapabilityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245SecurityCapability", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225H245Security (pctxt, &pvalue->h245SecurityCapability);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245SecurityCapability", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.fastStartPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastStart", -1);
|
|
|
|
stat = asn1PD_H225Setup_UUIE_fastStart (pctxt, &pvalue->fastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "fastStart", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.mediaWaitForConnectPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "mediaWaitForConnect", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->mediaWaitForConnect);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->mediaWaitForConnect);
|
|
|
|
invokeEndElement (pctxt, "mediaWaitForConnect", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.canOverlapSendPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "canOverlapSend", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canOverlapSend);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canOverlapSend);
|
|
|
|
invokeEndElement (pctxt, "canOverlapSend", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.endpointIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.connectionParametersPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "connectionParameters", -1);
|
|
|
|
stat = asn1PD_H225Setup_UUIE_connectionParameters (pctxt, &pvalue->connectionParameters);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "connectionParameters", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.languagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "language", -1);
|
|
|
|
stat = asn1PD_H225Setup_UUIE_language (pctxt, &pvalue->language);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "language", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.presentationIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "presentationIndicator", -1);
|
|
|
|
stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "presentationIndicator", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.screeningIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "screeningIndicator", -1);
|
|
|
|
stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "screeningIndicator", -1);
|
|
break;
|
|
|
|
case 16:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 17:
|
|
pvalue->m.symmetricOperationRequiredPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "symmetricOperationRequired", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "symmetricOperationRequired", -1);
|
|
break;
|
|
|
|
case 18:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 19:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 20:
|
|
pvalue->m.desiredProtocolsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "desiredProtocols", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->desiredProtocols);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "desiredProtocols", -1);
|
|
break;
|
|
|
|
case 21:
|
|
pvalue->m.neededFeaturesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "neededFeatures", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->neededFeatures);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "neededFeatures", -1);
|
|
break;
|
|
|
|
case 22:
|
|
pvalue->m.desiredFeaturesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "desiredFeatures", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->desiredFeatures);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "desiredFeatures", -1);
|
|
break;
|
|
|
|
case 23:
|
|
pvalue->m.supportedFeaturesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedFeatures", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->supportedFeatures);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedFeatures", -1);
|
|
break;
|
|
|
|
case 24:
|
|
pvalue->m.parallelH245ControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "parallelH245Control", -1);
|
|
|
|
stat = asn1PD_H225Setup_UUIE_parallelH245Control (pctxt, &pvalue->parallelH245Control);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "parallelH245Control", -1);
|
|
break;
|
|
|
|
case 25:
|
|
pvalue->m.additionalSourceAddressesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "additionalSourceAddresses", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ExtendedAliasAddress (pctxt, &pvalue->additionalSourceAddresses);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "additionalSourceAddresses", -1);
|
|
break;
|
|
|
|
case 26:
|
|
pvalue->m.hopCountPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "hopCount", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->hopCount, 1U, 31U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->hopCount);
|
|
|
|
invokeEndElement (pctxt, "hopCount", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallProceeding_UUIE_fastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* FeatureSet */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.neededFeaturesPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.desiredFeaturesPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.supportedFeaturesPresent = optbit;
|
|
|
|
/* decode replacementFeatureSet */
|
|
|
|
invokeStartElement (pctxt, "replacementFeatureSet", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->replacementFeatureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->replacementFeatureSet);
|
|
|
|
invokeEndElement (pctxt, "replacementFeatureSet", -1);
|
|
|
|
/* decode neededFeatures */
|
|
|
|
if (pvalue->m.neededFeaturesPresent) {
|
|
invokeStartElement (pctxt, "neededFeatures", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->neededFeatures);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "neededFeatures", -1);
|
|
}
|
|
|
|
/* decode desiredFeatures */
|
|
|
|
if (pvalue->m.desiredFeaturesPresent) {
|
|
invokeStartElement (pctxt, "desiredFeatures", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->desiredFeatures);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "desiredFeatures", -1);
|
|
}
|
|
|
|
/* decode supportedFeatures */
|
|
|
|
if (pvalue->m.supportedFeaturesPresent) {
|
|
invokeStartElement (pctxt, "supportedFeatures", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->supportedFeatures);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedFeatures", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallProceeding_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h245AddressPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode destinationInfo */
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
|
|
/* decode h245Address */
|
|
|
|
if (pvalue->m.h245AddressPresent) {
|
|
invokeStartElement (pctxt, "h245Address", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245Address", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 9 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.h245SecurityModePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245SecurityMode", -1);
|
|
|
|
stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245SecurityMode", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.fastStartPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastStart", -1);
|
|
|
|
stat = asn1PD_H225CallProceeding_UUIE_fastStart (pctxt, &pvalue->fastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "fastStart", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.fastConnectRefusedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastConnectRefused", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "fastConnectRefused", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Connect_UUIE_fastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Connect_UUIE_language */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue)
|
|
{
|
|
static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1IA5String);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
addSizeConstraint (pctxt, &element_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->elem[xx1], 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->elem[xx1]);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Connect_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h245AddressPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode h245Address */
|
|
|
|
if (pvalue->m.h245AddressPresent) {
|
|
invokeStartElement (pctxt, "h245Address", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245Address", -1);
|
|
}
|
|
|
|
/* decode destinationInfo */
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
|
|
/* decode conferenceID */
|
|
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 15 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.h245SecurityModePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245SecurityMode", -1);
|
|
|
|
stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245SecurityMode", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.fastStartPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastStart", -1);
|
|
|
|
stat = asn1PD_H225Connect_UUIE_fastStart (pctxt, &pvalue->fastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "fastStart", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.languagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "language", -1);
|
|
|
|
stat = asn1PD_H225Connect_UUIE_language (pctxt, &pvalue->language);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "language", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.connectedAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "connectedAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->connectedAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "connectedAddress", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.presentationIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "presentationIndicator", -1);
|
|
|
|
stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "presentationIndicator", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.screeningIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "screeningIndicator", -1);
|
|
|
|
stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "screeningIndicator", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.fastConnectRefusedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastConnectRefused", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "fastConnectRefused", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Alerting_UUIE_fastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Alerting_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h245AddressPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode destinationInfo */
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
|
|
/* decode h245Address */
|
|
|
|
if (pvalue->m.h245AddressPresent) {
|
|
invokeStartElement (pctxt, "h245Address", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245Address", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 14 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.h245SecurityModePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245SecurityMode", -1);
|
|
|
|
stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245SecurityMode", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.fastStartPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastStart", -1);
|
|
|
|
stat = asn1PD_H225Alerting_UUIE_fastStart (pctxt, &pvalue->fastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "fastStart", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.alertingAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alertingAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->alertingAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alertingAddress", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.presentationIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "presentationIndicator", -1);
|
|
|
|
stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "presentationIndicator", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.screeningIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "screeningIndicator", -1);
|
|
|
|
stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "screeningIndicator", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.fastConnectRefusedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastConnectRefused", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "fastConnectRefused", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Information_UUIE_fastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Information_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 6 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.fastStartPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastStart", -1);
|
|
|
|
stat = asn1PD_H225Information_UUIE_fastStart (pctxt, &pvalue->fastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "fastStart", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.fastConnectRefusedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastConnectRefused", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "fastConnectRefused", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SecurityErrors */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 15);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* securityWrongSyncTime */
|
|
case 0:
|
|
invokeStartElement (pctxt, "securityWrongSyncTime", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongSyncTime", -1);
|
|
|
|
break;
|
|
|
|
/* securityReplay */
|
|
case 1:
|
|
invokeStartElement (pctxt, "securityReplay", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityReplay", -1);
|
|
|
|
break;
|
|
|
|
/* securityWrongGeneralID */
|
|
case 2:
|
|
invokeStartElement (pctxt, "securityWrongGeneralID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongGeneralID", -1);
|
|
|
|
break;
|
|
|
|
/* securityWrongSendersID */
|
|
case 3:
|
|
invokeStartElement (pctxt, "securityWrongSendersID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongSendersID", -1);
|
|
|
|
break;
|
|
|
|
/* securityIntegrityFailed */
|
|
case 4:
|
|
invokeStartElement (pctxt, "securityIntegrityFailed", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityIntegrityFailed", -1);
|
|
|
|
break;
|
|
|
|
/* securityWrongOID */
|
|
case 5:
|
|
invokeStartElement (pctxt, "securityWrongOID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongOID", -1);
|
|
|
|
break;
|
|
|
|
/* securityDHmismatch */
|
|
case 6:
|
|
invokeStartElement (pctxt, "securityDHmismatch", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDHmismatch", -1);
|
|
|
|
break;
|
|
|
|
/* securityCertificateExpired */
|
|
case 7:
|
|
invokeStartElement (pctxt, "securityCertificateExpired", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityCertificateExpired", -1);
|
|
|
|
break;
|
|
|
|
/* securityCertificateDateInvalid */
|
|
case 8:
|
|
invokeStartElement (pctxt, "securityCertificateDateInvalid", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityCertificateDateInvalid", -1);
|
|
|
|
break;
|
|
|
|
/* securityCertificateRevoked */
|
|
case 9:
|
|
invokeStartElement (pctxt, "securityCertificateRevoked", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityCertificateRevoked", -1);
|
|
|
|
break;
|
|
|
|
/* securityCertificateNotReadable */
|
|
case 10:
|
|
invokeStartElement (pctxt, "securityCertificateNotReadable", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityCertificateNotReadable", -1);
|
|
|
|
break;
|
|
|
|
/* securityCertificateSignatureInvalid */
|
|
case 11:
|
|
invokeStartElement (pctxt, "securityCertificateSignatureInvalid", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityCertificateSignatureInvalid", -1);
|
|
|
|
break;
|
|
|
|
/* securityCertificateMissing */
|
|
case 12:
|
|
invokeStartElement (pctxt, "securityCertificateMissing", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityCertificateMissing", -1);
|
|
|
|
break;
|
|
|
|
/* securityCertificateIncomplete */
|
|
case 13:
|
|
invokeStartElement (pctxt, "securityCertificateIncomplete", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityCertificateIncomplete", -1);
|
|
|
|
break;
|
|
|
|
/* securityUnsupportedCertificateAlgOID */
|
|
case 14:
|
|
invokeStartElement (pctxt, "securityUnsupportedCertificateAlgOID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityUnsupportedCertificateAlgOID", -1);
|
|
|
|
break;
|
|
|
|
/* securityUnknownCA */
|
|
case 15:
|
|
invokeStartElement (pctxt, "securityUnknownCA", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityUnknownCA", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 17;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ReleaseCompleteReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 11);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* noBandwidth */
|
|
case 0:
|
|
invokeStartElement (pctxt, "noBandwidth", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "noBandwidth", -1);
|
|
|
|
break;
|
|
|
|
/* gatekeeperResources */
|
|
case 1:
|
|
invokeStartElement (pctxt, "gatekeeperResources", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "gatekeeperResources", -1);
|
|
|
|
break;
|
|
|
|
/* unreachableDestination */
|
|
case 2:
|
|
invokeStartElement (pctxt, "unreachableDestination", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "unreachableDestination", -1);
|
|
|
|
break;
|
|
|
|
/* destinationRejection */
|
|
case 3:
|
|
invokeStartElement (pctxt, "destinationRejection", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "destinationRejection", -1);
|
|
|
|
break;
|
|
|
|
/* invalidRevision */
|
|
case 4:
|
|
invokeStartElement (pctxt, "invalidRevision", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidRevision", -1);
|
|
|
|
break;
|
|
|
|
/* noPermission */
|
|
case 5:
|
|
invokeStartElement (pctxt, "noPermission", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "noPermission", -1);
|
|
|
|
break;
|
|
|
|
/* unreachableGatekeeper */
|
|
case 6:
|
|
invokeStartElement (pctxt, "unreachableGatekeeper", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "unreachableGatekeeper", -1);
|
|
|
|
break;
|
|
|
|
/* gatewayResources */
|
|
case 7:
|
|
invokeStartElement (pctxt, "gatewayResources", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "gatewayResources", -1);
|
|
|
|
break;
|
|
|
|
/* badFormatAddress */
|
|
case 8:
|
|
invokeStartElement (pctxt, "badFormatAddress", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "badFormatAddress", -1);
|
|
|
|
break;
|
|
|
|
/* adaptiveBusy */
|
|
case 9:
|
|
invokeStartElement (pctxt, "adaptiveBusy", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "adaptiveBusy", -1);
|
|
|
|
break;
|
|
|
|
/* inConf */
|
|
case 10:
|
|
invokeStartElement (pctxt, "inConf", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "inConf", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 11:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 13;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* facilityCallDeflection */
|
|
case 13:
|
|
invokeStartElement (pctxt, "facilityCallDeflection", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "facilityCallDeflection", -1);
|
|
|
|
break;
|
|
|
|
/* securityDenied */
|
|
case 14:
|
|
invokeStartElement (pctxt, "securityDenied", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenied", -1);
|
|
|
|
break;
|
|
|
|
/* calledPartyNotRegistered */
|
|
case 15:
|
|
invokeStartElement (pctxt, "calledPartyNotRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "calledPartyNotRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* callerNotRegistered */
|
|
case 16:
|
|
invokeStartElement (pctxt, "callerNotRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "callerNotRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* newConnectionNeeded */
|
|
case 17:
|
|
invokeStartElement (pctxt, "newConnectionNeeded", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "newConnectionNeeded", -1);
|
|
|
|
break;
|
|
|
|
/* nonStandardReason */
|
|
case 18:
|
|
invokeStartElement (pctxt, "nonStandardReason", -1);
|
|
|
|
pvalue->u.nonStandardReason = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandardReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardReason", -1);
|
|
|
|
break;
|
|
|
|
/* replaceWithConferenceInvite */
|
|
case 19:
|
|
invokeStartElement (pctxt, "replaceWithConferenceInvite", -1);
|
|
|
|
pvalue->u.replaceWithConferenceInvite = ALLOC_ASN1ELEM (pctxt, H225ConferenceIdentifier);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, pvalue->u.replaceWithConferenceInvite);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "replaceWithConferenceInvite", -1);
|
|
|
|
break;
|
|
|
|
/* genericDataReason */
|
|
case 20:
|
|
invokeStartElement (pctxt, "genericDataReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "genericDataReason", -1);
|
|
|
|
break;
|
|
|
|
/* neededFeatureNotSupported */
|
|
case 21:
|
|
invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* tunnelledSignallingRejected */
|
|
case 22:
|
|
invokeStartElement (pctxt, "tunnelledSignallingRejected", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "tunnelledSignallingRejected", -1);
|
|
|
|
break;
|
|
|
|
/* invalidCID */
|
|
case 23:
|
|
invokeStartElement (pctxt, "invalidCID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidCID", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 24:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors);
|
|
|
|
stat = asn1PD_H225SecurityErrors (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
/* hopCountExceeded */
|
|
case 25:
|
|
invokeStartElement (pctxt, "hopCountExceeded", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "hopCountExceeded", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ReleaseComplete_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.reasonPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode reason */
|
|
|
|
if (pvalue->m.reasonPresent) {
|
|
invokeStartElement (pctxt, "reason", -1);
|
|
|
|
stat = asn1PD_H225ReleaseCompleteReason (pctxt, &pvalue->reason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "reason", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 9 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.busyAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "busyAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->busyAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "busyAddress", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.presentationIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "presentationIndicator", -1);
|
|
|
|
stat = asn1PD_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "presentationIndicator", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.screeningIndicatorPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "screeningIndicator", -1);
|
|
|
|
stat = asn1PD_H225ScreeningIndicator (pctxt, &pvalue->screeningIndicator);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "screeningIndicator", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* FacilityReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* routeCallToGatekeeper */
|
|
case 0:
|
|
invokeStartElement (pctxt, "routeCallToGatekeeper", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "routeCallToGatekeeper", -1);
|
|
|
|
break;
|
|
|
|
/* callForwarded */
|
|
case 1:
|
|
invokeStartElement (pctxt, "callForwarded", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "callForwarded", -1);
|
|
|
|
break;
|
|
|
|
/* routeCallToMC */
|
|
case 2:
|
|
invokeStartElement (pctxt, "routeCallToMC", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "routeCallToMC", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 3:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* conferenceListChoice */
|
|
case 5:
|
|
invokeStartElement (pctxt, "conferenceListChoice", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "conferenceListChoice", -1);
|
|
|
|
break;
|
|
|
|
/* startH245 */
|
|
case 6:
|
|
invokeStartElement (pctxt, "startH245", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "startH245", -1);
|
|
|
|
break;
|
|
|
|
/* noH245 */
|
|
case 7:
|
|
invokeStartElement (pctxt, "noH245", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "noH245", -1);
|
|
|
|
break;
|
|
|
|
/* newTokens */
|
|
case 8:
|
|
invokeStartElement (pctxt, "newTokens", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "newTokens", -1);
|
|
|
|
break;
|
|
|
|
/* featureSetUpdate */
|
|
case 9:
|
|
invokeStartElement (pctxt, "featureSetUpdate", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "featureSetUpdate", -1);
|
|
|
|
break;
|
|
|
|
/* forwardedElements */
|
|
case 10:
|
|
invokeStartElement (pctxt, "forwardedElements", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "forwardedElements", -1);
|
|
|
|
break;
|
|
|
|
/* transportedInformation */
|
|
case 11:
|
|
invokeStartElement (pctxt, "transportedInformation", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "transportedInformation", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ConferenceList */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.conferenceIDPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.conferenceAliasPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode conferenceID */
|
|
|
|
if (pvalue->m.conferenceIDPresent) {
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
}
|
|
|
|
/* decode conferenceAlias */
|
|
|
|
if (pvalue->m.conferenceAliasPresent) {
|
|
invokeStartElement (pctxt, "conferenceAlias", -1);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, &pvalue->conferenceAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceAlias", -1);
|
|
}
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225ConferenceList */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225ConferenceList* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225ConferenceList);
|
|
|
|
stat = asn1PD_H225ConferenceList (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Facility_UUIE_fastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Facility_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.alternativeAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.alternativeAliasAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.conferenceIDPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode alternativeAddress */
|
|
|
|
if (pvalue->m.alternativeAddressPresent) {
|
|
invokeStartElement (pctxt, "alternativeAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->alternativeAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternativeAddress", -1);
|
|
}
|
|
|
|
/* decode alternativeAliasAddress */
|
|
|
|
if (pvalue->m.alternativeAliasAddressPresent) {
|
|
invokeStartElement (pctxt, "alternativeAliasAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->alternativeAliasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternativeAliasAddress", -1);
|
|
}
|
|
|
|
/* decode conferenceID */
|
|
|
|
if (pvalue->m.conferenceIDPresent) {
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
}
|
|
|
|
/* decode reason */
|
|
|
|
invokeStartElement (pctxt, "reason", -1);
|
|
|
|
stat = asn1PD_H225FacilityReason (pctxt, &pvalue->reason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "reason", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 16 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.destExtraCallInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destExtraCallInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destExtraCallInfo", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.remoteExtensionAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "remoteExtensionAddress", -1);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "remoteExtensionAddress", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.conferencesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "conferences", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ConferenceList (pctxt, &pvalue->conferences);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferences", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.h245AddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245Address", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245Address", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.fastStartPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastStart", -1);
|
|
|
|
stat = asn1PD_H225Facility_UUIE_fastStart (pctxt, &pvalue->fastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "fastStart", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.fastConnectRefusedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastConnectRefused", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "fastConnectRefused", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.destinationInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.h245SecurityModePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245SecurityMode", -1);
|
|
|
|
stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245SecurityMode", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Progress_UUIE_fastStart */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Progress_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h245AddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h245SecurityModePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.fastStartPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode destinationInfo */
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
|
|
/* decode h245Address */
|
|
|
|
if (pvalue->m.h245AddressPresent) {
|
|
invokeStartElement (pctxt, "h245Address", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->h245Address);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245Address", -1);
|
|
}
|
|
|
|
/* decode callIdentifier */
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
|
|
/* decode h245SecurityMode */
|
|
|
|
if (pvalue->m.h245SecurityModePresent) {
|
|
invokeStartElement (pctxt, "h245SecurityMode", -1);
|
|
|
|
stat = asn1PD_H225H245Security (pctxt, &pvalue->h245SecurityMode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245SecurityMode", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode fastStart */
|
|
|
|
if (pvalue->m.fastStartPresent) {
|
|
invokeStartElement (pctxt, "fastStart", -1);
|
|
|
|
stat = asn1PD_H225Progress_UUIE_fastStart (pctxt, &pvalue->fastStart);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "fastStart", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 3 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.fastConnectRefusedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "fastConnectRefused", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "fastConnectRefused", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Status_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode callIdentifier */
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* StatusInquiry_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode callIdentifier */
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SetupAcknowledge_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode callIdentifier */
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Notify_UUIE */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode callIdentifier */
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UU_PDU_h323_message_body */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* setup */
|
|
case 0:
|
|
invokeStartElement (pctxt, "setup", -1);
|
|
|
|
pvalue->u.setup = ALLOC_ASN1ELEM (pctxt, H225Setup_UUIE);
|
|
|
|
stat = asn1PD_H225Setup_UUIE (pctxt, pvalue->u.setup);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "setup", -1);
|
|
|
|
break;
|
|
|
|
/* callProceeding */
|
|
case 1:
|
|
invokeStartElement (pctxt, "callProceeding", -1);
|
|
|
|
pvalue->u.callProceeding = ALLOC_ASN1ELEM (pctxt, H225CallProceeding_UUIE);
|
|
|
|
stat = asn1PD_H225CallProceeding_UUIE (pctxt, pvalue->u.callProceeding);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callProceeding", -1);
|
|
|
|
break;
|
|
|
|
/* connect */
|
|
case 2:
|
|
invokeStartElement (pctxt, "connect", -1);
|
|
|
|
pvalue->u.connect = ALLOC_ASN1ELEM (pctxt, H225Connect_UUIE);
|
|
|
|
stat = asn1PD_H225Connect_UUIE (pctxt, pvalue->u.connect);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "connect", -1);
|
|
|
|
break;
|
|
|
|
/* alerting */
|
|
case 3:
|
|
invokeStartElement (pctxt, "alerting", -1);
|
|
|
|
pvalue->u.alerting = ALLOC_ASN1ELEM (pctxt, H225Alerting_UUIE);
|
|
|
|
stat = asn1PD_H225Alerting_UUIE (pctxt, pvalue->u.alerting);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alerting", -1);
|
|
|
|
break;
|
|
|
|
/* information */
|
|
case 4:
|
|
invokeStartElement (pctxt, "information", -1);
|
|
|
|
pvalue->u.information = ALLOC_ASN1ELEM (pctxt, H225Information_UUIE);
|
|
|
|
stat = asn1PD_H225Information_UUIE (pctxt, pvalue->u.information);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "information", -1);
|
|
|
|
break;
|
|
|
|
/* releaseComplete */
|
|
case 5:
|
|
invokeStartElement (pctxt, "releaseComplete", -1);
|
|
|
|
pvalue->u.releaseComplete = ALLOC_ASN1ELEM (pctxt, H225ReleaseComplete_UUIE);
|
|
|
|
stat = asn1PD_H225ReleaseComplete_UUIE (pctxt, pvalue->u.releaseComplete);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "releaseComplete", -1);
|
|
|
|
break;
|
|
|
|
/* facility */
|
|
case 6:
|
|
invokeStartElement (pctxt, "facility", -1);
|
|
|
|
pvalue->u.facility = ALLOC_ASN1ELEM (pctxt, H225Facility_UUIE);
|
|
|
|
stat = asn1PD_H225Facility_UUIE (pctxt, pvalue->u.facility);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "facility", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 8;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* progress */
|
|
case 8:
|
|
invokeStartElement (pctxt, "progress", -1);
|
|
|
|
pvalue->u.progress = ALLOC_ASN1ELEM (pctxt, H225Progress_UUIE);
|
|
|
|
stat = asn1PD_H225Progress_UUIE (pctxt, pvalue->u.progress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "progress", -1);
|
|
|
|
break;
|
|
|
|
/* empty */
|
|
case 9:
|
|
invokeStartElement (pctxt, "empty", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "empty", -1);
|
|
|
|
break;
|
|
|
|
/* status */
|
|
case 10:
|
|
invokeStartElement (pctxt, "status", -1);
|
|
|
|
pvalue->u.status = ALLOC_ASN1ELEM (pctxt, H225Status_UUIE);
|
|
|
|
stat = asn1PD_H225Status_UUIE (pctxt, pvalue->u.status);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "status", -1);
|
|
|
|
break;
|
|
|
|
/* statusInquiry */
|
|
case 11:
|
|
invokeStartElement (pctxt, "statusInquiry", -1);
|
|
|
|
pvalue->u.statusInquiry = ALLOC_ASN1ELEM (pctxt, H225StatusInquiry_UUIE);
|
|
|
|
stat = asn1PD_H225StatusInquiry_UUIE (pctxt, pvalue->u.statusInquiry);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "statusInquiry", -1);
|
|
|
|
break;
|
|
|
|
/* setupAcknowledge */
|
|
case 12:
|
|
invokeStartElement (pctxt, "setupAcknowledge", -1);
|
|
|
|
pvalue->u.setupAcknowledge = ALLOC_ASN1ELEM (pctxt, H225SetupAcknowledge_UUIE);
|
|
|
|
stat = asn1PD_H225SetupAcknowledge_UUIE (pctxt, pvalue->u.setupAcknowledge);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "setupAcknowledge", -1);
|
|
|
|
break;
|
|
|
|
/* notify */
|
|
case 13:
|
|
invokeStartElement (pctxt, "notify", -1);
|
|
|
|
pvalue->u.notify = ALLOC_ASN1ELEM (pctxt, H225Notify_UUIE);
|
|
|
|
stat = asn1PD_H225Notify_UUIE (pctxt, pvalue->u.notify);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "notify", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UU_PDU_h4501SupplementaryService */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UU_PDU_h245Control */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225NonStandardParameter */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225NonStandardParameter* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallLinkage */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.globalCallIdPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.threadIdPresent = optbit;
|
|
|
|
/* decode globalCallId */
|
|
|
|
if (pvalue->m.globalCallIdPresent) {
|
|
invokeStartElement (pctxt, "globalCallId", -1);
|
|
|
|
stat = asn1PD_H225GloballyUniqueID (pctxt, &pvalue->globalCallId);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "globalCallId", -1);
|
|
}
|
|
|
|
/* decode threadId */
|
|
|
|
if (pvalue->m.threadIdPresent) {
|
|
invokeStartElement (pctxt, "threadId", -1);
|
|
|
|
stat = asn1PD_H225GloballyUniqueID (pctxt, &pvalue->threadId);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "threadId", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UU_PDU_tunnelledSignallingMessage_messageContent */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1DynOctStr);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UU_PDU_tunnelledSignallingMessage */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tunnellingRequiredPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode tunnelledProtocolID */
|
|
|
|
invokeStartElement (pctxt, "tunnelledProtocolID", -1);
|
|
|
|
stat = asn1PD_H225TunnelledProtocol (pctxt, &pvalue->tunnelledProtocolID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tunnelledProtocolID", -1);
|
|
|
|
/* decode messageContent */
|
|
|
|
invokeStartElement (pctxt, "messageContent", -1);
|
|
|
|
stat = asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (pctxt, &pvalue->messageContent);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "messageContent", -1);
|
|
|
|
/* decode tunnellingRequired */
|
|
|
|
if (pvalue->m.tunnellingRequiredPresent) {
|
|
invokeStartElement (pctxt, "tunnellingRequired", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "tunnellingRequired", -1);
|
|
}
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* StimulusControl */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.isTextPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.h248MessagePresent = optbit;
|
|
|
|
/* decode nonStandard */
|
|
|
|
if (pvalue->m.nonStandardPresent) {
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
}
|
|
|
|
/* decode isText */
|
|
|
|
if (pvalue->m.isTextPresent) {
|
|
invokeStartElement (pctxt, "isText", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "isText", -1);
|
|
}
|
|
|
|
/* decode h248Message */
|
|
|
|
if (pvalue->m.h248MessagePresent) {
|
|
invokeStartElement (pctxt, "h248Message", -1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->h248Message);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->h248Message.numocts, pvalue->h248Message.data);
|
|
|
|
invokeEndElement (pctxt, "h248Message", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UU_PDU */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode h323_message_body */
|
|
|
|
invokeStartElement (pctxt, "h323_message_body", -1);
|
|
|
|
stat = asn1PD_H225H323_UU_PDU_h323_message_body (pctxt, &pvalue->h323_message_body);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h323_message_body", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 9 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.h4501SupplementaryServicePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h4501SupplementaryService", -1);
|
|
|
|
stat = asn1PD_H225H323_UU_PDU_h4501SupplementaryService (pctxt, &pvalue->h4501SupplementaryService);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h4501SupplementaryService", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.h245TunnelingPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245Tunneling", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->h245Tunneling);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->h245Tunneling);
|
|
|
|
invokeEndElement (pctxt, "h245Tunneling", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.h245ControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "h245Control", -1);
|
|
|
|
stat = asn1PD_H225H323_UU_PDU_h245Control (pctxt, &pvalue->h245Control);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245Control", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.nonStandardControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "nonStandardControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardControl", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.callLinkagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callLinkage", -1);
|
|
|
|
stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callLinkage", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.tunnelledSignallingMessagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tunnelledSignallingMessage", -1);
|
|
|
|
stat = asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage (pctxt, &pvalue->tunnelledSignallingMessage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tunnelledSignallingMessage", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.provisionalRespToH245TunnelingPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "provisionalRespToH245Tunneling", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "provisionalRespToH245Tunneling", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.stimulusControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "stimulusControl", -1);
|
|
|
|
stat = asn1PD_H225StimulusControl (pctxt, &pvalue->stimulusControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "stimulusControl", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UserInformation_user_data */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode protocol_discriminator */
|
|
|
|
invokeStartElement (pctxt, "protocol_discriminator", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->protocol_discriminator, 0U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->protocol_discriminator);
|
|
|
|
invokeEndElement (pctxt, "protocol_discriminator", -1);
|
|
|
|
/* decode user_information */
|
|
|
|
invokeStartElement (pctxt, "user_information", -1);
|
|
|
|
stat = asn1PD_H225H323_UserInformation_user_data_user_information (pctxt, &pvalue->user_information);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "user_information", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* H323_UserInformation */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.user_dataPresent = optbit;
|
|
|
|
/* decode h323_uu_pdu */
|
|
|
|
invokeStartElement (pctxt, "h323_uu_pdu", -1);
|
|
|
|
stat = asn1PD_H225H323_UU_PDU (pctxt, &pvalue->h323_uu_pdu);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h323_uu_pdu", -1);
|
|
|
|
/* decode user_data */
|
|
|
|
if (pvalue->m.user_dataPresent) {
|
|
invokeStartElement (pctxt, "user_data", -1);
|
|
|
|
stat = asn1PD_H225H323_UserInformation_user_data (pctxt, &pvalue->user_data);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "user_data", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AddressPattern_range */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode startOfRange */
|
|
|
|
invokeStartElement (pctxt, "startOfRange", -1);
|
|
|
|
stat = asn1PD_H225PartyNumber (pctxt, &pvalue->startOfRange);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "startOfRange", -1);
|
|
|
|
/* decode endOfRange */
|
|
|
|
invokeStartElement (pctxt, "endOfRange", -1);
|
|
|
|
stat = asn1PD_H225PartyNumber (pctxt, &pvalue->endOfRange);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endOfRange", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AddressPattern */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* wildcard */
|
|
case 0:
|
|
invokeStartElement (pctxt, "wildcard", -1);
|
|
|
|
pvalue->u.wildcard = ALLOC_ASN1ELEM (pctxt, H225AliasAddress);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, pvalue->u.wildcard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "wildcard", -1);
|
|
|
|
break;
|
|
|
|
/* range */
|
|
case 1:
|
|
invokeStartElement (pctxt, "range", -1);
|
|
|
|
pvalue->u.range = ALLOC_ASN1ELEM (pctxt, H225AddressPattern_range);
|
|
|
|
stat = asn1PD_H225AddressPattern_range (pctxt, pvalue->u.range);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "range", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225TransportAddress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225TransportAddress* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225TransportAddress);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AlternateTransportAddresses */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.annexEPresent = optbit;
|
|
|
|
/* decode annexE */
|
|
|
|
if (pvalue->m.annexEPresent) {
|
|
invokeStartElement (pctxt, "annexE", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->annexE);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "annexE", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 1 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.sctpPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "sctp", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->sctp);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sctp", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* Endpoint */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.aliasAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callSignalAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.rasAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endpointTypePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.priorityPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.remoteExtensionAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destExtraCallInfoPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode aliasAddress */
|
|
|
|
if (pvalue->m.aliasAddressPresent) {
|
|
invokeStartElement (pctxt, "aliasAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->aliasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "aliasAddress", -1);
|
|
}
|
|
|
|
/* decode callSignalAddress */
|
|
|
|
if (pvalue->m.callSignalAddressPresent) {
|
|
invokeStartElement (pctxt, "callSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignalAddress", -1);
|
|
}
|
|
|
|
/* decode rasAddress */
|
|
|
|
if (pvalue->m.rasAddressPresent) {
|
|
invokeStartElement (pctxt, "rasAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rasAddress", -1);
|
|
}
|
|
|
|
/* decode endpointType */
|
|
|
|
if (pvalue->m.endpointTypePresent) {
|
|
invokeStartElement (pctxt, "endpointType", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->endpointType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointType", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode priority */
|
|
|
|
if (pvalue->m.priorityPresent) {
|
|
invokeStartElement (pctxt, "priority", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->priority, 0U, 127U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->priority);
|
|
|
|
invokeEndElement (pctxt, "priority", -1);
|
|
}
|
|
|
|
/* decode remoteExtensionAddress */
|
|
|
|
if (pvalue->m.remoteExtensionAddressPresent) {
|
|
invokeStartElement (pctxt, "remoteExtensionAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "remoteExtensionAddress", -1);
|
|
}
|
|
|
|
/* decode destExtraCallInfo */
|
|
|
|
if (pvalue->m.destExtraCallInfoPresent) {
|
|
invokeStartElement (pctxt, "destExtraCallInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destExtraCallInfo", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 3 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.alternateTransportAddressesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateTransportAddresses", -1);
|
|
|
|
stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateTransportAddresses", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UseSpecifiedTransport */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* tcp */
|
|
case 0:
|
|
invokeStartElement (pctxt, "tcp", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "tcp", -1);
|
|
|
|
break;
|
|
|
|
/* annexE */
|
|
case 1:
|
|
invokeStartElement (pctxt, "annexE", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "annexE", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* sctp */
|
|
case 3:
|
|
invokeStartElement (pctxt, "sctp", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "sctp", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AlternateGK */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperIdentifierPresent = optbit;
|
|
|
|
/* decode rasAddress */
|
|
|
|
invokeStartElement (pctxt, "rasAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rasAddress", -1);
|
|
|
|
/* decode gatekeeperIdentifier */
|
|
|
|
if (pvalue->m.gatekeeperIdentifierPresent) {
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
}
|
|
|
|
/* decode needToRegister */
|
|
|
|
invokeStartElement (pctxt, "needToRegister", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->needToRegister);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->needToRegister);
|
|
|
|
invokeEndElement (pctxt, "needToRegister", -1);
|
|
|
|
/* decode priority */
|
|
|
|
invokeStartElement (pctxt, "priority", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->priority, 0U, 127U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->priority);
|
|
|
|
invokeEndElement (pctxt, "priority", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225AlternateGK */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225AlternateGK* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AlternateGK);
|
|
|
|
stat = asn1PD_H225AlternateGK (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AltGKInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode alternateGatekeeper */
|
|
|
|
invokeStartElement (pctxt, "alternateGatekeeper", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateGatekeeper", -1);
|
|
|
|
/* decode altGKisPermanent */
|
|
|
|
invokeStartElement (pctxt, "altGKisPermanent", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->altGKisPermanent);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->altGKisPermanent);
|
|
|
|
invokeEndElement (pctxt, "altGKisPermanent", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* SecurityErrors2 */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* securityWrongSyncTime */
|
|
case 0:
|
|
invokeStartElement (pctxt, "securityWrongSyncTime", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongSyncTime", -1);
|
|
|
|
break;
|
|
|
|
/* securityReplay */
|
|
case 1:
|
|
invokeStartElement (pctxt, "securityReplay", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityReplay", -1);
|
|
|
|
break;
|
|
|
|
/* securityWrongGeneralID */
|
|
case 2:
|
|
invokeStartElement (pctxt, "securityWrongGeneralID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongGeneralID", -1);
|
|
|
|
break;
|
|
|
|
/* securityWrongSendersID */
|
|
case 3:
|
|
invokeStartElement (pctxt, "securityWrongSendersID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongSendersID", -1);
|
|
|
|
break;
|
|
|
|
/* securityIntegrityFailed */
|
|
case 4:
|
|
invokeStartElement (pctxt, "securityIntegrityFailed", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityIntegrityFailed", -1);
|
|
|
|
break;
|
|
|
|
/* securityWrongOID */
|
|
case 5:
|
|
invokeStartElement (pctxt, "securityWrongOID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityWrongOID", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 7;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* EncryptIntAlg */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* nonStandard */
|
|
case 0:
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
|
|
break;
|
|
|
|
/* isoAlgorithm */
|
|
case 1:
|
|
invokeStartElement (pctxt, "isoAlgorithm", -1);
|
|
|
|
pvalue->u.isoAlgorithm = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, pvalue->u.isoAlgorithm);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->u.isoAlgorithm->numids, pvalue->u.isoAlgorithm->subid);
|
|
|
|
invokeEndElement (pctxt, "isoAlgorithm", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* NonIsoIntegrityMechanism */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* hMAC_MD5 */
|
|
case 0:
|
|
invokeStartElement (pctxt, "hMAC_MD5", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "hMAC_MD5", -1);
|
|
|
|
break;
|
|
|
|
/* hMAC_iso10118_2_s */
|
|
case 1:
|
|
invokeStartElement (pctxt, "hMAC_iso10118_2_s", -1);
|
|
|
|
pvalue->u.hMAC_iso10118_2_s = ALLOC_ASN1ELEM (pctxt, H225EncryptIntAlg);
|
|
|
|
stat = asn1PD_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_s);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "hMAC_iso10118_2_s", -1);
|
|
|
|
break;
|
|
|
|
/* hMAC_iso10118_2_l */
|
|
case 2:
|
|
invokeStartElement (pctxt, "hMAC_iso10118_2_l", -1);
|
|
|
|
pvalue->u.hMAC_iso10118_2_l = ALLOC_ASN1ELEM (pctxt, H225EncryptIntAlg);
|
|
|
|
stat = asn1PD_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_l);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "hMAC_iso10118_2_l", -1);
|
|
|
|
break;
|
|
|
|
/* hMAC_iso10118_3 */
|
|
case 3:
|
|
invokeStartElement (pctxt, "hMAC_iso10118_3", -1);
|
|
|
|
pvalue->u.hMAC_iso10118_3 = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, pvalue->u.hMAC_iso10118_3);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->u.hMAC_iso10118_3->numids, pvalue->u.hMAC_iso10118_3->subid);
|
|
|
|
invokeEndElement (pctxt, "hMAC_iso10118_3", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* IntegrityMechanism */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* nonStandard */
|
|
case 0:
|
|
invokeStartElement (pctxt, "nonStandard", -1);
|
|
|
|
pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H225NonStandardParameter);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, pvalue->u.nonStandard);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandard", -1);
|
|
|
|
break;
|
|
|
|
/* digSig */
|
|
case 1:
|
|
invokeStartElement (pctxt, "digSig", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "digSig", -1);
|
|
|
|
break;
|
|
|
|
/* iso9797 */
|
|
case 2:
|
|
invokeStartElement (pctxt, "iso9797", -1);
|
|
|
|
pvalue->u.iso9797 = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, pvalue->u.iso9797);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->u.iso9797->numids, pvalue->u.iso9797->subid);
|
|
|
|
invokeEndElement (pctxt, "iso9797", -1);
|
|
|
|
break;
|
|
|
|
/* nonIsoIM */
|
|
case 3:
|
|
invokeStartElement (pctxt, "nonIsoIM", -1);
|
|
|
|
pvalue->u.nonIsoIM = ALLOC_ASN1ELEM (pctxt, H225NonIsoIntegrityMechanism);
|
|
|
|
stat = asn1PD_H225NonIsoIntegrityMechanism (pctxt, pvalue->u.nonIsoIM);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonIsoIM", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ICV */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ICV (OOCTXT* pctxt, H225ICV* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode algorithmOID */
|
|
|
|
invokeStartElement (pctxt, "algorithmOID", -1);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
|
|
|
|
invokeEndElement (pctxt, "algorithmOID", -1);
|
|
|
|
/* decode icv */
|
|
|
|
invokeStartElement (pctxt, "icv", -1);
|
|
|
|
stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->icv);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeBitStrValue (pctxt, pvalue->icv.numbits, pvalue->icv.data);
|
|
|
|
invokeEndElement (pctxt, "icv", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CapacityReportingCapability */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode canReportCallCapacity */
|
|
|
|
invokeStartElement (pctxt, "canReportCallCapacity", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canReportCallCapacity);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canReportCallCapacity);
|
|
|
|
invokeEndElement (pctxt, "canReportCallCapacity", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CapacityReportingSpecification_when */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callStartPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callEndPresent = optbit;
|
|
|
|
/* decode callStart */
|
|
|
|
if (pvalue->m.callStartPresent) {
|
|
invokeStartElement (pctxt, "callStart", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "callStart", -1);
|
|
}
|
|
|
|
/* decode callEnd */
|
|
|
|
if (pvalue->m.callEndPresent) {
|
|
invokeStartElement (pctxt, "callEnd", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "callEnd", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CapacityReportingSpecification */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode when */
|
|
|
|
invokeStartElement (pctxt, "when", -1);
|
|
|
|
stat = asn1PD_H225CapacityReportingSpecification_when (pctxt, &pvalue->when);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "when", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RasUsageInfoTypes */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.startTimePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endTimePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.terminationCausePresent = optbit;
|
|
|
|
/* decode nonStandardUsageTypes */
|
|
|
|
invokeStartElement (pctxt, "nonStandardUsageTypes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageTypes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardUsageTypes", -1);
|
|
|
|
/* decode startTime */
|
|
|
|
if (pvalue->m.startTimePresent) {
|
|
invokeStartElement (pctxt, "startTime", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "startTime", -1);
|
|
}
|
|
|
|
/* decode endTime */
|
|
|
|
if (pvalue->m.endTimePresent) {
|
|
invokeStartElement (pctxt, "endTime", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "endTime", -1);
|
|
}
|
|
|
|
/* decode terminationCause */
|
|
|
|
if (pvalue->m.terminationCausePresent) {
|
|
invokeStartElement (pctxt, "terminationCause", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "terminationCause", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RasUsageSpecification_when */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.startPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.inIrrPresent = optbit;
|
|
|
|
/* decode start */
|
|
|
|
if (pvalue->m.startPresent) {
|
|
invokeStartElement (pctxt, "start", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "start", -1);
|
|
}
|
|
|
|
/* decode end */
|
|
|
|
if (pvalue->m.endPresent) {
|
|
invokeStartElement (pctxt, "end", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "end", -1);
|
|
}
|
|
|
|
/* decode inIrr */
|
|
|
|
if (pvalue->m.inIrrPresent) {
|
|
invokeStartElement (pctxt, "inIrr", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "inIrr", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RasUsageSpecification_callStartingPoint */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.alertingPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.connectPresent = optbit;
|
|
|
|
/* decode alerting */
|
|
|
|
if (pvalue->m.alertingPresent) {
|
|
invokeStartElement (pctxt, "alerting", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "alerting", -1);
|
|
}
|
|
|
|
/* decode connect */
|
|
|
|
if (pvalue->m.connectPresent) {
|
|
invokeStartElement (pctxt, "connect", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "connect", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RasUsageSpecification */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callStartingPointPresent = optbit;
|
|
|
|
/* decode when */
|
|
|
|
invokeStartElement (pctxt, "when", -1);
|
|
|
|
stat = asn1PD_H225RasUsageSpecification_when (pctxt, &pvalue->when);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "when", -1);
|
|
|
|
/* decode callStartingPoint */
|
|
|
|
if (pvalue->m.callStartingPointPresent) {
|
|
invokeStartElement (pctxt, "callStartingPoint", -1);
|
|
|
|
stat = asn1PD_H225RasUsageSpecification_callStartingPoint (pctxt, &pvalue->callStartingPoint);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callStartingPoint", -1);
|
|
}
|
|
|
|
/* decode required */
|
|
|
|
invokeStartElement (pctxt, "required", -1);
|
|
|
|
stat = asn1PD_H225RasUsageInfoTypes (pctxt, &pvalue->required);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "required", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RasUsageInformation */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.alertingTimePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.connectTimePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endTimePresent = optbit;
|
|
|
|
/* decode nonStandardUsageFields */
|
|
|
|
invokeStartElement (pctxt, "nonStandardUsageFields", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageFields);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardUsageFields", -1);
|
|
|
|
/* decode alertingTime */
|
|
|
|
if (pvalue->m.alertingTimePresent) {
|
|
invokeStartElement (pctxt, "alertingTime", -1);
|
|
|
|
stat = asn1PD_H235TimeStamp (pctxt, &pvalue->alertingTime);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alertingTime", -1);
|
|
}
|
|
|
|
/* decode connectTime */
|
|
|
|
if (pvalue->m.connectTimePresent) {
|
|
invokeStartElement (pctxt, "connectTime", -1);
|
|
|
|
stat = asn1PD_H235TimeStamp (pctxt, &pvalue->connectTime);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "connectTime", -1);
|
|
}
|
|
|
|
/* decode endTime */
|
|
|
|
if (pvalue->m.endTimePresent) {
|
|
invokeStartElement (pctxt, "endTime", -1);
|
|
|
|
stat = asn1PD_H235TimeStamp (pctxt, &pvalue->endTime);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endTime", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallTerminationCause */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* releaseCompleteReason */
|
|
case 0:
|
|
invokeStartElement (pctxt, "releaseCompleteReason", -1);
|
|
|
|
pvalue->u.releaseCompleteReason = ALLOC_ASN1ELEM (pctxt, H225ReleaseCompleteReason);
|
|
|
|
stat = asn1PD_H225ReleaseCompleteReason (pctxt, pvalue->u.releaseCompleteReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "releaseCompleteReason", -1);
|
|
|
|
break;
|
|
|
|
/* releaseCompleteCauseIE */
|
|
case 1:
|
|
invokeStartElement (pctxt, "releaseCompleteCauseIE", -1);
|
|
|
|
pvalue->u.releaseCompleteCauseIE = ALLOC_ASN1ELEM (pctxt, H225CallTerminationCause_releaseCompleteCauseIE);
|
|
|
|
stat = asn1PD_H225CallTerminationCause_releaseCompleteCauseIE (pctxt, pvalue->u.releaseCompleteCauseIE);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "releaseCompleteCauseIE", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportChannelInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.sendAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.recvAddressPresent = optbit;
|
|
|
|
/* decode sendAddress */
|
|
|
|
if (pvalue->m.sendAddressPresent) {
|
|
invokeStartElement (pctxt, "sendAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->sendAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sendAddress", -1);
|
|
}
|
|
|
|
/* decode recvAddress */
|
|
|
|
if (pvalue->m.recvAddressPresent) {
|
|
invokeStartElement (pctxt, "recvAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->recvAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "recvAddress", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* BandwidthDetails */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode sender */
|
|
|
|
invokeStartElement (pctxt, "sender", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->sender);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->sender);
|
|
|
|
invokeEndElement (pctxt, "sender", -1);
|
|
|
|
/* decode multicast */
|
|
|
|
invokeStartElement (pctxt, "multicast", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multicast);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multicast);
|
|
|
|
invokeEndElement (pctxt, "multicast", -1);
|
|
|
|
/* decode bandwidth */
|
|
|
|
invokeStartElement (pctxt, "bandwidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandwidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandwidth", -1);
|
|
|
|
/* decode rtcpAddresses */
|
|
|
|
invokeStartElement (pctxt, "rtcpAddresses", -1);
|
|
|
|
stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddresses);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rtcpAddresses", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallCreditCapability */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.canDisplayAmountStringPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.canEnforceDurationLimitPresent = optbit;
|
|
|
|
/* decode canDisplayAmountString */
|
|
|
|
if (pvalue->m.canDisplayAmountStringPresent) {
|
|
invokeStartElement (pctxt, "canDisplayAmountString", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canDisplayAmountString);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canDisplayAmountString);
|
|
|
|
invokeEndElement (pctxt, "canDisplayAmountString", -1);
|
|
}
|
|
|
|
/* decode canEnforceDurationLimit */
|
|
|
|
if (pvalue->m.canEnforceDurationLimitPresent) {
|
|
invokeStartElement (pctxt, "canEnforceDurationLimit", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canEnforceDurationLimit);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canEnforceDurationLimit);
|
|
|
|
invokeEndElement (pctxt, "canEnforceDurationLimit", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RTPSession_associatedSessionIds */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1UINT8);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 1U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->elem[xx1]);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RTPSession */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
/* decode rtpAddress */
|
|
|
|
invokeStartElement (pctxt, "rtpAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->rtpAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rtpAddress", -1);
|
|
|
|
/* decode rtcpAddress */
|
|
|
|
invokeStartElement (pctxt, "rtcpAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rtcpAddress", -1);
|
|
|
|
/* decode cname */
|
|
|
|
invokeStartElement (pctxt, "cname", -1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->cname, 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->cname);
|
|
|
|
invokeEndElement (pctxt, "cname", -1);
|
|
|
|
/* decode ssrc */
|
|
|
|
invokeStartElement (pctxt, "ssrc", -1);
|
|
|
|
stat = decodeConsUnsigned (pctxt, &pvalue->ssrc, 1U, ASN1UINT_MAX);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->ssrc);
|
|
|
|
invokeEndElement (pctxt, "ssrc", -1);
|
|
|
|
/* decode sessionId */
|
|
|
|
invokeStartElement (pctxt, "sessionId", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->sessionId, 1U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->sessionId);
|
|
|
|
invokeEndElement (pctxt, "sessionId", -1);
|
|
|
|
/* decode associatedSessionIds */
|
|
|
|
invokeStartElement (pctxt, "associatedSessionIds", -1);
|
|
|
|
stat = asn1PD_H225RTPSession_associatedSessionIds (pctxt, &pvalue->associatedSessionIds);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "associatedSessionIds", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.multicastPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multicast", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "multicast", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.bandwidthPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "bandwidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandwidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandwidth", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225Endpoint */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225Endpoint* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225Endpoint);
|
|
|
|
stat = asn1PD_H225Endpoint (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225AuthenticationMechanism */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H235AuthenticationMechanism* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H235AuthenticationMechanism);
|
|
|
|
stat = asn1PD_H235AuthenticationMechanism (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatekeeperRequest_algorithmOIDs */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1OBJID);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, &pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->elem[xx1].numids, pvalue->elem[xx1].subid);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225IntegrityMechanism */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225IntegrityMechanism* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225IntegrityMechanism);
|
|
|
|
stat = asn1PD_H225IntegrityMechanism (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatekeeperRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperIdentifierPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callServicesPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endpointAliasPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode rasAddress */
|
|
|
|
invokeStartElement (pctxt, "rasAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rasAddress", -1);
|
|
|
|
/* decode endpointType */
|
|
|
|
invokeStartElement (pctxt, "endpointType", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->endpointType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointType", -1);
|
|
|
|
/* decode gatekeeperIdentifier */
|
|
|
|
if (pvalue->m.gatekeeperIdentifierPresent) {
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
}
|
|
|
|
/* decode callServices */
|
|
|
|
if (pvalue->m.callServicesPresent) {
|
|
invokeStartElement (pctxt, "callServices", -1);
|
|
|
|
stat = asn1PD_H225QseriesOptions (pctxt, &pvalue->callServices);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callServices", -1);
|
|
}
|
|
|
|
/* decode endpointAlias */
|
|
|
|
if (pvalue->m.endpointAliasPresent) {
|
|
invokeStartElement (pctxt, "endpointAlias", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointAlias", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 10 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.alternateEndpointsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateEndpoints", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateEndpoints", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.authenticationCapabilityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "authenticationCapability", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AuthenticationMechanism (pctxt, &pvalue->authenticationCapability);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "authenticationCapability", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.algorithmOIDsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "algorithmOIDs", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperRequest_algorithmOIDs (pctxt, &pvalue->algorithmOIDs);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "algorithmOIDs", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.integrityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrity", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225IntegrityMechanism (pctxt, &pvalue->integrity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrity", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.supportsAltGKPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportsAltGK", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "supportsAltGK", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatekeeperConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperIdentifierPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode gatekeeperIdentifier */
|
|
|
|
if (pvalue->m.gatekeeperIdentifierPresent) {
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
}
|
|
|
|
/* decode rasAddress */
|
|
|
|
invokeStartElement (pctxt, "rasAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rasAddress", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 9 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.alternateGatekeeperPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateGatekeeper", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateGatekeeper", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.authenticationModePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "authenticationMode", -1);
|
|
|
|
stat = asn1PD_H235AuthenticationMechanism (pctxt, &pvalue->authenticationMode);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "authenticationMode", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.algorithmOIDPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "algorithmOID", -1);
|
|
|
|
stat = decodeObjectIdentifier (pctxt, &pvalue->algorithmOID);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOidValue (pctxt, pvalue->algorithmOID.numids, pvalue->algorithmOID.subid);
|
|
|
|
invokeEndElement (pctxt, "algorithmOID", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.integrityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrity", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225IntegrityMechanism (pctxt, &pvalue->integrity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrity", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatekeeperRejectReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* resourceUnavailable */
|
|
case 0:
|
|
invokeStartElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
break;
|
|
|
|
/* terminalExcluded */
|
|
case 1:
|
|
invokeStartElement (pctxt, "terminalExcluded", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "terminalExcluded", -1);
|
|
|
|
break;
|
|
|
|
/* invalidRevision */
|
|
case 2:
|
|
invokeStartElement (pctxt, "invalidRevision", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidRevision", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 3:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* securityDenial */
|
|
case 5:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* genericDataReason */
|
|
case 6:
|
|
invokeStartElement (pctxt, "genericDataReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "genericDataReason", -1);
|
|
|
|
break;
|
|
|
|
/* neededFeatureNotSupported */
|
|
case 7:
|
|
invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 8:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors);
|
|
|
|
stat = asn1PD_H225SecurityErrors (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* GatekeeperReject */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperIdentifierPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode gatekeeperIdentifier */
|
|
|
|
if (pvalue->m.gatekeeperIdentifierPresent) {
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
}
|
|
|
|
/* decode rejectReason */
|
|
|
|
invokeStartElement (pctxt, "rejectReason", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperRejectReason (pctxt, &pvalue->rejectReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rejectReason", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 6 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.altGKInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225AddressPattern */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225AddressPattern* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AddressPattern);
|
|
|
|
stat = asn1PD_H225AddressPattern (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225H248PackagesDescriptor */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, H225H248PackagesDescriptor);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = asn1PD_H225H248PackagesDescriptor (pctxt, &pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RegistrationRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.terminalAliasPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperIdentifierPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode discoveryComplete */
|
|
|
|
invokeStartElement (pctxt, "discoveryComplete", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->discoveryComplete);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->discoveryComplete);
|
|
|
|
invokeEndElement (pctxt, "discoveryComplete", -1);
|
|
|
|
/* decode callSignalAddress */
|
|
|
|
invokeStartElement (pctxt, "callSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignalAddress", -1);
|
|
|
|
/* decode rasAddress */
|
|
|
|
invokeStartElement (pctxt, "rasAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rasAddress", -1);
|
|
|
|
/* decode terminalType */
|
|
|
|
invokeStartElement (pctxt, "terminalType", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->terminalType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalType", -1);
|
|
|
|
/* decode terminalAlias */
|
|
|
|
if (pvalue->m.terminalAliasPresent) {
|
|
invokeStartElement (pctxt, "terminalAlias", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalAlias", -1);
|
|
}
|
|
|
|
/* decode gatekeeperIdentifier */
|
|
|
|
if (pvalue->m.gatekeeperIdentifierPresent) {
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
}
|
|
|
|
/* decode endpointVendor */
|
|
|
|
invokeStartElement (pctxt, "endpointVendor", -1);
|
|
|
|
stat = asn1PD_H225VendorIdentifier (pctxt, &pvalue->endpointVendor);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointVendor", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 23 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.alternateEndpointsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateEndpoints", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateEndpoints", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.timeToLivePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "timeToLive", -1);
|
|
|
|
stat = asn1PD_H225TimeToLive (pctxt, &pvalue->timeToLive);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "timeToLive", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.keepAlivePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "keepAlive", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->keepAlive);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->keepAlive);
|
|
|
|
invokeEndElement (pctxt, "keepAlive", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.endpointIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.willSupplyUUIEsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "willSupplyUUIEs", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->willSupplyUUIEs);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->willSupplyUUIEs);
|
|
|
|
invokeEndElement (pctxt, "willSupplyUUIEs", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.alternateTransportAddressesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateTransportAddresses", -1);
|
|
|
|
stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateTransportAddresses", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.additiveRegistrationPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "additiveRegistration", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "additiveRegistration", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.terminalAliasPatternPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "terminalAliasPattern", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalAliasPattern", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.supportsAltGKPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportsAltGK", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "supportsAltGK", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.usageReportingCapabilityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageReportingCapability", -1);
|
|
|
|
stat = asn1PD_H225RasUsageInfoTypes (pctxt, &pvalue->usageReportingCapability);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageReportingCapability", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.supportedH248PackagesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedH248Packages", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225H248PackagesDescriptor (pctxt, &pvalue->supportedH248Packages);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedH248Packages", -1);
|
|
break;
|
|
|
|
case 16:
|
|
pvalue->m.callCreditCapabilityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callCreditCapability", -1);
|
|
|
|
stat = asn1PD_H225CallCreditCapability (pctxt, &pvalue->callCreditCapability);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callCreditCapability", -1);
|
|
break;
|
|
|
|
case 17:
|
|
pvalue->m.capacityReportingCapabilityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacityReportingCapability", -1);
|
|
|
|
stat = asn1PD_H225CapacityReportingCapability (pctxt, &pvalue->capacityReportingCapability);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacityReportingCapability", -1);
|
|
break;
|
|
|
|
case 18:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 19:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 20:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
case 21:
|
|
pvalue->m.restartPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "restart", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "restart", -1);
|
|
break;
|
|
|
|
case 22:
|
|
pvalue->m.supportsACFSequencesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportsACFSequences", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "supportsACFSequences", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RegistrationConfirm_preGrantedARQ */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
/* decode makeCall */
|
|
|
|
invokeStartElement (pctxt, "makeCall", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->makeCall);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->makeCall);
|
|
|
|
invokeEndElement (pctxt, "makeCall", -1);
|
|
|
|
/* decode useGKCallSignalAddressToMakeCall */
|
|
|
|
invokeStartElement (pctxt, "useGKCallSignalAddressToMakeCall", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->useGKCallSignalAddressToMakeCall);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->useGKCallSignalAddressToMakeCall);
|
|
|
|
invokeEndElement (pctxt, "useGKCallSignalAddressToMakeCall", -1);
|
|
|
|
/* decode answerCall */
|
|
|
|
invokeStartElement (pctxt, "answerCall", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->answerCall);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->answerCall);
|
|
|
|
invokeEndElement (pctxt, "answerCall", -1);
|
|
|
|
/* decode useGKCallSignalAddressToAnswer */
|
|
|
|
invokeStartElement (pctxt, "useGKCallSignalAddressToAnswer", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->useGKCallSignalAddressToAnswer);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->useGKCallSignalAddressToAnswer);
|
|
|
|
invokeEndElement (pctxt, "useGKCallSignalAddressToAnswer", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 4 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.irrFrequencyInCallPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "irrFrequencyInCall", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->irrFrequencyInCall, 1U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->irrFrequencyInCall);
|
|
|
|
invokeEndElement (pctxt, "irrFrequencyInCall", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.totalBandwidthRestrictionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "totalBandwidthRestriction", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->totalBandwidthRestriction);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "totalBandwidthRestriction", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.alternateTransportAddressesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateTransportAddresses", -1);
|
|
|
|
stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateTransportAddresses", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.useSpecifiedTransportPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "useSpecifiedTransport", -1);
|
|
|
|
stat = asn1PD_H225UseSpecifiedTransport (pctxt, &pvalue->useSpecifiedTransport);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "useSpecifiedTransport", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225RasUsageSpecification */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225RasUsageSpecification* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225RasUsageSpecification);
|
|
|
|
stat = asn1PD_H225RasUsageSpecification (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RegistrationConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.terminalAliasPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperIdentifierPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode callSignalAddress */
|
|
|
|
invokeStartElement (pctxt, "callSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignalAddress", -1);
|
|
|
|
/* decode terminalAlias */
|
|
|
|
if (pvalue->m.terminalAliasPresent) {
|
|
invokeStartElement (pctxt, "terminalAlias", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalAlias", -1);
|
|
}
|
|
|
|
/* decode gatekeeperIdentifier */
|
|
|
|
if (pvalue->m.gatekeeperIdentifierPresent) {
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
}
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 17 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.alternateGatekeeperPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateGatekeeper", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateGatekeeper", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.timeToLivePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "timeToLive", -1);
|
|
|
|
stat = asn1PD_H225TimeToLive (pctxt, &pvalue->timeToLive);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "timeToLive", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.willRespondToIRRPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "willRespondToIRR", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->willRespondToIRR);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->willRespondToIRR);
|
|
|
|
invokeEndElement (pctxt, "willRespondToIRR", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.preGrantedARQPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "preGrantedARQ", -1);
|
|
|
|
stat = asn1PD_H225RegistrationConfirm_preGrantedARQ (pctxt, &pvalue->preGrantedARQ);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "preGrantedARQ", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.maintainConnectionPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "maintainConnection", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->maintainConnection);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->maintainConnection);
|
|
|
|
invokeEndElement (pctxt, "maintainConnection", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.supportsAdditiveRegistrationPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportsAdditiveRegistration", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "supportsAdditiveRegistration", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.terminalAliasPatternPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "terminalAliasPattern", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalAliasPattern", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.usageSpecPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageSpec", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225RasUsageSpecification (pctxt, &pvalue->usageSpec);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageSpec", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.featureServerAliasPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureServerAlias", -1);
|
|
|
|
stat = asn1PD_H225AliasAddress (pctxt, &pvalue->featureServerAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureServerAlias", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.capacityReportingSpecPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacityReportingSpec", -1);
|
|
|
|
stat = asn1PD_H225CapacityReportingSpecification (pctxt, &pvalue->capacityReportingSpec);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacityReportingSpec", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 16:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RegistrationRejectReason_invalidTerminalAliases */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.terminalAliasPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.terminalAliasPatternPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.supportedPrefixesPresent = optbit;
|
|
|
|
/* decode terminalAlias */
|
|
|
|
if (pvalue->m.terminalAliasPresent) {
|
|
invokeStartElement (pctxt, "terminalAlias", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalAlias", -1);
|
|
}
|
|
|
|
/* decode terminalAliasPattern */
|
|
|
|
if (pvalue->m.terminalAliasPatternPresent) {
|
|
invokeStartElement (pctxt, "terminalAliasPattern", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminalAliasPattern", -1);
|
|
}
|
|
|
|
/* decode supportedPrefixes */
|
|
|
|
if (pvalue->m.supportedPrefixesPresent) {
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RegistrationRejectReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* discoveryRequired */
|
|
case 0:
|
|
invokeStartElement (pctxt, "discoveryRequired", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "discoveryRequired", -1);
|
|
|
|
break;
|
|
|
|
/* invalidRevision */
|
|
case 1:
|
|
invokeStartElement (pctxt, "invalidRevision", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidRevision", -1);
|
|
|
|
break;
|
|
|
|
/* invalidCallSignalAddress */
|
|
case 2:
|
|
invokeStartElement (pctxt, "invalidCallSignalAddress", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidCallSignalAddress", -1);
|
|
|
|
break;
|
|
|
|
/* invalidRASAddress */
|
|
case 3:
|
|
invokeStartElement (pctxt, "invalidRASAddress", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidRASAddress", -1);
|
|
|
|
break;
|
|
|
|
/* duplicateAlias */
|
|
case 4:
|
|
invokeStartElement (pctxt, "duplicateAlias", -1);
|
|
|
|
pvalue->u.duplicateAlias = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225AliasAddress);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, pvalue->u.duplicateAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "duplicateAlias", -1);
|
|
|
|
break;
|
|
|
|
/* invalidTerminalType */
|
|
case 5:
|
|
invokeStartElement (pctxt, "invalidTerminalType", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidTerminalType", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 6:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
/* transportNotSupported */
|
|
case 7:
|
|
invokeStartElement (pctxt, "transportNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "transportNotSupported", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 9;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* transportQOSNotSupported */
|
|
case 9:
|
|
invokeStartElement (pctxt, "transportQOSNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "transportQOSNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* resourceUnavailable */
|
|
case 10:
|
|
invokeStartElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
break;
|
|
|
|
/* invalidAlias */
|
|
case 11:
|
|
invokeStartElement (pctxt, "invalidAlias", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidAlias", -1);
|
|
|
|
break;
|
|
|
|
/* securityDenial */
|
|
case 12:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* fullRegistrationRequired */
|
|
case 13:
|
|
invokeStartElement (pctxt, "fullRegistrationRequired", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "fullRegistrationRequired", -1);
|
|
|
|
break;
|
|
|
|
/* additiveRegistrationNotSupported */
|
|
case 14:
|
|
invokeStartElement (pctxt, "additiveRegistrationNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "additiveRegistrationNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* invalidTerminalAliases */
|
|
case 15:
|
|
invokeStartElement (pctxt, "invalidTerminalAliases", -1);
|
|
|
|
pvalue->u.invalidTerminalAliases = ALLOC_ASN1ELEM (pctxt, H225RegistrationRejectReason_invalidTerminalAliases);
|
|
|
|
stat = asn1PD_H225RegistrationRejectReason_invalidTerminalAliases (pctxt, pvalue->u.invalidTerminalAliases);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "invalidTerminalAliases", -1);
|
|
|
|
break;
|
|
|
|
/* genericDataReason */
|
|
case 16:
|
|
invokeStartElement (pctxt, "genericDataReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "genericDataReason", -1);
|
|
|
|
break;
|
|
|
|
/* neededFeatureNotSupported */
|
|
case 17:
|
|
invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 18:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors);
|
|
|
|
stat = asn1PD_H225SecurityErrors (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RegistrationReject */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.gatekeeperIdentifierPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode rejectReason */
|
|
|
|
invokeStartElement (pctxt, "rejectReason", -1);
|
|
|
|
stat = asn1PD_H225RegistrationRejectReason (pctxt, &pvalue->rejectReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rejectReason", -1);
|
|
|
|
/* decode gatekeeperIdentifier */
|
|
|
|
if (pvalue->m.gatekeeperIdentifierPresent) {
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 6 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.altGKInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UnregRequestReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* reregistrationRequired */
|
|
case 0:
|
|
invokeStartElement (pctxt, "reregistrationRequired", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "reregistrationRequired", -1);
|
|
|
|
break;
|
|
|
|
/* ttlExpired */
|
|
case 1:
|
|
invokeStartElement (pctxt, "ttlExpired", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "ttlExpired", -1);
|
|
|
|
break;
|
|
|
|
/* securityDenial */
|
|
case 2:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 3:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* maintenance */
|
|
case 5:
|
|
invokeStartElement (pctxt, "maintenance", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "maintenance", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 6:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
|
|
|
|
stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UnregistrationRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endpointAliasPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endpointIdentifierPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode callSignalAddress */
|
|
|
|
invokeStartElement (pctxt, "callSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignalAddress", -1);
|
|
|
|
/* decode endpointAlias */
|
|
|
|
if (pvalue->m.endpointAliasPresent) {
|
|
invokeStartElement (pctxt, "endpointAlias", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointAlias", -1);
|
|
}
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
if (pvalue->m.endpointIdentifierPresent) {
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 10 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.alternateEndpointsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateEndpoints", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateEndpoints", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.gatekeeperIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.reasonPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "reason", -1);
|
|
|
|
stat = asn1PD_H225UnregRequestReason (pctxt, &pvalue->reason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "reason", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.endpointAliasPatternPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "endpointAliasPattern", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AddressPattern (pctxt, &pvalue->endpointAliasPattern);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointAliasPattern", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.supportedPrefixesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedPrefixes", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedPrefixes", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.alternateGatekeeperPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateGatekeeper", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateGatekeeper", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UnregistrationConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 4 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UnregRejectReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* notCurrentlyRegistered */
|
|
case 0:
|
|
invokeStartElement (pctxt, "notCurrentlyRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "notCurrentlyRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* callInProgress */
|
|
case 1:
|
|
invokeStartElement (pctxt, "callInProgress", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "callInProgress", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 2:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* permissionDenied */
|
|
case 4:
|
|
invokeStartElement (pctxt, "permissionDenied", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "permissionDenied", -1);
|
|
|
|
break;
|
|
|
|
/* securityDenial */
|
|
case 5:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 6:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
|
|
|
|
stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UnregistrationReject */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode rejectReason */
|
|
|
|
invokeStartElement (pctxt, "rejectReason", -1);
|
|
|
|
stat = asn1PD_H225UnregRejectReason (pctxt, &pvalue->rejectReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rejectReason", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 5 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.altGKInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* CallModel */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* direct */
|
|
case 0:
|
|
invokeStartElement (pctxt, "direct", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "direct", -1);
|
|
|
|
break;
|
|
|
|
/* gatekeeperRouted */
|
|
case 1:
|
|
invokeStartElement (pctxt, "gatekeeperRouted", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "gatekeeperRouted", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* TransportQOS */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* endpointControlled */
|
|
case 0:
|
|
invokeStartElement (pctxt, "endpointControlled", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "endpointControlled", -1);
|
|
|
|
break;
|
|
|
|
/* gatekeeperControlled */
|
|
case 1:
|
|
invokeStartElement (pctxt, "gatekeeperControlled", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "gatekeeperControlled", -1);
|
|
|
|
break;
|
|
|
|
/* noControl */
|
|
case 2:
|
|
invokeStartElement (pctxt, "noControl", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "noControl", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AdmissionRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callModelPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destinationInfoPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destCallSignalAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.destExtraCallInfoPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.srcCallSignalAddressPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callServicesPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode callType */
|
|
|
|
invokeStartElement (pctxt, "callType", -1);
|
|
|
|
stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callType", -1);
|
|
|
|
/* decode callModel */
|
|
|
|
if (pvalue->m.callModelPresent) {
|
|
invokeStartElement (pctxt, "callModel", -1);
|
|
|
|
stat = asn1PD_H225CallModel (pctxt, &pvalue->callModel);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callModel", -1);
|
|
}
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
/* decode destinationInfo */
|
|
|
|
if (pvalue->m.destinationInfoPresent) {
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
}
|
|
|
|
/* decode destCallSignalAddress */
|
|
|
|
if (pvalue->m.destCallSignalAddressPresent) {
|
|
invokeStartElement (pctxt, "destCallSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destCallSignalAddress", -1);
|
|
}
|
|
|
|
/* decode destExtraCallInfo */
|
|
|
|
if (pvalue->m.destExtraCallInfoPresent) {
|
|
invokeStartElement (pctxt, "destExtraCallInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destExtraCallInfo", -1);
|
|
}
|
|
|
|
/* decode srcInfo */
|
|
|
|
invokeStartElement (pctxt, "srcInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->srcInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "srcInfo", -1);
|
|
|
|
/* decode srcCallSignalAddress */
|
|
|
|
if (pvalue->m.srcCallSignalAddressPresent) {
|
|
invokeStartElement (pctxt, "srcCallSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->srcCallSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "srcCallSignalAddress", -1);
|
|
}
|
|
|
|
/* decode bandWidth */
|
|
|
|
invokeStartElement (pctxt, "bandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandWidth", -1);
|
|
|
|
/* decode callReferenceValue */
|
|
|
|
invokeStartElement (pctxt, "callReferenceValue", -1);
|
|
|
|
stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callReferenceValue", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode callServices */
|
|
|
|
if (pvalue->m.callServicesPresent) {
|
|
invokeStartElement (pctxt, "callServices", -1);
|
|
|
|
stat = asn1PD_H225QseriesOptions (pctxt, &pvalue->callServices);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callServices", -1);
|
|
}
|
|
|
|
/* decode conferenceID */
|
|
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
|
|
/* decode activeMC */
|
|
|
|
invokeStartElement (pctxt, "activeMC", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->activeMC);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->activeMC);
|
|
|
|
invokeEndElement (pctxt, "activeMC", -1);
|
|
|
|
/* decode answerCall */
|
|
|
|
invokeStartElement (pctxt, "answerCall", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->answerCall);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->answerCall);
|
|
|
|
invokeEndElement (pctxt, "answerCall", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 19 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.canMapAliasPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "canMapAlias", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canMapAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canMapAlias);
|
|
|
|
invokeEndElement (pctxt, "canMapAlias", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.srcAlternativesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "srcAlternatives", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->srcAlternatives);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "srcAlternatives", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.destAlternativesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destAlternatives", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->destAlternatives);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destAlternatives", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.gatekeeperIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.transportQOSPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "transportQOS", -1);
|
|
|
|
stat = asn1PD_H225TransportQOS (pctxt, &pvalue->transportQOS);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "transportQOS", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.willSupplyUUIEsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "willSupplyUUIEs", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->willSupplyUUIEs);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->willSupplyUUIEs);
|
|
|
|
invokeEndElement (pctxt, "willSupplyUUIEs", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.callLinkagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callLinkage", -1);
|
|
|
|
stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callLinkage", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.gatewayDataRatePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "gatewayDataRate", -1);
|
|
|
|
stat = asn1PD_H225DataRate (pctxt, &pvalue->gatewayDataRate);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatewayDataRate", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.desiredProtocolsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "desiredProtocols", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->desiredProtocols);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "desiredProtocols", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.desiredTunnelledProtocolPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "desiredTunnelledProtocol", -1);
|
|
|
|
stat = asn1PD_H225TunnelledProtocol (pctxt, &pvalue->desiredTunnelledProtocol);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "desiredTunnelledProtocol", -1);
|
|
break;
|
|
|
|
case 16:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 17:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
case 18:
|
|
pvalue->m.canMapSrcAliasPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "canMapSrcAlias", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canMapSrcAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canMapSrcAlias);
|
|
|
|
invokeEndElement (pctxt, "canMapSrcAlias", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UUIEsRequested */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
/* decode setup */
|
|
|
|
invokeStartElement (pctxt, "setup", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->setup);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->setup);
|
|
|
|
invokeEndElement (pctxt, "setup", -1);
|
|
|
|
/* decode callProceeding */
|
|
|
|
invokeStartElement (pctxt, "callProceeding", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->callProceeding);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->callProceeding);
|
|
|
|
invokeEndElement (pctxt, "callProceeding", -1);
|
|
|
|
/* decode connect */
|
|
|
|
invokeStartElement (pctxt, "connect", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->connect);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->connect);
|
|
|
|
invokeEndElement (pctxt, "connect", -1);
|
|
|
|
/* decode alerting */
|
|
|
|
invokeStartElement (pctxt, "alerting", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->alerting);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->alerting);
|
|
|
|
invokeEndElement (pctxt, "alerting", -1);
|
|
|
|
/* decode information */
|
|
|
|
invokeStartElement (pctxt, "information", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->information);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->information);
|
|
|
|
invokeEndElement (pctxt, "information", -1);
|
|
|
|
/* decode releaseComplete */
|
|
|
|
invokeStartElement (pctxt, "releaseComplete", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->releaseComplete);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->releaseComplete);
|
|
|
|
invokeEndElement (pctxt, "releaseComplete", -1);
|
|
|
|
/* decode facility */
|
|
|
|
invokeStartElement (pctxt, "facility", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->facility);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->facility);
|
|
|
|
invokeEndElement (pctxt, "facility", -1);
|
|
|
|
/* decode progress */
|
|
|
|
invokeStartElement (pctxt, "progress", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->progress);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->progress);
|
|
|
|
invokeEndElement (pctxt, "progress", -1);
|
|
|
|
/* decode empty */
|
|
|
|
invokeStartElement (pctxt, "empty", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->empty);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->empty);
|
|
|
|
invokeEndElement (pctxt, "empty", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 4 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.statusPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "status", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->status);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->status);
|
|
|
|
invokeEndElement (pctxt, "status", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.statusInquiryPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "statusInquiry", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->statusInquiry);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->statusInquiry);
|
|
|
|
invokeEndElement (pctxt, "statusInquiry", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.setupAcknowledgePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "setupAcknowledge", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->setupAcknowledge);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->setupAcknowledge);
|
|
|
|
invokeEndElement (pctxt, "setupAcknowledge", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.notifyPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "notify", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->notify);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->notify);
|
|
|
|
invokeEndElement (pctxt, "notify", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AdmissionConfirm_language */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue)
|
|
{
|
|
static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 };
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, ASN1IA5String);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
addSizeConstraint (pctxt, &element_lsize1);
|
|
|
|
stat = decodeConstrainedStringEx (pctxt, &pvalue->elem[xx1], 0, 8, 7, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeCharStrValue (pctxt, pvalue->elem[xx1]);
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AdmissionConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.irrFrequencyPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode bandWidth */
|
|
|
|
invokeStartElement (pctxt, "bandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandWidth", -1);
|
|
|
|
/* decode callModel */
|
|
|
|
invokeStartElement (pctxt, "callModel", -1);
|
|
|
|
stat = asn1PD_H225CallModel (pctxt, &pvalue->callModel);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callModel", -1);
|
|
|
|
/* decode destCallSignalAddress */
|
|
|
|
invokeStartElement (pctxt, "destCallSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destCallSignalAddress", -1);
|
|
|
|
/* decode irrFrequency */
|
|
|
|
if (pvalue->m.irrFrequencyPresent) {
|
|
invokeStartElement (pctxt, "irrFrequency", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->irrFrequency, 1U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->irrFrequency);
|
|
|
|
invokeEndElement (pctxt, "irrFrequency", -1);
|
|
}
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 22 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.destinationInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.destExtraCallInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destExtraCallInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destExtraCallInfo", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.destinationTypePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destinationType", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationType", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.remoteExtensionAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "remoteExtensionAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "remoteExtensionAddress", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.alternateEndpointsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateEndpoints", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateEndpoints", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.transportQOSPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "transportQOS", -1);
|
|
|
|
stat = asn1PD_H225TransportQOS (pctxt, &pvalue->transportQOS);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "transportQOS", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.willRespondToIRRPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "willRespondToIRR", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->willRespondToIRR);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->willRespondToIRR);
|
|
|
|
invokeEndElement (pctxt, "willRespondToIRR", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.uuiesRequestedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "uuiesRequested", -1);
|
|
|
|
stat = asn1PD_H225UUIEsRequested (pctxt, &pvalue->uuiesRequested);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "uuiesRequested", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.languagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "language", -1);
|
|
|
|
stat = asn1PD_H225AdmissionConfirm_language (pctxt, &pvalue->language);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "language", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.alternateTransportAddressesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateTransportAddresses", -1);
|
|
|
|
stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateTransportAddresses", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.useSpecifiedTransportPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "useSpecifiedTransport", -1);
|
|
|
|
stat = asn1PD_H225UseSpecifiedTransport (pctxt, &pvalue->useSpecifiedTransport);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "useSpecifiedTransport", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.usageSpecPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageSpec", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225RasUsageSpecification (pctxt, &pvalue->usageSpec);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageSpec", -1);
|
|
break;
|
|
|
|
case 16:
|
|
pvalue->m.supportedProtocolsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedProtocols", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->supportedProtocols);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedProtocols", -1);
|
|
break;
|
|
|
|
case 17:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 18:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 19:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 20:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
case 21:
|
|
pvalue->m.modifiedSrcInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "modifiedSrcInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->modifiedSrcInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "modifiedSrcInfo", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225PartyNumber */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225PartyNumber* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225PartyNumber);
|
|
|
|
stat = asn1PD_H225PartyNumber (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AdmissionRejectReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 7);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* calledPartyNotRegistered */
|
|
case 0:
|
|
invokeStartElement (pctxt, "calledPartyNotRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "calledPartyNotRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* invalidPermission */
|
|
case 1:
|
|
invokeStartElement (pctxt, "invalidPermission", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidPermission", -1);
|
|
|
|
break;
|
|
|
|
/* requestDenied */
|
|
case 2:
|
|
invokeStartElement (pctxt, "requestDenied", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "requestDenied", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 3:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
/* callerNotRegistered */
|
|
case 4:
|
|
invokeStartElement (pctxt, "callerNotRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "callerNotRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* routeCallToGatekeeper */
|
|
case 5:
|
|
invokeStartElement (pctxt, "routeCallToGatekeeper", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "routeCallToGatekeeper", -1);
|
|
|
|
break;
|
|
|
|
/* invalidEndpointIdentifier */
|
|
case 6:
|
|
invokeStartElement (pctxt, "invalidEndpointIdentifier", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidEndpointIdentifier", -1);
|
|
|
|
break;
|
|
|
|
/* resourceUnavailable */
|
|
case 7:
|
|
invokeStartElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 9;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* securityDenial */
|
|
case 9:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* qosControlNotSupported */
|
|
case 10:
|
|
invokeStartElement (pctxt, "qosControlNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "qosControlNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* incompleteAddress */
|
|
case 11:
|
|
invokeStartElement (pctxt, "incompleteAddress", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "incompleteAddress", -1);
|
|
|
|
break;
|
|
|
|
/* aliasesInconsistent */
|
|
case 12:
|
|
invokeStartElement (pctxt, "aliasesInconsistent", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "aliasesInconsistent", -1);
|
|
|
|
break;
|
|
|
|
/* routeCallToSCN */
|
|
case 13:
|
|
invokeStartElement (pctxt, "routeCallToSCN", -1);
|
|
|
|
pvalue->u.routeCallToSCN = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225PartyNumber);
|
|
|
|
stat = asn1PD_H225_SeqOfH225PartyNumber (pctxt, pvalue->u.routeCallToSCN);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "routeCallToSCN", -1);
|
|
|
|
break;
|
|
|
|
/* exceedsCallCapacity */
|
|
case 14:
|
|
invokeStartElement (pctxt, "exceedsCallCapacity", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "exceedsCallCapacity", -1);
|
|
|
|
break;
|
|
|
|
/* collectDestination */
|
|
case 15:
|
|
invokeStartElement (pctxt, "collectDestination", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "collectDestination", -1);
|
|
|
|
break;
|
|
|
|
/* collectPIN */
|
|
case 16:
|
|
invokeStartElement (pctxt, "collectPIN", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "collectPIN", -1);
|
|
|
|
break;
|
|
|
|
/* genericDataReason */
|
|
case 17:
|
|
invokeStartElement (pctxt, "genericDataReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "genericDataReason", -1);
|
|
|
|
break;
|
|
|
|
/* neededFeatureNotSupported */
|
|
case 18:
|
|
invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* securityErrors */
|
|
case 19:
|
|
invokeStartElement (pctxt, "securityErrors", -1);
|
|
|
|
pvalue->u.securityErrors = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
|
|
|
|
stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityErrors);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityErrors", -1);
|
|
|
|
break;
|
|
|
|
/* securityDHmismatch */
|
|
case 20:
|
|
invokeStartElement (pctxt, "securityDHmismatch", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDHmismatch", -1);
|
|
|
|
break;
|
|
|
|
/* noRouteToDestination */
|
|
case 21:
|
|
invokeStartElement (pctxt, "noRouteToDestination", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "noRouteToDestination", -1);
|
|
|
|
break;
|
|
|
|
/* unallocatedNumber */
|
|
case 22:
|
|
invokeStartElement (pctxt, "unallocatedNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "unallocatedNumber", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* AdmissionReject */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode rejectReason */
|
|
|
|
invokeStartElement (pctxt, "rejectReason", -1);
|
|
|
|
stat = asn1PD_H225AdmissionRejectReason (pctxt, &pvalue->rejectReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rejectReason", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 8 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.altGKInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.callSignalAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignalAddress", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225BandwidthDetails */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225BandwidthDetails* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225BandwidthDetails);
|
|
|
|
stat = asn1PD_H225BandwidthDetails (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* BandwidthRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callTypePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
/* decode conferenceID */
|
|
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
|
|
/* decode callReferenceValue */
|
|
|
|
invokeStartElement (pctxt, "callReferenceValue", -1);
|
|
|
|
stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callReferenceValue", -1);
|
|
|
|
/* decode callType */
|
|
|
|
if (pvalue->m.callTypePresent) {
|
|
invokeStartElement (pctxt, "callType", -1);
|
|
|
|
stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callType", -1);
|
|
}
|
|
|
|
/* decode bandWidth */
|
|
|
|
invokeStartElement (pctxt, "bandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandWidth", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 11 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.gatekeeperIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.answeredCallPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "answeredCall", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->answeredCall);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->answeredCall);
|
|
|
|
invokeEndElement (pctxt, "answeredCall", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.callLinkagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callLinkage", -1);
|
|
|
|
stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callLinkage", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.usageInformationPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageInformation", -1);
|
|
|
|
stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageInformation", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.bandwidthDetailsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "bandwidthDetails", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225BandwidthDetails (pctxt, &pvalue->bandwidthDetails);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandwidthDetails", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* BandwidthConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode bandWidth */
|
|
|
|
invokeStartElement (pctxt, "bandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandWidth", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 5 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* BandRejectReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* notBound */
|
|
case 0:
|
|
invokeStartElement (pctxt, "notBound", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "notBound", -1);
|
|
|
|
break;
|
|
|
|
/* invalidConferenceID */
|
|
case 1:
|
|
invokeStartElement (pctxt, "invalidConferenceID", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidConferenceID", -1);
|
|
|
|
break;
|
|
|
|
/* invalidPermission */
|
|
case 2:
|
|
invokeStartElement (pctxt, "invalidPermission", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidPermission", -1);
|
|
|
|
break;
|
|
|
|
/* insufficientResources */
|
|
case 3:
|
|
invokeStartElement (pctxt, "insufficientResources", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "insufficientResources", -1);
|
|
|
|
break;
|
|
|
|
/* invalidRevision */
|
|
case 4:
|
|
invokeStartElement (pctxt, "invalidRevision", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidRevision", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 5:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 7;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* securityDenial */
|
|
case 7:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 8:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
|
|
|
|
stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* BandwidthReject */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode rejectReason */
|
|
|
|
invokeStartElement (pctxt, "rejectReason", -1);
|
|
|
|
stat = asn1PD_H225BandRejectReason (pctxt, &pvalue->rejectReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rejectReason", -1);
|
|
|
|
/* decode allowedBandWidth */
|
|
|
|
invokeStartElement (pctxt, "allowedBandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->allowedBandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "allowedBandWidth", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 5 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.altGKInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* DisengageReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* forcedDrop */
|
|
case 0:
|
|
invokeStartElement (pctxt, "forcedDrop", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "forcedDrop", -1);
|
|
|
|
break;
|
|
|
|
/* normalDrop */
|
|
case 1:
|
|
invokeStartElement (pctxt, "normalDrop", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "normalDrop", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 2:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* DisengageRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
/* decode conferenceID */
|
|
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
|
|
/* decode callReferenceValue */
|
|
|
|
invokeStartElement (pctxt, "callReferenceValue", -1);
|
|
|
|
stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callReferenceValue", -1);
|
|
|
|
/* decode disengageReason */
|
|
|
|
invokeStartElement (pctxt, "disengageReason", -1);
|
|
|
|
stat = asn1PD_H225DisengageReason (pctxt, &pvalue->disengageReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "disengageReason", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 13 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.gatekeeperIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.answeredCallPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "answeredCall", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->answeredCall);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->answeredCall);
|
|
|
|
invokeEndElement (pctxt, "answeredCall", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.callLinkagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callLinkage", -1);
|
|
|
|
stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callLinkage", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.usageInformationPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageInformation", -1);
|
|
|
|
stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageInformation", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.terminationCausePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "terminationCause", -1);
|
|
|
|
stat = asn1PD_H225CallTerminationCause (pctxt, &pvalue->terminationCause);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "terminationCause", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* DisengageConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 7 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.usageInformationPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageInformation", -1);
|
|
|
|
stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageInformation", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* DisengageRejectReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* notRegistered */
|
|
case 0:
|
|
invokeStartElement (pctxt, "notRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "notRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* requestToDropOther */
|
|
case 1:
|
|
invokeStartElement (pctxt, "requestToDropOther", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "requestToDropOther", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 3;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* securityDenial */
|
|
case 3:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 4:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
|
|
|
|
stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* DisengageReject */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode rejectReason */
|
|
|
|
invokeStartElement (pctxt, "rejectReason", -1);
|
|
|
|
stat = asn1PD_H225DisengageRejectReason (pctxt, &pvalue->rejectReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rejectReason", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 5 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.altGKInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* LocationRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endpointIdentifierPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
if (pvalue->m.endpointIdentifierPresent) {
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
}
|
|
|
|
/* decode destinationInfo */
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode replyAddress */
|
|
|
|
invokeStartElement (pctxt, "replyAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->replyAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "replyAddress", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 16 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.sourceInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "sourceInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sourceInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.canMapAliasPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "canMapAlias", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canMapAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canMapAlias);
|
|
|
|
invokeEndElement (pctxt, "canMapAlias", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.gatekeeperIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "gatekeeperIdentifier", -1);
|
|
|
|
stat = asn1PD_H225GatekeeperIdentifier (pctxt, &pvalue->gatekeeperIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperIdentifier", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.desiredProtocolsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "desiredProtocols", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->desiredProtocols);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "desiredProtocols", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.desiredTunnelledProtocolPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "desiredTunnelledProtocol", -1);
|
|
|
|
stat = asn1PD_H225TunnelledProtocol (pctxt, &pvalue->desiredTunnelledProtocol);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "desiredTunnelledProtocol", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.hopCountPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "hopCount", -1);
|
|
|
|
stat = decodeConsUInt8 (pctxt, &pvalue->hopCount, 1U, 255U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->hopCount);
|
|
|
|
invokeEndElement (pctxt, "hopCount", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.bandWidthPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "bandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandWidth", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.sourceEndpointInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "sourceEndpointInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceEndpointInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "sourceEndpointInfo", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.canMapSrcAliasPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "canMapSrcAlias", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->canMapSrcAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->canMapSrcAlias);
|
|
|
|
invokeEndElement (pctxt, "canMapSrcAlias", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* LocationConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode callSignalAddress */
|
|
|
|
invokeStartElement (pctxt, "callSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->callSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignalAddress", -1);
|
|
|
|
/* decode rasAddress */
|
|
|
|
invokeStartElement (pctxt, "rasAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rasAddress", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 17 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.destinationInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destinationInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.destExtraCallInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destExtraCallInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destExtraCallInfo", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.destinationTypePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "destinationType", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->destinationType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "destinationType", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.remoteExtensionAddressPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "remoteExtensionAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "remoteExtensionAddress", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.alternateEndpointsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateEndpoints", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225Endpoint (pctxt, &pvalue->alternateEndpoints);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateEndpoints", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.alternateTransportAddressesPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "alternateTransportAddresses", -1);
|
|
|
|
stat = asn1PD_H225AlternateTransportAddresses (pctxt, &pvalue->alternateTransportAddresses);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "alternateTransportAddresses", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.supportedProtocolsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "supportedProtocols", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->supportedProtocols);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "supportedProtocols", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.multipleCallsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "multipleCalls", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->multipleCalls);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->multipleCalls);
|
|
|
|
invokeEndElement (pctxt, "multipleCalls", -1);
|
|
break;
|
|
|
|
case 11:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 12:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
case 13:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
case 14:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
case 15:
|
|
pvalue->m.modifiedSrcInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "modifiedSrcInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->modifiedSrcInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "modifiedSrcInfo", -1);
|
|
break;
|
|
|
|
case 16:
|
|
pvalue->m.bandWidthPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "bandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandWidth", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* LocationRejectReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* notRegistered */
|
|
case 0:
|
|
invokeStartElement (pctxt, "notRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "notRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* invalidPermission */
|
|
case 1:
|
|
invokeStartElement (pctxt, "invalidPermission", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidPermission", -1);
|
|
|
|
break;
|
|
|
|
/* requestDenied */
|
|
case 2:
|
|
invokeStartElement (pctxt, "requestDenied", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "requestDenied", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 3:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* securityDenial */
|
|
case 5:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* aliasesInconsistent */
|
|
case 6:
|
|
invokeStartElement (pctxt, "aliasesInconsistent", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "aliasesInconsistent", -1);
|
|
|
|
break;
|
|
|
|
/* routeCalltoSCN */
|
|
case 7:
|
|
invokeStartElement (pctxt, "routeCalltoSCN", -1);
|
|
|
|
pvalue->u.routeCalltoSCN = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225PartyNumber);
|
|
|
|
stat = asn1PD_H225_SeqOfH225PartyNumber (pctxt, pvalue->u.routeCalltoSCN);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "routeCalltoSCN", -1);
|
|
|
|
break;
|
|
|
|
/* resourceUnavailable */
|
|
case 8:
|
|
invokeStartElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "resourceUnavailable", -1);
|
|
|
|
break;
|
|
|
|
/* genericDataReason */
|
|
case 9:
|
|
invokeStartElement (pctxt, "genericDataReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "genericDataReason", -1);
|
|
|
|
break;
|
|
|
|
/* neededFeatureNotSupported */
|
|
case 10:
|
|
invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
break;
|
|
|
|
/* hopCountExceeded */
|
|
case 11:
|
|
invokeStartElement (pctxt, "hopCountExceeded", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "hopCountExceeded", -1);
|
|
|
|
break;
|
|
|
|
/* incompleteAddress */
|
|
case 12:
|
|
invokeStartElement (pctxt, "incompleteAddress", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "incompleteAddress", -1);
|
|
|
|
break;
|
|
|
|
/* securityError */
|
|
case 13:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
|
|
|
|
stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
/* securityDHmismatch */
|
|
case 14:
|
|
invokeStartElement (pctxt, "securityDHmismatch", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDHmismatch", -1);
|
|
|
|
break;
|
|
|
|
/* noRouteToDestination */
|
|
case 15:
|
|
invokeStartElement (pctxt, "noRouteToDestination", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "noRouteToDestination", -1);
|
|
|
|
break;
|
|
|
|
/* unallocatedNumber */
|
|
case 16:
|
|
invokeStartElement (pctxt, "unallocatedNumber", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "unallocatedNumber", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* LocationReject */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode rejectReason */
|
|
|
|
invokeStartElement (pctxt, "rejectReason", -1);
|
|
|
|
stat = asn1PD_H225LocationRejectReason (pctxt, &pvalue->rejectReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rejectReason", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 7 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.altGKInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.serviceControlPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequest */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.replyAddressPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode callReferenceValue */
|
|
|
|
invokeStartElement (pctxt, "callReferenceValue", -1);
|
|
|
|
stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callReferenceValue", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode replyAddress */
|
|
|
|
if (pvalue->m.replyAddressPresent) {
|
|
invokeStartElement (pctxt, "replyAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->replyAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "replyAddress", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 11 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.uuiesRequestedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "uuiesRequested", -1);
|
|
|
|
stat = asn1PD_H225UUIEsRequested (pctxt, &pvalue->uuiesRequested);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "uuiesRequested", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.callLinkagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callLinkage", -1);
|
|
|
|
stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callLinkage", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.usageInfoRequestedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageInfoRequested", -1);
|
|
|
|
stat = asn1PD_H225RasUsageInfoTypes (pctxt, &pvalue->usageInfoRequested);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageInfoRequested", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.segmentedResponseSupportedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "segmentedResponseSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "segmentedResponseSupported", -1);
|
|
break;
|
|
|
|
case 8:
|
|
pvalue->m.nextSegmentRequestedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "nextSegmentRequested", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->nextSegmentRequested, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->nextSegmentRequested);
|
|
|
|
invokeEndElement (pctxt, "nextSegmentRequested", -1);
|
|
break;
|
|
|
|
case 9:
|
|
pvalue->m.capacityInfoRequestedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacityInfoRequested", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "capacityInfoRequested", -1);
|
|
break;
|
|
|
|
case 10:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225RTPSession */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225RTPSession* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225RTPSession);
|
|
|
|
stat = asn1PD_H225RTPSession (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225TransportChannelInfo */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225TransportChannelInfo* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225TransportChannelInfo);
|
|
|
|
stat = asn1PD_H225TransportChannelInfo (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225ConferenceIdentifier */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT xx1;
|
|
|
|
/* decode length determinant */
|
|
|
|
stat = decodeLength (pctxt, &pvalue->n);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
/* decode elements */
|
|
|
|
ALLOC_ASN1ARRAY (pctxt, pvalue, H225ConferenceIdentifier);
|
|
|
|
for (xx1 = 0; xx1 < pvalue->n; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->elem[xx1]);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequestResponse_perCallInfo_element_pdu_element */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
|
|
/* decode h323pdu */
|
|
|
|
invokeStartElement (pctxt, "h323pdu", -1);
|
|
|
|
stat = asn1PD_H225H323_UU_PDU (pctxt, &pvalue->h323pdu);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h323pdu", -1);
|
|
|
|
/* decode sent */
|
|
|
|
invokeStartElement (pctxt, "sent", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->sent);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->sent);
|
|
|
|
invokeEndElement (pctxt, "sent", -1);
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_el */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225InfoRequestResponse_perCallInfo_element_pdu_element* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element);
|
|
|
|
stat = asn1PD_H225InfoRequestResponse_perCallInfo_element_pdu_element (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequestResponse_perCallInfo_element */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.originatorPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.audioPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.videoPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.dataPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode callReferenceValue */
|
|
|
|
invokeStartElement (pctxt, "callReferenceValue", -1);
|
|
|
|
stat = asn1PD_H225CallReferenceValue (pctxt, &pvalue->callReferenceValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callReferenceValue", -1);
|
|
|
|
/* decode conferenceID */
|
|
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
|
|
/* decode originator */
|
|
|
|
if (pvalue->m.originatorPresent) {
|
|
invokeStartElement (pctxt, "originator", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->originator);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->originator);
|
|
|
|
invokeEndElement (pctxt, "originator", -1);
|
|
}
|
|
|
|
/* decode audio */
|
|
|
|
if (pvalue->m.audioPresent) {
|
|
invokeStartElement (pctxt, "audio", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225RTPSession (pctxt, &pvalue->audio);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "audio", -1);
|
|
}
|
|
|
|
/* decode video */
|
|
|
|
if (pvalue->m.videoPresent) {
|
|
invokeStartElement (pctxt, "video", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225RTPSession (pctxt, &pvalue->video);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "video", -1);
|
|
}
|
|
|
|
/* decode data */
|
|
|
|
if (pvalue->m.dataPresent) {
|
|
invokeStartElement (pctxt, "data", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportChannelInfo (pctxt, &pvalue->data);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "data", -1);
|
|
}
|
|
|
|
/* decode h245 */
|
|
|
|
invokeStartElement (pctxt, "h245", -1);
|
|
|
|
stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->h245);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "h245", -1);
|
|
|
|
/* decode callSignaling */
|
|
|
|
invokeStartElement (pctxt, "callSignaling", -1);
|
|
|
|
stat = asn1PD_H225TransportChannelInfo (pctxt, &pvalue->callSignaling);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignaling", -1);
|
|
|
|
/* decode callType */
|
|
|
|
invokeStartElement (pctxt, "callType", -1);
|
|
|
|
stat = asn1PD_H225CallType (pctxt, &pvalue->callType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callType", -1);
|
|
|
|
/* decode bandWidth */
|
|
|
|
invokeStartElement (pctxt, "bandWidth", -1);
|
|
|
|
stat = asn1PD_H225BandWidth (pctxt, &pvalue->bandWidth);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandWidth", -1);
|
|
|
|
/* decode callModel */
|
|
|
|
invokeStartElement (pctxt, "callModel", -1);
|
|
|
|
stat = asn1PD_H225CallModel (pctxt, &pvalue->callModel);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callModel", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 8 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.callIdentifierPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.substituteConfIDsPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "substituteConfIDs", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ConferenceIdentifier (pctxt, &pvalue->substituteConfIDs);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "substituteConfIDs", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.pduPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "pdu", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (pctxt, &pvalue->pdu);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "pdu", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.callLinkagePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "callLinkage", -1);
|
|
|
|
stat = asn1PD_H225CallLinkage (pctxt, &pvalue->callLinkage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callLinkage", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.usageInformationPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "usageInformation", -1);
|
|
|
|
stat = asn1PD_H225RasUsageInformation (pctxt, &pvalue->usageInformation);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "usageInformation", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.circuitInfoPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "circuitInfo", -1);
|
|
|
|
stat = asn1PD_H225CircuitInfo (pctxt, &pvalue->circuitInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "circuitInfo", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225InfoRequestResponse_perCallInfo_element */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225InfoRequestResponse_perCallInfo_element* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225InfoRequestResponse_perCallInfo_element);
|
|
|
|
stat = asn1PD_H225InfoRequestResponse_perCallInfo_element (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequestResponseStatus */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 3);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* complete */
|
|
case 0:
|
|
invokeStartElement (pctxt, "complete", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "complete", -1);
|
|
|
|
break;
|
|
|
|
/* incomplete */
|
|
case 1:
|
|
invokeStartElement (pctxt, "incomplete", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "incomplete", -1);
|
|
|
|
break;
|
|
|
|
/* segment */
|
|
case 2:
|
|
invokeStartElement (pctxt, "segment", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->u.segment, 0U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->u.segment);
|
|
|
|
invokeEndElement (pctxt, "segment", -1);
|
|
|
|
break;
|
|
|
|
/* invalidCall */
|
|
case 3:
|
|
invokeStartElement (pctxt, "invalidCall", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "invalidCall", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 5;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequestResponse */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endpointAliasPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.perCallInfoPresent = optbit;
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode endpointType */
|
|
|
|
invokeStartElement (pctxt, "endpointType", -1);
|
|
|
|
stat = asn1PD_H225EndpointType (pctxt, &pvalue->endpointType);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointType", -1);
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
/* decode rasAddress */
|
|
|
|
invokeStartElement (pctxt, "rasAddress", -1);
|
|
|
|
stat = asn1PD_H225TransportAddress (pctxt, &pvalue->rasAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "rasAddress", -1);
|
|
|
|
/* decode callSignalAddress */
|
|
|
|
invokeStartElement (pctxt, "callSignalAddress", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSignalAddress", -1);
|
|
|
|
/* decode endpointAlias */
|
|
|
|
if (pvalue->m.endpointAliasPresent) {
|
|
invokeStartElement (pctxt, "endpointAlias", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointAlias", -1);
|
|
}
|
|
|
|
/* decode perCallInfo */
|
|
|
|
if (pvalue->m.perCallInfoPresent) {
|
|
invokeStartElement (pctxt, "perCallInfo", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (pctxt, &pvalue->perCallInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "perCallInfo", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 8 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.needResponsePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "needResponse", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->needResponse);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->needResponse);
|
|
|
|
invokeEndElement (pctxt, "needResponse", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 5:
|
|
pvalue->m.irrStatusPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "irrStatus", -1);
|
|
|
|
stat = asn1PD_H225InfoRequestResponseStatus (pctxt, &pvalue->irrStatus);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "irrStatus", -1);
|
|
break;
|
|
|
|
case 6:
|
|
pvalue->m.unsolicitedPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "unsolicited", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->unsolicited);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->unsolicited);
|
|
|
|
invokeEndElement (pctxt, "unsolicited", -1);
|
|
break;
|
|
|
|
case 7:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* NonStandardMessage */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 5 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.featureSetPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
break;
|
|
|
|
case 4:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* UnknownMessageResponse */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 4 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.tokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.cryptoTokensPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
break;
|
|
|
|
case 2:
|
|
pvalue->m.integrityCheckValuePresent = 1;
|
|
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
break;
|
|
|
|
case 3:
|
|
pvalue->m.messageNotUnderstoodPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "messageNotUnderstood", -1);
|
|
|
|
stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->messageNotUnderstood);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeOctStrValue (pctxt, pvalue->messageNotUnderstood.numocts, pvalue->messageNotUnderstood.data);
|
|
|
|
invokeEndElement (pctxt, "messageNotUnderstood", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RequestInProgress */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.integrityCheckValuePresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode integrityCheckValue */
|
|
|
|
if (pvalue->m.integrityCheckValuePresent) {
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
}
|
|
|
|
/* decode delay */
|
|
|
|
invokeStartElement (pctxt, "delay", -1);
|
|
|
|
stat = decodeConsUInt16 (pctxt, &pvalue->delay, 1U, 65535U);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeUIntValue (pctxt, pvalue->delay);
|
|
|
|
invokeEndElement (pctxt, "delay", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ResourcesAvailableIndicate */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.integrityCheckValuePresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
/* decode protocols */
|
|
|
|
invokeStartElement (pctxt, "protocols", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocols);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocols", -1);
|
|
|
|
/* decode almostOutOfResources */
|
|
|
|
invokeStartElement (pctxt, "almostOutOfResources", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->almostOutOfResources);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->almostOutOfResources);
|
|
|
|
invokeEndElement (pctxt, "almostOutOfResources", -1);
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode integrityCheckValue */
|
|
|
|
if (pvalue->m.integrityCheckValuePresent) {
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 2 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.capacityPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "capacity", -1);
|
|
|
|
stat = asn1PD_H225CallCapacity (pctxt, &pvalue->capacity);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "capacity", -1);
|
|
break;
|
|
|
|
case 1:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ResourcesAvailableConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
OOCTXT lctxt2;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.integrityCheckValuePresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode protocolIdentifier */
|
|
|
|
invokeStartElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
stat = asn1PD_H225ProtocolIdentifier (pctxt, &pvalue->protocolIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "protocolIdentifier", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode integrityCheckValue */
|
|
|
|
if (pvalue->m.integrityCheckValuePresent) {
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
if (i < 1 && openType.numocts > 0) { /* known element */
|
|
copyContext (&lctxt2, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (i) {
|
|
case 0:
|
|
pvalue->m.genericDataPresent = 1;
|
|
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
break;
|
|
|
|
default:
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
copyContext (pctxt, &lctxt2);
|
|
}
|
|
else { /* unknown element */
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequestAck */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.integrityCheckValuePresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode integrityCheckValue */
|
|
|
|
if (pvalue->m.integrityCheckValuePresent) {
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequestNakReason */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* notRegistered */
|
|
case 0:
|
|
invokeStartElement (pctxt, "notRegistered", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "notRegistered", -1);
|
|
|
|
break;
|
|
|
|
/* securityDenial */
|
|
case 1:
|
|
invokeStartElement (pctxt, "securityDenial", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "securityDenial", -1);
|
|
|
|
break;
|
|
|
|
/* undefinedReason */
|
|
case 2:
|
|
invokeStartElement (pctxt, "undefinedReason", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "undefinedReason", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 4;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* securityError */
|
|
case 4:
|
|
invokeStartElement (pctxt, "securityError", -1);
|
|
|
|
pvalue->u.securityError = ALLOC_ASN1ELEM (pctxt, H225SecurityErrors2);
|
|
|
|
stat = asn1PD_H225SecurityErrors2 (pctxt, pvalue->u.securityError);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "securityError", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* InfoRequestNak */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.altGKInfoPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.integrityCheckValuePresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode nakReason */
|
|
|
|
invokeStartElement (pctxt, "nakReason", -1);
|
|
|
|
stat = asn1PD_H225InfoRequestNakReason (pctxt, &pvalue->nakReason);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nakReason", -1);
|
|
|
|
/* decode altGKInfo */
|
|
|
|
if (pvalue->m.altGKInfoPresent) {
|
|
invokeStartElement (pctxt, "altGKInfo", -1);
|
|
|
|
stat = asn1PD_H225AltGKInfo (pctxt, &pvalue->altGKInfo);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "altGKInfo", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode integrityCheckValue */
|
|
|
|
if (pvalue->m.integrityCheckValuePresent) {
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ServiceControlIndication_callSpecific */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* decode callIdentifier */
|
|
|
|
invokeStartElement (pctxt, "callIdentifier", -1);
|
|
|
|
stat = asn1PD_H225CallIdentifier (pctxt, &pvalue->callIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callIdentifier", -1);
|
|
|
|
/* decode conferenceID */
|
|
|
|
invokeStartElement (pctxt, "conferenceID", -1);
|
|
|
|
stat = asn1PD_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "conferenceID", -1);
|
|
|
|
/* decode answeredCall */
|
|
|
|
invokeStartElement (pctxt, "answeredCall", -1);
|
|
|
|
stat = DECODEBIT (pctxt, &pvalue->answeredCall);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeBoolValue (pctxt, pvalue->answeredCall);
|
|
|
|
invokeEndElement (pctxt, "answeredCall", -1);
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ServiceControlIndication */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.endpointIdentifierPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.callSpecificPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.integrityCheckValuePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.featureSetPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.genericDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode serviceControl */
|
|
|
|
invokeStartElement (pctxt, "serviceControl", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControl", -1);
|
|
|
|
/* decode endpointIdentifier */
|
|
|
|
if (pvalue->m.endpointIdentifierPresent) {
|
|
invokeStartElement (pctxt, "endpointIdentifier", -1);
|
|
|
|
stat = asn1PD_H225EndpointIdentifier (pctxt, &pvalue->endpointIdentifier);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "endpointIdentifier", -1);
|
|
}
|
|
|
|
/* decode callSpecific */
|
|
|
|
if (pvalue->m.callSpecificPresent) {
|
|
invokeStartElement (pctxt, "callSpecific", -1);
|
|
|
|
stat = asn1PD_H225ServiceControlIndication_callSpecific (pctxt, &pvalue->callSpecific);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "callSpecific", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode integrityCheckValue */
|
|
|
|
if (pvalue->m.integrityCheckValuePresent) {
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
}
|
|
|
|
/* decode featureSet */
|
|
|
|
if (pvalue->m.featureSetPresent) {
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
}
|
|
|
|
/* decode genericData */
|
|
|
|
if (pvalue->m.genericDataPresent) {
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ServiceControlResponse_result */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* started */
|
|
case 0:
|
|
invokeStartElement (pctxt, "started", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "started", -1);
|
|
|
|
break;
|
|
|
|
/* failed */
|
|
case 1:
|
|
invokeStartElement (pctxt, "failed", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "failed", -1);
|
|
|
|
break;
|
|
|
|
/* stopped */
|
|
case 2:
|
|
invokeStartElement (pctxt, "stopped", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "stopped", -1);
|
|
|
|
break;
|
|
|
|
/* notAvailable */
|
|
case 3:
|
|
invokeStartElement (pctxt, "notAvailable", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "notAvailable", -1);
|
|
|
|
break;
|
|
|
|
/* neededFeatureNotSupported */
|
|
case 4:
|
|
invokeStartElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
/* NULL */
|
|
invokeNullValue (pctxt);
|
|
|
|
invokeEndElement (pctxt, "neededFeatureNotSupported", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 6;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* ServiceControlResponse */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
OOCTXT lctxt;
|
|
ASN1OpenType openType;
|
|
ASN1UINT bitcnt;
|
|
ASN1UINT i;
|
|
ASN1BOOL optbit = 0;
|
|
ASN1BOOL extbit = 0;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
/* optional bits */
|
|
|
|
memset (&pvalue->m, 0, sizeof(pvalue->m));
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.resultPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.nonStandardDataPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.tokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.cryptoTokensPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.integrityCheckValuePresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.featureSetPresent = optbit;
|
|
|
|
DECODEBIT (pctxt, &optbit);
|
|
pvalue->m.genericDataPresent = optbit;
|
|
|
|
/* decode requestSeqNum */
|
|
|
|
invokeStartElement (pctxt, "requestSeqNum", -1);
|
|
|
|
stat = asn1PD_H225RequestSeqNum (pctxt, &pvalue->requestSeqNum);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestSeqNum", -1);
|
|
|
|
/* decode result */
|
|
|
|
if (pvalue->m.resultPresent) {
|
|
invokeStartElement (pctxt, "result", -1);
|
|
|
|
stat = asn1PD_H225ServiceControlResponse_result (pctxt, &pvalue->result);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "result", -1);
|
|
}
|
|
|
|
/* decode nonStandardData */
|
|
|
|
if (pvalue->m.nonStandardDataPresent) {
|
|
invokeStartElement (pctxt, "nonStandardData", -1);
|
|
|
|
stat = asn1PD_H225NonStandardParameter (pctxt, &pvalue->nonStandardData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardData", -1);
|
|
}
|
|
|
|
/* decode tokens */
|
|
|
|
if (pvalue->m.tokensPresent) {
|
|
invokeStartElement (pctxt, "tokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "tokens", -1);
|
|
}
|
|
|
|
/* decode cryptoTokens */
|
|
|
|
if (pvalue->m.cryptoTokensPresent) {
|
|
invokeStartElement (pctxt, "cryptoTokens", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "cryptoTokens", -1);
|
|
}
|
|
|
|
/* decode integrityCheckValue */
|
|
|
|
if (pvalue->m.integrityCheckValuePresent) {
|
|
invokeStartElement (pctxt, "integrityCheckValue", -1);
|
|
|
|
stat = asn1PD_H225ICV (pctxt, &pvalue->integrityCheckValue);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "integrityCheckValue", -1);
|
|
}
|
|
|
|
/* decode featureSet */
|
|
|
|
if (pvalue->m.featureSetPresent) {
|
|
invokeStartElement (pctxt, "featureSet", -1);
|
|
|
|
stat = asn1PD_H225FeatureSet (pctxt, &pvalue->featureSet);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "featureSet", -1);
|
|
}
|
|
|
|
/* decode genericData */
|
|
|
|
if (pvalue->m.genericDataPresent) {
|
|
invokeStartElement (pctxt, "genericData", -1);
|
|
|
|
stat = asn1PD_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "genericData", -1);
|
|
}
|
|
|
|
if (extbit) {
|
|
|
|
/* decode extension optional bits length */
|
|
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
bitcnt += 1;
|
|
|
|
ZEROCONTEXT (&lctxt);
|
|
stat = setPERBufferUsingCtxt (&lctxt, pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = moveBitCursor (pctxt, bitcnt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
for (i = 0; i < bitcnt; i++) {
|
|
DECODEBIT (&lctxt, &optbit);
|
|
|
|
if (optbit) {
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
pctxt->buffer.byteIndex += openType.numocts;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* _SeqOfH225AdmissionConfirm */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
H225AdmissionConfirm* pdata;
|
|
ASN1UINT count = 0;
|
|
ASN1UINT xx1;
|
|
int lstat;
|
|
|
|
dListInit (pvalue);
|
|
|
|
for (;;) {
|
|
/* decode length determinant */
|
|
|
|
lstat = decodeLength (pctxt, &count);
|
|
if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
|
|
return lstat;
|
|
}
|
|
|
|
/* decode elements */
|
|
|
|
for (xx1 = 0; xx1 < count; xx1++) {
|
|
invokeStartElement (pctxt, "elem", xx1);
|
|
|
|
pdata = ALLOC_ASN1ELEMDNODE (pctxt, H225AdmissionConfirm);
|
|
|
|
stat = asn1PD_H225AdmissionConfirm (pctxt, pdata);
|
|
if (stat != ASN_OK) return stat;
|
|
invokeEndElement (pctxt, "elem", xx1);
|
|
|
|
dListAppendNode (pctxt, pvalue, pdata);
|
|
}
|
|
|
|
if(lstat == ASN_OK) break;
|
|
}
|
|
|
|
return (stat);
|
|
}
|
|
|
|
/**************************************************************/
|
|
/* */
|
|
/* RasMessage */
|
|
/* */
|
|
/**************************************************************/
|
|
|
|
EXTERN int asn1PD_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue)
|
|
{
|
|
int stat = ASN_OK;
|
|
ASN1UINT ui;
|
|
ASN1OpenType openType;
|
|
ASN1BOOL extbit = 0;
|
|
OOCTXT lctxt;
|
|
|
|
/* extension bit */
|
|
|
|
DECODEBIT (pctxt, &extbit);
|
|
|
|
if (!extbit) {
|
|
stat = decodeConsUnsigned (pctxt, &ui, 0, 24);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 1;
|
|
|
|
switch (ui) {
|
|
/* gatekeeperRequest */
|
|
case 0:
|
|
invokeStartElement (pctxt, "gatekeeperRequest", -1);
|
|
|
|
pvalue->u.gatekeeperRequest = ALLOC_ASN1ELEM (pctxt, H225GatekeeperRequest);
|
|
|
|
stat = asn1PD_H225GatekeeperRequest (pctxt, pvalue->u.gatekeeperRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperRequest", -1);
|
|
|
|
break;
|
|
|
|
/* gatekeeperConfirm */
|
|
case 1:
|
|
invokeStartElement (pctxt, "gatekeeperConfirm", -1);
|
|
|
|
pvalue->u.gatekeeperConfirm = ALLOC_ASN1ELEM (pctxt, H225GatekeeperConfirm);
|
|
|
|
stat = asn1PD_H225GatekeeperConfirm (pctxt, pvalue->u.gatekeeperConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* gatekeeperReject */
|
|
case 2:
|
|
invokeStartElement (pctxt, "gatekeeperReject", -1);
|
|
|
|
pvalue->u.gatekeeperReject = ALLOC_ASN1ELEM (pctxt, H225GatekeeperReject);
|
|
|
|
stat = asn1PD_H225GatekeeperReject (pctxt, pvalue->u.gatekeeperReject);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "gatekeeperReject", -1);
|
|
|
|
break;
|
|
|
|
/* registrationRequest */
|
|
case 3:
|
|
invokeStartElement (pctxt, "registrationRequest", -1);
|
|
|
|
pvalue->u.registrationRequest = ALLOC_ASN1ELEM (pctxt, H225RegistrationRequest);
|
|
|
|
stat = asn1PD_H225RegistrationRequest (pctxt, pvalue->u.registrationRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "registrationRequest", -1);
|
|
|
|
break;
|
|
|
|
/* registrationConfirm */
|
|
case 4:
|
|
invokeStartElement (pctxt, "registrationConfirm", -1);
|
|
|
|
pvalue->u.registrationConfirm = ALLOC_ASN1ELEM (pctxt, H225RegistrationConfirm);
|
|
|
|
stat = asn1PD_H225RegistrationConfirm (pctxt, pvalue->u.registrationConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "registrationConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* registrationReject */
|
|
case 5:
|
|
invokeStartElement (pctxt, "registrationReject", -1);
|
|
|
|
pvalue->u.registrationReject = ALLOC_ASN1ELEM (pctxt, H225RegistrationReject);
|
|
|
|
stat = asn1PD_H225RegistrationReject (pctxt, pvalue->u.registrationReject);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "registrationReject", -1);
|
|
|
|
break;
|
|
|
|
/* unregistrationRequest */
|
|
case 6:
|
|
invokeStartElement (pctxt, "unregistrationRequest", -1);
|
|
|
|
pvalue->u.unregistrationRequest = ALLOC_ASN1ELEM (pctxt, H225UnregistrationRequest);
|
|
|
|
stat = asn1PD_H225UnregistrationRequest (pctxt, pvalue->u.unregistrationRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "unregistrationRequest", -1);
|
|
|
|
break;
|
|
|
|
/* unregistrationConfirm */
|
|
case 7:
|
|
invokeStartElement (pctxt, "unregistrationConfirm", -1);
|
|
|
|
pvalue->u.unregistrationConfirm = ALLOC_ASN1ELEM (pctxt, H225UnregistrationConfirm);
|
|
|
|
stat = asn1PD_H225UnregistrationConfirm (pctxt, pvalue->u.unregistrationConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "unregistrationConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* unregistrationReject */
|
|
case 8:
|
|
invokeStartElement (pctxt, "unregistrationReject", -1);
|
|
|
|
pvalue->u.unregistrationReject = ALLOC_ASN1ELEM (pctxt, H225UnregistrationReject);
|
|
|
|
stat = asn1PD_H225UnregistrationReject (pctxt, pvalue->u.unregistrationReject);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "unregistrationReject", -1);
|
|
|
|
break;
|
|
|
|
/* admissionRequest */
|
|
case 9:
|
|
invokeStartElement (pctxt, "admissionRequest", -1);
|
|
|
|
pvalue->u.admissionRequest = ALLOC_ASN1ELEM (pctxt, H225AdmissionRequest);
|
|
|
|
stat = asn1PD_H225AdmissionRequest (pctxt, pvalue->u.admissionRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "admissionRequest", -1);
|
|
|
|
break;
|
|
|
|
/* admissionConfirm */
|
|
case 10:
|
|
invokeStartElement (pctxt, "admissionConfirm", -1);
|
|
|
|
pvalue->u.admissionConfirm = ALLOC_ASN1ELEM (pctxt, H225AdmissionConfirm);
|
|
|
|
stat = asn1PD_H225AdmissionConfirm (pctxt, pvalue->u.admissionConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "admissionConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* admissionReject */
|
|
case 11:
|
|
invokeStartElement (pctxt, "admissionReject", -1);
|
|
|
|
pvalue->u.admissionReject = ALLOC_ASN1ELEM (pctxt, H225AdmissionReject);
|
|
|
|
stat = asn1PD_H225AdmissionReject (pctxt, pvalue->u.admissionReject);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "admissionReject", -1);
|
|
|
|
break;
|
|
|
|
/* bandwidthRequest */
|
|
case 12:
|
|
invokeStartElement (pctxt, "bandwidthRequest", -1);
|
|
|
|
pvalue->u.bandwidthRequest = ALLOC_ASN1ELEM (pctxt, H225BandwidthRequest);
|
|
|
|
stat = asn1PD_H225BandwidthRequest (pctxt, pvalue->u.bandwidthRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandwidthRequest", -1);
|
|
|
|
break;
|
|
|
|
/* bandwidthConfirm */
|
|
case 13:
|
|
invokeStartElement (pctxt, "bandwidthConfirm", -1);
|
|
|
|
pvalue->u.bandwidthConfirm = ALLOC_ASN1ELEM (pctxt, H225BandwidthConfirm);
|
|
|
|
stat = asn1PD_H225BandwidthConfirm (pctxt, pvalue->u.bandwidthConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandwidthConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* bandwidthReject */
|
|
case 14:
|
|
invokeStartElement (pctxt, "bandwidthReject", -1);
|
|
|
|
pvalue->u.bandwidthReject = ALLOC_ASN1ELEM (pctxt, H225BandwidthReject);
|
|
|
|
stat = asn1PD_H225BandwidthReject (pctxt, pvalue->u.bandwidthReject);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "bandwidthReject", -1);
|
|
|
|
break;
|
|
|
|
/* disengageRequest */
|
|
case 15:
|
|
invokeStartElement (pctxt, "disengageRequest", -1);
|
|
|
|
pvalue->u.disengageRequest = ALLOC_ASN1ELEM (pctxt, H225DisengageRequest);
|
|
|
|
stat = asn1PD_H225DisengageRequest (pctxt, pvalue->u.disengageRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "disengageRequest", -1);
|
|
|
|
break;
|
|
|
|
/* disengageConfirm */
|
|
case 16:
|
|
invokeStartElement (pctxt, "disengageConfirm", -1);
|
|
|
|
pvalue->u.disengageConfirm = ALLOC_ASN1ELEM (pctxt, H225DisengageConfirm);
|
|
|
|
stat = asn1PD_H225DisengageConfirm (pctxt, pvalue->u.disengageConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "disengageConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* disengageReject */
|
|
case 17:
|
|
invokeStartElement (pctxt, "disengageReject", -1);
|
|
|
|
pvalue->u.disengageReject = ALLOC_ASN1ELEM (pctxt, H225DisengageReject);
|
|
|
|
stat = asn1PD_H225DisengageReject (pctxt, pvalue->u.disengageReject);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "disengageReject", -1);
|
|
|
|
break;
|
|
|
|
/* locationRequest */
|
|
case 18:
|
|
invokeStartElement (pctxt, "locationRequest", -1);
|
|
|
|
pvalue->u.locationRequest = ALLOC_ASN1ELEM (pctxt, H225LocationRequest);
|
|
|
|
stat = asn1PD_H225LocationRequest (pctxt, pvalue->u.locationRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "locationRequest", -1);
|
|
|
|
break;
|
|
|
|
/* locationConfirm */
|
|
case 19:
|
|
invokeStartElement (pctxt, "locationConfirm", -1);
|
|
|
|
pvalue->u.locationConfirm = ALLOC_ASN1ELEM (pctxt, H225LocationConfirm);
|
|
|
|
stat = asn1PD_H225LocationConfirm (pctxt, pvalue->u.locationConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "locationConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* locationReject */
|
|
case 20:
|
|
invokeStartElement (pctxt, "locationReject", -1);
|
|
|
|
pvalue->u.locationReject = ALLOC_ASN1ELEM (pctxt, H225LocationReject);
|
|
|
|
stat = asn1PD_H225LocationReject (pctxt, pvalue->u.locationReject);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "locationReject", -1);
|
|
|
|
break;
|
|
|
|
/* infoRequest */
|
|
case 21:
|
|
invokeStartElement (pctxt, "infoRequest", -1);
|
|
|
|
pvalue->u.infoRequest = ALLOC_ASN1ELEM (pctxt, H225InfoRequest);
|
|
|
|
stat = asn1PD_H225InfoRequest (pctxt, pvalue->u.infoRequest);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "infoRequest", -1);
|
|
|
|
break;
|
|
|
|
/* infoRequestResponse */
|
|
case 22:
|
|
invokeStartElement (pctxt, "infoRequestResponse", -1);
|
|
|
|
pvalue->u.infoRequestResponse = ALLOC_ASN1ELEM (pctxt, H225InfoRequestResponse);
|
|
|
|
stat = asn1PD_H225InfoRequestResponse (pctxt, pvalue->u.infoRequestResponse);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "infoRequestResponse", -1);
|
|
|
|
break;
|
|
|
|
/* nonStandardMessage */
|
|
case 23:
|
|
invokeStartElement (pctxt, "nonStandardMessage", -1);
|
|
|
|
pvalue->u.nonStandardMessage = ALLOC_ASN1ELEM (pctxt, H225NonStandardMessage);
|
|
|
|
stat = asn1PD_H225NonStandardMessage (pctxt, pvalue->u.nonStandardMessage);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "nonStandardMessage", -1);
|
|
|
|
break;
|
|
|
|
/* unknownMessageResponse */
|
|
case 24:
|
|
invokeStartElement (pctxt, "unknownMessageResponse", -1);
|
|
|
|
pvalue->u.unknownMessageResponse = ALLOC_ASN1ELEM (pctxt, H225UnknownMessageResponse);
|
|
|
|
stat = asn1PD_H225UnknownMessageResponse (pctxt, pvalue->u.unknownMessageResponse);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "unknownMessageResponse", -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
return ASN_E_INVOPT;
|
|
}
|
|
}
|
|
else {
|
|
stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
|
|
if (stat != ASN_OK) return stat;
|
|
else pvalue->t = ui + 26;
|
|
|
|
stat = decodeByteAlign (pctxt);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
copyContext (&lctxt, pctxt);
|
|
initContextBuffer (pctxt, openType.data, openType.numocts);
|
|
|
|
switch (pvalue->t) {
|
|
/* requestInProgress */
|
|
case 26:
|
|
invokeStartElement (pctxt, "requestInProgress", -1);
|
|
|
|
pvalue->u.requestInProgress = ALLOC_ASN1ELEM (pctxt, H225RequestInProgress);
|
|
|
|
stat = asn1PD_H225RequestInProgress (pctxt, pvalue->u.requestInProgress);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "requestInProgress", -1);
|
|
|
|
break;
|
|
|
|
/* resourcesAvailableIndicate */
|
|
case 27:
|
|
invokeStartElement (pctxt, "resourcesAvailableIndicate", -1);
|
|
|
|
pvalue->u.resourcesAvailableIndicate = ALLOC_ASN1ELEM (pctxt, H225ResourcesAvailableIndicate);
|
|
|
|
stat = asn1PD_H225ResourcesAvailableIndicate (pctxt, pvalue->u.resourcesAvailableIndicate);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "resourcesAvailableIndicate", -1);
|
|
|
|
break;
|
|
|
|
/* resourcesAvailableConfirm */
|
|
case 28:
|
|
invokeStartElement (pctxt, "resourcesAvailableConfirm", -1);
|
|
|
|
pvalue->u.resourcesAvailableConfirm = ALLOC_ASN1ELEM (pctxt, H225ResourcesAvailableConfirm);
|
|
|
|
stat = asn1PD_H225ResourcesAvailableConfirm (pctxt, pvalue->u.resourcesAvailableConfirm);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "resourcesAvailableConfirm", -1);
|
|
|
|
break;
|
|
|
|
/* infoRequestAck */
|
|
case 29:
|
|
invokeStartElement (pctxt, "infoRequestAck", -1);
|
|
|
|
pvalue->u.infoRequestAck = ALLOC_ASN1ELEM (pctxt, H225InfoRequestAck);
|
|
|
|
stat = asn1PD_H225InfoRequestAck (pctxt, pvalue->u.infoRequestAck);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "infoRequestAck", -1);
|
|
|
|
break;
|
|
|
|
/* infoRequestNak */
|
|
case 30:
|
|
invokeStartElement (pctxt, "infoRequestNak", -1);
|
|
|
|
pvalue->u.infoRequestNak = ALLOC_ASN1ELEM (pctxt, H225InfoRequestNak);
|
|
|
|
stat = asn1PD_H225InfoRequestNak (pctxt, pvalue->u.infoRequestNak);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "infoRequestNak", -1);
|
|
|
|
break;
|
|
|
|
/* serviceControlIndication */
|
|
case 31:
|
|
invokeStartElement (pctxt, "serviceControlIndication", -1);
|
|
|
|
pvalue->u.serviceControlIndication = ALLOC_ASN1ELEM (pctxt, H225ServiceControlIndication);
|
|
|
|
stat = asn1PD_H225ServiceControlIndication (pctxt, pvalue->u.serviceControlIndication);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControlIndication", -1);
|
|
|
|
break;
|
|
|
|
/* serviceControlResponse */
|
|
case 32:
|
|
invokeStartElement (pctxt, "serviceControlResponse", -1);
|
|
|
|
pvalue->u.serviceControlResponse = ALLOC_ASN1ELEM (pctxt, H225ServiceControlResponse);
|
|
|
|
stat = asn1PD_H225ServiceControlResponse (pctxt, pvalue->u.serviceControlResponse);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "serviceControlResponse", -1);
|
|
|
|
break;
|
|
|
|
/* admissionConfirmSequence */
|
|
case 33:
|
|
invokeStartElement (pctxt, "admissionConfirmSequence", -1);
|
|
|
|
pvalue->u.admissionConfirmSequence = ALLOC_ASN1ELEM (pctxt, H225_SeqOfH225AdmissionConfirm);
|
|
|
|
stat = asn1PD_H225_SeqOfH225AdmissionConfirm (pctxt, pvalue->u.admissionConfirmSequence);
|
|
if (stat != ASN_OK) return stat;
|
|
|
|
invokeEndElement (pctxt, "admissionConfirmSequence", -1);
|
|
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
copyContext (pctxt, &lctxt);
|
|
}
|
|
|
|
return (stat);
|
|
}
|